diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..3d1738203f372e1db6048e44d850a09832eb6cba
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,23 @@
+# Pull eris/data
+FROM eris/data
+
+# Set the env variables to non-interactive
+ENV DEBIAN_FRONTEND noninteractive
+ENV DEBIAN_PRIORITY critical
+ENV DEBCONF_NOWARNINGS yes
+ENV TERM linux
+RUN echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections
+
+# grab deps (gmp)
+RUN apt-get update && \
+ apt-get install -y --no-install-recommends \
+ libgmp3-dev && \
+ rm -rf /var/lib/apt/lists/*
+
+# set the repo and install tendermint
+ENV repo /go/src/github.com/eris-ltd/eris-db
+ADD . $repo
+WORKDIR $repo
+RUN cd ./cmd/erisdb && go install
+USER eris
+ENTRYPOINT ["erisdb"]
\ No newline at end of file
diff --git a/Godeps/_workspace/src/code.google.com/p/go.crypto/ripemd160/ripemd160.go b/Godeps/_workspace/src/code.google.com/p/go.crypto/ripemd160/ripemd160.go
new file mode 100644
index 0000000000000000000000000000000000000000..da690f0b92f52f5b1b7f983f3198f2697b14dc85
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/go.crypto/ripemd160/ripemd160.go
@@ -0,0 +1,120 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package ripemd160 implements the RIPEMD-160 hash algorithm.
+package ripemd160
+
+// RIPEMD-160 is designed by by Hans Dobbertin, Antoon Bosselaers, and Bart
+// Preneel with specifications available at:
+// http://homes.esat.kuleuven.be/~cosicart/pdf/AB-9601/AB-9601.pdf.
+
+import (
+ "crypto"
+ "hash"
+)
+
+func init() {
+ crypto.RegisterHash(crypto.RIPEMD160, New)
+}
+
+// The size of the checksum in bytes.
+const Size = 20
+
+// The block size of the hash algorithm in bytes.
+const BlockSize = 64
+
+const (
+ _s0 = 0x67452301
+ _s1 = 0xefcdab89
+ _s2 = 0x98badcfe
+ _s3 = 0x10325476
+ _s4 = 0xc3d2e1f0
+)
+
+// digest represents the partial evaluation of a checksum.
+type digest struct {
+ s [5]uint32 // running context
+ x [BlockSize]byte // temporary buffer
+ nx int // index into x
+ tc uint64 // total count of bytes processed
+}
+
+func (d *digest) Reset() {
+ d.s[0], d.s[1], d.s[2], d.s[3], d.s[4] = _s0, _s1, _s2, _s3, _s4
+ d.nx = 0
+ d.tc = 0
+}
+
+// New returns a new hash.Hash computing the checksum.
+func New() hash.Hash {
+ result := new(digest)
+ result.Reset()
+ return result
+}
+
+func (d *digest) Size() int { return Size }
+
+func (d *digest) BlockSize() int { return BlockSize }
+
+func (d *digest) Write(p []byte) (nn int, err error) {
+ nn = len(p)
+ d.tc += uint64(nn)
+ if d.nx > 0 {
+ n := len(p)
+ if n > BlockSize-d.nx {
+ n = BlockSize - d.nx
+ }
+ for i := 0; i < n; i++ {
+ d.x[d.nx+i] = p[i]
+ }
+ d.nx += n
+ if d.nx == BlockSize {
+ _Block(d, d.x[0:])
+ d.nx = 0
+ }
+ p = p[n:]
+ }
+ n := _Block(d, p)
+ p = p[n:]
+ if len(p) > 0 {
+ d.nx = copy(d.x[:], p)
+ }
+ return
+}
+
+func (d0 *digest) Sum(in []byte) []byte {
+ // Make a copy of d0 so that caller can keep writing and summing.
+ d := *d0
+
+ // Padding. Add a 1 bit and 0 bits until 56 bytes mod 64.
+ tc := d.tc
+ var tmp [64]byte
+ tmp[0] = 0x80
+ if tc%64 < 56 {
+ d.Write(tmp[0 : 56-tc%64])
+ } else {
+ d.Write(tmp[0 : 64+56-tc%64])
+ }
+
+ // Length in bits.
+ tc <<= 3
+ for i := uint(0); i < 8; i++ {
+ tmp[i] = byte(tc >> (8 * i))
+ }
+ d.Write(tmp[0:8])
+
+ if d.nx != 0 {
+ panic("d.nx != 0")
+ }
+
+ var digest [Size]byte
+ for i, s := range d.s {
+ digest[i*4] = byte(s)
+ digest[i*4+1] = byte(s >> 8)
+ digest[i*4+2] = byte(s >> 16)
+ digest[i*4+3] = byte(s >> 24)
+ }
+
+ return append(in, digest[:]...)
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/go.crypto/ripemd160/ripemd160_test.go b/Godeps/_workspace/src/code.google.com/p/go.crypto/ripemd160/ripemd160_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..5df1b2593d2c16aa5bef5a54cb8fd18d0d895fa7
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/go.crypto/ripemd160/ripemd160_test.go
@@ -0,0 +1,64 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ripemd160
+
+// Test vectors are from:
+// http://homes.esat.kuleuven.be/~bosselae/ripemd160.html
+
+import (
+ "fmt"
+ "io"
+ "testing"
+)
+
+type mdTest struct {
+ out string
+ in string
+}
+
+var vectors = [...]mdTest{
+ {"9c1185a5c5e9fc54612808977ee8f548b2258d31", ""},
+ {"0bdc9d2d256b3ee9daae347be6f4dc835a467ffe", "a"},
+ {"8eb208f7e05d987a9b044a8e98c6b087f15a0bfc", "abc"},
+ {"5d0689ef49d2fae572b881b123a85ffa21595f36", "message digest"},
+ {"f71c27109c692c1b56bbdceb5b9d2865b3708dbc", "abcdefghijklmnopqrstuvwxyz"},
+ {"12a053384a9c0c88e405a06c27dcf49ada62eb2b", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
+ {"b0e20b6e3116640286ed3a87a5713079b21f5189", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"},
+ {"9b752e45573d4b39f4dbd3323cab82bf63326bfb", "12345678901234567890123456789012345678901234567890123456789012345678901234567890"},
+}
+
+func TestVectors(t *testing.T) {
+ for i := 0; i < len(vectors); i++ {
+ tv := vectors[i]
+ md := New()
+ for j := 0; j < 3; j++ {
+ if j < 2 {
+ io.WriteString(md, tv.in)
+ } else {
+ io.WriteString(md, tv.in[0:len(tv.in)/2])
+ md.Sum(nil)
+ io.WriteString(md, tv.in[len(tv.in)/2:])
+ }
+ s := fmt.Sprintf("%x", md.Sum(nil))
+ if s != tv.out {
+ t.Fatalf("RIPEMD-160[%d](%s) = %s, expected %s", j, tv.in, s, tv.out)
+ }
+ md.Reset()
+ }
+ }
+}
+
+func TestMillionA(t *testing.T) {
+ md := New()
+ for i := 0; i < 100000; i++ {
+ io.WriteString(md, "aaaaaaaaaa")
+ }
+ out := "52783243c1697bdbe16d37f97f68f08325dc1528"
+ s := fmt.Sprintf("%x", md.Sum(nil))
+ if s != out {
+ t.Fatalf("RIPEMD-160 (1 million 'a') = %s, expected %s", s, out)
+ }
+ md.Reset()
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/go.crypto/ripemd160/ripemd160block.go b/Godeps/_workspace/src/code.google.com/p/go.crypto/ripemd160/ripemd160block.go
new file mode 100644
index 0000000000000000000000000000000000000000..7bc8e6c485e53c6b55dfd2f16c2d93b84b2b4bee
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/go.crypto/ripemd160/ripemd160block.go
@@ -0,0 +1,161 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// RIPEMD-160 block step.
+// In its own file so that a faster assembly or C version
+// can be substituted easily.
+
+package ripemd160
+
+// work buffer indices and roll amounts for one line
+var _n = [80]uint{
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
+ 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
+ 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
+ 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13,
+}
+
+var _r = [80]uint{
+ 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
+ 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
+ 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
+ 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
+ 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6,
+}
+
+// same for the other parallel one
+var n_ = [80]uint{
+ 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
+ 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
+ 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
+ 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
+ 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11,
+}
+
+var r_ = [80]uint{
+ 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
+ 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
+ 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
+ 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
+ 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11,
+}
+
+func _Block(md *digest, p []byte) int {
+ n := 0
+ var x [16]uint32
+ var alpha, beta uint32
+ for len(p) >= BlockSize {
+ a, b, c, d, e := md.s[0], md.s[1], md.s[2], md.s[3], md.s[4]
+ aa, bb, cc, dd, ee := a, b, c, d, e
+ j := 0
+ for i := 0; i < 16; i++ {
+ x[i] = uint32(p[j]) | uint32(p[j+1])<<8 | uint32(p[j+2])<<16 | uint32(p[j+3])<<24
+ j += 4
+ }
+
+ // round 1
+ i := 0
+ for i < 16 {
+ alpha = a + (b ^ c ^ d) + x[_n[i]]
+ s := _r[i]
+ alpha = (alpha<<s | alpha>>(32-s)) + e
+ beta = c<<10 | c>>22
+ a, b, c, d, e = e, alpha, b, beta, d
+
+ // parallel line
+ alpha = aa + (bb ^ (cc | ^dd)) + x[n_[i]] + 0x50a28be6
+ s = r_[i]
+ alpha = (alpha<<s | alpha>>(32-s)) + ee
+ beta = cc<<10 | cc>>22
+ aa, bb, cc, dd, ee = ee, alpha, bb, beta, dd
+
+ i++
+ }
+
+ // round 2
+ for i < 32 {
+ alpha = a + (b&c | ^b&d) + x[_n[i]] + 0x5a827999
+ s := _r[i]
+ alpha = (alpha<<s | alpha>>(32-s)) + e
+ beta = c<<10 | c>>22
+ a, b, c, d, e = e, alpha, b, beta, d
+
+ // parallel line
+ alpha = aa + (bb&dd | cc&^dd) + x[n_[i]] + 0x5c4dd124
+ s = r_[i]
+ alpha = (alpha<<s | alpha>>(32-s)) + ee
+ beta = cc<<10 | cc>>22
+ aa, bb, cc, dd, ee = ee, alpha, bb, beta, dd
+
+ i++
+ }
+
+ // round 3
+ for i < 48 {
+ alpha = a + (b | ^c ^ d) + x[_n[i]] + 0x6ed9eba1
+ s := _r[i]
+ alpha = (alpha<<s | alpha>>(32-s)) + e
+ beta = c<<10 | c>>22
+ a, b, c, d, e = e, alpha, b, beta, d
+
+ // parallel line
+ alpha = aa + (bb | ^cc ^ dd) + x[n_[i]] + 0x6d703ef3
+ s = r_[i]
+ alpha = (alpha<<s | alpha>>(32-s)) + ee
+ beta = cc<<10 | cc>>22
+ aa, bb, cc, dd, ee = ee, alpha, bb, beta, dd
+
+ i++
+ }
+
+ // round 4
+ for i < 64 {
+ alpha = a + (b&d | c&^d) + x[_n[i]] + 0x8f1bbcdc
+ s := _r[i]
+ alpha = (alpha<<s | alpha>>(32-s)) + e
+ beta = c<<10 | c>>22
+ a, b, c, d, e = e, alpha, b, beta, d
+
+ // parallel line
+ alpha = aa + (bb&cc | ^bb&dd) + x[n_[i]] + 0x7a6d76e9
+ s = r_[i]
+ alpha = (alpha<<s | alpha>>(32-s)) + ee
+ beta = cc<<10 | cc>>22
+ aa, bb, cc, dd, ee = ee, alpha, bb, beta, dd
+
+ i++
+ }
+
+ // round 5
+ for i < 80 {
+ alpha = a + (b ^ (c | ^d)) + x[_n[i]] + 0xa953fd4e
+ s := _r[i]
+ alpha = (alpha<<s | alpha>>(32-s)) + e
+ beta = c<<10 | c>>22
+ a, b, c, d, e = e, alpha, b, beta, d
+
+ // parallel line
+ alpha = aa + (bb ^ cc ^ dd) + x[n_[i]]
+ s = r_[i]
+ alpha = (alpha<<s | alpha>>(32-s)) + ee
+ beta = cc<<10 | cc>>22
+ aa, bb, cc, dd, ee = ee, alpha, bb, beta, dd
+
+ i++
+ }
+
+ // combine results
+ dd += c + md.s[1]
+ md.s[1] = md.s[2] + d + ee
+ md.s[2] = md.s[3] + e + aa
+ md.s[3] = md.s[4] + a + bb
+ md.s[4] = md.s[0] + b + cc
+ md.s[0] = dd
+
+ p = p[BlockSize:]
+ n += BlockSize
+ }
+ return n
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/mxk/go1/flowcontrol/flowcontrol.go b/Godeps/_workspace/src/code.google.com/p/mxk/go1/flowcontrol/flowcontrol.go
new file mode 100644
index 0000000000000000000000000000000000000000..40db5d89ece5cfe9a478be8f4dbe2ba70a7119ca
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/mxk/go1/flowcontrol/flowcontrol.go
@@ -0,0 +1,267 @@
+//
+// Written by Maxim Khitrov (November 2012)
+//
+
+// Package flowcontrol provides the tools for monitoring and limiting the
+// transfer rate of an arbitrary data stream.
+package flowcontrol
+
+import (
+ "math"
+ "sync"
+ "time"
+)
+
+// Monitor monitors and limits the transfer rate of a data stream.
+type Monitor struct {
+ mu sync.Mutex // Mutex guarding access to all internal fields
+ active bool // Flag indicating an active transfer
+ start time.Duration // Transfer start time (clock() value)
+ bytes int64 // Total number of bytes transferred
+ samples int64 // Total number of samples taken
+
+ rSample float64 // Most recent transfer rate sample (bytes per second)
+ rEMA float64 // Exponential moving average of rSample
+ rPeak float64 // Peak transfer rate (max of all rSamples)
+ rWindow float64 // rEMA window (seconds)
+
+ sBytes int64 // Number of bytes transferred since sLast
+ sLast time.Duration // Most recent sample time (stop time when inactive)
+ sRate time.Duration // Sampling rate
+
+ tBytes int64 // Number of bytes expected in the current transfer
+ tLast time.Duration // Time of the most recent transfer of at least 1 byte
+}
+
+// New creates a new flow control monitor. Instantaneous transfer rate is
+// measured and updated for each sampleRate interval. windowSize determines the
+// weight of each sample in the exponential moving average (EMA) calculation.
+// The exact formulas are:
+//
+// sampleTime = currentTime - prevSampleTime
+// sampleRate = byteCount / sampleTime
+// weight = 1 - exp(-sampleTime/windowSize)
+// newRate = weight*sampleRate + (1-weight)*oldRate
+//
+// The default values for sampleRate and windowSize (if <= 0) are 100ms and 1s,
+// respectively.
+func New(sampleRate, windowSize time.Duration) *Monitor {
+ if sampleRate = clockRound(sampleRate); sampleRate <= 0 {
+ sampleRate = 5 * clockRate
+ }
+ if windowSize <= 0 {
+ windowSize = 1 * time.Second
+ }
+ now := clock()
+ return &Monitor{
+ active: true,
+ start: now,
+ rWindow: windowSize.Seconds(),
+ sLast: now,
+ sRate: sampleRate,
+ tLast: now,
+ }
+}
+
+// Update records the transfer of n bytes and returns n. It should be called
+// after each Read/Write operation, even if n is 0.
+func (m *Monitor) Update(n int) int {
+ m.mu.Lock()
+ m.update(n)
+ m.mu.Unlock()
+ return n
+}
+
+// IO is a convenience method intended to wrap io.Reader and io.Writer method
+// execution. It calls m.Update(n) and then returns (n, err) unmodified.
+func (m *Monitor) IO(n int, err error) (int, error) {
+ return m.Update(n), err
+}
+
+// Done marks the transfer as finished and prevents any further updates or
+// limiting. Instantaneous and current transfer rates drop to 0. Update, IO, and
+// Limit methods become NOOPs. It returns the total number of bytes transferred.
+func (m *Monitor) Done() int64 {
+ m.mu.Lock()
+ if now := m.update(0); m.sBytes > 0 {
+ m.reset(now)
+ }
+ m.active = false
+ m.tLast = 0
+ n := m.bytes
+ m.mu.Unlock()
+ return n
+}
+
+// timeRemLimit is the maximum Status.TimeRem value.
+const timeRemLimit = 999*time.Hour + 59*time.Minute + 59*time.Second
+
+// Status represents the current Monitor status. All transfer rates are in bytes
+// per second rounded to the nearest byte.
+type Status struct {
+ Active bool // Flag indicating an active transfer
+ Start time.Time // Transfer start time
+ Duration time.Duration // Time period covered by the statistics
+ Idle time.Duration // Time since the last transfer of at least 1 byte
+ Bytes int64 // Total number of bytes transferred
+ Samples int64 // Total number of samples taken
+ InstRate int64 // Instantaneous transfer rate
+ CurRate int64 // Current transfer rate (EMA of InstRate)
+ AvgRate int64 // Average transfer rate (Bytes / Duration)
+ PeakRate int64 // Maximum instantaneous transfer rate
+ BytesRem int64 // Number of bytes remaining in the transfer
+ TimeRem time.Duration // Estimated time to completion
+ Progress Percent // Overall transfer progress
+}
+
+// Status returns current transfer status information. The returned value
+// becomes static after a call to Done.
+func (m *Monitor) Status() Status {
+ m.mu.Lock()
+ now := m.update(0)
+ s := Status{
+ Active: m.active,
+ Start: clockToTime(m.start),
+ Duration: m.sLast - m.start,
+ Idle: now - m.tLast,
+ Bytes: m.bytes,
+ Samples: m.samples,
+ PeakRate: round(m.rPeak),
+ BytesRem: m.tBytes - m.bytes,
+ Progress: percentOf(float64(m.bytes), float64(m.tBytes)),
+ }
+ if s.BytesRem < 0 {
+ s.BytesRem = 0
+ }
+ if s.Duration > 0 {
+ rAvg := float64(s.Bytes) / s.Duration.Seconds()
+ s.AvgRate = round(rAvg)
+ if s.Active {
+ s.InstRate = round(m.rSample)
+ s.CurRate = round(m.rEMA)
+ if s.BytesRem > 0 {
+ if tRate := 0.8*m.rEMA + 0.2*rAvg; tRate > 0 {
+ ns := float64(s.BytesRem) / tRate * 1e9
+ if ns > float64(timeRemLimit) {
+ ns = float64(timeRemLimit)
+ }
+ s.TimeRem = clockRound(time.Duration(ns))
+ }
+ }
+ }
+ }
+ m.mu.Unlock()
+ return s
+}
+
+// Limit restricts the instantaneous (per-sample) data flow to rate bytes per
+// second. It returns the maximum number of bytes (0 <= n <= want) that may be
+// transferred immediately without exceeding the limit. If block == true, the
+// call blocks until n > 0. want is returned unmodified if want < 1, rate < 1,
+// or the transfer is inactive (after a call to Done).
+//
+// At least one byte is always allowed to be transferred in any given sampling
+// period. Thus, if the sampling rate is 100ms, the lowest achievable flow rate
+// is 10 bytes per second.
+//
+// For usage examples, see the implementation of Reader and Writer in io.go.
+func (m *Monitor) Limit(want int, rate int64, block bool) (n int) {
+ if want < 1 || rate < 1 {
+ return want
+ }
+ m.mu.Lock()
+
+ // Determine the maximum number of bytes that can be sent in one sample
+ limit := round(float64(rate) * m.sRate.Seconds())
+ if limit <= 0 {
+ limit = 1
+ }
+
+ // If block == true, wait until m.sBytes < limit
+ if now := m.update(0); block {
+ for m.sBytes >= limit && m.active {
+ now = m.waitNextSample(now)
+ }
+ }
+
+ // Make limit <= want (unlimited if the transfer is no longer active)
+ if limit -= m.sBytes; limit > int64(want) || !m.active {
+ limit = int64(want)
+ }
+ m.mu.Unlock()
+
+ if limit < 0 {
+ limit = 0
+ }
+ return int(limit)
+}
+
+// SetTransferSize specifies the total size of the data transfer, which allows
+// the Monitor to calculate the overall progress and time to completion.
+func (m *Monitor) SetTransferSize(bytes int64) {
+ if bytes < 0 {
+ bytes = 0
+ }
+ m.mu.Lock()
+ m.tBytes = bytes
+ m.mu.Unlock()
+}
+
+// update accumulates the transferred byte count for the current sample until
+// clock() - m.sLast >= m.sRate. The monitor status is updated once the current
+// sample is done.
+func (m *Monitor) update(n int) (now time.Duration) {
+ if !m.active {
+ return
+ }
+ if now = clock(); n > 0 {
+ m.tLast = now
+ }
+ m.sBytes += int64(n)
+ if sTime := now - m.sLast; sTime >= m.sRate {
+ t := sTime.Seconds()
+ if m.rSample = float64(m.sBytes) / t; m.rSample > m.rPeak {
+ m.rPeak = m.rSample
+ }
+
+ // Exponential moving average using a method similar to *nix load
+ // average calculation. Longer sampling periods carry greater weight.
+ if m.samples > 0 {
+ w := math.Exp(-t / m.rWindow)
+ m.rEMA = m.rSample + w*(m.rEMA-m.rSample)
+ } else {
+ m.rEMA = m.rSample
+ }
+ m.reset(now)
+ }
+ return
+}
+
+// reset clears the current sample state in preparation for the next sample.
+func (m *Monitor) reset(sampleTime time.Duration) {
+ m.bytes += m.sBytes
+ m.samples++
+ m.sBytes = 0
+ m.sLast = sampleTime
+}
+
+// waitNextSample sleeps for the remainder of the current sample. The lock is
+// released and reacquired during the actual sleep period, so it's possible for
+// the transfer to be inactive when this method returns.
+func (m *Monitor) waitNextSample(now time.Duration) time.Duration {
+ const minWait = 5 * time.Millisecond
+ current := m.sLast
+
+ // sleep until the last sample time changes (ideally, just one iteration)
+ for m.sLast == current && m.active {
+ d := current + m.sRate - now
+ m.mu.Unlock()
+ if d < minWait {
+ d = minWait
+ }
+ time.Sleep(d)
+ m.mu.Lock()
+ now = m.update(0)
+ }
+ return now
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/mxk/go1/flowcontrol/io.go b/Godeps/_workspace/src/code.google.com/p/mxk/go1/flowcontrol/io.go
new file mode 100644
index 0000000000000000000000000000000000000000..12a753ddf95497f686ac3274e3bbe067f44de497
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/mxk/go1/flowcontrol/io.go
@@ -0,0 +1,133 @@
+//
+// Written by Maxim Khitrov (November 2012)
+//
+
+package flowcontrol
+
+import (
+ "errors"
+ "io"
+)
+
+// ErrLimit is returned by the Writer when a non-blocking write is short due to
+// the transfer rate limit.
+var ErrLimit = errors.New("flowcontrol: transfer rate limit exceeded")
+
+// Limiter is implemented by the Reader and Writer to provide a consistent
+// interface for monitoring and controlling data transfer.
+type Limiter interface {
+ Done() int64
+ Status() Status
+ SetTransferSize(bytes int64)
+ SetLimit(new int64) (old int64)
+ SetBlocking(new bool) (old bool)
+}
+
+// Reader implements io.ReadCloser with a restriction on the rate of data
+// transfer.
+type Reader struct {
+ io.Reader // Data source
+ *Monitor // Flow control monitor
+
+ limit int64 // Rate limit in bytes per second (unlimited when <= 0)
+ block bool // What to do when no new bytes can be read due to the limit
+}
+
+// NewReader restricts all Read operations on r to limit bytes per second.
+func NewReader(r io.Reader, limit int64) *Reader {
+ return &Reader{r, New(0, 0), limit, true}
+}
+
+// Read reads up to len(p) bytes into p without exceeding the current transfer
+// rate limit. It returns (0, nil) immediately if r is non-blocking and no new
+// bytes can be read at this time.
+func (r *Reader) Read(p []byte) (n int, err error) {
+ p = p[:r.Limit(len(p), r.limit, r.block)]
+ if len(p) > 0 {
+ n, err = r.IO(r.Reader.Read(p))
+ }
+ return
+}
+
+// SetLimit changes the transfer rate limit to new bytes per second and returns
+// the previous setting.
+func (r *Reader) SetLimit(new int64) (old int64) {
+ old, r.limit = r.limit, new
+ return
+}
+
+// SetBlocking changes the blocking behavior and returns the previous setting. A
+// Read call on a non-blocking reader returns immediately if no additional bytes
+// may be read at this time due to the rate limit.
+func (r *Reader) SetBlocking(new bool) (old bool) {
+ old, r.block = r.block, new
+ return
+}
+
+// Close closes the underlying reader if it implements the io.Closer interface.
+func (r *Reader) Close() error {
+ defer r.Done()
+ if c, ok := r.Reader.(io.Closer); ok {
+ return c.Close()
+ }
+ return nil
+}
+
+// Writer implements io.WriteCloser with a restriction on the rate of data
+// transfer.
+type Writer struct {
+ io.Writer // Data destination
+ *Monitor // Flow control monitor
+
+ limit int64 // Rate limit in bytes per second (unlimited when <= 0)
+ block bool // What to do when no new bytes can be written due to the limit
+}
+
+// NewWriter restricts all Write operations on w to limit bytes per second. The
+// transfer rate and the default blocking behavior (true) can be changed
+// directly on the returned *Writer.
+func NewWriter(w io.Writer, limit int64) *Writer {
+ return &Writer{w, New(0, 0), limit, true}
+}
+
+// Write writes len(p) bytes from p to the underlying data stream without
+// exceeding the current transfer rate limit. It returns (n, ErrLimit) if w is
+// non-blocking and no additional bytes can be written at this time.
+func (w *Writer) Write(p []byte) (n int, err error) {
+ var c int
+ for len(p) > 0 && err == nil {
+ s := p[:w.Limit(len(p), w.limit, w.block)]
+ if len(s) > 0 {
+ c, err = w.IO(w.Writer.Write(s))
+ } else {
+ return n, ErrLimit
+ }
+ p = p[c:]
+ n += c
+ }
+ return
+}
+
+// SetLimit changes the transfer rate limit to new bytes per second and returns
+// the previous setting.
+func (w *Writer) SetLimit(new int64) (old int64) {
+ old, w.limit = w.limit, new
+ return
+}
+
+// SetBlocking changes the blocking behavior and returns the previous setting. A
+// Write call on a non-blocking writer returns as soon as no additional bytes
+// may be written at this time due to the rate limit.
+func (w *Writer) SetBlocking(new bool) (old bool) {
+ old, w.block = w.block, new
+ return
+}
+
+// Close closes the underlying writer if it implements the io.Closer interface.
+func (w *Writer) Close() error {
+ defer w.Done()
+ if c, ok := w.Writer.(io.Closer); ok {
+ return c.Close()
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/mxk/go1/flowcontrol/io_test.go b/Godeps/_workspace/src/code.google.com/p/mxk/go1/flowcontrol/io_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..3180693666284fd530657aa12846c94918f477a3
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/mxk/go1/flowcontrol/io_test.go
@@ -0,0 +1,146 @@
+//
+// Written by Maxim Khitrov (November 2012)
+//
+
+package flowcontrol
+
+import (
+ "bytes"
+ "reflect"
+ "testing"
+ "time"
+)
+
+const (
+ _50ms = 50 * time.Millisecond
+ _100ms = 100 * time.Millisecond
+ _200ms = 200 * time.Millisecond
+ _300ms = 300 * time.Millisecond
+ _400ms = 400 * time.Millisecond
+ _500ms = 500 * time.Millisecond
+)
+
+func nextStatus(m *Monitor) Status {
+ samples := m.samples
+ for i := 0; i < 30; i++ {
+ if s := m.Status(); s.Samples != samples {
+ return s
+ }
+ time.Sleep(5 * time.Millisecond)
+ }
+ return m.Status()
+}
+
+func TestReader(t *testing.T) {
+ in := make([]byte, 100)
+ for i := range in {
+ in[i] = byte(i)
+ }
+ b := make([]byte, 100)
+ r := NewReader(bytes.NewReader(in), 100)
+ start := time.Now()
+
+ // Make sure r implements Limiter
+ _ = Limiter(r)
+
+ // 1st read of 10 bytes is performed immediately
+ if n, err := r.Read(b); n != 10 || err != nil {
+ t.Fatalf("r.Read(b) expected 10 (<nil>); got %v (%v)", n, err)
+ } else if rt := time.Since(start); rt > _50ms {
+ t.Fatalf("r.Read(b) took too long (%v)", rt)
+ }
+
+ // No new Reads allowed in the current sample
+ r.SetBlocking(false)
+ if n, err := r.Read(b); n != 0 || err != nil {
+ t.Fatalf("r.Read(b) expected 0 (<nil>); got %v (%v)", n, err)
+ } else if rt := time.Since(start); rt > _50ms {
+ t.Fatalf("r.Read(b) took too long (%v)", rt)
+ }
+
+ status := [6]Status{0: r.Status()} // No samples in the first status
+
+ // 2nd read of 10 bytes blocks until the next sample
+ r.SetBlocking(true)
+ if n, err := r.Read(b[10:]); n != 10 || err != nil {
+ t.Fatalf("r.Read(b[10:]) expected 10 (<nil>); got %v (%v)", n, err)
+ } else if rt := time.Since(start); rt < _100ms {
+ t.Fatalf("r.Read(b[10:]) returned ahead of time (%v)", rt)
+ }
+
+ status[1] = r.Status() // 1st sample
+ status[2] = nextStatus(r.Monitor) // 2nd sample
+ status[3] = nextStatus(r.Monitor) // No activity for the 3rd sample
+
+ if n := r.Done(); n != 20 {
+ t.Fatalf("r.Done() expected 20; got %v", n)
+ }
+
+ status[4] = r.Status()
+ status[5] = nextStatus(r.Monitor) // Timeout
+ start = status[0].Start
+
+ // Active, Start, Duration, Idle, Bytes, Samples, InstRate, CurRate, AvgRate, PeakRate, BytesRem, TimeRem, Progress
+ want := []Status{
+ Status{true, start, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ Status{true, start, _100ms, 0, 10, 1, 100, 100, 100, 100, 0, 0, 0},
+ Status{true, start, _200ms, _100ms, 20, 2, 100, 100, 100, 100, 0, 0, 0},
+ Status{true, start, _300ms, _200ms, 20, 3, 0, 90, 67, 100, 0, 0, 0},
+ Status{false, start, _300ms, 0, 20, 3, 0, 0, 67, 100, 0, 0, 0},
+ Status{false, start, _300ms, 0, 20, 3, 0, 0, 67, 100, 0, 0, 0},
+ }
+ for i, s := range status {
+ if !reflect.DeepEqual(&s, &want[i]) {
+ t.Errorf("r.Status(%v) expected %v; got %v", i, want[i], s)
+ }
+ }
+ if !bytes.Equal(b[:20], in[:20]) {
+ t.Errorf("r.Read() input doesn't match output")
+ }
+}
+
+func TestWriter(t *testing.T) {
+ b := make([]byte, 100)
+ for i := range b {
+ b[i] = byte(i)
+ }
+ w := NewWriter(&bytes.Buffer{}, 200)
+ start := time.Now()
+
+ // Make sure w implements Limiter
+ _ = Limiter(w)
+
+ // Non-blocking 20-byte write for the first sample returns ErrLimit
+ w.SetBlocking(false)
+ if n, err := w.Write(b); n != 20 || err != ErrLimit {
+ t.Fatalf("w.Write(b) expected 20 (ErrLimit); got %v (%v)", n, err)
+ } else if rt := time.Since(start); rt > _50ms {
+ t.Fatalf("w.Write(b) took too long (%v)", rt)
+ }
+
+ // Blocking 80-byte write
+ w.SetBlocking(true)
+ if n, err := w.Write(b[20:]); n != 80 || err != nil {
+ t.Fatalf("w.Write(b[20:]) expected 80 (<nil>); got %v (%v)", n, err)
+ } else if rt := time.Since(start); rt < _400ms {
+ t.Fatalf("w.Write(b[20:]) returned ahead of time (%v)", rt)
+ }
+
+ w.SetTransferSize(100)
+ status := []Status{w.Status(), nextStatus(w.Monitor)}
+ start = status[0].Start
+
+ // Active, Start, Duration, Idle, Bytes, Samples, InstRate, CurRate, AvgRate, PeakRate, BytesRem, TimeRem, Progress
+ want := []Status{
+ Status{true, start, _400ms, 0, 80, 4, 200, 200, 200, 200, 20, _100ms, 80000},
+ Status{true, start, _500ms, _100ms, 100, 5, 200, 200, 200, 200, 0, 0, 100000},
+ }
+ for i, s := range status {
+ if !reflect.DeepEqual(&s, &want[i]) {
+ t.Errorf("w.Status(%v) expected %v; got %v", i, want[i], s)
+ }
+ }
+ if !bytes.Equal(b, w.Writer.(*bytes.Buffer).Bytes()) {
+ t.Errorf("w.Write() input doesn't match output")
+ }
+}
diff --git a/Godeps/_workspace/src/code.google.com/p/mxk/go1/flowcontrol/util.go b/Godeps/_workspace/src/code.google.com/p/mxk/go1/flowcontrol/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..91efd8815f5b1adaaaa0f98b3f070980ed9243ce
--- /dev/null
+++ b/Godeps/_workspace/src/code.google.com/p/mxk/go1/flowcontrol/util.go
@@ -0,0 +1,67 @@
+//
+// Written by Maxim Khitrov (November 2012)
+//
+
+package flowcontrol
+
+import (
+ "math"
+ "strconv"
+ "time"
+)
+
+// clockRate is the resolution and precision of clock().
+const clockRate = 20 * time.Millisecond
+
+// czero is the process start time rounded down to the nearest clockRate
+// increment.
+var czero = time.Duration(time.Now().UnixNano()) / clockRate * clockRate
+
+// clock returns a low resolution timestamp relative to the process start time.
+func clock() time.Duration {
+ return time.Duration(time.Now().UnixNano())/clockRate*clockRate - czero
+}
+
+// clockToTime converts a clock() timestamp to an absolute time.Time value.
+func clockToTime(c time.Duration) time.Time {
+ return time.Unix(0, int64(czero+c))
+}
+
+// clockRound returns d rounded to the nearest clockRate increment.
+func clockRound(d time.Duration) time.Duration {
+ return (d + clockRate>>1) / clockRate * clockRate
+}
+
+// round returns x rounded to the nearest int64 (non-negative values only).
+func round(x float64) int64 {
+ if _, frac := math.Modf(x); frac >= 0.5 {
+ return int64(math.Ceil(x))
+ }
+ return int64(math.Floor(x))
+}
+
+// Percent represents a percentage in increments of 1/1000th of a percent.
+type Percent uint32
+
+// percentOf calculates what percent of the total is x.
+func percentOf(x, total float64) Percent {
+ if x < 0 || total <= 0 {
+ return 0
+ } else if p := round(x / total * 1e5); p <= math.MaxUint32 {
+ return Percent(p)
+ }
+ return Percent(math.MaxUint32)
+}
+
+func (p Percent) Float() float64 {
+ return float64(p) * 1e-3
+}
+
+func (p Percent) String() string {
+ var buf [12]byte
+ b := strconv.AppendUint(buf[:0], uint64(p)/1000, 10)
+ n := len(b)
+ b = strconv.AppendUint(b, 1000+uint64(p)%1000, 10)
+ b[n] = '.'
+ return string(append(b, '%'))
+}
diff --git a/Godeps/_workspace/src/github.com/agl/ed25519/edwards25519/const.go b/Godeps/_workspace/src/github.com/agl/ed25519/edwards25519/const.go
new file mode 100644
index 0000000000000000000000000000000000000000..ea5b77a710e73c79c168762567a547b80c9912ed
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/agl/ed25519/edwards25519/const.go
@@ -0,0 +1,1411 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package edwards25519
+
+var d = FieldElement{
+ -10913610, 13857413, -15372611, 6949391, 114729, -8787816, -6275908, -3247719, -18696448, -12055116,
+}
+
+var d2 = FieldElement{
+ -21827239, -5839606, -30745221, 13898782, 229458, 15978800, -12551817, -6495438, 29715968, 9444199,
+}
+
+var SqrtM1 = FieldElement{
+ -32595792, -7943725, 9377950, 3500415, 12389472, -272473, -25146209, -2005654, 326686, 11406482,
+}
+
+var A = FieldElement{
+ 486662, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+}
+
+var bi = [8]PreComputedGroupElement{
+ {
+ FieldElement{25967493, -14356035, 29566456, 3660896, -12694345, 4014787, 27544626, -11754271, -6079156, 2047605},
+ FieldElement{-12545711, 934262, -2722910, 3049990, -727428, 9406986, 12720692, 5043384, 19500929, -15469378},
+ FieldElement{-8738181, 4489570, 9688441, -14785194, 10184609, -12363380, 29287919, 11864899, -24514362, -4438546},
+ },
+ {
+ FieldElement{15636291, -9688557, 24204773, -7912398, 616977, -16685262, 27787600, -14772189, 28944400, -1550024},
+ FieldElement{16568933, 4717097, -11556148, -1102322, 15682896, -11807043, 16354577, -11775962, 7689662, 11199574},
+ FieldElement{30464156, -5976125, -11779434, -15670865, 23220365, 15915852, 7512774, 10017326, -17749093, -9920357},
+ },
+ {
+ FieldElement{10861363, 11473154, 27284546, 1981175, -30064349, 12577861, 32867885, 14515107, -15438304, 10819380},
+ FieldElement{4708026, 6336745, 20377586, 9066809, -11272109, 6594696, -25653668, 12483688, -12668491, 5581306},
+ FieldElement{19563160, 16186464, -29386857, 4097519, 10237984, -4348115, 28542350, 13850243, -23678021, -15815942},
+ },
+ {
+ FieldElement{5153746, 9909285, 1723747, -2777874, 30523605, 5516873, 19480852, 5230134, -23952439, -15175766},
+ FieldElement{-30269007, -3463509, 7665486, 10083793, 28475525, 1649722, 20654025, 16520125, 30598449, 7715701},
+ FieldElement{28881845, 14381568, 9657904, 3680757, -20181635, 7843316, -31400660, 1370708, 29794553, -1409300},
+ },
+ {
+ FieldElement{-22518993, -6692182, 14201702, -8745502, -23510406, 8844726, 18474211, -1361450, -13062696, 13821877},
+ FieldElement{-6455177, -7839871, 3374702, -4740862, -27098617, -10571707, 31655028, -7212327, 18853322, -14220951},
+ FieldElement{4566830, -12963868, -28974889, -12240689, -7602672, -2830569, -8514358, -10431137, 2207753, -3209784},
+ },
+ {
+ FieldElement{-25154831, -4185821, 29681144, 7868801, -6854661, -9423865, -12437364, -663000, -31111463, -16132436},
+ FieldElement{25576264, -2703214, 7349804, -11814844, 16472782, 9300885, 3844789, 15725684, 171356, 6466918},
+ FieldElement{23103977, 13316479, 9739013, -16149481, 817875, -15038942, 8965339, -14088058, -30714912, 16193877},
+ },
+ {
+ FieldElement{-33521811, 3180713, -2394130, 14003687, -16903474, -16270840, 17238398, 4729455, -18074513, 9256800},
+ FieldElement{-25182317, -4174131, 32336398, 5036987, -21236817, 11360617, 22616405, 9761698, -19827198, 630305},
+ FieldElement{-13720693, 2639453, -24237460, -7406481, 9494427, -5774029, -6554551, -15960994, -2449256, -14291300},
+ },
+ {
+ FieldElement{-3151181, -5046075, 9282714, 6866145, -31907062, -863023, -18940575, 15033784, 25105118, -7894876},
+ FieldElement{-24326370, 15950226, -31801215, -14592823, -11662737, -5090925, 1573892, -2625887, 2198790, -15804619},
+ FieldElement{-3099351, 10324967, -2241613, 7453183, -5446979, -2735503, -13812022, -16236442, -32461234, -12290683},
+ },
+}
+
+var base = [32][8]PreComputedGroupElement{
+ {
+ {
+ FieldElement{25967493, -14356035, 29566456, 3660896, -12694345, 4014787, 27544626, -11754271, -6079156, 2047605},
+ FieldElement{-12545711, 934262, -2722910, 3049990, -727428, 9406986, 12720692, 5043384, 19500929, -15469378},
+ FieldElement{-8738181, 4489570, 9688441, -14785194, 10184609, -12363380, 29287919, 11864899, -24514362, -4438546},
+ },
+ {
+ FieldElement{-12815894, -12976347, -21581243, 11784320, -25355658, -2750717, -11717903, -3814571, -358445, -10211303},
+ FieldElement{-21703237, 6903825, 27185491, 6451973, -29577724, -9554005, -15616551, 11189268, -26829678, -5319081},
+ FieldElement{26966642, 11152617, 32442495, 15396054, 14353839, -12752335, -3128826, -9541118, -15472047, -4166697},
+ },
+ {
+ FieldElement{15636291, -9688557, 24204773, -7912398, 616977, -16685262, 27787600, -14772189, 28944400, -1550024},
+ FieldElement{16568933, 4717097, -11556148, -1102322, 15682896, -11807043, 16354577, -11775962, 7689662, 11199574},
+ FieldElement{30464156, -5976125, -11779434, -15670865, 23220365, 15915852, 7512774, 10017326, -17749093, -9920357},
+ },
+ {
+ FieldElement{-17036878, 13921892, 10945806, -6033431, 27105052, -16084379, -28926210, 15006023, 3284568, -6276540},
+ FieldElement{23599295, -8306047, -11193664, -7687416, 13236774, 10506355, 7464579, 9656445, 13059162, 10374397},
+ FieldElement{7798556, 16710257, 3033922, 2874086, 28997861, 2835604, 32406664, -3839045, -641708, -101325},
+ },
+ {
+ FieldElement{10861363, 11473154, 27284546, 1981175, -30064349, 12577861, 32867885, 14515107, -15438304, 10819380},
+ FieldElement{4708026, 6336745, 20377586, 9066809, -11272109, 6594696, -25653668, 12483688, -12668491, 5581306},
+ FieldElement{19563160, 16186464, -29386857, 4097519, 10237984, -4348115, 28542350, 13850243, -23678021, -15815942},
+ },
+ {
+ FieldElement{-15371964, -12862754, 32573250, 4720197, -26436522, 5875511, -19188627, -15224819, -9818940, -12085777},
+ FieldElement{-8549212, 109983, 15149363, 2178705, 22900618, 4543417, 3044240, -15689887, 1762328, 14866737},
+ FieldElement{-18199695, -15951423, -10473290, 1707278, -17185920, 3916101, -28236412, 3959421, 27914454, 4383652},
+ },
+ {
+ FieldElement{5153746, 9909285, 1723747, -2777874, 30523605, 5516873, 19480852, 5230134, -23952439, -15175766},
+ FieldElement{-30269007, -3463509, 7665486, 10083793, 28475525, 1649722, 20654025, 16520125, 30598449, 7715701},
+ FieldElement{28881845, 14381568, 9657904, 3680757, -20181635, 7843316, -31400660, 1370708, 29794553, -1409300},
+ },
+ {
+ FieldElement{14499471, -2729599, -33191113, -4254652, 28494862, 14271267, 30290735, 10876454, -33154098, 2381726},
+ FieldElement{-7195431, -2655363, -14730155, 462251, -27724326, 3941372, -6236617, 3696005, -32300832, 15351955},
+ FieldElement{27431194, 8222322, 16448760, -3907995, -18707002, 11938355, -32961401, -2970515, 29551813, 10109425},
+ },
+ },
+ {
+ {
+ FieldElement{-13657040, -13155431, -31283750, 11777098, 21447386, 6519384, -2378284, -1627556, 10092783, -4764171},
+ FieldElement{27939166, 14210322, 4677035, 16277044, -22964462, -12398139, -32508754, 12005538, -17810127, 12803510},
+ FieldElement{17228999, -15661624, -1233527, 300140, -1224870, -11714777, 30364213, -9038194, 18016357, 4397660},
+ },
+ {
+ FieldElement{-10958843, -7690207, 4776341, -14954238, 27850028, -15602212, -26619106, 14544525, -17477504, 982639},
+ FieldElement{29253598, 15796703, -2863982, -9908884, 10057023, 3163536, 7332899, -4120128, -21047696, 9934963},
+ FieldElement{5793303, 16271923, -24131614, -10116404, 29188560, 1206517, -14747930, 4559895, -30123922, -10897950},
+ },
+ {
+ FieldElement{-27643952, -11493006, 16282657, -11036493, 28414021, -15012264, 24191034, 4541697, -13338309, 5500568},
+ FieldElement{12650548, -1497113, 9052871, 11355358, -17680037, -8400164, -17430592, 12264343, 10874051, 13524335},
+ FieldElement{25556948, -3045990, 714651, 2510400, 23394682, -10415330, 33119038, 5080568, -22528059, 5376628},
+ },
+ {
+ FieldElement{-26088264, -4011052, -17013699, -3537628, -6726793, 1920897, -22321305, -9447443, 4535768, 1569007},
+ FieldElement{-2255422, 14606630, -21692440, -8039818, 28430649, 8775819, -30494562, 3044290, 31848280, 12543772},
+ FieldElement{-22028579, 2943893, -31857513, 6777306, 13784462, -4292203, -27377195, -2062731, 7718482, 14474653},
+ },
+ {
+ FieldElement{2385315, 2454213, -22631320, 46603, -4437935, -15680415, 656965, -7236665, 24316168, -5253567},
+ FieldElement{13741529, 10911568, -33233417, -8603737, -20177830, -1033297, 33040651, -13424532, -20729456, 8321686},
+ FieldElement{21060490, -2212744, 15712757, -4336099, 1639040, 10656336, 23845965, -11874838, -9984458, 608372},
+ },
+ {
+ FieldElement{-13672732, -15087586, -10889693, -7557059, -6036909, 11305547, 1123968, -6780577, 27229399, 23887},
+ FieldElement{-23244140, -294205, -11744728, 14712571, -29465699, -2029617, 12797024, -6440308, -1633405, 16678954},
+ FieldElement{-29500620, 4770662, -16054387, 14001338, 7830047, 9564805, -1508144, -4795045, -17169265, 4904953},
+ },
+ {
+ FieldElement{24059557, 14617003, 19037157, -15039908, 19766093, -14906429, 5169211, 16191880, 2128236, -4326833},
+ FieldElement{-16981152, 4124966, -8540610, -10653797, 30336522, -14105247, -29806336, 916033, -6882542, -2986532},
+ FieldElement{-22630907, 12419372, -7134229, -7473371, -16478904, 16739175, 285431, 2763829, 15736322, 4143876},
+ },
+ {
+ FieldElement{2379352, 11839345, -4110402, -5988665, 11274298, 794957, 212801, -14594663, 23527084, -16458268},
+ FieldElement{33431127, -11130478, -17838966, -15626900, 8909499, 8376530, -32625340, 4087881, -15188911, -14416214},
+ FieldElement{1767683, 7197987, -13205226, -2022635, -13091350, 448826, 5799055, 4357868, -4774191, -16323038},
+ },
+ },
+ {
+ {
+ FieldElement{6721966, 13833823, -23523388, -1551314, 26354293, -11863321, 23365147, -3949732, 7390890, 2759800},
+ FieldElement{4409041, 2052381, 23373853, 10530217, 7676779, -12885954, 21302353, -4264057, 1244380, -12919645},
+ FieldElement{-4421239, 7169619, 4982368, -2957590, 30256825, -2777540, 14086413, 9208236, 15886429, 16489664},
+ },
+ {
+ FieldElement{1996075, 10375649, 14346367, 13311202, -6874135, -16438411, -13693198, 398369, -30606455, -712933},
+ FieldElement{-25307465, 9795880, -2777414, 14878809, -33531835, 14780363, 13348553, 12076947, -30836462, 5113182},
+ FieldElement{-17770784, 11797796, 31950843, 13929123, -25888302, 12288344, -30341101, -7336386, 13847711, 5387222},
+ },
+ {
+ FieldElement{-18582163, -3416217, 17824843, -2340966, 22744343, -10442611, 8763061, 3617786, -19600662, 10370991},
+ FieldElement{20246567, -14369378, 22358229, -543712, 18507283, -10413996, 14554437, -8746092, 32232924, 16763880},
+ FieldElement{9648505, 10094563, 26416693, 14745928, -30374318, -6472621, 11094161, 15689506, 3140038, -16510092},
+ },
+ {
+ FieldElement{-16160072, 5472695, 31895588, 4744994, 8823515, 10365685, -27224800, 9448613, -28774454, 366295},
+ FieldElement{19153450, 11523972, -11096490, -6503142, -24647631, 5420647, 28344573, 8041113, 719605, 11671788},
+ FieldElement{8678025, 2694440, -6808014, 2517372, 4964326, 11152271, -15432916, -15266516, 27000813, -10195553},
+ },
+ {
+ FieldElement{-15157904, 7134312, 8639287, -2814877, -7235688, 10421742, 564065, 5336097, 6750977, -14521026},
+ FieldElement{11836410, -3979488, 26297894, 16080799, 23455045, 15735944, 1695823, -8819122, 8169720, 16220347},
+ FieldElement{-18115838, 8653647, 17578566, -6092619, -8025777, -16012763, -11144307, -2627664, -5990708, -14166033},
+ },
+ {
+ FieldElement{-23308498, -10968312, 15213228, -10081214, -30853605, -11050004, 27884329, 2847284, 2655861, 1738395},
+ FieldElement{-27537433, -14253021, -25336301, -8002780, -9370762, 8129821, 21651608, -3239336, -19087449, -11005278},
+ FieldElement{1533110, 3437855, 23735889, 459276, 29970501, 11335377, 26030092, 5821408, 10478196, 8544890},
+ },
+ {
+ FieldElement{32173121, -16129311, 24896207, 3921497, 22579056, -3410854, 19270449, 12217473, 17789017, -3395995},
+ FieldElement{-30552961, -2228401, -15578829, -10147201, 13243889, 517024, 15479401, -3853233, 30460520, 1052596},
+ FieldElement{-11614875, 13323618, 32618793, 8175907, -15230173, 12596687, 27491595, -4612359, 3179268, -9478891},
+ },
+ {
+ FieldElement{31947069, -14366651, -4640583, -15339921, -15125977, -6039709, -14756777, -16411740, 19072640, -9511060},
+ FieldElement{11685058, 11822410, 3158003, -13952594, 33402194, -4165066, 5977896, -5215017, 473099, 5040608},
+ FieldElement{-20290863, 8198642, -27410132, 11602123, 1290375, -2799760, 28326862, 1721092, -19558642, -3131606},
+ },
+ },
+ {
+ {
+ FieldElement{7881532, 10687937, 7578723, 7738378, -18951012, -2553952, 21820786, 8076149, -27868496, 11538389},
+ FieldElement{-19935666, 3899861, 18283497, -6801568, -15728660, -11249211, 8754525, 7446702, -5676054, 5797016},
+ FieldElement{-11295600, -3793569, -15782110, -7964573, 12708869, -8456199, 2014099, -9050574, -2369172, -5877341},
+ },
+ {
+ FieldElement{-22472376, -11568741, -27682020, 1146375, 18956691, 16640559, 1192730, -3714199, 15123619, 10811505},
+ FieldElement{14352098, -3419715, -18942044, 10822655, 32750596, 4699007, -70363, 15776356, -28886779, -11974553},
+ FieldElement{-28241164, -8072475, -4978962, -5315317, 29416931, 1847569, -20654173, -16484855, 4714547, -9600655},
+ },
+ {
+ FieldElement{15200332, 8368572, 19679101, 15970074, -31872674, 1959451, 24611599, -4543832, -11745876, 12340220},
+ FieldElement{12876937, -10480056, 33134381, 6590940, -6307776, 14872440, 9613953, 8241152, 15370987, 9608631},
+ FieldElement{-4143277, -12014408, 8446281, -391603, 4407738, 13629032, -7724868, 15866074, -28210621, -8814099},
+ },
+ {
+ FieldElement{26660628, -15677655, 8393734, 358047, -7401291, 992988, -23904233, 858697, 20571223, 8420556},
+ FieldElement{14620715, 13067227, -15447274, 8264467, 14106269, 15080814, 33531827, 12516406, -21574435, -12476749},
+ FieldElement{236881, 10476226, 57258, -14677024, 6472998, 2466984, 17258519, 7256740, 8791136, 15069930},
+ },
+ {
+ FieldElement{1276410, -9371918, 22949635, -16322807, -23493039, -5702186, 14711875, 4874229, -30663140, -2331391},
+ FieldElement{5855666, 4990204, -13711848, 7294284, -7804282, 1924647, -1423175, -7912378, -33069337, 9234253},
+ FieldElement{20590503, -9018988, 31529744, -7352666, -2706834, 10650548, 31559055, -11609587, 18979186, 13396066},
+ },
+ {
+ FieldElement{24474287, 4968103, 22267082, 4407354, 24063882, -8325180, -18816887, 13594782, 33514650, 7021958},
+ FieldElement{-11566906, -6565505, -21365085, 15928892, -26158305, 4315421, -25948728, -3916677, -21480480, 12868082},
+ FieldElement{-28635013, 13504661, 19988037, -2132761, 21078225, 6443208, -21446107, 2244500, -12455797, -8089383},
+ },
+ {
+ FieldElement{-30595528, 13793479, -5852820, 319136, -25723172, -6263899, 33086546, 8957937, -15233648, 5540521},
+ FieldElement{-11630176, -11503902, -8119500, -7643073, 2620056, 1022908, -23710744, -1568984, -16128528, -14962807},
+ FieldElement{23152971, 775386, 27395463, 14006635, -9701118, 4649512, 1689819, 892185, -11513277, -15205948},
+ },
+ {
+ FieldElement{9770129, 9586738, 26496094, 4324120, 1556511, -3550024, 27453819, 4763127, -19179614, 5867134},
+ FieldElement{-32765025, 1927590, 31726409, -4753295, 23962434, -16019500, 27846559, 5931263, -29749703, -16108455},
+ FieldElement{27461885, -2977536, 22380810, 1815854, -23033753, -3031938, 7283490, -15148073, -19526700, 7734629},
+ },
+ },
+ {
+ {
+ FieldElement{-8010264, -9590817, -11120403, 6196038, 29344158, -13430885, 7585295, -3176626, 18549497, 15302069},
+ FieldElement{-32658337, -6171222, -7672793, -11051681, 6258878, 13504381, 10458790, -6418461, -8872242, 8424746},
+ FieldElement{24687205, 8613276, -30667046, -3233545, 1863892, -1830544, 19206234, 7134917, -11284482, -828919},
+ },
+ {
+ FieldElement{11334899, -9218022, 8025293, 12707519, 17523892, -10476071, 10243738, -14685461, -5066034, 16498837},
+ FieldElement{8911542, 6887158, -9584260, -6958590, 11145641, -9543680, 17303925, -14124238, 6536641, 10543906},
+ FieldElement{-28946384, 15479763, -17466835, 568876, -1497683, 11223454, -2669190, -16625574, -27235709, 8876771},
+ },
+ {
+ FieldElement{-25742899, -12566864, -15649966, -846607, -33026686, -796288, -33481822, 15824474, -604426, -9039817},
+ FieldElement{10330056, 70051, 7957388, -9002667, 9764902, 15609756, 27698697, -4890037, 1657394, 3084098},
+ FieldElement{10477963, -7470260, 12119566, -13250805, 29016247, -5365589, 31280319, 14396151, -30233575, 15272409},
+ },
+ {
+ FieldElement{-12288309, 3169463, 28813183, 16658753, 25116432, -5630466, -25173957, -12636138, -25014757, 1950504},
+ FieldElement{-26180358, 9489187, 11053416, -14746161, -31053720, 5825630, -8384306, -8767532, 15341279, 8373727},
+ FieldElement{28685821, 7759505, -14378516, -12002860, -31971820, 4079242, 298136, -10232602, -2878207, 15190420},
+ },
+ {
+ FieldElement{-32932876, 13806336, -14337485, -15794431, -24004620, 10940928, 8669718, 2742393, -26033313, -6875003},
+ FieldElement{-1580388, -11729417, -25979658, -11445023, -17411874, -10912854, 9291594, -16247779, -12154742, 6048605},
+ FieldElement{-30305315, 14843444, 1539301, 11864366, 20201677, 1900163, 13934231, 5128323, 11213262, 9168384},
+ },
+ {
+ FieldElement{-26280513, 11007847, 19408960, -940758, -18592965, -4328580, -5088060, -11105150, 20470157, -16398701},
+ FieldElement{-23136053, 9282192, 14855179, -15390078, -7362815, -14408560, -22783952, 14461608, 14042978, 5230683},
+ FieldElement{29969567, -2741594, -16711867, -8552442, 9175486, -2468974, 21556951, 3506042, -5933891, -12449708},
+ },
+ {
+ FieldElement{-3144746, 8744661, 19704003, 4581278, -20430686, 6830683, -21284170, 8971513, -28539189, 15326563},
+ FieldElement{-19464629, 10110288, -17262528, -3503892, -23500387, 1355669, -15523050, 15300988, -20514118, 9168260},
+ FieldElement{-5353335, 4488613, -23803248, 16314347, 7780487, -15638939, -28948358, 9601605, 33087103, -9011387},
+ },
+ {
+ FieldElement{-19443170, -15512900, -20797467, -12445323, -29824447, 10229461, -27444329, -15000531, -5996870, 15664672},
+ FieldElement{23294591, -16632613, -22650781, -8470978, 27844204, 11461195, 13099750, -2460356, 18151676, 13417686},
+ FieldElement{-24722913, -4176517, -31150679, 5988919, -26858785, 6685065, 1661597, -12551441, 15271676, -15452665},
+ },
+ },
+ {
+ {
+ FieldElement{11433042, -13228665, 8239631, -5279517, -1985436, -725718, -18698764, 2167544, -6921301, -13440182},
+ FieldElement{-31436171, 15575146, 30436815, 12192228, -22463353, 9395379, -9917708, -8638997, 12215110, 12028277},
+ FieldElement{14098400, 6555944, 23007258, 5757252, -15427832, -12950502, 30123440, 4617780, -16900089, -655628},
+ },
+ {
+ FieldElement{-4026201, -15240835, 11893168, 13718664, -14809462, 1847385, -15819999, 10154009, 23973261, -12684474},
+ FieldElement{-26531820, -3695990, -1908898, 2534301, -31870557, -16550355, 18341390, -11419951, 32013174, -10103539},
+ FieldElement{-25479301, 10876443, -11771086, -14625140, -12369567, 1838104, 21911214, 6354752, 4425632, -837822},
+ },
+ {
+ FieldElement{-10433389, -14612966, 22229858, -3091047, -13191166, 776729, -17415375, -12020462, 4725005, 14044970},
+ FieldElement{19268650, -7304421, 1555349, 8692754, -21474059, -9910664, 6347390, -1411784, -19522291, -16109756},
+ FieldElement{-24864089, 12986008, -10898878, -5558584, -11312371, -148526, 19541418, 8180106, 9282262, 10282508},
+ },
+ {
+ FieldElement{-26205082, 4428547, -8661196, -13194263, 4098402, -14165257, 15522535, 8372215, 5542595, -10702683},
+ FieldElement{-10562541, 14895633, 26814552, -16673850, -17480754, -2489360, -2781891, 6993761, -18093885, 10114655},
+ FieldElement{-20107055, -929418, 31422704, 10427861, -7110749, 6150669, -29091755, -11529146, 25953725, -106158},
+ },
+ {
+ FieldElement{-4234397, -8039292, -9119125, 3046000, 2101609, -12607294, 19390020, 6094296, -3315279, 12831125},
+ FieldElement{-15998678, 7578152, 5310217, 14408357, -33548620, -224739, 31575954, 6326196, 7381791, -2421839},
+ FieldElement{-20902779, 3296811, 24736065, -16328389, 18374254, 7318640, 6295303, 8082724, -15362489, 12339664},
+ },
+ {
+ FieldElement{27724736, 2291157, 6088201, -14184798, 1792727, 5857634, 13848414, 15768922, 25091167, 14856294},
+ FieldElement{-18866652, 8331043, 24373479, 8541013, -701998, -9269457, 12927300, -12695493, -22182473, -9012899},
+ FieldElement{-11423429, -5421590, 11632845, 3405020, 30536730, -11674039, -27260765, 13866390, 30146206, 9142070},
+ },
+ {
+ FieldElement{3924129, -15307516, -13817122, -10054960, 12291820, -668366, -27702774, 9326384, -8237858, 4171294},
+ FieldElement{-15921940, 16037937, 6713787, 16606682, -21612135, 2790944, 26396185, 3731949, 345228, -5462949},
+ FieldElement{-21327538, 13448259, 25284571, 1143661, 20614966, -8849387, 2031539, -12391231, -16253183, -13582083},
+ },
+ {
+ FieldElement{31016211, -16722429, 26371392, -14451233, -5027349, 14854137, 17477601, 3842657, 28012650, -16405420},
+ FieldElement{-5075835, 9368966, -8562079, -4600902, -15249953, 6970560, -9189873, 16292057, -8867157, 3507940},
+ FieldElement{29439664, 3537914, 23333589, 6997794, -17555561, -11018068, -15209202, -15051267, -9164929, 6580396},
+ },
+ },
+ {
+ {
+ FieldElement{-12185861, -7679788, 16438269, 10826160, -8696817, -6235611, 17860444, -9273846, -2095802, 9304567},
+ FieldElement{20714564, -4336911, 29088195, 7406487, 11426967, -5095705, 14792667, -14608617, 5289421, -477127},
+ FieldElement{-16665533, -10650790, -6160345, -13305760, 9192020, -1802462, 17271490, 12349094, 26939669, -3752294},
+ },
+ {
+ FieldElement{-12889898, 9373458, 31595848, 16374215, 21471720, 13221525, -27283495, -12348559, -3698806, 117887},
+ FieldElement{22263325, -6560050, 3984570, -11174646, -15114008, -566785, 28311253, 5358056, -23319780, 541964},
+ FieldElement{16259219, 3261970, 2309254, -15534474, -16885711, -4581916, 24134070, -16705829, -13337066, -13552195},
+ },
+ {
+ FieldElement{9378160, -13140186, -22845982, -12745264, 28198281, -7244098, -2399684, -717351, 690426, 14876244},
+ FieldElement{24977353, -314384, -8223969, -13465086, 28432343, -1176353, -13068804, -12297348, -22380984, 6618999},
+ FieldElement{-1538174, 11685646, 12944378, 13682314, -24389511, -14413193, 8044829, -13817328, 32239829, -5652762},
+ },
+ {
+ FieldElement{-18603066, 4762990, -926250, 8885304, -28412480, -3187315, 9781647, -10350059, 32779359, 5095274},
+ FieldElement{-33008130, -5214506, -32264887, -3685216, 9460461, -9327423, -24601656, 14506724, 21639561, -2630236},
+ FieldElement{-16400943, -13112215, 25239338, 15531969, 3987758, -4499318, -1289502, -6863535, 17874574, 558605},
+ },
+ {
+ FieldElement{-13600129, 10240081, 9171883, 16131053, -20869254, 9599700, 33499487, 5080151, 2085892, 5119761},
+ FieldElement{-22205145, -2519528, -16381601, 414691, -25019550, 2170430, 30634760, -8363614, -31999993, -5759884},
+ FieldElement{-6845704, 15791202, 8550074, -1312654, 29928809, -12092256, 27534430, -7192145, -22351378, 12961482},
+ },
+ {
+ FieldElement{-24492060, -9570771, 10368194, 11582341, -23397293, -2245287, 16533930, 8206996, -30194652, -5159638},
+ FieldElement{-11121496, -3382234, 2307366, 6362031, -135455, 8868177, -16835630, 7031275, 7589640, 8945490},
+ FieldElement{-32152748, 8917967, 6661220, -11677616, -1192060, -15793393, 7251489, -11182180, 24099109, -14456170},
+ },
+ {
+ FieldElement{5019558, -7907470, 4244127, -14714356, -26933272, 6453165, -19118182, -13289025, -6231896, -10280736},
+ FieldElement{10853594, 10721687, 26480089, 5861829, -22995819, 1972175, -1866647, -10557898, -3363451, -6441124},
+ FieldElement{-17002408, 5906790, 221599, -6563147, 7828208, -13248918, 24362661, -2008168, -13866408, 7421392},
+ },
+ {
+ FieldElement{8139927, -6546497, 32257646, -5890546, 30375719, 1886181, -21175108, 15441252, 28826358, -4123029},
+ FieldElement{6267086, 9695052, 7709135, -16603597, -32869068, -1886135, 14795160, -7840124, 13746021, -1742048},
+ FieldElement{28584902, 7787108, -6732942, -15050729, 22846041, -7571236, -3181936, -363524, 4771362, -8419958},
+ },
+ },
+ {
+ {
+ FieldElement{24949256, 6376279, -27466481, -8174608, -18646154, -9930606, 33543569, -12141695, 3569627, 11342593},
+ FieldElement{26514989, 4740088, 27912651, 3697550, 19331575, -11472339, 6809886, 4608608, 7325975, -14801071},
+ FieldElement{-11618399, -14554430, -24321212, 7655128, -1369274, 5214312, -27400540, 10258390, -17646694, -8186692},
+ },
+ {
+ FieldElement{11431204, 15823007, 26570245, 14329124, 18029990, 4796082, -31446179, 15580664, 9280358, -3973687},
+ FieldElement{-160783, -10326257, -22855316, -4304997, -20861367, -13621002, -32810901, -11181622, -15545091, 4387441},
+ FieldElement{-20799378, 12194512, 3937617, -5805892, -27154820, 9340370, -24513992, 8548137, 20617071, -7482001},
+ },
+ {
+ FieldElement{-938825, -3930586, -8714311, 16124718, 24603125, -6225393, -13775352, -11875822, 24345683, 10325460},
+ FieldElement{-19855277, -1568885, -22202708, 8714034, 14007766, 6928528, 16318175, -1010689, 4766743, 3552007},
+ FieldElement{-21751364, -16730916, 1351763, -803421, -4009670, 3950935, 3217514, 14481909, 10988822, -3994762},
+ },
+ {
+ FieldElement{15564307, -14311570, 3101243, 5684148, 30446780, -8051356, 12677127, -6505343, -8295852, 13296005},
+ FieldElement{-9442290, 6624296, -30298964, -11913677, -4670981, -2057379, 31521204, 9614054, -30000824, 12074674},
+ FieldElement{4771191, -135239, 14290749, -13089852, 27992298, 14998318, -1413936, -1556716, 29832613, -16391035},
+ },
+ {
+ FieldElement{7064884, -7541174, -19161962, -5067537, -18891269, -2912736, 25825242, 5293297, -27122660, 13101590},
+ FieldElement{-2298563, 2439670, -7466610, 1719965, -27267541, -16328445, 32512469, -5317593, -30356070, -4190957},
+ FieldElement{-30006540, 10162316, -33180176, 3981723, -16482138, -13070044, 14413974, 9515896, 19568978, 9628812},
+ },
+ {
+ FieldElement{33053803, 199357, 15894591, 1583059, 27380243, -4580435, -17838894, -6106839, -6291786, 3437740},
+ FieldElement{-18978877, 3884493, 19469877, 12726490, 15913552, 13614290, -22961733, 70104, 7463304, 4176122},
+ FieldElement{-27124001, 10659917, 11482427, -16070381, 12771467, -6635117, -32719404, -5322751, 24216882, 5944158},
+ },
+ {
+ FieldElement{8894125, 7450974, -2664149, -9765752, -28080517, -12389115, 19345746, 14680796, 11632993, 5847885},
+ FieldElement{26942781, -2315317, 9129564, -4906607, 26024105, 11769399, -11518837, 6367194, -9727230, 4782140},
+ FieldElement{19916461, -4828410, -22910704, -11414391, 25606324, -5972441, 33253853, 8220911, 6358847, -1873857},
+ },
+ {
+ FieldElement{801428, -2081702, 16569428, 11065167, 29875704, 96627, 7908388, -4480480, -13538503, 1387155},
+ FieldElement{19646058, 5720633, -11416706, 12814209, 11607948, 12749789, 14147075, 15156355, -21866831, 11835260},
+ FieldElement{19299512, 1155910, 28703737, 14890794, 2925026, 7269399, 26121523, 15467869, -26560550, 5052483},
+ },
+ },
+ {
+ {
+ FieldElement{-3017432, 10058206, 1980837, 3964243, 22160966, 12322533, -6431123, -12618185, 12228557, -7003677},
+ FieldElement{32944382, 14922211, -22844894, 5188528, 21913450, -8719943, 4001465, 13238564, -6114803, 8653815},
+ FieldElement{22865569, -4652735, 27603668, -12545395, 14348958, 8234005, 24808405, 5719875, 28483275, 2841751},
+ },
+ {
+ FieldElement{-16420968, -1113305, -327719, -12107856, 21886282, -15552774, -1887966, -315658, 19932058, -12739203},
+ FieldElement{-11656086, 10087521, -8864888, -5536143, -19278573, -3055912, 3999228, 13239134, -4777469, -13910208},
+ FieldElement{1382174, -11694719, 17266790, 9194690, -13324356, 9720081, 20403944, 11284705, -14013818, 3093230},
+ },
+ {
+ FieldElement{16650921, -11037932, -1064178, 1570629, -8329746, 7352753, -302424, 16271225, -24049421, -6691850},
+ FieldElement{-21911077, -5927941, -4611316, -5560156, -31744103, -10785293, 24123614, 15193618, -21652117, -16739389},
+ FieldElement{-9935934, -4289447, -25279823, 4372842, 2087473, 10399484, 31870908, 14690798, 17361620, 11864968},
+ },
+ {
+ FieldElement{-11307610, 6210372, 13206574, 5806320, -29017692, -13967200, -12331205, -7486601, -25578460, -16240689},
+ FieldElement{14668462, -12270235, 26039039, 15305210, 25515617, 4542480, 10453892, 6577524, 9145645, -6443880},
+ FieldElement{5974874, 3053895, -9433049, -10385191, -31865124, 3225009, -7972642, 3936128, -5652273, -3050304},
+ },
+ {
+ FieldElement{30625386, -4729400, -25555961, -12792866, -20484575, 7695099, 17097188, -16303496, -27999779, 1803632},
+ FieldElement{-3553091, 9865099, -5228566, 4272701, -5673832, -16689700, 14911344, 12196514, -21405489, 7047412},
+ FieldElement{20093277, 9920966, -11138194, -5343857, 13161587, 12044805, -32856851, 4124601, -32343828, -10257566},
+ },
+ {
+ FieldElement{-20788824, 14084654, -13531713, 7842147, 19119038, -13822605, 4752377, -8714640, -21679658, 2288038},
+ FieldElement{-26819236, -3283715, 29965059, 3039786, -14473765, 2540457, 29457502, 14625692, -24819617, 12570232},
+ FieldElement{-1063558, -11551823, 16920318, 12494842, 1278292, -5869109, -21159943, -3498680, -11974704, 4724943},
+ },
+ {
+ FieldElement{17960970, -11775534, -4140968, -9702530, -8876562, -1410617, -12907383, -8659932, -29576300, 1903856},
+ FieldElement{23134274, -14279132, -10681997, -1611936, 20684485, 15770816, -12989750, 3190296, 26955097, 14109738},
+ FieldElement{15308788, 5320727, -30113809, -14318877, 22902008, 7767164, 29425325, -11277562, 31960942, 11934971},
+ },
+ {
+ FieldElement{-27395711, 8435796, 4109644, 12222639, -24627868, 14818669, 20638173, 4875028, 10491392, 1379718},
+ FieldElement{-13159415, 9197841, 3875503, -8936108, -1383712, -5879801, 33518459, 16176658, 21432314, 12180697},
+ FieldElement{-11787308, 11500838, 13787581, -13832590, -22430679, 10140205, 1465425, 12689540, -10301319, -13872883},
+ },
+ },
+ {
+ {
+ FieldElement{5414091, -15386041, -21007664, 9643570, 12834970, 1186149, -2622916, -1342231, 26128231, 6032912},
+ FieldElement{-26337395, -13766162, 32496025, -13653919, 17847801, -12669156, 3604025, 8316894, -25875034, -10437358},
+ FieldElement{3296484, 6223048, 24680646, -12246460, -23052020, 5903205, -8862297, -4639164, 12376617, 3188849},
+ },
+ {
+ FieldElement{29190488, -14659046, 27549113, -1183516, 3520066, -10697301, 32049515, -7309113, -16109234, -9852307},
+ FieldElement{-14744486, -9309156, 735818, -598978, -20407687, -5057904, 25246078, -15795669, 18640741, -960977},
+ FieldElement{-6928835, -16430795, 10361374, 5642961, 4910474, 12345252, -31638386, -494430, 10530747, 1053335},
+ },
+ {
+ FieldElement{-29265967, -14186805, -13538216, -12117373, -19457059, -10655384, -31462369, -2948985, 24018831, 15026644},
+ FieldElement{-22592535, -3145277, -2289276, 5953843, -13440189, 9425631, 25310643, 13003497, -2314791, -15145616},
+ FieldElement{-27419985, -603321, -8043984, -1669117, -26092265, 13987819, -27297622, 187899, -23166419, -2531735},
+ },
+ {
+ FieldElement{-21744398, -13810475, 1844840, 5021428, -10434399, -15911473, 9716667, 16266922, -5070217, 726099},
+ FieldElement{29370922, -6053998, 7334071, -15342259, 9385287, 2247707, -13661962, -4839461, 30007388, -15823341},
+ FieldElement{-936379, 16086691, 23751945, -543318, -1167538, -5189036, 9137109, 730663, 9835848, 4555336},
+ },
+ {
+ FieldElement{-23376435, 1410446, -22253753, -12899614, 30867635, 15826977, 17693930, 544696, -11985298, 12422646},
+ FieldElement{31117226, -12215734, -13502838, 6561947, -9876867, -12757670, -5118685, -4096706, 29120153, 13924425},
+ FieldElement{-17400879, -14233209, 19675799, -2734756, -11006962, -5858820, -9383939, -11317700, 7240931, -237388},
+ },
+ {
+ FieldElement{-31361739, -11346780, -15007447, -5856218, -22453340, -12152771, 1222336, 4389483, 3293637, -15551743},
+ FieldElement{-16684801, -14444245, 11038544, 11054958, -13801175, -3338533, -24319580, 7733547, 12796905, -6335822},
+ FieldElement{-8759414, -10817836, -25418864, 10783769, -30615557, -9746811, -28253339, 3647836, 3222231, -11160462},
+ },
+ {
+ FieldElement{18606113, 1693100, -25448386, -15170272, 4112353, 10045021, 23603893, -2048234, -7550776, 2484985},
+ FieldElement{9255317, -3131197, -12156162, -1004256, 13098013, -9214866, 16377220, -2102812, -19802075, -3034702},
+ FieldElement{-22729289, 7496160, -5742199, 11329249, 19991973, -3347502, -31718148, 9936966, -30097688, -10618797},
+ },
+ {
+ FieldElement{21878590, -5001297, 4338336, 13643897, -3036865, 13160960, 19708896, 5415497, -7360503, -4109293},
+ FieldElement{27736861, 10103576, 12500508, 8502413, -3413016, -9633558, 10436918, -1550276, -23659143, -8132100},
+ FieldElement{19492550, -12104365, -29681976, -852630, -3208171, 12403437, 30066266, 8367329, 13243957, 8709688},
+ },
+ },
+ {
+ {
+ FieldElement{12015105, 2801261, 28198131, 10151021, 24818120, -4743133, -11194191, -5645734, 5150968, 7274186},
+ FieldElement{2831366, -12492146, 1478975, 6122054, 23825128, -12733586, 31097299, 6083058, 31021603, -9793610},
+ FieldElement{-2529932, -2229646, 445613, 10720828, -13849527, -11505937, -23507731, 16354465, 15067285, -14147707},
+ },
+ {
+ FieldElement{7840942, 14037873, -33364863, 15934016, -728213, -3642706, 21403988, 1057586, -19379462, -12403220},
+ FieldElement{915865, -16469274, 15608285, -8789130, -24357026, 6060030, -17371319, 8410997, -7220461, 16527025},
+ FieldElement{32922597, -556987, 20336074, -16184568, 10903705, -5384487, 16957574, 52992, 23834301, 6588044},
+ },
+ {
+ FieldElement{32752030, 11232950, 3381995, -8714866, 22652988, -10744103, 17159699, 16689107, -20314580, -1305992},
+ FieldElement{-4689649, 9166776, -25710296, -10847306, 11576752, 12733943, 7924251, -2752281, 1976123, -7249027},
+ FieldElement{21251222, 16309901, -2983015, -6783122, 30810597, 12967303, 156041, -3371252, 12331345, -8237197},
+ },
+ {
+ FieldElement{8651614, -4477032, -16085636, -4996994, 13002507, 2950805, 29054427, -5106970, 10008136, -4667901},
+ FieldElement{31486080, 15114593, -14261250, 12951354, 14369431, -7387845, 16347321, -13662089, 8684155, -10532952},
+ FieldElement{19443825, 11385320, 24468943, -9659068, -23919258, 2187569, -26263207, -6086921, 31316348, 14219878},
+ },
+ {
+ FieldElement{-28594490, 1193785, 32245219, 11392485, 31092169, 15722801, 27146014, 6992409, 29126555, 9207390},
+ FieldElement{32382935, 1110093, 18477781, 11028262, -27411763, -7548111, -4980517, 10843782, -7957600, -14435730},
+ FieldElement{2814918, 7836403, 27519878, -7868156, -20894015, -11553689, -21494559, 8550130, 28346258, 1994730},
+ },
+ {
+ FieldElement{-19578299, 8085545, -14000519, -3948622, 2785838, -16231307, -19516951, 7174894, 22628102, 8115180},
+ FieldElement{-30405132, 955511, -11133838, -15078069, -32447087, -13278079, -25651578, 3317160, -9943017, 930272},
+ FieldElement{-15303681, -6833769, 28856490, 1357446, 23421993, 1057177, 24091212, -1388970, -22765376, -10650715},
+ },
+ {
+ FieldElement{-22751231, -5303997, -12907607, -12768866, -15811511, -7797053, -14839018, -16554220, -1867018, 8398970},
+ FieldElement{-31969310, 2106403, -4736360, 1362501, 12813763, 16200670, 22981545, -6291273, 18009408, -15772772},
+ FieldElement{-17220923, -9545221, -27784654, 14166835, 29815394, 7444469, 29551787, -3727419, 19288549, 1325865},
+ },
+ {
+ FieldElement{15100157, -15835752, -23923978, -1005098, -26450192, 15509408, 12376730, -3479146, 33166107, -8042750},
+ FieldElement{20909231, 13023121, -9209752, 16251778, -5778415, -8094914, 12412151, 10018715, 2213263, -13878373},
+ FieldElement{32529814, -11074689, 30361439, -16689753, -9135940, 1513226, 22922121, 6382134, -5766928, 8371348},
+ },
+ },
+ {
+ {
+ FieldElement{9923462, 11271500, 12616794, 3544722, -29998368, -1721626, 12891687, -8193132, -26442943, 10486144},
+ FieldElement{-22597207, -7012665, 8587003, -8257861, 4084309, -12970062, 361726, 2610596, -23921530, -11455195},
+ FieldElement{5408411, -1136691, -4969122, 10561668, 24145918, 14240566, 31319731, -4235541, 19985175, -3436086},
+ },
+ {
+ FieldElement{-13994457, 16616821, 14549246, 3341099, 32155958, 13648976, -17577068, 8849297, 65030, 8370684},
+ FieldElement{-8320926, -12049626, 31204563, 5839400, -20627288, -1057277, -19442942, 6922164, 12743482, -9800518},
+ FieldElement{-2361371, 12678785, 28815050, 4759974, -23893047, 4884717, 23783145, 11038569, 18800704, 255233},
+ },
+ {
+ FieldElement{-5269658, -1773886, 13957886, 7990715, 23132995, 728773, 13393847, 9066957, 19258688, -14753793},
+ FieldElement{-2936654, -10827535, -10432089, 14516793, -3640786, 4372541, -31934921, 2209390, -1524053, 2055794},
+ FieldElement{580882, 16705327, 5468415, -2683018, -30926419, -14696000, -7203346, -8994389, -30021019, 7394435},
+ },
+ {
+ FieldElement{23838809, 1822728, -15738443, 15242727, 8318092, -3733104, -21672180, -3492205, -4821741, 14799921},
+ FieldElement{13345610, 9759151, 3371034, -16137791, 16353039, 8577942, 31129804, 13496856, -9056018, 7402518},
+ FieldElement{2286874, -4435931, -20042458, -2008336, -13696227, 5038122, 11006906, -15760352, 8205061, 1607563},
+ },
+ {
+ FieldElement{14414086, -8002132, 3331830, -3208217, 22249151, -5594188, 18364661, -2906958, 30019587, -9029278},
+ FieldElement{-27688051, 1585953, -10775053, 931069, -29120221, -11002319, -14410829, 12029093, 9944378, 8024},
+ FieldElement{4368715, -3709630, 29874200, -15022983, -20230386, -11410704, -16114594, -999085, -8142388, 5640030},
+ },
+ {
+ FieldElement{10299610, 13746483, 11661824, 16234854, 7630238, 5998374, 9809887, -16694564, 15219798, -14327783},
+ FieldElement{27425505, -5719081, 3055006, 10660664, 23458024, 595578, -15398605, -1173195, -18342183, 9742717},
+ FieldElement{6744077, 2427284, 26042789, 2720740, -847906, 1118974, 32324614, 7406442, 12420155, 1994844},
+ },
+ {
+ FieldElement{14012521, -5024720, -18384453, -9578469, -26485342, -3936439, -13033478, -10909803, 24319929, -6446333},
+ FieldElement{16412690, -4507367, 10772641, 15929391, -17068788, -4658621, 10555945, -10484049, -30102368, -4739048},
+ FieldElement{22397382, -7767684, -9293161, -12792868, 17166287, -9755136, -27333065, 6199366, 21880021, -12250760},
+ },
+ {
+ FieldElement{-4283307, 5368523, -31117018, 8163389, -30323063, 3209128, 16557151, 8890729, 8840445, 4957760},
+ FieldElement{-15447727, 709327, -6919446, -10870178, -29777922, 6522332, -21720181, 12130072, -14796503, 5005757},
+ FieldElement{-2114751, -14308128, 23019042, 15765735, -25269683, 6002752, 10183197, -13239326, -16395286, -2176112},
+ },
+ },
+ {
+ {
+ FieldElement{-19025756, 1632005, 13466291, -7995100, -23640451, 16573537, -32013908, -3057104, 22208662, 2000468},
+ FieldElement{3065073, -1412761, -25598674, -361432, -17683065, -5703415, -8164212, 11248527, -3691214, -7414184},
+ FieldElement{10379208, -6045554, 8877319, 1473647, -29291284, -12507580, 16690915, 2553332, -3132688, 16400289},
+ },
+ {
+ FieldElement{15716668, 1254266, -18472690, 7446274, -8448918, 6344164, -22097271, -7285580, 26894937, 9132066},
+ FieldElement{24158887, 12938817, 11085297, -8177598, -28063478, -4457083, -30576463, 64452, -6817084, -2692882},
+ FieldElement{13488534, 7794716, 22236231, 5989356, 25426474, -12578208, 2350710, -3418511, -4688006, 2364226},
+ },
+ {
+ FieldElement{16335052, 9132434, 25640582, 6678888, 1725628, 8517937, -11807024, -11697457, 15445875, -7798101},
+ FieldElement{29004207, -7867081, 28661402, -640412, -12794003, -7943086, 31863255, -4135540, -278050, -15759279},
+ FieldElement{-6122061, -14866665, -28614905, 14569919, -10857999, -3591829, 10343412, -6976290, -29828287, -10815811},
+ },
+ {
+ FieldElement{27081650, 3463984, 14099042, -4517604, 1616303, -6205604, 29542636, 15372179, 17293797, 960709},
+ FieldElement{20263915, 11434237, -5765435, 11236810, 13505955, -10857102, -16111345, 6493122, -19384511, 7639714},
+ FieldElement{-2830798, -14839232, 25403038, -8215196, -8317012, -16173699, 18006287, -16043750, 29994677, -15808121},
+ },
+ {
+ FieldElement{9769828, 5202651, -24157398, -13631392, -28051003, -11561624, -24613141, -13860782, -31184575, 709464},
+ FieldElement{12286395, 13076066, -21775189, -1176622, -25003198, 4057652, -32018128, -8890874, 16102007, 13205847},
+ FieldElement{13733362, 5599946, 10557076, 3195751, -5557991, 8536970, -25540170, 8525972, 10151379, 10394400},
+ },
+ {
+ FieldElement{4024660, -16137551, 22436262, 12276534, -9099015, -2686099, 19698229, 11743039, -33302334, 8934414},
+ FieldElement{-15879800, -4525240, -8580747, -2934061, 14634845, -698278, -9449077, 3137094, -11536886, 11721158},
+ FieldElement{17555939, -5013938, 8268606, 2331751, -22738815, 9761013, 9319229, 8835153, -9205489, -1280045},
+ },
+ {
+ FieldElement{-461409, -7830014, 20614118, 16688288, -7514766, -4807119, 22300304, 505429, 6108462, -6183415},
+ FieldElement{-5070281, 12367917, -30663534, 3234473, 32617080, -8422642, 29880583, -13483331, -26898490, -7867459},
+ FieldElement{-31975283, 5726539, 26934134, 10237677, -3173717, -605053, 24199304, 3795095, 7592688, -14992079},
+ },
+ {
+ FieldElement{21594432, -14964228, 17466408, -4077222, 32537084, 2739898, 6407723, 12018833, -28256052, 4298412},
+ FieldElement{-20650503, -11961496, -27236275, 570498, 3767144, -1717540, 13891942, -1569194, 13717174, 10805743},
+ FieldElement{-14676630, -15644296, 15287174, 11927123, 24177847, -8175568, -796431, 14860609, -26938930, -5863836},
+ },
+ },
+ {
+ {
+ FieldElement{12962541, 5311799, -10060768, 11658280, 18855286, -7954201, 13286263, -12808704, -4381056, 9882022},
+ FieldElement{18512079, 11319350, -20123124, 15090309, 18818594, 5271736, -22727904, 3666879, -23967430, -3299429},
+ FieldElement{-6789020, -3146043, 16192429, 13241070, 15898607, -14206114, -10084880, -6661110, -2403099, 5276065},
+ },
+ {
+ FieldElement{30169808, -5317648, 26306206, -11750859, 27814964, 7069267, 7152851, 3684982, 1449224, 13082861},
+ FieldElement{10342826, 3098505, 2119311, 193222, 25702612, 12233820, 23697382, 15056736, -21016438, -8202000},
+ FieldElement{-33150110, 3261608, 22745853, 7948688, 19370557, -15177665, -26171976, 6482814, -10300080, -11060101},
+ },
+ {
+ FieldElement{32869458, -5408545, 25609743, 15678670, -10687769, -15471071, 26112421, 2521008, -22664288, 6904815},
+ FieldElement{29506923, 4457497, 3377935, -9796444, -30510046, 12935080, 1561737, 3841096, -29003639, -6657642},
+ FieldElement{10340844, -6630377, -18656632, -2278430, 12621151, -13339055, 30878497, -11824370, -25584551, 5181966},
+ },
+ {
+ FieldElement{25940115, -12658025, 17324188, -10307374, -8671468, 15029094, 24396252, -16450922, -2322852, -12388574},
+ FieldElement{-21765684, 9916823, -1300409, 4079498, -1028346, 11909559, 1782390, 12641087, 20603771, -6561742},
+ FieldElement{-18882287, -11673380, 24849422, 11501709, 13161720, -4768874, 1925523, 11914390, 4662781, 7820689},
+ },
+ {
+ FieldElement{12241050, -425982, 8132691, 9393934, 32846760, -1599620, 29749456, 12172924, 16136752, 15264020},
+ FieldElement{-10349955, -14680563, -8211979, 2330220, -17662549, -14545780, 10658213, 6671822, 19012087, 3772772},
+ FieldElement{3753511, -3421066, 10617074, 2028709, 14841030, -6721664, 28718732, -15762884, 20527771, 12988982},
+ },
+ {
+ FieldElement{-14822485, -5797269, -3707987, 12689773, -898983, -10914866, -24183046, -10564943, 3299665, -12424953},
+ FieldElement{-16777703, -15253301, -9642417, 4978983, 3308785, 8755439, 6943197, 6461331, -25583147, 8991218},
+ FieldElement{-17226263, 1816362, -1673288, -6086439, 31783888, -8175991, -32948145, 7417950, -30242287, 1507265},
+ },
+ {
+ FieldElement{29692663, 6829891, -10498800, 4334896, 20945975, -11906496, -28887608, 8209391, 14606362, -10647073},
+ FieldElement{-3481570, 8707081, 32188102, 5672294, 22096700, 1711240, -33020695, 9761487, 4170404, -2085325},
+ FieldElement{-11587470, 14855945, -4127778, -1531857, -26649089, 15084046, 22186522, 16002000, -14276837, -8400798},
+ },
+ {
+ FieldElement{-4811456, 13761029, -31703877, -2483919, -3312471, 7869047, -7113572, -9620092, 13240845, 10965870},
+ FieldElement{-7742563, -8256762, -14768334, -13656260, -23232383, 12387166, 4498947, 14147411, 29514390, 4302863},
+ FieldElement{-13413405, -12407859, 20757302, -13801832, 14785143, 8976368, -5061276, -2144373, 17846988, -13971927},
+ },
+ },
+ {
+ {
+ FieldElement{-2244452, -754728, -4597030, -1066309, -6247172, 1455299, -21647728, -9214789, -5222701, 12650267},
+ FieldElement{-9906797, -16070310, 21134160, 12198166, -27064575, 708126, 387813, 13770293, -19134326, 10958663},
+ FieldElement{22470984, 12369526, 23446014, -5441109, -21520802, -9698723, -11772496, -11574455, -25083830, 4271862},
+ },
+ {
+ FieldElement{-25169565, -10053642, -19909332, 15361595, -5984358, 2159192, 75375, -4278529, -32526221, 8469673},
+ FieldElement{15854970, 4148314, -8893890, 7259002, 11666551, 13824734, -30531198, 2697372, 24154791, -9460943},
+ FieldElement{15446137, -15806644, 29759747, 14019369, 30811221, -9610191, -31582008, 12840104, 24913809, 9815020},
+ },
+ {
+ FieldElement{-4709286, -5614269, -31841498, -12288893, -14443537, 10799414, -9103676, 13438769, 18735128, 9466238},
+ FieldElement{11933045, 9281483, 5081055, -5183824, -2628162, -4905629, -7727821, -10896103, -22728655, 16199064},
+ FieldElement{14576810, 379472, -26786533, -8317236, -29426508, -10812974, -102766, 1876699, 30801119, 2164795},
+ },
+ {
+ FieldElement{15995086, 3199873, 13672555, 13712240, -19378835, -4647646, -13081610, -15496269, -13492807, 1268052},
+ FieldElement{-10290614, -3659039, -3286592, 10948818, 23037027, 3794475, -3470338, -12600221, -17055369, 3565904},
+ FieldElement{29210088, -9419337, -5919792, -4952785, 10834811, -13327726, -16512102, -10820713, -27162222, -14030531},
+ },
+ {
+ FieldElement{-13161890, 15508588, 16663704, -8156150, -28349942, 9019123, -29183421, -3769423, 2244111, -14001979},
+ FieldElement{-5152875, -3800936, -9306475, -6071583, 16243069, 14684434, -25673088, -16180800, 13491506, 4641841},
+ FieldElement{10813417, 643330, -19188515, -728916, 30292062, -16600078, 27548447, -7721242, 14476989, -12767431},
+ },
+ {
+ FieldElement{10292079, 9984945, 6481436, 8279905, -7251514, 7032743, 27282937, -1644259, -27912810, 12651324},
+ FieldElement{-31185513, -813383, 22271204, 11835308, 10201545, 15351028, 17099662, 3988035, 21721536, -3148940},
+ FieldElement{10202177, -6545839, -31373232, -9574638, -32150642, -8119683, -12906320, 3852694, 13216206, 14842320},
+ },
+ {
+ FieldElement{-15815640, -10601066, -6538952, -7258995, -6984659, -6581778, -31500847, 13765824, -27434397, 9900184},
+ FieldElement{14465505, -13833331, -32133984, -14738873, -27443187, 12990492, 33046193, 15796406, -7051866, -8040114},
+ FieldElement{30924417, -8279620, 6359016, -12816335, 16508377, 9071735, -25488601, 15413635, 9524356, -7018878},
+ },
+ {
+ FieldElement{12274201, -13175547, 32627641, -1785326, 6736625, 13267305, 5237659, -5109483, 15663516, 4035784},
+ FieldElement{-2951309, 8903985, 17349946, 601635, -16432815, -4612556, -13732739, -15889334, -22258478, 4659091},
+ FieldElement{-16916263, -4952973, -30393711, -15158821, 20774812, 15897498, 5736189, 15026997, -2178256, -13455585},
+ },
+ },
+ {
+ {
+ FieldElement{-8858980, -2219056, 28571666, -10155518, -474467, -10105698, -3801496, 278095, 23440562, -290208},
+ FieldElement{10226241, -5928702, 15139956, 120818, -14867693, 5218603, 32937275, 11551483, -16571960, -7442864},
+ FieldElement{17932739, -12437276, -24039557, 10749060, 11316803, 7535897, 22503767, 5561594, -3646624, 3898661},
+ },
+ {
+ FieldElement{7749907, -969567, -16339731, -16464, -25018111, 15122143, -1573531, 7152530, 21831162, 1245233},
+ FieldElement{26958459, -14658026, 4314586, 8346991, -5677764, 11960072, -32589295, -620035, -30402091, -16716212},
+ FieldElement{-12165896, 9166947, 33491384, 13673479, 29787085, 13096535, 6280834, 14587357, -22338025, 13987525},
+ },
+ {
+ FieldElement{-24349909, 7778775, 21116000, 15572597, -4833266, -5357778, -4300898, -5124639, -7469781, -2858068},
+ FieldElement{9681908, -6737123, -31951644, 13591838, -6883821, 386950, 31622781, 6439245, -14581012, 4091397},
+ FieldElement{-8426427, 1470727, -28109679, -1596990, 3978627, -5123623, -19622683, 12092163, 29077877, -14741988},
+ },
+ {
+ FieldElement{5269168, -6859726, -13230211, -8020715, 25932563, 1763552, -5606110, -5505881, -20017847, 2357889},
+ FieldElement{32264008, -15407652, -5387735, -1160093, -2091322, -3946900, 23104804, -12869908, 5727338, 189038},
+ FieldElement{14609123, -8954470, -6000566, -16622781, -14577387, -7743898, -26745169, 10942115, -25888931, -14884697},
+ },
+ {
+ FieldElement{20513500, 5557931, -15604613, 7829531, 26413943, -2019404, -21378968, 7471781, 13913677, -5137875},
+ FieldElement{-25574376, 11967826, 29233242, 12948236, -6754465, 4713227, -8940970, 14059180, 12878652, 8511905},
+ FieldElement{-25656801, 3393631, -2955415, -7075526, -2250709, 9366908, -30223418, 6812974, 5568676, -3127656},
+ },
+ {
+ FieldElement{11630004, 12144454, 2116339, 13606037, 27378885, 15676917, -17408753, -13504373, -14395196, 8070818},
+ FieldElement{27117696, -10007378, -31282771, -5570088, 1127282, 12772488, -29845906, 10483306, -11552749, -1028714},
+ FieldElement{10637467, -5688064, 5674781, 1072708, -26343588, -6982302, -1683975, 9177853, -27493162, 15431203},
+ },
+ {
+ FieldElement{20525145, 10892566, -12742472, 12779443, -29493034, 16150075, -28240519, 14943142, -15056790, -7935931},
+ FieldElement{-30024462, 5626926, -551567, -9981087, 753598, 11981191, 25244767, -3239766, -3356550, 9594024},
+ FieldElement{-23752644, 2636870, -5163910, -10103818, 585134, 7877383, 11345683, -6492290, 13352335, -10977084},
+ },
+ {
+ FieldElement{-1931799, -5407458, 3304649, -12884869, 17015806, -4877091, -29783850, -7752482, -13215537, -319204},
+ FieldElement{20239939, 6607058, 6203985, 3483793, -18386976, -779229, -20723742, 15077870, -22750759, 14523817},
+ FieldElement{27406042, -6041657, 27423596, -4497394, 4996214, 10002360, -28842031, -4545494, -30172742, -4805667},
+ },
+ },
+ {
+ {
+ FieldElement{11374242, 12660715, 17861383, -12540833, 10935568, 1099227, -13886076, -9091740, -27727044, 11358504},
+ FieldElement{-12730809, 10311867, 1510375, 10778093, -2119455, -9145702, 32676003, 11149336, -26123651, 4985768},
+ FieldElement{-19096303, 341147, -6197485, -239033, 15756973, -8796662, -983043, 13794114, -19414307, -15621255},
+ },
+ {
+ FieldElement{6490081, 11940286, 25495923, -7726360, 8668373, -8751316, 3367603, 6970005, -1691065, -9004790},
+ FieldElement{1656497, 13457317, 15370807, 6364910, 13605745, 8362338, -19174622, -5475723, -16796596, -5031438},
+ FieldElement{-22273315, -13524424, -64685, -4334223, -18605636, -10921968, -20571065, -7007978, -99853, -10237333},
+ },
+ {
+ FieldElement{17747465, 10039260, 19368299, -4050591, -20630635, -16041286, 31992683, -15857976, -29260363, -5511971},
+ FieldElement{31932027, -4986141, -19612382, 16366580, 22023614, 88450, 11371999, -3744247, 4882242, -10626905},
+ FieldElement{29796507, 37186, 19818052, 10115756, -11829032, 3352736, 18551198, 3272828, -5190932, -4162409},
+ },
+ {
+ FieldElement{12501286, 4044383, -8612957, -13392385, -32430052, 5136599, -19230378, -3529697, 330070, -3659409},
+ FieldElement{6384877, 2899513, 17807477, 7663917, -2358888, 12363165, 25366522, -8573892, -271295, 12071499},
+ FieldElement{-8365515, -4042521, 25133448, -4517355, -6211027, 2265927, -32769618, 1936675, -5159697, 3829363},
+ },
+ {
+ FieldElement{28425966, -5835433, -577090, -4697198, -14217555, 6870930, 7921550, -6567787, 26333140, 14267664},
+ FieldElement{-11067219, 11871231, 27385719, -10559544, -4585914, -11189312, 10004786, -8709488, -21761224, 8930324},
+ FieldElement{-21197785, -16396035, 25654216, -1725397, 12282012, 11008919, 1541940, 4757911, -26491501, -16408940},
+ },
+ {
+ FieldElement{13537262, -7759490, -20604840, 10961927, -5922820, -13218065, -13156584, 6217254, -15943699, 13814990},
+ FieldElement{-17422573, 15157790, 18705543, 29619, 24409717, -260476, 27361681, 9257833, -1956526, -1776914},
+ FieldElement{-25045300, -10191966, 15366585, 15166509, -13105086, 8423556, -29171540, 12361135, -18685978, 4578290},
+ },
+ {
+ FieldElement{24579768, 3711570, 1342322, -11180126, -27005135, 14124956, -22544529, 14074919, 21964432, 8235257},
+ FieldElement{-6528613, -2411497, 9442966, -5925588, 12025640, -1487420, -2981514, -1669206, 13006806, 2355433},
+ FieldElement{-16304899, -13605259, -6632427, -5142349, 16974359, -10911083, 27202044, 1719366, 1141648, -12796236},
+ },
+ {
+ FieldElement{-12863944, -13219986, -8318266, -11018091, -6810145, -4843894, 13475066, -3133972, 32674895, 13715045},
+ FieldElement{11423335, -5468059, 32344216, 8962751, 24989809, 9241752, -13265253, 16086212, -28740881, -15642093},
+ FieldElement{-1409668, 12530728, -6368726, 10847387, 19531186, -14132160, -11709148, 7791794, -27245943, 4383347},
+ },
+ },
+ {
+ {
+ FieldElement{-28970898, 5271447, -1266009, -9736989, -12455236, 16732599, -4862407, -4906449, 27193557, 6245191},
+ FieldElement{-15193956, 5362278, -1783893, 2695834, 4960227, 12840725, 23061898, 3260492, 22510453, 8577507},
+ FieldElement{-12632451, 11257346, -32692994, 13548177, -721004, 10879011, 31168030, 13952092, -29571492, -3635906},
+ },
+ {
+ FieldElement{3877321, -9572739, 32416692, 5405324, -11004407, -13656635, 3759769, 11935320, 5611860, 8164018},
+ FieldElement{-16275802, 14667797, 15906460, 12155291, -22111149, -9039718, 32003002, -8832289, 5773085, -8422109},
+ FieldElement{-23788118, -8254300, 1950875, 8937633, 18686727, 16459170, -905725, 12376320, 31632953, 190926},
+ },
+ {
+ FieldElement{-24593607, -16138885, -8423991, 13378746, 14162407, 6901328, -8288749, 4508564, -25341555, -3627528},
+ FieldElement{8884438, -5884009, 6023974, 10104341, -6881569, -4941533, 18722941, -14786005, -1672488, 827625},
+ FieldElement{-32720583, -16289296, -32503547, 7101210, 13354605, 2659080, -1800575, -14108036, -24878478, 1541286},
+ },
+ {
+ FieldElement{2901347, -1117687, 3880376, -10059388, -17620940, -3612781, -21802117, -3567481, 20456845, -1885033},
+ FieldElement{27019610, 12299467, -13658288, -1603234, -12861660, -4861471, -19540150, -5016058, 29439641, 15138866},
+ FieldElement{21536104, -6626420, -32447818, -10690208, -22408077, 5175814, -5420040, -16361163, 7779328, 109896},
+ },
+ {
+ FieldElement{30279744, 14648750, -8044871, 6425558, 13639621, -743509, 28698390, 12180118, 23177719, -554075},
+ FieldElement{26572847, 3405927, -31701700, 12890905, -19265668, 5335866, -6493768, 2378492, 4439158, -13279347},
+ FieldElement{-22716706, 3489070, -9225266, -332753, 18875722, -1140095, 14819434, -12731527, -17717757, -5461437},
+ },
+ {
+ FieldElement{-5056483, 16566551, 15953661, 3767752, -10436499, 15627060, -820954, 2177225, 8550082, -15114165},
+ FieldElement{-18473302, 16596775, -381660, 15663611, 22860960, 15585581, -27844109, -3582739, -23260460, -8428588},
+ FieldElement{-32480551, 15707275, -8205912, -5652081, 29464558, 2713815, -22725137, 15860482, -21902570, 1494193},
+ },
+ {
+ FieldElement{-19562091, -14087393, -25583872, -9299552, 13127842, 759709, 21923482, 16529112, 8742704, 12967017},
+ FieldElement{-28464899, 1553205, 32536856, -10473729, -24691605, -406174, -8914625, -2933896, -29903758, 15553883},
+ FieldElement{21877909, 3230008, 9881174, 10539357, -4797115, 2841332, 11543572, 14513274, 19375923, -12647961},
+ },
+ {
+ FieldElement{8832269, -14495485, 13253511, 5137575, 5037871, 4078777, 24880818, -6222716, 2862653, 9455043},
+ FieldElement{29306751, 5123106, 20245049, -14149889, 9592566, 8447059, -2077124, -2990080, 15511449, 4789663},
+ FieldElement{-20679756, 7004547, 8824831, -9434977, -4045704, -3750736, -5754762, 108893, 23513200, 16652362},
+ },
+ },
+ {
+ {
+ FieldElement{-33256173, 4144782, -4476029, -6579123, 10770039, -7155542, -6650416, -12936300, -18319198, 10212860},
+ FieldElement{2756081, 8598110, 7383731, -6859892, 22312759, -1105012, 21179801, 2600940, -9988298, -12506466},
+ FieldElement{-24645692, 13317462, -30449259, -15653928, 21365574, -10869657, 11344424, 864440, -2499677, -16710063},
+ },
+ {
+ FieldElement{-26432803, 6148329, -17184412, -14474154, 18782929, -275997, -22561534, 211300, 2719757, 4940997},
+ FieldElement{-1323882, 3911313, -6948744, 14759765, -30027150, 7851207, 21690126, 8518463, 26699843, 5276295},
+ FieldElement{-13149873, -6429067, 9396249, 365013, 24703301, -10488939, 1321586, 149635, -15452774, 7159369},
+ },
+ {
+ FieldElement{9987780, -3404759, 17507962, 9505530, 9731535, -2165514, 22356009, 8312176, 22477218, -8403385},
+ FieldElement{18155857, -16504990, 19744716, 9006923, 15154154, -10538976, 24256460, -4864995, -22548173, 9334109},
+ FieldElement{2986088, -4911893, 10776628, -3473844, 10620590, -7083203, -21413845, 14253545, -22587149, 536906},
+ },
+ {
+ FieldElement{4377756, 8115836, 24567078, 15495314, 11625074, 13064599, 7390551, 10589625, 10838060, -15420424},
+ FieldElement{-19342404, 867880, 9277171, -3218459, -14431572, -1986443, 19295826, -15796950, 6378260, 699185},
+ FieldElement{7895026, 4057113, -7081772, -13077756, -17886831, -323126, -716039, 15693155, -5045064, -13373962},
+ },
+ {
+ FieldElement{-7737563, -5869402, -14566319, -7406919, 11385654, 13201616, 31730678, -10962840, -3918636, -9669325},
+ FieldElement{10188286, -15770834, -7336361, 13427543, 22223443, 14896287, 30743455, 7116568, -21786507, 5427593},
+ FieldElement{696102, 13206899, 27047647, -10632082, 15285305, -9853179, 10798490, -4578720, 19236243, 12477404},
+ },
+ {
+ FieldElement{-11229439, 11243796, -17054270, -8040865, -788228, -8167967, -3897669, 11180504, -23169516, 7733644},
+ FieldElement{17800790, -14036179, -27000429, -11766671, 23887827, 3149671, 23466177, -10538171, 10322027, 15313801},
+ FieldElement{26246234, 11968874, 32263343, -5468728, 6830755, -13323031, -15794704, -101982, -24449242, 10890804},
+ },
+ {
+ FieldElement{-31365647, 10271363, -12660625, -6267268, 16690207, -13062544, -14982212, 16484931, 25180797, -5334884},
+ FieldElement{-586574, 10376444, -32586414, -11286356, 19801893, 10997610, 2276632, 9482883, 316878, 13820577},
+ FieldElement{-9882808, -4510367, -2115506, 16457136, -11100081, 11674996, 30756178, -7515054, 30696930, -3712849},
+ },
+ {
+ FieldElement{32988917, -9603412, 12499366, 7910787, -10617257, -11931514, -7342816, -9985397, -32349517, 7392473},
+ FieldElement{-8855661, 15927861, 9866406, -3649411, -2396914, -16655781, -30409476, -9134995, 25112947, -2926644},
+ FieldElement{-2504044, -436966, 25621774, -5678772, 15085042, -5479877, -24884878, -13526194, 5537438, -13914319},
+ },
+ },
+ {
+ {
+ FieldElement{-11225584, 2320285, -9584280, 10149187, -33444663, 5808648, -14876251, -1729667, 31234590, 6090599},
+ FieldElement{-9633316, 116426, 26083934, 2897444, -6364437, -2688086, 609721, 15878753, -6970405, -9034768},
+ FieldElement{-27757857, 247744, -15194774, -9002551, 23288161, -10011936, -23869595, 6503646, 20650474, 1804084},
+ },
+ {
+ FieldElement{-27589786, 15456424, 8972517, 8469608, 15640622, 4439847, 3121995, -10329713, 27842616, -202328},
+ FieldElement{-15306973, 2839644, 22530074, 10026331, 4602058, 5048462, 28248656, 5031932, -11375082, 12714369},
+ FieldElement{20807691, -7270825, 29286141, 11421711, -27876523, -13868230, -21227475, 1035546, -19733229, 12796920},
+ },
+ {
+ FieldElement{12076899, -14301286, -8785001, -11848922, -25012791, 16400684, -17591495, -12899438, 3480665, -15182815},
+ FieldElement{-32361549, 5457597, 28548107, 7833186, 7303070, -11953545, -24363064, -15921875, -33374054, 2771025},
+ FieldElement{-21389266, 421932, 26597266, 6860826, 22486084, -6737172, -17137485, -4210226, -24552282, 15673397},
+ },
+ {
+ FieldElement{-20184622, 2338216, 19788685, -9620956, -4001265, -8740893, -20271184, 4733254, 3727144, -12934448},
+ FieldElement{6120119, 814863, -11794402, -622716, 6812205, -15747771, 2019594, 7975683, 31123697, -10958981},
+ FieldElement{30069250, -11435332, 30434654, 2958439, 18399564, -976289, 12296869, 9204260, -16432438, 9648165},
+ },
+ {
+ FieldElement{32705432, -1550977, 30705658, 7451065, -11805606, 9631813, 3305266, 5248604, -26008332, -11377501},
+ FieldElement{17219865, 2375039, -31570947, -5575615, -19459679, 9219903, 294711, 15298639, 2662509, -16297073},
+ FieldElement{-1172927, -7558695, -4366770, -4287744, -21346413, -8434326, 32087529, -1222777, 32247248, -14389861},
+ },
+ {
+ FieldElement{14312628, 1221556, 17395390, -8700143, -4945741, -8684635, -28197744, -9637817, -16027623, -13378845},
+ FieldElement{-1428825, -9678990, -9235681, 6549687, -7383069, -468664, 23046502, 9803137, 17597934, 2346211},
+ FieldElement{18510800, 15337574, 26171504, 981392, -22241552, 7827556, -23491134, -11323352, 3059833, -11782870},
+ },
+ {
+ FieldElement{10141598, 6082907, 17829293, -1947643, 9830092, 13613136, -25556636, -5544586, -33502212, 3592096},
+ FieldElement{33114168, -15889352, -26525686, -13343397, 33076705, 8716171, 1151462, 1521897, -982665, -6837803},
+ FieldElement{-32939165, -4255815, 23947181, -324178, -33072974, -12305637, -16637686, 3891704, 26353178, 693168},
+ },
+ {
+ FieldElement{30374239, 1595580, -16884039, 13186931, 4600344, 406904, 9585294, -400668, 31375464, 14369965},
+ FieldElement{-14370654, -7772529, 1510301, 6434173, -18784789, -6262728, 32732230, -13108839, 17901441, 16011505},
+ FieldElement{18171223, -11934626, -12500402, 15197122, -11038147, -15230035, -19172240, -16046376, 8764035, 12309598},
+ },
+ },
+ {
+ {
+ FieldElement{5975908, -5243188, -19459362, -9681747, -11541277, 14015782, -23665757, 1228319, 17544096, -10593782},
+ FieldElement{5811932, -1715293, 3442887, -2269310, -18367348, -8359541, -18044043, -15410127, -5565381, 12348900},
+ FieldElement{-31399660, 11407555, 25755363, 6891399, -3256938, 14872274, -24849353, 8141295, -10632534, -585479},
+ },
+ {
+ FieldElement{-12675304, 694026, -5076145, 13300344, 14015258, -14451394, -9698672, -11329050, 30944593, 1130208},
+ FieldElement{8247766, -6710942, -26562381, -7709309, -14401939, -14648910, 4652152, 2488540, 23550156, -271232},
+ FieldElement{17294316, -3788438, 7026748, 15626851, 22990044, 113481, 2267737, -5908146, -408818, -137719},
+ },
+ {
+ FieldElement{16091085, -16253926, 18599252, 7340678, 2137637, -1221657, -3364161, 14550936, 3260525, -7166271},
+ FieldElement{-4910104, -13332887, 18550887, 10864893, -16459325, -7291596, -23028869, -13204905, -12748722, 2701326},
+ FieldElement{-8574695, 16099415, 4629974, -16340524, -20786213, -6005432, -10018363, 9276971, 11329923, 1862132},
+ },
+ {
+ FieldElement{14763076, -15903608, -30918270, 3689867, 3511892, 10313526, -21951088, 12219231, -9037963, -940300},
+ FieldElement{8894987, -3446094, 6150753, 3013931, 301220, 15693451, -31981216, -2909717, -15438168, 11595570},
+ FieldElement{15214962, 3537601, -26238722, -14058872, 4418657, -15230761, 13947276, 10730794, -13489462, -4363670},
+ },
+ {
+ FieldElement{-2538306, 7682793, 32759013, 263109, -29984731, -7955452, -22332124, -10188635, 977108, 699994},
+ FieldElement{-12466472, 4195084, -9211532, 550904, -15565337, 12917920, 19118110, -439841, -30534533, -14337913},
+ FieldElement{31788461, -14507657, 4799989, 7372237, 8808585, -14747943, 9408237, -10051775, 12493932, -5409317},
+ },
+ {
+ FieldElement{-25680606, 5260744, -19235809, -6284470, -3695942, 16566087, 27218280, 2607121, 29375955, 6024730},
+ FieldElement{842132, -2794693, -4763381, -8722815, 26332018, -12405641, 11831880, 6985184, -9940361, 2854096},
+ FieldElement{-4847262, -7969331, 2516242, -5847713, 9695691, -7221186, 16512645, 960770, 12121869, 16648078},
+ },
+ {
+ FieldElement{-15218652, 14667096, -13336229, 2013717, 30598287, -464137, -31504922, -7882064, 20237806, 2838411},
+ FieldElement{-19288047, 4453152, 15298546, -16178388, 22115043, -15972604, 12544294, -13470457, 1068881, -12499905},
+ FieldElement{-9558883, -16518835, 33238498, 13506958, 30505848, -1114596, -8486907, -2630053, 12521378, 4845654},
+ },
+ {
+ FieldElement{-28198521, 10744108, -2958380, 10199664, 7759311, -13088600, 3409348, -873400, -6482306, -12885870},
+ FieldElement{-23561822, 6230156, -20382013, 10655314, -24040585, -11621172, 10477734, -1240216, -3113227, 13974498},
+ FieldElement{12966261, 15550616, -32038948, -1615346, 21025980, -629444, 5642325, 7188737, 18895762, 12629579},
+ },
+ },
+ {
+ {
+ FieldElement{14741879, -14946887, 22177208, -11721237, 1279741, 8058600, 11758140, 789443, 32195181, 3895677},
+ FieldElement{10758205, 15755439, -4509950, 9243698, -4879422, 6879879, -2204575, -3566119, -8982069, 4429647},
+ FieldElement{-2453894, 15725973, -20436342, -10410672, -5803908, -11040220, -7135870, -11642895, 18047436, -15281743},
+ },
+ {
+ FieldElement{-25173001, -11307165, 29759956, 11776784, -22262383, -15820455, 10993114, -12850837, -17620701, -9408468},
+ FieldElement{21987233, 700364, -24505048, 14972008, -7774265, -5718395, 32155026, 2581431, -29958985, 8773375},
+ FieldElement{-25568350, 454463, -13211935, 16126715, 25240068, 8594567, 20656846, 12017935, -7874389, -13920155},
+ },
+ {
+ FieldElement{6028182, 6263078, -31011806, -11301710, -818919, 2461772, -31841174, -5468042, -1721788, -2776725},
+ FieldElement{-12278994, 16624277, 987579, -5922598, 32908203, 1248608, 7719845, -4166698, 28408820, 6816612},
+ FieldElement{-10358094, -8237829, 19549651, -12169222, 22082623, 16147817, 20613181, 13982702, -10339570, 5067943},
+ },
+ {
+ FieldElement{-30505967, -3821767, 12074681, 13582412, -19877972, 2443951, -19719286, 12746132, 5331210, -10105944},
+ FieldElement{30528811, 3601899, -1957090, 4619785, -27361822, -15436388, 24180793, -12570394, 27679908, -1648928},
+ FieldElement{9402404, -13957065, 32834043, 10838634, -26580150, -13237195, 26653274, -8685565, 22611444, -12715406},
+ },
+ {
+ FieldElement{22190590, 1118029, 22736441, 15130463, -30460692, -5991321, 19189625, -4648942, 4854859, 6622139},
+ FieldElement{-8310738, -2953450, -8262579, -3388049, -10401731, -271929, 13424426, -3567227, 26404409, 13001963},
+ FieldElement{-31241838, -15415700, -2994250, 8939346, 11562230, -12840670, -26064365, -11621720, -15405155, 11020693},
+ },
+ {
+ FieldElement{1866042, -7949489, -7898649, -10301010, 12483315, 13477547, 3175636, -12424163, 28761762, 1406734},
+ FieldElement{-448555, -1777666, 13018551, 3194501, -9580420, -11161737, 24760585, -4347088, 25577411, -13378680},
+ FieldElement{-24290378, 4759345, -690653, -1852816, 2066747, 10693769, -29595790, 9884936, -9368926, 4745410},
+ },
+ {
+ FieldElement{-9141284, 6049714, -19531061, -4341411, -31260798, 9944276, -15462008, -11311852, 10931924, -11931931},
+ FieldElement{-16561513, 14112680, -8012645, 4817318, -8040464, -11414606, -22853429, 10856641, -20470770, 13434654},
+ FieldElement{22759489, -10073434, -16766264, -1871422, 13637442, -10168091, 1765144, -12654326, 28445307, -5364710},
+ },
+ {
+ FieldElement{29875063, 12493613, 2795536, -3786330, 1710620, 15181182, -10195717, -8788675, 9074234, 1167180},
+ FieldElement{-26205683, 11014233, -9842651, -2635485, -26908120, 7532294, -18716888, -9535498, 3843903, 9367684},
+ FieldElement{-10969595, -6403711, 9591134, 9582310, 11349256, 108879, 16235123, 8601684, -139197, 4242895},
+ },
+ },
+ {
+ {
+ FieldElement{22092954, -13191123, -2042793, -11968512, 32186753, -11517388, -6574341, 2470660, -27417366, 16625501},
+ FieldElement{-11057722, 3042016, 13770083, -9257922, 584236, -544855, -7770857, 2602725, -27351616, 14247413},
+ FieldElement{6314175, -10264892, -32772502, 15957557, -10157730, 168750, -8618807, 14290061, 27108877, -1180880},
+ },
+ {
+ FieldElement{-8586597, -7170966, 13241782, 10960156, -32991015, -13794596, 33547976, -11058889, -27148451, 981874},
+ FieldElement{22833440, 9293594, -32649448, -13618667, -9136966, 14756819, -22928859, -13970780, -10479804, -16197962},
+ FieldElement{-7768587, 3326786, -28111797, 10783824, 19178761, 14905060, 22680049, 13906969, -15933690, 3797899},
+ },
+ {
+ FieldElement{21721356, -4212746, -12206123, 9310182, -3882239, -13653110, 23740224, -2709232, 20491983, -8042152},
+ FieldElement{9209270, -15135055, -13256557, -6167798, -731016, 15289673, 25947805, 15286587, 30997318, -6703063},
+ FieldElement{7392032, 16618386, 23946583, -8039892, -13265164, -1533858, -14197445, -2321576, 17649998, -250080},
+ },
+ {
+ FieldElement{-9301088, -14193827, 30609526, -3049543, -25175069, -1283752, -15241566, -9525724, -2233253, 7662146},
+ FieldElement{-17558673, 1763594, -33114336, 15908610, -30040870, -12174295, 7335080, -8472199, -3174674, 3440183},
+ FieldElement{-19889700, -5977008, -24111293, -9688870, 10799743, -16571957, 40450, -4431835, 4862400, 1133},
+ },
+ {
+ FieldElement{-32856209, -7873957, -5422389, 14860950, -16319031, 7956142, 7258061, 311861, -30594991, -7379421},
+ FieldElement{-3773428, -1565936, 28985340, 7499440, 24445838, 9325937, 29727763, 16527196, 18278453, 15405622},
+ FieldElement{-4381906, 8508652, -19898366, -3674424, -5984453, 15149970, -13313598, 843523, -21875062, 13626197},
+ },
+ {
+ FieldElement{2281448, -13487055, -10915418, -2609910, 1879358, 16164207, -10783882, 3953792, 13340839, 15928663},
+ FieldElement{31727126, -7179855, -18437503, -8283652, 2875793, -16390330, -25269894, -7014826, -23452306, 5964753},
+ FieldElement{4100420, -5959452, -17179337, 6017714, -18705837, 12227141, -26684835, 11344144, 2538215, -7570755},
+ },
+ {
+ FieldElement{-9433605, 6123113, 11159803, -2156608, 30016280, 14966241, -20474983, 1485421, -629256, -15958862},
+ FieldElement{-26804558, 4260919, 11851389, 9658551, -32017107, 16367492, -20205425, -13191288, 11659922, -11115118},
+ FieldElement{26180396, 10015009, -30844224, -8581293, 5418197, 9480663, 2231568, -10170080, 33100372, -1306171},
+ },
+ {
+ FieldElement{15121113, -5201871, -10389905, 15427821, -27509937, -15992507, 21670947, 4486675, -5931810, -14466380},
+ FieldElement{16166486, -9483733, -11104130, 6023908, -31926798, -1364923, 2340060, -16254968, -10735770, -10039824},
+ FieldElement{28042865, -3557089, -12126526, 12259706, -3717498, -6945899, 6766453, -8689599, 18036436, 5803270},
+ },
+ },
+ {
+ {
+ FieldElement{-817581, 6763912, 11803561, 1585585, 10958447, -2671165, 23855391, 4598332, -6159431, -14117438},
+ FieldElement{-31031306, -14256194, 17332029, -2383520, 31312682, -5967183, 696309, 50292, -20095739, 11763584},
+ FieldElement{-594563, -2514283, -32234153, 12643980, 12650761, 14811489, 665117, -12613632, -19773211, -10713562},
+ },
+ {
+ FieldElement{30464590, -11262872, -4127476, -12734478, 19835327, -7105613, -24396175, 2075773, -17020157, 992471},
+ FieldElement{18357185, -6994433, 7766382, 16342475, -29324918, 411174, 14578841, 8080033, -11574335, -10601610},
+ FieldElement{19598397, 10334610, 12555054, 2555664, 18821899, -10339780, 21873263, 16014234, 26224780, 16452269},
+ },
+ {
+ FieldElement{-30223925, 5145196, 5944548, 16385966, 3976735, 2009897, -11377804, -7618186, -20533829, 3698650},
+ FieldElement{14187449, 3448569, -10636236, -10810935, -22663880, -3433596, 7268410, -10890444, 27394301, 12015369},
+ FieldElement{19695761, 16087646, 28032085, 12999827, 6817792, 11427614, 20244189, -1312777, -13259127, -3402461},
+ },
+ {
+ FieldElement{30860103, 12735208, -1888245, -4699734, -16974906, 2256940, -8166013, 12298312, -8550524, -10393462},
+ FieldElement{-5719826, -11245325, -1910649, 15569035, 26642876, -7587760, -5789354, -15118654, -4976164, 12651793},
+ FieldElement{-2848395, 9953421, 11531313, -5282879, 26895123, -12697089, -13118820, -16517902, 9768698, -2533218},
+ },
+ {
+ FieldElement{-24719459, 1894651, -287698, -4704085, 15348719, -8156530, 32767513, 12765450, 4940095, 10678226},
+ FieldElement{18860224, 15980149, -18987240, -1562570, -26233012, -11071856, -7843882, 13944024, -24372348, 16582019},
+ FieldElement{-15504260, 4970268, -29893044, 4175593, -20993212, -2199756, -11704054, 15444560, -11003761, 7989037},
+ },
+ {
+ FieldElement{31490452, 5568061, -2412803, 2182383, -32336847, 4531686, -32078269, 6200206, -19686113, -14800171},
+ FieldElement{-17308668, -15879940, -31522777, -2831, -32887382, 16375549, 8680158, -16371713, 28550068, -6857132},
+ FieldElement{-28126887, -5688091, 16837845, -1820458, -6850681, 12700016, -30039981, 4364038, 1155602, 5988841},
+ },
+ {
+ FieldElement{21890435, -13272907, -12624011, 12154349, -7831873, 15300496, 23148983, -4470481, 24618407, 8283181},
+ FieldElement{-33136107, -10512751, 9975416, 6841041, -31559793, 16356536, 3070187, -7025928, 1466169, 10740210},
+ FieldElement{-1509399, -15488185, -13503385, -10655916, 32799044, 909394, -13938903, -5779719, -32164649, -15327040},
+ },
+ {
+ FieldElement{3960823, -14267803, -28026090, -15918051, -19404858, 13146868, 15567327, 951507, -3260321, -573935},
+ FieldElement{24740841, 5052253, -30094131, 8961361, 25877428, 6165135, -24368180, 14397372, -7380369, -6144105},
+ FieldElement{-28888365, 3510803, -28103278, -1158478, -11238128, -10631454, -15441463, -14453128, -1625486, -6494814},
+ },
+ },
+ {
+ {
+ FieldElement{793299, -9230478, 8836302, -6235707, -27360908, -2369593, 33152843, -4885251, -9906200, -621852},
+ FieldElement{5666233, 525582, 20782575, -8038419, -24538499, 14657740, 16099374, 1468826, -6171428, -15186581},
+ FieldElement{-4859255, -3779343, -2917758, -6748019, 7778750, 11688288, -30404353, -9871238, -1558923, -9863646},
+ },
+ {
+ FieldElement{10896332, -7719704, 824275, 472601, -19460308, 3009587, 25248958, 14783338, -30581476, -15757844},
+ FieldElement{10566929, 12612572, -31944212, 11118703, -12633376, 12362879, 21752402, 8822496, 24003793, 14264025},
+ FieldElement{27713862, -7355973, -11008240, 9227530, 27050101, 2504721, 23886875, -13117525, 13958495, -5732453},
+ },
+ {
+ FieldElement{-23481610, 4867226, -27247128, 3900521, 29838369, -8212291, -31889399, -10041781, 7340521, -15410068},
+ FieldElement{4646514, -8011124, -22766023, -11532654, 23184553, 8566613, 31366726, -1381061, -15066784, -10375192},
+ FieldElement{-17270517, 12723032, -16993061, 14878794, 21619651, -6197576, 27584817, 3093888, -8843694, 3849921},
+ },
+ {
+ FieldElement{-9064912, 2103172, 25561640, -15125738, -5239824, 9582958, 32477045, -9017955, 5002294, -15550259},
+ FieldElement{-12057553, -11177906, 21115585, -13365155, 8808712, -12030708, 16489530, 13378448, -25845716, 12741426},
+ FieldElement{-5946367, 10645103, -30911586, 15390284, -3286982, -7118677, 24306472, 15852464, 28834118, -7646072},
+ },
+ {
+ FieldElement{-17335748, -9107057, -24531279, 9434953, -8472084, -583362, -13090771, 455841, 20461858, 5491305},
+ FieldElement{13669248, -16095482, -12481974, -10203039, -14569770, -11893198, -24995986, 11293807, -28588204, -9421832},
+ FieldElement{28497928, 6272777, -33022994, 14470570, 8906179, -1225630, 18504674, -14165166, 29867745, -8795943},
+ },
+ {
+ FieldElement{-16207023, 13517196, -27799630, -13697798, 24009064, -6373891, -6367600, -13175392, 22853429, -4012011},
+ FieldElement{24191378, 16712145, -13931797, 15217831, 14542237, 1646131, 18603514, -11037887, 12876623, -2112447},
+ FieldElement{17902668, 4518229, -411702, -2829247, 26878217, 5258055, -12860753, 608397, 16031844, 3723494},
+ },
+ {
+ FieldElement{-28632773, 12763728, -20446446, 7577504, 33001348, -13017745, 17558842, -7872890, 23896954, -4314245},
+ FieldElement{-20005381, -12011952, 31520464, 605201, 2543521, 5991821, -2945064, 7229064, -9919646, -8826859},
+ FieldElement{28816045, 298879, -28165016, -15920938, 19000928, -1665890, -12680833, -2949325, -18051778, -2082915},
+ },
+ {
+ FieldElement{16000882, -344896, 3493092, -11447198, -29504595, -13159789, 12577740, 16041268, -19715240, 7847707},
+ FieldElement{10151868, 10572098, 27312476, 7922682, 14825339, 4723128, -32855931, -6519018, -10020567, 3852848},
+ FieldElement{-11430470, 15697596, -21121557, -4420647, 5386314, 15063598, 16514493, -15932110, 29330899, -15076224},
+ },
+ },
+ {
+ {
+ FieldElement{-25499735, -4378794, -15222908, -6901211, 16615731, 2051784, 3303702, 15490, -27548796, 12314391},
+ FieldElement{15683520, -6003043, 18109120, -9980648, 15337968, -5997823, -16717435, 15921866, 16103996, -3731215},
+ FieldElement{-23169824, -10781249, 13588192, -1628807, -3798557, -1074929, -19273607, 5402699, -29815713, -9841101},
+ },
+ {
+ FieldElement{23190676, 2384583, -32714340, 3462154, -29903655, -1529132, -11266856, 8911517, -25205859, 2739713},
+ FieldElement{21374101, -3554250, -33524649, 9874411, 15377179, 11831242, -33529904, 6134907, 4931255, 11987849},
+ FieldElement{-7732, -2978858, -16223486, 7277597, 105524, -322051, -31480539, 13861388, -30076310, 10117930},
+ },
+ {
+ FieldElement{-29501170, -10744872, -26163768, 13051539, -25625564, 5089643, -6325503, 6704079, 12890019, 15728940},
+ FieldElement{-21972360, -11771379, -951059, -4418840, 14704840, 2695116, 903376, -10428139, 12885167, 8311031},
+ FieldElement{-17516482, 5352194, 10384213, -13811658, 7506451, 13453191, 26423267, 4384730, 1888765, -5435404},
+ },
+ {
+ FieldElement{-25817338, -3107312, -13494599, -3182506, 30896459, -13921729, -32251644, -12707869, -19464434, -3340243},
+ FieldElement{-23607977, -2665774, -526091, 4651136, 5765089, 4618330, 6092245, 14845197, 17151279, -9854116},
+ FieldElement{-24830458, -12733720, -15165978, 10367250, -29530908, -265356, 22825805, -7087279, -16866484, 16176525},
+ },
+ {
+ FieldElement{-23583256, 6564961, 20063689, 3798228, -4740178, 7359225, 2006182, -10363426, -28746253, -10197509},
+ FieldElement{-10626600, -4486402, -13320562, -5125317, 3432136, -6393229, 23632037, -1940610, 32808310, 1099883},
+ FieldElement{15030977, 5768825, -27451236, -2887299, -6427378, -15361371, -15277896, -6809350, 2051441, -15225865},
+ },
+ {
+ FieldElement{-3362323, -7239372, 7517890, 9824992, 23555850, 295369, 5148398, -14154188, -22686354, 16633660},
+ FieldElement{4577086, -16752288, 13249841, -15304328, 19958763, -14537274, 18559670, -10759549, 8402478, -9864273},
+ FieldElement{-28406330, -1051581, -26790155, -907698, -17212414, -11030789, 9453451, -14980072, 17983010, 9967138},
+ },
+ {
+ FieldElement{-25762494, 6524722, 26585488, 9969270, 24709298, 1220360, -1677990, 7806337, 17507396, 3651560},
+ FieldElement{-10420457, -4118111, 14584639, 15971087, -15768321, 8861010, 26556809, -5574557, -18553322, -11357135},
+ FieldElement{2839101, 14284142, 4029895, 3472686, 14402957, 12689363, -26642121, 8459447, -5605463, -7621941},
+ },
+ {
+ FieldElement{-4839289, -3535444, 9744961, 2871048, 25113978, 3187018, -25110813, -849066, 17258084, -7977739},
+ FieldElement{18164541, -10595176, -17154882, -1542417, 19237078, -9745295, 23357533, -15217008, 26908270, 12150756},
+ FieldElement{-30264870, -7647865, 5112249, -7036672, -1499807, -6974257, 43168, -5537701, -32302074, 16215819},
+ },
+ },
+ {
+ {
+ FieldElement{-6898905, 9824394, -12304779, -4401089, -31397141, -6276835, 32574489, 12532905, -7503072, -8675347},
+ FieldElement{-27343522, -16515468, -27151524, -10722951, 946346, 16291093, 254968, 7168080, 21676107, -1943028},
+ FieldElement{21260961, -8424752, -16831886, -11920822, -23677961, 3968121, -3651949, -6215466, -3556191, -7913075},
+ },
+ {
+ FieldElement{16544754, 13250366, -16804428, 15546242, -4583003, 12757258, -2462308, -8680336, -18907032, -9662799},
+ FieldElement{-2415239, -15577728, 18312303, 4964443, -15272530, -12653564, 26820651, 16690659, 25459437, -4564609},
+ FieldElement{-25144690, 11425020, 28423002, -11020557, -6144921, -15826224, 9142795, -2391602, -6432418, -1644817},
+ },
+ {
+ FieldElement{-23104652, 6253476, 16964147, -3768872, -25113972, -12296437, -27457225, -16344658, 6335692, 7249989},
+ FieldElement{-30333227, 13979675, 7503222, -12368314, -11956721, -4621693, -30272269, 2682242, 25993170, -12478523},
+ FieldElement{4364628, 5930691, 32304656, -10044554, -8054781, 15091131, 22857016, -10598955, 31820368, 15075278},
+ },
+ {
+ FieldElement{31879134, -8918693, 17258761, 90626, -8041836, -4917709, 24162788, -9650886, -17970238, 12833045},
+ FieldElement{19073683, 14851414, -24403169, -11860168, 7625278, 11091125, -19619190, 2074449, -9413939, 14905377},
+ FieldElement{24483667, -11935567, -2518866, -11547418, -1553130, 15355506, -25282080, 9253129, 27628530, -7555480},
+ },
+ {
+ FieldElement{17597607, 8340603, 19355617, 552187, 26198470, -3176583, 4593324, -9157582, -14110875, 15297016},
+ FieldElement{510886, 14337390, -31785257, 16638632, 6328095, 2713355, -20217417, -11864220, 8683221, 2921426},
+ FieldElement{18606791, 11874196, 27155355, -5281482, -24031742, 6265446, -25178240, -1278924, 4674690, 13890525},
+ },
+ {
+ FieldElement{13609624, 13069022, -27372361, -13055908, 24360586, 9592974, 14977157, 9835105, 4389687, 288396},
+ FieldElement{9922506, -519394, 13613107, 5883594, -18758345, -434263, -12304062, 8317628, 23388070, 16052080},
+ FieldElement{12720016, 11937594, -31970060, -5028689, 26900120, 8561328, -20155687, -11632979, -14754271, -10812892},
+ },
+ {
+ FieldElement{15961858, 14150409, 26716931, -665832, -22794328, 13603569, 11829573, 7467844, -28822128, 929275},
+ FieldElement{11038231, -11582396, -27310482, -7316562, -10498527, -16307831, -23479533, -9371869, -21393143, 2465074},
+ FieldElement{20017163, -4323226, 27915242, 1529148, 12396362, 15675764, 13817261, -9658066, 2463391, -4622140},
+ },
+ {
+ FieldElement{-16358878, -12663911, -12065183, 4996454, -1256422, 1073572, 9583558, 12851107, 4003896, 12673717},
+ FieldElement{-1731589, -15155870, -3262930, 16143082, 19294135, 13385325, 14741514, -9103726, 7903886, 2348101},
+ FieldElement{24536016, -16515207, 12715592, -3862155, 1511293, 10047386, -3842346, -7129159, -28377538, 10048127},
+ },
+ },
+ {
+ {
+ FieldElement{-12622226, -6204820, 30718825, 2591312, -10617028, 12192840, 18873298, -7297090, -32297756, 15221632},
+ FieldElement{-26478122, -11103864, 11546244, -1852483, 9180880, 7656409, -21343950, 2095755, 29769758, 6593415},
+ FieldElement{-31994208, -2907461, 4176912, 3264766, 12538965, -868111, 26312345, -6118678, 30958054, 8292160},
+ },
+ {
+ FieldElement{31429822, -13959116, 29173532, 15632448, 12174511, -2760094, 32808831, 3977186, 26143136, -3148876},
+ FieldElement{22648901, 1402143, -22799984, 13746059, 7936347, 365344, -8668633, -1674433, -3758243, -2304625},
+ FieldElement{-15491917, 8012313, -2514730, -12702462, -23965846, -10254029, -1612713, -1535569, -16664475, 8194478},
+ },
+ {
+ FieldElement{27338066, -7507420, -7414224, 10140405, -19026427, -6589889, 27277191, 8855376, 28572286, 3005164},
+ FieldElement{26287124, 4821776, 25476601, -4145903, -3764513, -15788984, -18008582, 1182479, -26094821, -13079595},
+ FieldElement{-7171154, 3178080, 23970071, 6201893, -17195577, -4489192, -21876275, -13982627, 32208683, -1198248},
+ },
+ {
+ FieldElement{-16657702, 2817643, -10286362, 14811298, 6024667, 13349505, -27315504, -10497842, -27672585, -11539858},
+ FieldElement{15941029, -9405932, -21367050, 8062055, 31876073, -238629, -15278393, -1444429, 15397331, -4130193},
+ FieldElement{8934485, -13485467, -23286397, -13423241, -32446090, 14047986, 31170398, -1441021, -27505566, 15087184},
+ },
+ {
+ FieldElement{-18357243, -2156491, 24524913, -16677868, 15520427, -6360776, -15502406, 11461896, 16788528, -5868942},
+ FieldElement{-1947386, 16013773, 21750665, 3714552, -17401782, -16055433, -3770287, -10323320, 31322514, -11615635},
+ FieldElement{21426655, -5650218, -13648287, -5347537, -28812189, -4920970, -18275391, -14621414, 13040862, -12112948},
+ },
+ {
+ FieldElement{11293895, 12478086, -27136401, 15083750, -29307421, 14748872, 14555558, -13417103, 1613711, 4896935},
+ FieldElement{-25894883, 15323294, -8489791, -8057900, 25967126, -13425460, 2825960, -4897045, -23971776, -11267415},
+ FieldElement{-15924766, -5229880, -17443532, 6410664, 3622847, 10243618, 20615400, 12405433, -23753030, -8436416},
+ },
+ {
+ FieldElement{-7091295, 12556208, -20191352, 9025187, -17072479, 4333801, 4378436, 2432030, 23097949, -566018},
+ FieldElement{4565804, -16025654, 20084412, -7842817, 1724999, 189254, 24767264, 10103221, -18512313, 2424778},
+ FieldElement{366633, -11976806, 8173090, -6890119, 30788634, 5745705, -7168678, 1344109, -3642553, 12412659},
+ },
+ {
+ FieldElement{-24001791, 7690286, 14929416, -168257, -32210835, -13412986, 24162697, -15326504, -3141501, 11179385},
+ FieldElement{18289522, -14724954, 8056945, 16430056, -21729724, 7842514, -6001441, -1486897, -18684645, -11443503},
+ FieldElement{476239, 6601091, -6152790, -9723375, 17503545, -4863900, 27672959, 13403813, 11052904, 5219329},
+ },
+ },
+ {
+ {
+ FieldElement{20678546, -8375738, -32671898, 8849123, -5009758, 14574752, 31186971, -3973730, 9014762, -8579056},
+ FieldElement{-13644050, -10350239, -15962508, 5075808, -1514661, -11534600, -33102500, 9160280, 8473550, -3256838},
+ FieldElement{24900749, 14435722, 17209120, -15292541, -22592275, 9878983, -7689309, -16335821, -24568481, 11788948},
+ },
+ {
+ FieldElement{-3118155, -11395194, -13802089, 14797441, 9652448, -6845904, -20037437, 10410733, -24568470, -1458691},
+ FieldElement{-15659161, 16736706, -22467150, 10215878, -9097177, 7563911, 11871841, -12505194, -18513325, 8464118},
+ FieldElement{-23400612, 8348507, -14585951, -861714, -3950205, -6373419, 14325289, 8628612, 33313881, -8370517},
+ },
+ {
+ FieldElement{-20186973, -4967935, 22367356, 5271547, -1097117, -4788838, -24805667, -10236854, -8940735, -5818269},
+ FieldElement{-6948785, -1795212, -32625683, -16021179, 32635414, -7374245, 15989197, -12838188, 28358192, -4253904},
+ FieldElement{-23561781, -2799059, -32351682, -1661963, -9147719, 10429267, -16637684, 4072016, -5351664, 5596589},
+ },
+ {
+ FieldElement{-28236598, -3390048, 12312896, 6213178, 3117142, 16078565, 29266239, 2557221, 1768301, 15373193},
+ FieldElement{-7243358, -3246960, -4593467, -7553353, -127927, -912245, -1090902, -4504991, -24660491, 3442910},
+ FieldElement{-30210571, 5124043, 14181784, 8197961, 18964734, -11939093, 22597931, 7176455, -18585478, 13365930},
+ },
+ {
+ FieldElement{-7877390, -1499958, 8324673, 4690079, 6261860, 890446, 24538107, -8570186, -9689599, -3031667},
+ FieldElement{25008904, -10771599, -4305031, -9638010, 16265036, 15721635, 683793, -11823784, 15723479, -15163481},
+ FieldElement{-9660625, 12374379, -27006999, -7026148, -7724114, -12314514, 11879682, 5400171, 519526, -1235876},
+ },
+ {
+ FieldElement{22258397, -16332233, -7869817, 14613016, -22520255, -2950923, -20353881, 7315967, 16648397, 7605640},
+ FieldElement{-8081308, -8464597, -8223311, 9719710, 19259459, -15348212, 23994942, -5281555, -9468848, 4763278},
+ FieldElement{-21699244, 9220969, -15730624, 1084137, -25476107, -2852390, 31088447, -7764523, -11356529, 728112},
+ },
+ {
+ FieldElement{26047220, -11751471, -6900323, -16521798, 24092068, 9158119, -4273545, -12555558, -29365436, -5498272},
+ FieldElement{17510331, -322857, 5854289, 8403524, 17133918, -3112612, -28111007, 12327945, 10750447, 10014012},
+ FieldElement{-10312768, 3936952, 9156313, -8897683, 16498692, -994647, -27481051, -666732, 3424691, 7540221},
+ },
+ {
+ FieldElement{30322361, -6964110, 11361005, -4143317, 7433304, 4989748, -7071422, -16317219, -9244265, 15258046},
+ FieldElement{13054562, -2779497, 19155474, 469045, -12482797, 4566042, 5631406, 2711395, 1062915, -5136345},
+ FieldElement{-19240248, -11254599, -29509029, -7499965, -5835763, 13005411, -6066489, 12194497, 32960380, 1459310},
+ },
+ },
+ {
+ {
+ FieldElement{19852034, 7027924, 23669353, 10020366, 8586503, -6657907, 394197, -6101885, 18638003, -11174937},
+ FieldElement{31395534, 15098109, 26581030, 8030562, -16527914, -5007134, 9012486, -7584354, -6643087, -5442636},
+ FieldElement{-9192165, -2347377, -1997099, 4529534, 25766844, 607986, -13222, 9677543, -32294889, -6456008},
+ },
+ {
+ FieldElement{-2444496, -149937, 29348902, 8186665, 1873760, 12489863, -30934579, -7839692, -7852844, -8138429},
+ FieldElement{-15236356, -15433509, 7766470, 746860, 26346930, -10221762, -27333451, 10754588, -9431476, 5203576},
+ FieldElement{31834314, 14135496, -770007, 5159118, 20917671, -16768096, -7467973, -7337524, 31809243, 7347066},
+ },
+ {
+ FieldElement{-9606723, -11874240, 20414459, 13033986, 13716524, -11691881, 19797970, -12211255, 15192876, -2087490},
+ FieldElement{-12663563, -2181719, 1168162, -3804809, 26747877, -14138091, 10609330, 12694420, 33473243, -13382104},
+ FieldElement{33184999, 11180355, 15832085, -11385430, -1633671, 225884, 15089336, -11023903, -6135662, 14480053},
+ },
+ {
+ FieldElement{31308717, -5619998, 31030840, -1897099, 15674547, -6582883, 5496208, 13685227, 27595050, 8737275},
+ FieldElement{-20318852, -15150239, 10933843, -16178022, 8335352, -7546022, -31008351, -12610604, 26498114, 66511},
+ FieldElement{22644454, -8761729, -16671776, 4884562, -3105614, -13559366, 30540766, -4286747, -13327787, -7515095},
+ },
+ {
+ FieldElement{-28017847, 9834845, 18617207, -2681312, -3401956, -13307506, 8205540, 13585437, -17127465, 15115439},
+ FieldElement{23711543, -672915, 31206561, -8362711, 6164647, -9709987, -33535882, -1426096, 8236921, 16492939},
+ FieldElement{-23910559, -13515526, -26299483, -4503841, 25005590, -7687270, 19574902, 10071562, 6708380, -6222424},
+ },
+ {
+ FieldElement{2101391, -4930054, 19702731, 2367575, -15427167, 1047675, 5301017, 9328700, 29955601, -11678310},
+ FieldElement{3096359, 9271816, -21620864, -15521844, -14847996, -7592937, -25892142, -12635595, -9917575, 6216608},
+ FieldElement{-32615849, 338663, -25195611, 2510422, -29213566, -13820213, 24822830, -6146567, -26767480, 7525079},
+ },
+ {
+ FieldElement{-23066649, -13985623, 16133487, -7896178, -3389565, 778788, -910336, -2782495, -19386633, 11994101},
+ FieldElement{21691500, -13624626, -641331, -14367021, 3285881, -3483596, -25064666, 9718258, -7477437, 13381418},
+ FieldElement{18445390, -4202236, 14979846, 11622458, -1727110, -3582980, 23111648, -6375247, 28535282, 15779576},
+ },
+ {
+ FieldElement{30098053, 3089662, -9234387, 16662135, -21306940, 11308411, -14068454, 12021730, 9955285, -16303356},
+ FieldElement{9734894, -14576830, -7473633, -9138735, 2060392, 11313496, -18426029, 9924399, 20194861, 13380996},
+ FieldElement{-26378102, -7965207, -22167821, 15789297, -18055342, -6168792, -1984914, 15707771, 26342023, 10146099},
+ },
+ },
+ {
+ {
+ FieldElement{-26016874, -219943, 21339191, -41388, 19745256, -2878700, -29637280, 2227040, 21612326, -545728},
+ FieldElement{-13077387, 1184228, 23562814, -5970442, -20351244, -6348714, 25764461, 12243797, -20856566, 11649658},
+ FieldElement{-10031494, 11262626, 27384172, 2271902, 26947504, -15997771, 39944, 6114064, 33514190, 2333242},
+ },
+ {
+ FieldElement{-21433588, -12421821, 8119782, 7219913, -21830522, -9016134, -6679750, -12670638, 24350578, -13450001},
+ FieldElement{-4116307, -11271533, -23886186, 4843615, -30088339, 690623, -31536088, -10406836, 8317860, 12352766},
+ FieldElement{18200138, -14475911, -33087759, -2696619, -23702521, -9102511, -23552096, -2287550, 20712163, 6719373},
+ },
+ {
+ FieldElement{26656208, 6075253, -7858556, 1886072, -28344043, 4262326, 11117530, -3763210, 26224235, -3297458},
+ FieldElement{-17168938, -14854097, -3395676, -16369877, -19954045, 14050420, 21728352, 9493610, 18620611, -16428628},
+ FieldElement{-13323321, 13325349, 11432106, 5964811, 18609221, 6062965, -5269471, -9725556, -30701573, -16479657},
+ },
+ {
+ FieldElement{-23860538, -11233159, 26961357, 1640861, -32413112, -16737940, 12248509, -5240639, 13735342, 1934062},
+ FieldElement{25089769, 6742589, 17081145, -13406266, 21909293, -16067981, -15136294, -3765346, -21277997, 5473616},
+ FieldElement{31883677, -7961101, 1083432, -11572403, 22828471, 13290673, -7125085, 12469656, 29111212, -5451014},
+ },
+ {
+ FieldElement{24244947, -15050407, -26262976, 2791540, -14997599, 16666678, 24367466, 6388839, -10295587, 452383},
+ FieldElement{-25640782, -3417841, 5217916, 16224624, 19987036, -4082269, -24236251, -5915248, 15766062, 8407814},
+ FieldElement{-20406999, 13990231, 15495425, 16395525, 5377168, 15166495, -8917023, -4388953, -8067909, 2276718},
+ },
+ {
+ FieldElement{30157918, 12924066, -17712050, 9245753, 19895028, 3368142, -23827587, 5096219, 22740376, -7303417},
+ FieldElement{2041139, -14256350, 7783687, 13876377, -25946985, -13352459, 24051124, 13742383, -15637599, 13295222},
+ FieldElement{33338237, -8505733, 12532113, 7977527, 9106186, -1715251, -17720195, -4612972, -4451357, -14669444},
+ },
+ {
+ FieldElement{-20045281, 5454097, -14346548, 6447146, 28862071, 1883651, -2469266, -4141880, 7770569, 9620597},
+ FieldElement{23208068, 7979712, 33071466, 8149229, 1758231, -10834995, 30945528, -1694323, -33502340, -14767970},
+ FieldElement{1439958, -16270480, -1079989, -793782, 4625402, 10647766, -5043801, 1220118, 30494170, -11440799},
+ },
+ {
+ FieldElement{-5037580, -13028295, -2970559, -3061767, 15640974, -6701666, -26739026, 926050, -1684339, -13333647},
+ FieldElement{13908495, -3549272, 30919928, -6273825, -21521863, 7989039, 9021034, 9078865, 3353509, 4033511},
+ FieldElement{-29663431, -15113610, 32259991, -344482, 24295849, -12912123, 23161163, 8839127, 27485041, 7356032},
+ },
+ },
+ {
+ {
+ FieldElement{9661027, 705443, 11980065, -5370154, -1628543, 14661173, -6346142, 2625015, 28431036, -16771834},
+ FieldElement{-23839233, -8311415, -25945511, 7480958, -17681669, -8354183, -22545972, 14150565, 15970762, 4099461},
+ FieldElement{29262576, 16756590, 26350592, -8793563, 8529671, -11208050, 13617293, -9937143, 11465739, 8317062},
+ },
+ {
+ FieldElement{-25493081, -6962928, 32500200, -9419051, -23038724, -2302222, 14898637, 3848455, 20969334, -5157516},
+ FieldElement{-20384450, -14347713, -18336405, 13884722, -33039454, 2842114, -21610826, -3649888, 11177095, 14989547},
+ FieldElement{-24496721, -11716016, 16959896, 2278463, 12066309, 10137771, 13515641, 2581286, -28487508, 9930240},
+ },
+ {
+ FieldElement{-17751622, -2097826, 16544300, -13009300, -15914807, -14949081, 18345767, -13403753, 16291481, -5314038},
+ FieldElement{-33229194, 2553288, 32678213, 9875984, 8534129, 6889387, -9676774, 6957617, 4368891, 9788741},
+ FieldElement{16660756, 7281060, -10830758, 12911820, 20108584, -8101676, -21722536, -8613148, 16250552, -11111103},
+ },
+ {
+ FieldElement{-19765507, 2390526, -16551031, 14161980, 1905286, 6414907, 4689584, 10604807, -30190403, 4782747},
+ FieldElement{-1354539, 14736941, -7367442, -13292886, 7710542, -14155590, -9981571, 4383045, 22546403, 437323},
+ FieldElement{31665577, -12180464, -16186830, 1491339, -18368625, 3294682, 27343084, 2786261, -30633590, -14097016},
+ },
+ {
+ FieldElement{-14467279, -683715, -33374107, 7448552, 19294360, 14334329, -19690631, 2355319, -19284671, -6114373},
+ FieldElement{15121312, -15796162, 6377020, -6031361, -10798111, -12957845, 18952177, 15496498, -29380133, 11754228},
+ FieldElement{-2637277, -13483075, 8488727, -14303896, 12728761, -1622493, 7141596, 11724556, 22761615, -10134141},
+ },
+ {
+ FieldElement{16918416, 11729663, -18083579, 3022987, -31015732, -13339659, -28741185, -12227393, 32851222, 11717399},
+ FieldElement{11166634, 7338049, -6722523, 4531520, -29468672, -7302055, 31474879, 3483633, -1193175, -4030831},
+ FieldElement{-185635, 9921305, 31456609, -13536438, -12013818, 13348923, 33142652, 6546660, -19985279, -3948376},
+ },
+ {
+ FieldElement{-32460596, 11266712, -11197107, -7899103, 31703694, 3855903, -8537131, -12833048, -30772034, -15486313},
+ FieldElement{-18006477, 12709068, 3991746, -6479188, -21491523, -10550425, -31135347, -16049879, 10928917, 3011958},
+ FieldElement{-6957757, -15594337, 31696059, 334240, 29576716, 14796075, -30831056, -12805180, 18008031, 10258577},
+ },
+ {
+ FieldElement{-22448644, 15655569, 7018479, -4410003, -30314266, -1201591, -1853465, 1367120, 25127874, 6671743},
+ FieldElement{29701166, -14373934, -10878120, 9279288, -17568, 13127210, 21382910, 11042292, 25838796, 4642684},
+ FieldElement{-20430234, 14955537, -24126347, 8124619, -5369288, -5990470, 30468147, -13900640, 18423289, 4177476},
+ },
+ },
+}
diff --git a/Godeps/_workspace/src/github.com/agl/ed25519/edwards25519/edwards25519.go b/Godeps/_workspace/src/github.com/agl/ed25519/edwards25519/edwards25519.go
new file mode 100644
index 0000000000000000000000000000000000000000..184b4a85963fe18959ba9ec14e0b26be30124a52
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/agl/ed25519/edwards25519/edwards25519.go
@@ -0,0 +1,2127 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package edwards25519 implements operations in GF(2**255-19) and on an
+// Edwards curve that is isomorphic to curve25519. See
+// http://ed25519.cr.yp.to/.
+package edwards25519
+
+// This code is a port of the public domain, "ref10" implementation of ed25519
+// from SUPERCOP.
+
+// FieldElement represents an element of the field GF(2^255 - 19). An element
+// t, entries t[0]...t[9], represents the integer t[0]+2^26 t[1]+2^51 t[2]+2^77
+// t[3]+2^102 t[4]+...+2^230 t[9]. Bounds on each t[i] vary depending on
+// context.
+type FieldElement [10]int32
+
+func FeZero(fe *FieldElement) {
+ for i := range fe {
+ fe[i] = 0
+ }
+}
+
+func FeOne(fe *FieldElement) {
+ FeZero(fe)
+ fe[0] = 1
+}
+
+func FeAdd(dst, a, b *FieldElement) {
+ for i := range dst {
+ dst[i] = a[i] + b[i]
+ }
+}
+
+func FeSub(dst, a, b *FieldElement) {
+ for i := range dst {
+ dst[i] = a[i] - b[i]
+ }
+}
+
+func FeCopy(dst, src *FieldElement) {
+ for i := range dst {
+ dst[i] = src[i]
+ }
+}
+
+// Replace (f,g) with (g,g) if b == 1;
+// replace (f,g) with (f,g) if b == 0.
+//
+// Preconditions: b in {0,1}.
+func FeCMove(f, g *FieldElement, b int32) {
+ var x FieldElement
+ b = -b
+ for i := range x {
+ x[i] = b & (f[i] ^ g[i])
+ }
+
+ for i := range f {
+ f[i] ^= x[i]
+ }
+}
+
+func load3(in []byte) int64 {
+ var r int64
+ r = int64(in[0])
+ r |= int64(in[1]) << 8
+ r |= int64(in[2]) << 16
+ return r
+}
+
+func load4(in []byte) int64 {
+ var r int64
+ r = int64(in[0])
+ r |= int64(in[1]) << 8
+ r |= int64(in[2]) << 16
+ r |= int64(in[3]) << 24
+ return r
+}
+
+func FeFromBytes(dst *FieldElement, src *[32]byte) {
+ h0 := load4(src[:])
+ h1 := load3(src[4:]) << 6
+ h2 := load3(src[7:]) << 5
+ h3 := load3(src[10:]) << 3
+ h4 := load3(src[13:]) << 2
+ h5 := load4(src[16:])
+ h6 := load3(src[20:]) << 7
+ h7 := load3(src[23:]) << 5
+ h8 := load3(src[26:]) << 4
+ h9 := (load3(src[29:]) & 8388607) << 2
+
+ var carry [10]int64
+ carry[9] = (h9 + 1<<24) >> 25
+ h0 += carry[9] * 19
+ h9 -= carry[9] << 25
+ carry[1] = (h1 + 1<<24) >> 25
+ h2 += carry[1]
+ h1 -= carry[1] << 25
+ carry[3] = (h3 + 1<<24) >> 25
+ h4 += carry[3]
+ h3 -= carry[3] << 25
+ carry[5] = (h5 + 1<<24) >> 25
+ h6 += carry[5]
+ h5 -= carry[5] << 25
+ carry[7] = (h7 + 1<<24) >> 25
+ h8 += carry[7]
+ h7 -= carry[7] << 25
+
+ carry[0] = (h0 + 1<<25) >> 26
+ h1 += carry[0]
+ h0 -= carry[0] << 26
+ carry[2] = (h2 + 1<<25) >> 26
+ h3 += carry[2]
+ h2 -= carry[2] << 26
+ carry[4] = (h4 + 1<<25) >> 26
+ h5 += carry[4]
+ h4 -= carry[4] << 26
+ carry[6] = (h6 + 1<<25) >> 26
+ h7 += carry[6]
+ h6 -= carry[6] << 26
+ carry[8] = (h8 + 1<<25) >> 26
+ h9 += carry[8]
+ h8 -= carry[8] << 26
+
+ dst[0] = int32(h0)
+ dst[1] = int32(h1)
+ dst[2] = int32(h2)
+ dst[3] = int32(h3)
+ dst[4] = int32(h4)
+ dst[5] = int32(h5)
+ dst[6] = int32(h6)
+ dst[7] = int32(h7)
+ dst[8] = int32(h8)
+ dst[9] = int32(h9)
+}
+
+// FeToBytes marshals h to s.
+// Preconditions:
+// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+//
+// Write p=2^255-19; q=floor(h/p).
+// Basic claim: q = floor(2^(-255)(h + 19 2^(-25)h9 + 2^(-1))).
+//
+// Proof:
+// Have |h|<=p so |q|<=1 so |19^2 2^(-255) q|<1/4.
+// Also have |h-2^230 h9|<2^230 so |19 2^(-255)(h-2^230 h9)|<1/4.
+//
+// Write y=2^(-1)-19^2 2^(-255)q-19 2^(-255)(h-2^230 h9).
+// Then 0<y<1.
+//
+// Write r=h-pq.
+// Have 0<=r<=p-1=2^255-20.
+// Thus 0<=r+19(2^-255)r<r+19(2^-255)2^255<=2^255-1.
+//
+// Write x=r+19(2^-255)r+y.
+// Then 0<x<2^255 so floor(2^(-255)x) = 0 so floor(q+2^(-255)x) = q.
+//
+// Have q+2^(-255)x = 2^(-255)(h + 19 2^(-25) h9 + 2^(-1))
+// so floor(2^(-255)(h + 19 2^(-25) h9 + 2^(-1))) = q.
+func FeToBytes(s *[32]byte, h *FieldElement) {
+ var carry [10]int32
+
+ q := (19*h[9] + (1 << 24)) >> 25
+ q = (h[0] + q) >> 26
+ q = (h[1] + q) >> 25
+ q = (h[2] + q) >> 26
+ q = (h[3] + q) >> 25
+ q = (h[4] + q) >> 26
+ q = (h[5] + q) >> 25
+ q = (h[6] + q) >> 26
+ q = (h[7] + q) >> 25
+ q = (h[8] + q) >> 26
+ q = (h[9] + q) >> 25
+
+ // Goal: Output h-(2^255-19)q, which is between 0 and 2^255-20.
+ h[0] += 19 * q
+ // Goal: Output h-2^255 q, which is between 0 and 2^255-20.
+
+ carry[0] = h[0] >> 26
+ h[1] += carry[0]
+ h[0] -= carry[0] << 26
+ carry[1] = h[1] >> 25
+ h[2] += carry[1]
+ h[1] -= carry[1] << 25
+ carry[2] = h[2] >> 26
+ h[3] += carry[2]
+ h[2] -= carry[2] << 26
+ carry[3] = h[3] >> 25
+ h[4] += carry[3]
+ h[3] -= carry[3] << 25
+ carry[4] = h[4] >> 26
+ h[5] += carry[4]
+ h[4] -= carry[4] << 26
+ carry[5] = h[5] >> 25
+ h[6] += carry[5]
+ h[5] -= carry[5] << 25
+ carry[6] = h[6] >> 26
+ h[7] += carry[6]
+ h[6] -= carry[6] << 26
+ carry[7] = h[7] >> 25
+ h[8] += carry[7]
+ h[7] -= carry[7] << 25
+ carry[8] = h[8] >> 26
+ h[9] += carry[8]
+ h[8] -= carry[8] << 26
+ carry[9] = h[9] >> 25
+ h[9] -= carry[9] << 25
+ // h10 = carry9
+
+ // Goal: Output h[0]+...+2^255 h10-2^255 q, which is between 0 and 2^255-20.
+ // Have h[0]+...+2^230 h[9] between 0 and 2^255-1;
+ // evidently 2^255 h10-2^255 q = 0.
+ // Goal: Output h[0]+...+2^230 h[9].
+
+ s[0] = byte(h[0] >> 0)
+ s[1] = byte(h[0] >> 8)
+ s[2] = byte(h[0] >> 16)
+ s[3] = byte((h[0] >> 24) | (h[1] << 2))
+ s[4] = byte(h[1] >> 6)
+ s[5] = byte(h[1] >> 14)
+ s[6] = byte((h[1] >> 22) | (h[2] << 3))
+ s[7] = byte(h[2] >> 5)
+ s[8] = byte(h[2] >> 13)
+ s[9] = byte((h[2] >> 21) | (h[3] << 5))
+ s[10] = byte(h[3] >> 3)
+ s[11] = byte(h[3] >> 11)
+ s[12] = byte((h[3] >> 19) | (h[4] << 6))
+ s[13] = byte(h[4] >> 2)
+ s[14] = byte(h[4] >> 10)
+ s[15] = byte(h[4] >> 18)
+ s[16] = byte(h[5] >> 0)
+ s[17] = byte(h[5] >> 8)
+ s[18] = byte(h[5] >> 16)
+ s[19] = byte((h[5] >> 24) | (h[6] << 1))
+ s[20] = byte(h[6] >> 7)
+ s[21] = byte(h[6] >> 15)
+ s[22] = byte((h[6] >> 23) | (h[7] << 3))
+ s[23] = byte(h[7] >> 5)
+ s[24] = byte(h[7] >> 13)
+ s[25] = byte((h[7] >> 21) | (h[8] << 4))
+ s[26] = byte(h[8] >> 4)
+ s[27] = byte(h[8] >> 12)
+ s[28] = byte((h[8] >> 20) | (h[9] << 6))
+ s[29] = byte(h[9] >> 2)
+ s[30] = byte(h[9] >> 10)
+ s[31] = byte(h[9] >> 18)
+}
+
+func FeIsNegative(f *FieldElement) byte {
+ var s [32]byte
+ FeToBytes(&s, f)
+ return s[0] & 1
+}
+
+func FeIsNonZero(f *FieldElement) int32 {
+ var s [32]byte
+ FeToBytes(&s, f)
+ var x uint8
+ for _, b := range s {
+ x |= b
+ }
+ x |= x >> 4
+ x |= x >> 2
+ x |= x >> 1
+ return int32(x & 1)
+}
+
+// FeNeg sets h = -f
+//
+// Preconditions:
+// |f| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+//
+// Postconditions:
+// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+func FeNeg(h, f *FieldElement) {
+ for i := range h {
+ h[i] = -f[i]
+ }
+}
+
+// FeMul calculates h = f * g
+// Can overlap h with f or g.
+//
+// Preconditions:
+// |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
+// |g| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
+//
+// Postconditions:
+// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+//
+// Notes on implementation strategy:
+//
+// Using schoolbook multiplication.
+// Karatsuba would save a little in some cost models.
+//
+// Most multiplications by 2 and 19 are 32-bit precomputations;
+// cheaper than 64-bit postcomputations.
+//
+// There is one remaining multiplication by 19 in the carry chain;
+// one *19 precomputation can be merged into this,
+// but the resulting data flow is considerably less clean.
+//
+// There are 12 carries below.
+// 10 of them are 2-way parallelizable and vectorizable.
+// Can get away with 11 carries, but then data flow is much deeper.
+//
+// With tighter constraints on inputs can squeeze carries into int32.
+func FeMul(h, f, g *FieldElement) {
+ f0 := f[0]
+ f1 := f[1]
+ f2 := f[2]
+ f3 := f[3]
+ f4 := f[4]
+ f5 := f[5]
+ f6 := f[6]
+ f7 := f[7]
+ f8 := f[8]
+ f9 := f[9]
+ g0 := g[0]
+ g1 := g[1]
+ g2 := g[2]
+ g3 := g[3]
+ g4 := g[4]
+ g5 := g[5]
+ g6 := g[6]
+ g7 := g[7]
+ g8 := g[8]
+ g9 := g[9]
+ g1_19 := 19 * g1 /* 1.4*2^29 */
+ g2_19 := 19 * g2 /* 1.4*2^30; still ok */
+ g3_19 := 19 * g3
+ g4_19 := 19 * g4
+ g5_19 := 19 * g5
+ g6_19 := 19 * g6
+ g7_19 := 19 * g7
+ g8_19 := 19 * g8
+ g9_19 := 19 * g9
+ f1_2 := 2 * f1
+ f3_2 := 2 * f3
+ f5_2 := 2 * f5
+ f7_2 := 2 * f7
+ f9_2 := 2 * f9
+ f0g0 := int64(f0) * int64(g0)
+ f0g1 := int64(f0) * int64(g1)
+ f0g2 := int64(f0) * int64(g2)
+ f0g3 := int64(f0) * int64(g3)
+ f0g4 := int64(f0) * int64(g4)
+ f0g5 := int64(f0) * int64(g5)
+ f0g6 := int64(f0) * int64(g6)
+ f0g7 := int64(f0) * int64(g7)
+ f0g8 := int64(f0) * int64(g8)
+ f0g9 := int64(f0) * int64(g9)
+ f1g0 := int64(f1) * int64(g0)
+ f1g1_2 := int64(f1_2) * int64(g1)
+ f1g2 := int64(f1) * int64(g2)
+ f1g3_2 := int64(f1_2) * int64(g3)
+ f1g4 := int64(f1) * int64(g4)
+ f1g5_2 := int64(f1_2) * int64(g5)
+ f1g6 := int64(f1) * int64(g6)
+ f1g7_2 := int64(f1_2) * int64(g7)
+ f1g8 := int64(f1) * int64(g8)
+ f1g9_38 := int64(f1_2) * int64(g9_19)
+ f2g0 := int64(f2) * int64(g0)
+ f2g1 := int64(f2) * int64(g1)
+ f2g2 := int64(f2) * int64(g2)
+ f2g3 := int64(f2) * int64(g3)
+ f2g4 := int64(f2) * int64(g4)
+ f2g5 := int64(f2) * int64(g5)
+ f2g6 := int64(f2) * int64(g6)
+ f2g7 := int64(f2) * int64(g7)
+ f2g8_19 := int64(f2) * int64(g8_19)
+ f2g9_19 := int64(f2) * int64(g9_19)
+ f3g0 := int64(f3) * int64(g0)
+ f3g1_2 := int64(f3_2) * int64(g1)
+ f3g2 := int64(f3) * int64(g2)
+ f3g3_2 := int64(f3_2) * int64(g3)
+ f3g4 := int64(f3) * int64(g4)
+ f3g5_2 := int64(f3_2) * int64(g5)
+ f3g6 := int64(f3) * int64(g6)
+ f3g7_38 := int64(f3_2) * int64(g7_19)
+ f3g8_19 := int64(f3) * int64(g8_19)
+ f3g9_38 := int64(f3_2) * int64(g9_19)
+ f4g0 := int64(f4) * int64(g0)
+ f4g1 := int64(f4) * int64(g1)
+ f4g2 := int64(f4) * int64(g2)
+ f4g3 := int64(f4) * int64(g3)
+ f4g4 := int64(f4) * int64(g4)
+ f4g5 := int64(f4) * int64(g5)
+ f4g6_19 := int64(f4) * int64(g6_19)
+ f4g7_19 := int64(f4) * int64(g7_19)
+ f4g8_19 := int64(f4) * int64(g8_19)
+ f4g9_19 := int64(f4) * int64(g9_19)
+ f5g0 := int64(f5) * int64(g0)
+ f5g1_2 := int64(f5_2) * int64(g1)
+ f5g2 := int64(f5) * int64(g2)
+ f5g3_2 := int64(f5_2) * int64(g3)
+ f5g4 := int64(f5) * int64(g4)
+ f5g5_38 := int64(f5_2) * int64(g5_19)
+ f5g6_19 := int64(f5) * int64(g6_19)
+ f5g7_38 := int64(f5_2) * int64(g7_19)
+ f5g8_19 := int64(f5) * int64(g8_19)
+ f5g9_38 := int64(f5_2) * int64(g9_19)
+ f6g0 := int64(f6) * int64(g0)
+ f6g1 := int64(f6) * int64(g1)
+ f6g2 := int64(f6) * int64(g2)
+ f6g3 := int64(f6) * int64(g3)
+ f6g4_19 := int64(f6) * int64(g4_19)
+ f6g5_19 := int64(f6) * int64(g5_19)
+ f6g6_19 := int64(f6) * int64(g6_19)
+ f6g7_19 := int64(f6) * int64(g7_19)
+ f6g8_19 := int64(f6) * int64(g8_19)
+ f6g9_19 := int64(f6) * int64(g9_19)
+ f7g0 := int64(f7) * int64(g0)
+ f7g1_2 := int64(f7_2) * int64(g1)
+ f7g2 := int64(f7) * int64(g2)
+ f7g3_38 := int64(f7_2) * int64(g3_19)
+ f7g4_19 := int64(f7) * int64(g4_19)
+ f7g5_38 := int64(f7_2) * int64(g5_19)
+ f7g6_19 := int64(f7) * int64(g6_19)
+ f7g7_38 := int64(f7_2) * int64(g7_19)
+ f7g8_19 := int64(f7) * int64(g8_19)
+ f7g9_38 := int64(f7_2) * int64(g9_19)
+ f8g0 := int64(f8) * int64(g0)
+ f8g1 := int64(f8) * int64(g1)
+ f8g2_19 := int64(f8) * int64(g2_19)
+ f8g3_19 := int64(f8) * int64(g3_19)
+ f8g4_19 := int64(f8) * int64(g4_19)
+ f8g5_19 := int64(f8) * int64(g5_19)
+ f8g6_19 := int64(f8) * int64(g6_19)
+ f8g7_19 := int64(f8) * int64(g7_19)
+ f8g8_19 := int64(f8) * int64(g8_19)
+ f8g9_19 := int64(f8) * int64(g9_19)
+ f9g0 := int64(f9) * int64(g0)
+ f9g1_38 := int64(f9_2) * int64(g1_19)
+ f9g2_19 := int64(f9) * int64(g2_19)
+ f9g3_38 := int64(f9_2) * int64(g3_19)
+ f9g4_19 := int64(f9) * int64(g4_19)
+ f9g5_38 := int64(f9_2) * int64(g5_19)
+ f9g6_19 := int64(f9) * int64(g6_19)
+ f9g7_38 := int64(f9_2) * int64(g7_19)
+ f9g8_19 := int64(f9) * int64(g8_19)
+ f9g9_38 := int64(f9_2) * int64(g9_19)
+ h0 := f0g0 + f1g9_38 + f2g8_19 + f3g7_38 + f4g6_19 + f5g5_38 + f6g4_19 + f7g3_38 + f8g2_19 + f9g1_38
+ h1 := f0g1 + f1g0 + f2g9_19 + f3g8_19 + f4g7_19 + f5g6_19 + f6g5_19 + f7g4_19 + f8g3_19 + f9g2_19
+ h2 := f0g2 + f1g1_2 + f2g0 + f3g9_38 + f4g8_19 + f5g7_38 + f6g6_19 + f7g5_38 + f8g4_19 + f9g3_38
+ h3 := f0g3 + f1g2 + f2g1 + f3g0 + f4g9_19 + f5g8_19 + f6g7_19 + f7g6_19 + f8g5_19 + f9g4_19
+ h4 := f0g4 + f1g3_2 + f2g2 + f3g1_2 + f4g0 + f5g9_38 + f6g8_19 + f7g7_38 + f8g6_19 + f9g5_38
+ h5 := f0g5 + f1g4 + f2g3 + f3g2 + f4g1 + f5g0 + f6g9_19 + f7g8_19 + f8g7_19 + f9g6_19
+ h6 := f0g6 + f1g5_2 + f2g4 + f3g3_2 + f4g2 + f5g1_2 + f6g0 + f7g9_38 + f8g8_19 + f9g7_38
+ h7 := f0g7 + f1g6 + f2g5 + f3g4 + f4g3 + f5g2 + f6g1 + f7g0 + f8g9_19 + f9g8_19
+ h8 := f0g8 + f1g7_2 + f2g6 + f3g5_2 + f4g4 + f5g3_2 + f6g2 + f7g1_2 + f8g0 + f9g9_38
+ h9 := f0g9 + f1g8 + f2g7 + f3g6 + f4g5 + f5g4 + f6g3 + f7g2 + f8g1 + f9g0
+ var carry [10]int64
+
+ /*
+ |h0| <= (1.1*1.1*2^52*(1+19+19+19+19)+1.1*1.1*2^50*(38+38+38+38+38))
+ i.e. |h0| <= 1.2*2^59; narrower ranges for h2, h4, h6, h8
+ |h1| <= (1.1*1.1*2^51*(1+1+19+19+19+19+19+19+19+19))
+ i.e. |h1| <= 1.5*2^58; narrower ranges for h3, h5, h7, h9
+ */
+
+ carry[0] = (h0 + (1 << 25)) >> 26
+ h1 += carry[0]
+ h0 -= carry[0] << 26
+ carry[4] = (h4 + (1 << 25)) >> 26
+ h5 += carry[4]
+ h4 -= carry[4] << 26
+ /* |h0| <= 2^25 */
+ /* |h4| <= 2^25 */
+ /* |h1| <= 1.51*2^58 */
+ /* |h5| <= 1.51*2^58 */
+
+ carry[1] = (h1 + (1 << 24)) >> 25
+ h2 += carry[1]
+ h1 -= carry[1] << 25
+ carry[5] = (h5 + (1 << 24)) >> 25
+ h6 += carry[5]
+ h5 -= carry[5] << 25
+ /* |h1| <= 2^24; from now on fits into int32 */
+ /* |h5| <= 2^24; from now on fits into int32 */
+ /* |h2| <= 1.21*2^59 */
+ /* |h6| <= 1.21*2^59 */
+
+ carry[2] = (h2 + (1 << 25)) >> 26
+ h3 += carry[2]
+ h2 -= carry[2] << 26
+ carry[6] = (h6 + (1 << 25)) >> 26
+ h7 += carry[6]
+ h6 -= carry[6] << 26
+ /* |h2| <= 2^25; from now on fits into int32 unchanged */
+ /* |h6| <= 2^25; from now on fits into int32 unchanged */
+ /* |h3| <= 1.51*2^58 */
+ /* |h7| <= 1.51*2^58 */
+
+ carry[3] = (h3 + (1 << 24)) >> 25
+ h4 += carry[3]
+ h3 -= carry[3] << 25
+ carry[7] = (h7 + (1 << 24)) >> 25
+ h8 += carry[7]
+ h7 -= carry[7] << 25
+ /* |h3| <= 2^24; from now on fits into int32 unchanged */
+ /* |h7| <= 2^24; from now on fits into int32 unchanged */
+ /* |h4| <= 1.52*2^33 */
+ /* |h8| <= 1.52*2^33 */
+
+ carry[4] = (h4 + (1 << 25)) >> 26
+ h5 += carry[4]
+ h4 -= carry[4] << 26
+ carry[8] = (h8 + (1 << 25)) >> 26
+ h9 += carry[8]
+ h8 -= carry[8] << 26
+ /* |h4| <= 2^25; from now on fits into int32 unchanged */
+ /* |h8| <= 2^25; from now on fits into int32 unchanged */
+ /* |h5| <= 1.01*2^24 */
+ /* |h9| <= 1.51*2^58 */
+
+ carry[9] = (h9 + (1 << 24)) >> 25
+ h0 += carry[9] * 19
+ h9 -= carry[9] << 25
+ /* |h9| <= 2^24; from now on fits into int32 unchanged */
+ /* |h0| <= 1.8*2^37 */
+
+ carry[0] = (h0 + (1 << 25)) >> 26
+ h1 += carry[0]
+ h0 -= carry[0] << 26
+ /* |h0| <= 2^25; from now on fits into int32 unchanged */
+ /* |h1| <= 1.01*2^24 */
+
+ h[0] = int32(h0)
+ h[1] = int32(h1)
+ h[2] = int32(h2)
+ h[3] = int32(h3)
+ h[4] = int32(h4)
+ h[5] = int32(h5)
+ h[6] = int32(h6)
+ h[7] = int32(h7)
+ h[8] = int32(h8)
+ h[9] = int32(h9)
+}
+
+// FeSquare calculates h = f*f. Can overlap h with f.
+//
+// Preconditions:
+// |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
+//
+// Postconditions:
+// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+func FeSquare(h, f *FieldElement) {
+ f0 := f[0]
+ f1 := f[1]
+ f2 := f[2]
+ f3 := f[3]
+ f4 := f[4]
+ f5 := f[5]
+ f6 := f[6]
+ f7 := f[7]
+ f8 := f[8]
+ f9 := f[9]
+ f0_2 := 2 * f0
+ f1_2 := 2 * f1
+ f2_2 := 2 * f2
+ f3_2 := 2 * f3
+ f4_2 := 2 * f4
+ f5_2 := 2 * f5
+ f6_2 := 2 * f6
+ f7_2 := 2 * f7
+ f5_38 := 38 * f5 // 1.31*2^30
+ f6_19 := 19 * f6 // 1.31*2^30
+ f7_38 := 38 * f7 // 1.31*2^30
+ f8_19 := 19 * f8 // 1.31*2^30
+ f9_38 := 38 * f9 // 1.31*2^30
+ f0f0 := int64(f0) * int64(f0)
+ f0f1_2 := int64(f0_2) * int64(f1)
+ f0f2_2 := int64(f0_2) * int64(f2)
+ f0f3_2 := int64(f0_2) * int64(f3)
+ f0f4_2 := int64(f0_2) * int64(f4)
+ f0f5_2 := int64(f0_2) * int64(f5)
+ f0f6_2 := int64(f0_2) * int64(f6)
+ f0f7_2 := int64(f0_2) * int64(f7)
+ f0f8_2 := int64(f0_2) * int64(f8)
+ f0f9_2 := int64(f0_2) * int64(f9)
+ f1f1_2 := int64(f1_2) * int64(f1)
+ f1f2_2 := int64(f1_2) * int64(f2)
+ f1f3_4 := int64(f1_2) * int64(f3_2)
+ f1f4_2 := int64(f1_2) * int64(f4)
+ f1f5_4 := int64(f1_2) * int64(f5_2)
+ f1f6_2 := int64(f1_2) * int64(f6)
+ f1f7_4 := int64(f1_2) * int64(f7_2)
+ f1f8_2 := int64(f1_2) * int64(f8)
+ f1f9_76 := int64(f1_2) * int64(f9_38)
+ f2f2 := int64(f2) * int64(f2)
+ f2f3_2 := int64(f2_2) * int64(f3)
+ f2f4_2 := int64(f2_2) * int64(f4)
+ f2f5_2 := int64(f2_2) * int64(f5)
+ f2f6_2 := int64(f2_2) * int64(f6)
+ f2f7_2 := int64(f2_2) * int64(f7)
+ f2f8_38 := int64(f2_2) * int64(f8_19)
+ f2f9_38 := int64(f2) * int64(f9_38)
+ f3f3_2 := int64(f3_2) * int64(f3)
+ f3f4_2 := int64(f3_2) * int64(f4)
+ f3f5_4 := int64(f3_2) * int64(f5_2)
+ f3f6_2 := int64(f3_2) * int64(f6)
+ f3f7_76 := int64(f3_2) * int64(f7_38)
+ f3f8_38 := int64(f3_2) * int64(f8_19)
+ f3f9_76 := int64(f3_2) * int64(f9_38)
+ f4f4 := int64(f4) * int64(f4)
+ f4f5_2 := int64(f4_2) * int64(f5)
+ f4f6_38 := int64(f4_2) * int64(f6_19)
+ f4f7_38 := int64(f4) * int64(f7_38)
+ f4f8_38 := int64(f4_2) * int64(f8_19)
+ f4f9_38 := int64(f4) * int64(f9_38)
+ f5f5_38 := int64(f5) * int64(f5_38)
+ f5f6_38 := int64(f5_2) * int64(f6_19)
+ f5f7_76 := int64(f5_2) * int64(f7_38)
+ f5f8_38 := int64(f5_2) * int64(f8_19)
+ f5f9_76 := int64(f5_2) * int64(f9_38)
+ f6f6_19 := int64(f6) * int64(f6_19)
+ f6f7_38 := int64(f6) * int64(f7_38)
+ f6f8_38 := int64(f6_2) * int64(f8_19)
+ f6f9_38 := int64(f6) * int64(f9_38)
+ f7f7_38 := int64(f7) * int64(f7_38)
+ f7f8_38 := int64(f7_2) * int64(f8_19)
+ f7f9_76 := int64(f7_2) * int64(f9_38)
+ f8f8_19 := int64(f8) * int64(f8_19)
+ f8f9_38 := int64(f8) * int64(f9_38)
+ f9f9_38 := int64(f9) * int64(f9_38)
+ h0 := f0f0 + f1f9_76 + f2f8_38 + f3f7_76 + f4f6_38 + f5f5_38
+ h1 := f0f1_2 + f2f9_38 + f3f8_38 + f4f7_38 + f5f6_38
+ h2 := f0f2_2 + f1f1_2 + f3f9_76 + f4f8_38 + f5f7_76 + f6f6_19
+ h3 := f0f3_2 + f1f2_2 + f4f9_38 + f5f8_38 + f6f7_38
+ h4 := f0f4_2 + f1f3_4 + f2f2 + f5f9_76 + f6f8_38 + f7f7_38
+ h5 := f0f5_2 + f1f4_2 + f2f3_2 + f6f9_38 + f7f8_38
+ h6 := f0f6_2 + f1f5_4 + f2f4_2 + f3f3_2 + f7f9_76 + f8f8_19
+ h7 := f0f7_2 + f1f6_2 + f2f5_2 + f3f4_2 + f8f9_38
+ h8 := f0f8_2 + f1f7_4 + f2f6_2 + f3f5_4 + f4f4 + f9f9_38
+ h9 := f0f9_2 + f1f8_2 + f2f7_2 + f3f6_2 + f4f5_2
+ var carry [10]int64
+
+ carry[0] = (h0 + (1 << 25)) >> 26
+ h1 += carry[0]
+ h0 -= carry[0] << 26
+ carry[4] = (h4 + (1 << 25)) >> 26
+ h5 += carry[4]
+ h4 -= carry[4] << 26
+
+ carry[1] = (h1 + (1 << 24)) >> 25
+ h2 += carry[1]
+ h1 -= carry[1] << 25
+ carry[5] = (h5 + (1 << 24)) >> 25
+ h6 += carry[5]
+ h5 -= carry[5] << 25
+
+ carry[2] = (h2 + (1 << 25)) >> 26
+ h3 += carry[2]
+ h2 -= carry[2] << 26
+ carry[6] = (h6 + (1 << 25)) >> 26
+ h7 += carry[6]
+ h6 -= carry[6] << 26
+
+ carry[3] = (h3 + (1 << 24)) >> 25
+ h4 += carry[3]
+ h3 -= carry[3] << 25
+ carry[7] = (h7 + (1 << 24)) >> 25
+ h8 += carry[7]
+ h7 -= carry[7] << 25
+
+ carry[4] = (h4 + (1 << 25)) >> 26
+ h5 += carry[4]
+ h4 -= carry[4] << 26
+ carry[8] = (h8 + (1 << 25)) >> 26
+ h9 += carry[8]
+ h8 -= carry[8] << 26
+
+ carry[9] = (h9 + (1 << 24)) >> 25
+ h0 += carry[9] * 19
+ h9 -= carry[9] << 25
+
+ carry[0] = (h0 + (1 << 25)) >> 26
+ h1 += carry[0]
+ h0 -= carry[0] << 26
+
+ h[0] = int32(h0)
+ h[1] = int32(h1)
+ h[2] = int32(h2)
+ h[3] = int32(h3)
+ h[4] = int32(h4)
+ h[5] = int32(h5)
+ h[6] = int32(h6)
+ h[7] = int32(h7)
+ h[8] = int32(h8)
+ h[9] = int32(h9)
+}
+
+// FeSquare2 sets h = 2 * f * f
+//
+// Can overlap h with f.
+//
+// Preconditions:
+// |f| bounded by 1.65*2^26,1.65*2^25,1.65*2^26,1.65*2^25,etc.
+//
+// Postconditions:
+// |h| bounded by 1.01*2^25,1.01*2^24,1.01*2^25,1.01*2^24,etc.
+// See fe_mul.c for discussion of implementation strategy.
+func FeSquare2(h, f *FieldElement) {
+ f0 := f[0]
+ f1 := f[1]
+ f2 := f[2]
+ f3 := f[3]
+ f4 := f[4]
+ f5 := f[5]
+ f6 := f[6]
+ f7 := f[7]
+ f8 := f[8]
+ f9 := f[9]
+ f0_2 := 2 * f0
+ f1_2 := 2 * f1
+ f2_2 := 2 * f2
+ f3_2 := 2 * f3
+ f4_2 := 2 * f4
+ f5_2 := 2 * f5
+ f6_2 := 2 * f6
+ f7_2 := 2 * f7
+ f5_38 := 38 * f5 // 1.959375*2^30
+ f6_19 := 19 * f6 // 1.959375*2^30
+ f7_38 := 38 * f7 // 1.959375*2^30
+ f8_19 := 19 * f8 // 1.959375*2^30
+ f9_38 := 38 * f9 // 1.959375*2^30
+ f0f0 := int64(f0) * int64(f0)
+ f0f1_2 := int64(f0_2) * int64(f1)
+ f0f2_2 := int64(f0_2) * int64(f2)
+ f0f3_2 := int64(f0_2) * int64(f3)
+ f0f4_2 := int64(f0_2) * int64(f4)
+ f0f5_2 := int64(f0_2) * int64(f5)
+ f0f6_2 := int64(f0_2) * int64(f6)
+ f0f7_2 := int64(f0_2) * int64(f7)
+ f0f8_2 := int64(f0_2) * int64(f8)
+ f0f9_2 := int64(f0_2) * int64(f9)
+ f1f1_2 := int64(f1_2) * int64(f1)
+ f1f2_2 := int64(f1_2) * int64(f2)
+ f1f3_4 := int64(f1_2) * int64(f3_2)
+ f1f4_2 := int64(f1_2) * int64(f4)
+ f1f5_4 := int64(f1_2) * int64(f5_2)
+ f1f6_2 := int64(f1_2) * int64(f6)
+ f1f7_4 := int64(f1_2) * int64(f7_2)
+ f1f8_2 := int64(f1_2) * int64(f8)
+ f1f9_76 := int64(f1_2) * int64(f9_38)
+ f2f2 := int64(f2) * int64(f2)
+ f2f3_2 := int64(f2_2) * int64(f3)
+ f2f4_2 := int64(f2_2) * int64(f4)
+ f2f5_2 := int64(f2_2) * int64(f5)
+ f2f6_2 := int64(f2_2) * int64(f6)
+ f2f7_2 := int64(f2_2) * int64(f7)
+ f2f8_38 := int64(f2_2) * int64(f8_19)
+ f2f9_38 := int64(f2) * int64(f9_38)
+ f3f3_2 := int64(f3_2) * int64(f3)
+ f3f4_2 := int64(f3_2) * int64(f4)
+ f3f5_4 := int64(f3_2) * int64(f5_2)
+ f3f6_2 := int64(f3_2) * int64(f6)
+ f3f7_76 := int64(f3_2) * int64(f7_38)
+ f3f8_38 := int64(f3_2) * int64(f8_19)
+ f3f9_76 := int64(f3_2) * int64(f9_38)
+ f4f4 := int64(f4) * int64(f4)
+ f4f5_2 := int64(f4_2) * int64(f5)
+ f4f6_38 := int64(f4_2) * int64(f6_19)
+ f4f7_38 := int64(f4) * int64(f7_38)
+ f4f8_38 := int64(f4_2) * int64(f8_19)
+ f4f9_38 := int64(f4) * int64(f9_38)
+ f5f5_38 := int64(f5) * int64(f5_38)
+ f5f6_38 := int64(f5_2) * int64(f6_19)
+ f5f7_76 := int64(f5_2) * int64(f7_38)
+ f5f8_38 := int64(f5_2) * int64(f8_19)
+ f5f9_76 := int64(f5_2) * int64(f9_38)
+ f6f6_19 := int64(f6) * int64(f6_19)
+ f6f7_38 := int64(f6) * int64(f7_38)
+ f6f8_38 := int64(f6_2) * int64(f8_19)
+ f6f9_38 := int64(f6) * int64(f9_38)
+ f7f7_38 := int64(f7) * int64(f7_38)
+ f7f8_38 := int64(f7_2) * int64(f8_19)
+ f7f9_76 := int64(f7_2) * int64(f9_38)
+ f8f8_19 := int64(f8) * int64(f8_19)
+ f8f9_38 := int64(f8) * int64(f9_38)
+ f9f9_38 := int64(f9) * int64(f9_38)
+ h0 := f0f0 + f1f9_76 + f2f8_38 + f3f7_76 + f4f6_38 + f5f5_38
+ h1 := f0f1_2 + f2f9_38 + f3f8_38 + f4f7_38 + f5f6_38
+ h2 := f0f2_2 + f1f1_2 + f3f9_76 + f4f8_38 + f5f7_76 + f6f6_19
+ h3 := f0f3_2 + f1f2_2 + f4f9_38 + f5f8_38 + f6f7_38
+ h4 := f0f4_2 + f1f3_4 + f2f2 + f5f9_76 + f6f8_38 + f7f7_38
+ h5 := f0f5_2 + f1f4_2 + f2f3_2 + f6f9_38 + f7f8_38
+ h6 := f0f6_2 + f1f5_4 + f2f4_2 + f3f3_2 + f7f9_76 + f8f8_19
+ h7 := f0f7_2 + f1f6_2 + f2f5_2 + f3f4_2 + f8f9_38
+ h8 := f0f8_2 + f1f7_4 + f2f6_2 + f3f5_4 + f4f4 + f9f9_38
+ h9 := f0f9_2 + f1f8_2 + f2f7_2 + f3f6_2 + f4f5_2
+ var carry [10]int64
+
+ h0 += h0
+ h1 += h1
+ h2 += h2
+ h3 += h3
+ h4 += h4
+ h5 += h5
+ h6 += h6
+ h7 += h7
+ h8 += h8
+ h9 += h9
+
+ carry[0] = (h0 + (1 << 25)) >> 26
+ h1 += carry[0]
+ h0 -= carry[0] << 26
+ carry[4] = (h4 + (1 << 25)) >> 26
+ h5 += carry[4]
+ h4 -= carry[4] << 26
+
+ carry[1] = (h1 + (1 << 24)) >> 25
+ h2 += carry[1]
+ h1 -= carry[1] << 25
+ carry[5] = (h5 + (1 << 24)) >> 25
+ h6 += carry[5]
+ h5 -= carry[5] << 25
+
+ carry[2] = (h2 + (1 << 25)) >> 26
+ h3 += carry[2]
+ h2 -= carry[2] << 26
+ carry[6] = (h6 + (1 << 25)) >> 26
+ h7 += carry[6]
+ h6 -= carry[6] << 26
+
+ carry[3] = (h3 + (1 << 24)) >> 25
+ h4 += carry[3]
+ h3 -= carry[3] << 25
+ carry[7] = (h7 + (1 << 24)) >> 25
+ h8 += carry[7]
+ h7 -= carry[7] << 25
+
+ carry[4] = (h4 + (1 << 25)) >> 26
+ h5 += carry[4]
+ h4 -= carry[4] << 26
+ carry[8] = (h8 + (1 << 25)) >> 26
+ h9 += carry[8]
+ h8 -= carry[8] << 26
+
+ carry[9] = (h9 + (1 << 24)) >> 25
+ h0 += carry[9] * 19
+ h9 -= carry[9] << 25
+
+ carry[0] = (h0 + (1 << 25)) >> 26
+ h1 += carry[0]
+ h0 -= carry[0] << 26
+
+ h[0] = int32(h0)
+ h[1] = int32(h1)
+ h[2] = int32(h2)
+ h[3] = int32(h3)
+ h[4] = int32(h4)
+ h[5] = int32(h5)
+ h[6] = int32(h6)
+ h[7] = int32(h7)
+ h[8] = int32(h8)
+ h[9] = int32(h9)
+}
+
+func FeInvert(out, z *FieldElement) {
+ var t0, t1, t2, t3 FieldElement
+ var i int
+
+ FeSquare(&t0, z) // 2^1
+ FeSquare(&t1, &t0) // 2^2
+ for i = 1; i < 2; i++ { // 2^3
+ FeSquare(&t1, &t1)
+ }
+ FeMul(&t1, z, &t1) // 2^3 + 2^0
+ FeMul(&t0, &t0, &t1) // 2^3 + 2^1 + 2^0
+ FeSquare(&t2, &t0) // 2^4 + 2^2 + 2^1
+ FeMul(&t1, &t1, &t2) // 2^4 + 2^3 + 2^2 + 2^1 + 2^0
+ FeSquare(&t2, &t1) // 5,4,3,2,1
+ for i = 1; i < 5; i++ { // 9,8,7,6,5
+ FeSquare(&t2, &t2)
+ }
+ FeMul(&t1, &t2, &t1) // 9,8,7,6,5,4,3,2,1,0
+ FeSquare(&t2, &t1) // 10..1
+ for i = 1; i < 10; i++ { // 19..10
+ FeSquare(&t2, &t2)
+ }
+ FeMul(&t2, &t2, &t1) // 19..0
+ FeSquare(&t3, &t2) // 20..1
+ for i = 1; i < 20; i++ { // 39..20
+ FeSquare(&t3, &t3)
+ }
+ FeMul(&t2, &t3, &t2) // 39..0
+ FeSquare(&t2, &t2) // 40..1
+ for i = 1; i < 10; i++ { // 49..10
+ FeSquare(&t2, &t2)
+ }
+ FeMul(&t1, &t2, &t1) // 49..0
+ FeSquare(&t2, &t1) // 50..1
+ for i = 1; i < 50; i++ { // 99..50
+ FeSquare(&t2, &t2)
+ }
+ FeMul(&t2, &t2, &t1) // 99..0
+ FeSquare(&t3, &t2) // 100..1
+ for i = 1; i < 100; i++ { // 199..100
+ FeSquare(&t3, &t3)
+ }
+ FeMul(&t2, &t3, &t2) // 199..0
+ FeSquare(&t2, &t2) // 200..1
+ for i = 1; i < 50; i++ { // 249..50
+ FeSquare(&t2, &t2)
+ }
+ FeMul(&t1, &t2, &t1) // 249..0
+ FeSquare(&t1, &t1) // 250..1
+ for i = 1; i < 5; i++ { // 254..5
+ FeSquare(&t1, &t1)
+ }
+ FeMul(out, &t1, &t0) // 254..5,3,1,0
+}
+
+func fePow22523(out, z *FieldElement) {
+ var t0, t1, t2 FieldElement
+ var i int
+
+ FeSquare(&t0, z)
+ for i = 1; i < 1; i++ {
+ FeSquare(&t0, &t0)
+ }
+ FeSquare(&t1, &t0)
+ for i = 1; i < 2; i++ {
+ FeSquare(&t1, &t1)
+ }
+ FeMul(&t1, z, &t1)
+ FeMul(&t0, &t0, &t1)
+ FeSquare(&t0, &t0)
+ for i = 1; i < 1; i++ {
+ FeSquare(&t0, &t0)
+ }
+ FeMul(&t0, &t1, &t0)
+ FeSquare(&t1, &t0)
+ for i = 1; i < 5; i++ {
+ FeSquare(&t1, &t1)
+ }
+ FeMul(&t0, &t1, &t0)
+ FeSquare(&t1, &t0)
+ for i = 1; i < 10; i++ {
+ FeSquare(&t1, &t1)
+ }
+ FeMul(&t1, &t1, &t0)
+ FeSquare(&t2, &t1)
+ for i = 1; i < 20; i++ {
+ FeSquare(&t2, &t2)
+ }
+ FeMul(&t1, &t2, &t1)
+ FeSquare(&t1, &t1)
+ for i = 1; i < 10; i++ {
+ FeSquare(&t1, &t1)
+ }
+ FeMul(&t0, &t1, &t0)
+ FeSquare(&t1, &t0)
+ for i = 1; i < 50; i++ {
+ FeSquare(&t1, &t1)
+ }
+ FeMul(&t1, &t1, &t0)
+ FeSquare(&t2, &t1)
+ for i = 1; i < 100; i++ {
+ FeSquare(&t2, &t2)
+ }
+ FeMul(&t1, &t2, &t1)
+ FeSquare(&t1, &t1)
+ for i = 1; i < 50; i++ {
+ FeSquare(&t1, &t1)
+ }
+ FeMul(&t0, &t1, &t0)
+ FeSquare(&t0, &t0)
+ for i = 1; i < 2; i++ {
+ FeSquare(&t0, &t0)
+ }
+ FeMul(out, &t0, z)
+}
+
+// Group elements are members of the elliptic curve -x^2 + y^2 = 1 + d * x^2 *
+// y^2 where d = -121665/121666.
+//
+// Several representations are used:
+// ProjectiveGroupElement: (X:Y:Z) satisfying x=X/Z, y=Y/Z
+// ExtendedGroupElement: (X:Y:Z:T) satisfying x=X/Z, y=Y/Z, XY=ZT
+// CompletedGroupElement: ((X:Z),(Y:T)) satisfying x=X/Z, y=Y/T
+// PreComputedGroupElement: (y+x,y-x,2dxy)
+
+type ProjectiveGroupElement struct {
+ X, Y, Z FieldElement
+}
+
+type ExtendedGroupElement struct {
+ X, Y, Z, T FieldElement
+}
+
+type CompletedGroupElement struct {
+ X, Y, Z, T FieldElement
+}
+
+type PreComputedGroupElement struct {
+ yPlusX, yMinusX, xy2d FieldElement
+}
+
+type CachedGroupElement struct {
+ yPlusX, yMinusX, Z, T2d FieldElement
+}
+
+func (p *ProjectiveGroupElement) Zero() {
+ FeZero(&p.X)
+ FeOne(&p.Y)
+ FeOne(&p.Z)
+}
+
+func (p *ProjectiveGroupElement) Double(r *CompletedGroupElement) {
+ var t0 FieldElement
+
+ FeSquare(&r.X, &p.X)
+ FeSquare(&r.Z, &p.Y)
+ FeSquare2(&r.T, &p.Z)
+ FeAdd(&r.Y, &p.X, &p.Y)
+ FeSquare(&t0, &r.Y)
+ FeAdd(&r.Y, &r.Z, &r.X)
+ FeSub(&r.Z, &r.Z, &r.X)
+ FeSub(&r.X, &t0, &r.Y)
+ FeSub(&r.T, &r.T, &r.Z)
+}
+
+func (p *ProjectiveGroupElement) ToBytes(s *[32]byte) {
+ var recip, x, y FieldElement
+
+ FeInvert(&recip, &p.Z)
+ FeMul(&x, &p.X, &recip)
+ FeMul(&y, &p.Y, &recip)
+ FeToBytes(s, &y)
+ s[31] ^= FeIsNegative(&x) << 7
+}
+
+func (p *ExtendedGroupElement) Zero() {
+ FeZero(&p.X)
+ FeOne(&p.Y)
+ FeOne(&p.Z)
+ FeZero(&p.T)
+}
+
+func (p *ExtendedGroupElement) Double(r *CompletedGroupElement) {
+ var q ProjectiveGroupElement
+ p.ToProjective(&q)
+ q.Double(r)
+}
+
+func (p *ExtendedGroupElement) ToCached(r *CachedGroupElement) {
+ FeAdd(&r.yPlusX, &p.Y, &p.X)
+ FeSub(&r.yMinusX, &p.Y, &p.X)
+ FeCopy(&r.Z, &p.Z)
+ FeMul(&r.T2d, &p.T, &d2)
+}
+
+func (p *ExtendedGroupElement) ToProjective(r *ProjectiveGroupElement) {
+ FeCopy(&r.X, &p.X)
+ FeCopy(&r.Y, &p.Y)
+ FeCopy(&r.Z, &p.Z)
+}
+
+func (p *ExtendedGroupElement) ToBytes(s *[32]byte) {
+ var recip, x, y FieldElement
+
+ FeInvert(&recip, &p.Z)
+ FeMul(&x, &p.X, &recip)
+ FeMul(&y, &p.Y, &recip)
+ FeToBytes(s, &y)
+ s[31] ^= FeIsNegative(&x) << 7
+}
+
+func (p *ExtendedGroupElement) FromBytes(s *[32]byte) bool {
+ var u, v, v3, vxx, check FieldElement
+
+ FeFromBytes(&p.Y, s)
+ FeOne(&p.Z)
+ FeSquare(&u, &p.Y)
+ FeMul(&v, &u, &d)
+ FeSub(&u, &u, &p.Z) // y = y^2-1
+ FeAdd(&v, &v, &p.Z) // v = dy^2+1
+
+ FeSquare(&v3, &v)
+ FeMul(&v3, &v3, &v) // v3 = v^3
+ FeSquare(&p.X, &v3)
+ FeMul(&p.X, &p.X, &v)
+ FeMul(&p.X, &p.X, &u) // x = uv^7
+
+ fePow22523(&p.X, &p.X) // x = (uv^7)^((q-5)/8)
+ FeMul(&p.X, &p.X, &v3)
+ FeMul(&p.X, &p.X, &u) // x = uv^3(uv^7)^((q-5)/8)
+
+ var tmpX, tmp2 [32]byte
+
+ FeSquare(&vxx, &p.X)
+ FeMul(&vxx, &vxx, &v)
+ FeSub(&check, &vxx, &u) // vx^2-u
+ if FeIsNonZero(&check) == 1 {
+ FeAdd(&check, &vxx, &u) // vx^2+u
+ if FeIsNonZero(&check) == 1 {
+ return false
+ }
+ FeMul(&p.X, &p.X, &SqrtM1)
+
+ FeToBytes(&tmpX, &p.X)
+ for i, v := range tmpX {
+ tmp2[31-i] = v
+ }
+ }
+
+ if FeIsNegative(&p.X) == (s[31] >> 7) {
+ FeNeg(&p.X, &p.X)
+ }
+
+ FeMul(&p.T, &p.X, &p.Y)
+ return true
+}
+
+func (p *CompletedGroupElement) ToProjective(r *ProjectiveGroupElement) {
+ FeMul(&r.X, &p.X, &p.T)
+ FeMul(&r.Y, &p.Y, &p.Z)
+ FeMul(&r.Z, &p.Z, &p.T)
+}
+
+func (p *CompletedGroupElement) ToExtended(r *ExtendedGroupElement) {
+ FeMul(&r.X, &p.X, &p.T)
+ FeMul(&r.Y, &p.Y, &p.Z)
+ FeMul(&r.Z, &p.Z, &p.T)
+ FeMul(&r.T, &p.X, &p.Y)
+}
+
+func (p *PreComputedGroupElement) Zero() {
+ FeOne(&p.yPlusX)
+ FeOne(&p.yMinusX)
+ FeZero(&p.xy2d)
+}
+
+func geAdd(r *CompletedGroupElement, p *ExtendedGroupElement, q *CachedGroupElement) {
+ var t0 FieldElement
+
+ FeAdd(&r.X, &p.Y, &p.X)
+ FeSub(&r.Y, &p.Y, &p.X)
+ FeMul(&r.Z, &r.X, &q.yPlusX)
+ FeMul(&r.Y, &r.Y, &q.yMinusX)
+ FeMul(&r.T, &q.T2d, &p.T)
+ FeMul(&r.X, &p.Z, &q.Z)
+ FeAdd(&t0, &r.X, &r.X)
+ FeSub(&r.X, &r.Z, &r.Y)
+ FeAdd(&r.Y, &r.Z, &r.Y)
+ FeAdd(&r.Z, &t0, &r.T)
+ FeSub(&r.T, &t0, &r.T)
+}
+
+func geSub(r *CompletedGroupElement, p *ExtendedGroupElement, q *CachedGroupElement) {
+ var t0 FieldElement
+
+ FeAdd(&r.X, &p.Y, &p.X)
+ FeSub(&r.Y, &p.Y, &p.X)
+ FeMul(&r.Z, &r.X, &q.yMinusX)
+ FeMul(&r.Y, &r.Y, &q.yPlusX)
+ FeMul(&r.T, &q.T2d, &p.T)
+ FeMul(&r.X, &p.Z, &q.Z)
+ FeAdd(&t0, &r.X, &r.X)
+ FeSub(&r.X, &r.Z, &r.Y)
+ FeAdd(&r.Y, &r.Z, &r.Y)
+ FeSub(&r.Z, &t0, &r.T)
+ FeAdd(&r.T, &t0, &r.T)
+}
+
+func geMixedAdd(r *CompletedGroupElement, p *ExtendedGroupElement, q *PreComputedGroupElement) {
+ var t0 FieldElement
+
+ FeAdd(&r.X, &p.Y, &p.X)
+ FeSub(&r.Y, &p.Y, &p.X)
+ FeMul(&r.Z, &r.X, &q.yPlusX)
+ FeMul(&r.Y, &r.Y, &q.yMinusX)
+ FeMul(&r.T, &q.xy2d, &p.T)
+ FeAdd(&t0, &p.Z, &p.Z)
+ FeSub(&r.X, &r.Z, &r.Y)
+ FeAdd(&r.Y, &r.Z, &r.Y)
+ FeAdd(&r.Z, &t0, &r.T)
+ FeSub(&r.T, &t0, &r.T)
+}
+
+func geMixedSub(r *CompletedGroupElement, p *ExtendedGroupElement, q *PreComputedGroupElement) {
+ var t0 FieldElement
+
+ FeAdd(&r.X, &p.Y, &p.X)
+ FeSub(&r.Y, &p.Y, &p.X)
+ FeMul(&r.Z, &r.X, &q.yMinusX)
+ FeMul(&r.Y, &r.Y, &q.yPlusX)
+ FeMul(&r.T, &q.xy2d, &p.T)
+ FeAdd(&t0, &p.Z, &p.Z)
+ FeSub(&r.X, &r.Z, &r.Y)
+ FeAdd(&r.Y, &r.Z, &r.Y)
+ FeSub(&r.Z, &t0, &r.T)
+ FeAdd(&r.T, &t0, &r.T)
+}
+
+func slide(r *[256]int8, a *[32]byte) {
+ for i := range r {
+ r[i] = int8(1 & (a[i>>3] >> uint(i&7)))
+ }
+
+ for i := range r {
+ if r[i] != 0 {
+ for b := 1; b <= 6 && i+b < 256; b++ {
+ if r[i+b] != 0 {
+ if r[i]+(r[i+b]<<uint(b)) <= 15 {
+ r[i] += r[i+b] << uint(b)
+ r[i+b] = 0
+ } else if r[i]-(r[i+b]<<uint(b)) >= -15 {
+ r[i] -= r[i+b] << uint(b)
+ for k := i + b; k < 256; k++ {
+ if r[k] == 0 {
+ r[k] = 1
+ break
+ }
+ r[k] = 0
+ }
+ } else {
+ break
+ }
+ }
+ }
+ }
+ }
+}
+
+// GeDoubleScalarMultVartime sets r = a*A + b*B
+// where a = a[0]+256*a[1]+...+256^31 a[31].
+// and b = b[0]+256*b[1]+...+256^31 b[31].
+// B is the Ed25519 base point (x,4/5) with x positive.
+func GeDoubleScalarMultVartime(r *ProjectiveGroupElement, a *[32]byte, A *ExtendedGroupElement, b *[32]byte) {
+ var aSlide, bSlide [256]int8
+ var Ai [8]CachedGroupElement // A,3A,5A,7A,9A,11A,13A,15A
+ var t CompletedGroupElement
+ var u, A2 ExtendedGroupElement
+ var i int
+
+ slide(&aSlide, a)
+ slide(&bSlide, b)
+
+ A.ToCached(&Ai[0])
+ A.Double(&t)
+ t.ToExtended(&A2)
+
+ for i := 0; i < 7; i++ {
+ geAdd(&t, &A2, &Ai[i])
+ t.ToExtended(&u)
+ u.ToCached(&Ai[i+1])
+ }
+
+ r.Zero()
+
+ for i = 255; i >= 0; i-- {
+ if aSlide[i] != 0 || bSlide[i] != 0 {
+ break
+ }
+ }
+
+ for ; i >= 0; i-- {
+ r.Double(&t)
+
+ if aSlide[i] > 0 {
+ t.ToExtended(&u)
+ geAdd(&t, &u, &Ai[aSlide[i]/2])
+ } else if aSlide[i] < 0 {
+ t.ToExtended(&u)
+ geSub(&t, &u, &Ai[(-aSlide[i])/2])
+ }
+
+ if bSlide[i] > 0 {
+ t.ToExtended(&u)
+ geMixedAdd(&t, &u, &bi[bSlide[i]/2])
+ } else if bSlide[i] < 0 {
+ t.ToExtended(&u)
+ geMixedSub(&t, &u, &bi[(-bSlide[i])/2])
+ }
+
+ t.ToProjective(r)
+ }
+}
+
+// equal returns 1 if b == c and 0 otherwise.
+func equal(b, c int32) int32 {
+ x := uint32(b ^ c)
+ x--
+ return int32(x >> 31)
+}
+
+// negative returns 1 if b < 0 and 0 otherwise.
+func negative(b int32) int32 {
+ return (b >> 31) & 1
+}
+
+func PreComputedGroupElementCMove(t, u *PreComputedGroupElement, b int32) {
+ FeCMove(&t.yPlusX, &u.yPlusX, b)
+ FeCMove(&t.yMinusX, &u.yMinusX, b)
+ FeCMove(&t.xy2d, &u.xy2d, b)
+}
+
+func selectPoint(t *PreComputedGroupElement, pos int32, b int32) {
+ var minusT PreComputedGroupElement
+ bNegative := negative(b)
+ bAbs := b - (((-bNegative) & b) << 1)
+
+ t.Zero()
+ for i := int32(0); i < 8; i++ {
+ PreComputedGroupElementCMove(t, &base[pos][i], equal(bAbs, i+1))
+ }
+ FeCopy(&minusT.yPlusX, &t.yMinusX)
+ FeCopy(&minusT.yMinusX, &t.yPlusX)
+ FeNeg(&minusT.xy2d, &t.xy2d)
+ PreComputedGroupElementCMove(t, &minusT, bNegative)
+}
+
+// GeScalarMultBase computes h = a*B, where
+// a = a[0]+256*a[1]+...+256^31 a[31]
+// B is the Ed25519 base point (x,4/5) with x positive.
+//
+// Preconditions:
+// a[31] <= 127
+func GeScalarMultBase(h *ExtendedGroupElement, a *[32]byte) {
+ var e [64]int8
+
+ for i, v := range a {
+ e[2*i] = int8(v & 15)
+ e[2*i+1] = int8((v >> 4) & 15)
+ }
+
+ // each e[i] is between 0 and 15 and e[63] is between 0 and 7.
+
+ carry := int8(0)
+ for i := 0; i < 63; i++ {
+ e[i] += carry
+ carry = (e[i] + 8) >> 4
+ e[i] -= carry << 4
+ }
+ e[63] += carry
+ // each e[i] is between -8 and 8.
+
+ h.Zero()
+ var t PreComputedGroupElement
+ var r CompletedGroupElement
+ for i := int32(1); i < 64; i += 2 {
+ selectPoint(&t, i/2, int32(e[i]))
+ geMixedAdd(&r, h, &t)
+ r.ToExtended(h)
+ }
+
+ var s ProjectiveGroupElement
+
+ h.Double(&r)
+ r.ToProjective(&s)
+ s.Double(&r)
+ r.ToProjective(&s)
+ s.Double(&r)
+ r.ToProjective(&s)
+ s.Double(&r)
+ r.ToExtended(h)
+
+ for i := int32(0); i < 64; i += 2 {
+ selectPoint(&t, i/2, int32(e[i]))
+ geMixedAdd(&r, h, &t)
+ r.ToExtended(h)
+ }
+}
+
+// The scalars are GF(2^252 + 27742317777372353535851937790883648493).
+
+// Input:
+// a[0]+256*a[1]+...+256^31*a[31] = a
+// b[0]+256*b[1]+...+256^31*b[31] = b
+// c[0]+256*c[1]+...+256^31*c[31] = c
+//
+// Output:
+// s[0]+256*s[1]+...+256^31*s[31] = (ab+c) mod l
+// where l = 2^252 + 27742317777372353535851937790883648493.
+func ScMulAdd(s, a, b, c *[32]byte) {
+ a0 := 2097151 & load3(a[:])
+ a1 := 2097151 & (load4(a[2:]) >> 5)
+ a2 := 2097151 & (load3(a[5:]) >> 2)
+ a3 := 2097151 & (load4(a[7:]) >> 7)
+ a4 := 2097151 & (load4(a[10:]) >> 4)
+ a5 := 2097151 & (load3(a[13:]) >> 1)
+ a6 := 2097151 & (load4(a[15:]) >> 6)
+ a7 := 2097151 & (load3(a[18:]) >> 3)
+ a8 := 2097151 & load3(a[21:])
+ a9 := 2097151 & (load4(a[23:]) >> 5)
+ a10 := 2097151 & (load3(a[26:]) >> 2)
+ a11 := (load4(a[28:]) >> 7)
+ b0 := 2097151 & load3(b[:])
+ b1 := 2097151 & (load4(b[2:]) >> 5)
+ b2 := 2097151 & (load3(b[5:]) >> 2)
+ b3 := 2097151 & (load4(b[7:]) >> 7)
+ b4 := 2097151 & (load4(b[10:]) >> 4)
+ b5 := 2097151 & (load3(b[13:]) >> 1)
+ b6 := 2097151 & (load4(b[15:]) >> 6)
+ b7 := 2097151 & (load3(b[18:]) >> 3)
+ b8 := 2097151 & load3(b[21:])
+ b9 := 2097151 & (load4(b[23:]) >> 5)
+ b10 := 2097151 & (load3(b[26:]) >> 2)
+ b11 := (load4(b[28:]) >> 7)
+ c0 := 2097151 & load3(c[:])
+ c1 := 2097151 & (load4(c[2:]) >> 5)
+ c2 := 2097151 & (load3(c[5:]) >> 2)
+ c3 := 2097151 & (load4(c[7:]) >> 7)
+ c4 := 2097151 & (load4(c[10:]) >> 4)
+ c5 := 2097151 & (load3(c[13:]) >> 1)
+ c6 := 2097151 & (load4(c[15:]) >> 6)
+ c7 := 2097151 & (load3(c[18:]) >> 3)
+ c8 := 2097151 & load3(c[21:])
+ c9 := 2097151 & (load4(c[23:]) >> 5)
+ c10 := 2097151 & (load3(c[26:]) >> 2)
+ c11 := (load4(c[28:]) >> 7)
+ var carry [23]int64
+
+ s0 := c0 + a0*b0
+ s1 := c1 + a0*b1 + a1*b0
+ s2 := c2 + a0*b2 + a1*b1 + a2*b0
+ s3 := c3 + a0*b3 + a1*b2 + a2*b1 + a3*b0
+ s4 := c4 + a0*b4 + a1*b3 + a2*b2 + a3*b1 + a4*b0
+ s5 := c5 + a0*b5 + a1*b4 + a2*b3 + a3*b2 + a4*b1 + a5*b0
+ s6 := c6 + a0*b6 + a1*b5 + a2*b4 + a3*b3 + a4*b2 + a5*b1 + a6*b0
+ s7 := c7 + a0*b7 + a1*b6 + a2*b5 + a3*b4 + a4*b3 + a5*b2 + a6*b1 + a7*b0
+ s8 := c8 + a0*b8 + a1*b7 + a2*b6 + a3*b5 + a4*b4 + a5*b3 + a6*b2 + a7*b1 + a8*b0
+ s9 := c9 + a0*b9 + a1*b8 + a2*b7 + a3*b6 + a4*b5 + a5*b4 + a6*b3 + a7*b2 + a8*b1 + a9*b0
+ s10 := c10 + a0*b10 + a1*b9 + a2*b8 + a3*b7 + a4*b6 + a5*b5 + a6*b4 + a7*b3 + a8*b2 + a9*b1 + a10*b0
+ s11 := c11 + a0*b11 + a1*b10 + a2*b9 + a3*b8 + a4*b7 + a5*b6 + a6*b5 + a7*b4 + a8*b3 + a9*b2 + a10*b1 + a11*b0
+ s12 := a1*b11 + a2*b10 + a3*b9 + a4*b8 + a5*b7 + a6*b6 + a7*b5 + a8*b4 + a9*b3 + a10*b2 + a11*b1
+ s13 := a2*b11 + a3*b10 + a4*b9 + a5*b8 + a6*b7 + a7*b6 + a8*b5 + a9*b4 + a10*b3 + a11*b2
+ s14 := a3*b11 + a4*b10 + a5*b9 + a6*b8 + a7*b7 + a8*b6 + a9*b5 + a10*b4 + a11*b3
+ s15 := a4*b11 + a5*b10 + a6*b9 + a7*b8 + a8*b7 + a9*b6 + a10*b5 + a11*b4
+ s16 := a5*b11 + a6*b10 + a7*b9 + a8*b8 + a9*b7 + a10*b6 + a11*b5
+ s17 := a6*b11 + a7*b10 + a8*b9 + a9*b8 + a10*b7 + a11*b6
+ s18 := a7*b11 + a8*b10 + a9*b9 + a10*b8 + a11*b7
+ s19 := a8*b11 + a9*b10 + a10*b9 + a11*b8
+ s20 := a9*b11 + a10*b10 + a11*b9
+ s21 := a10*b11 + a11*b10
+ s22 := a11 * b11
+ s23 := int64(0)
+
+ carry[0] = (s0 + (1 << 20)) >> 21
+ s1 += carry[0]
+ s0 -= carry[0] << 21
+ carry[2] = (s2 + (1 << 20)) >> 21
+ s3 += carry[2]
+ s2 -= carry[2] << 21
+ carry[4] = (s4 + (1 << 20)) >> 21
+ s5 += carry[4]
+ s4 -= carry[4] << 21
+ carry[6] = (s6 + (1 << 20)) >> 21
+ s7 += carry[6]
+ s6 -= carry[6] << 21
+ carry[8] = (s8 + (1 << 20)) >> 21
+ s9 += carry[8]
+ s8 -= carry[8] << 21
+ carry[10] = (s10 + (1 << 20)) >> 21
+ s11 += carry[10]
+ s10 -= carry[10] << 21
+ carry[12] = (s12 + (1 << 20)) >> 21
+ s13 += carry[12]
+ s12 -= carry[12] << 21
+ carry[14] = (s14 + (1 << 20)) >> 21
+ s15 += carry[14]
+ s14 -= carry[14] << 21
+ carry[16] = (s16 + (1 << 20)) >> 21
+ s17 += carry[16]
+ s16 -= carry[16] << 21
+ carry[18] = (s18 + (1 << 20)) >> 21
+ s19 += carry[18]
+ s18 -= carry[18] << 21
+ carry[20] = (s20 + (1 << 20)) >> 21
+ s21 += carry[20]
+ s20 -= carry[20] << 21
+ carry[22] = (s22 + (1 << 20)) >> 21
+ s23 += carry[22]
+ s22 -= carry[22] << 21
+
+ carry[1] = (s1 + (1 << 20)) >> 21
+ s2 += carry[1]
+ s1 -= carry[1] << 21
+ carry[3] = (s3 + (1 << 20)) >> 21
+ s4 += carry[3]
+ s3 -= carry[3] << 21
+ carry[5] = (s5 + (1 << 20)) >> 21
+ s6 += carry[5]
+ s5 -= carry[5] << 21
+ carry[7] = (s7 + (1 << 20)) >> 21
+ s8 += carry[7]
+ s7 -= carry[7] << 21
+ carry[9] = (s9 + (1 << 20)) >> 21
+ s10 += carry[9]
+ s9 -= carry[9] << 21
+ carry[11] = (s11 + (1 << 20)) >> 21
+ s12 += carry[11]
+ s11 -= carry[11] << 21
+ carry[13] = (s13 + (1 << 20)) >> 21
+ s14 += carry[13]
+ s13 -= carry[13] << 21
+ carry[15] = (s15 + (1 << 20)) >> 21
+ s16 += carry[15]
+ s15 -= carry[15] << 21
+ carry[17] = (s17 + (1 << 20)) >> 21
+ s18 += carry[17]
+ s17 -= carry[17] << 21
+ carry[19] = (s19 + (1 << 20)) >> 21
+ s20 += carry[19]
+ s19 -= carry[19] << 21
+ carry[21] = (s21 + (1 << 20)) >> 21
+ s22 += carry[21]
+ s21 -= carry[21] << 21
+
+ s11 += s23 * 666643
+ s12 += s23 * 470296
+ s13 += s23 * 654183
+ s14 -= s23 * 997805
+ s15 += s23 * 136657
+ s16 -= s23 * 683901
+ s23 = 0
+
+ s10 += s22 * 666643
+ s11 += s22 * 470296
+ s12 += s22 * 654183
+ s13 -= s22 * 997805
+ s14 += s22 * 136657
+ s15 -= s22 * 683901
+ s22 = 0
+
+ s9 += s21 * 666643
+ s10 += s21 * 470296
+ s11 += s21 * 654183
+ s12 -= s21 * 997805
+ s13 += s21 * 136657
+ s14 -= s21 * 683901
+ s21 = 0
+
+ s8 += s20 * 666643
+ s9 += s20 * 470296
+ s10 += s20 * 654183
+ s11 -= s20 * 997805
+ s12 += s20 * 136657
+ s13 -= s20 * 683901
+ s20 = 0
+
+ s7 += s19 * 666643
+ s8 += s19 * 470296
+ s9 += s19 * 654183
+ s10 -= s19 * 997805
+ s11 += s19 * 136657
+ s12 -= s19 * 683901
+ s19 = 0
+
+ s6 += s18 * 666643
+ s7 += s18 * 470296
+ s8 += s18 * 654183
+ s9 -= s18 * 997805
+ s10 += s18 * 136657
+ s11 -= s18 * 683901
+ s18 = 0
+
+ carry[6] = (s6 + (1 << 20)) >> 21
+ s7 += carry[6]
+ s6 -= carry[6] << 21
+ carry[8] = (s8 + (1 << 20)) >> 21
+ s9 += carry[8]
+ s8 -= carry[8] << 21
+ carry[10] = (s10 + (1 << 20)) >> 21
+ s11 += carry[10]
+ s10 -= carry[10] << 21
+ carry[12] = (s12 + (1 << 20)) >> 21
+ s13 += carry[12]
+ s12 -= carry[12] << 21
+ carry[14] = (s14 + (1 << 20)) >> 21
+ s15 += carry[14]
+ s14 -= carry[14] << 21
+ carry[16] = (s16 + (1 << 20)) >> 21
+ s17 += carry[16]
+ s16 -= carry[16] << 21
+
+ carry[7] = (s7 + (1 << 20)) >> 21
+ s8 += carry[7]
+ s7 -= carry[7] << 21
+ carry[9] = (s9 + (1 << 20)) >> 21
+ s10 += carry[9]
+ s9 -= carry[9] << 21
+ carry[11] = (s11 + (1 << 20)) >> 21
+ s12 += carry[11]
+ s11 -= carry[11] << 21
+ carry[13] = (s13 + (1 << 20)) >> 21
+ s14 += carry[13]
+ s13 -= carry[13] << 21
+ carry[15] = (s15 + (1 << 20)) >> 21
+ s16 += carry[15]
+ s15 -= carry[15] << 21
+
+ s5 += s17 * 666643
+ s6 += s17 * 470296
+ s7 += s17 * 654183
+ s8 -= s17 * 997805
+ s9 += s17 * 136657
+ s10 -= s17 * 683901
+ s17 = 0
+
+ s4 += s16 * 666643
+ s5 += s16 * 470296
+ s6 += s16 * 654183
+ s7 -= s16 * 997805
+ s8 += s16 * 136657
+ s9 -= s16 * 683901
+ s16 = 0
+
+ s3 += s15 * 666643
+ s4 += s15 * 470296
+ s5 += s15 * 654183
+ s6 -= s15 * 997805
+ s7 += s15 * 136657
+ s8 -= s15 * 683901
+ s15 = 0
+
+ s2 += s14 * 666643
+ s3 += s14 * 470296
+ s4 += s14 * 654183
+ s5 -= s14 * 997805
+ s6 += s14 * 136657
+ s7 -= s14 * 683901
+ s14 = 0
+
+ s1 += s13 * 666643
+ s2 += s13 * 470296
+ s3 += s13 * 654183
+ s4 -= s13 * 997805
+ s5 += s13 * 136657
+ s6 -= s13 * 683901
+ s13 = 0
+
+ s0 += s12 * 666643
+ s1 += s12 * 470296
+ s2 += s12 * 654183
+ s3 -= s12 * 997805
+ s4 += s12 * 136657
+ s5 -= s12 * 683901
+ s12 = 0
+
+ carry[0] = (s0 + (1 << 20)) >> 21
+ s1 += carry[0]
+ s0 -= carry[0] << 21
+ carry[2] = (s2 + (1 << 20)) >> 21
+ s3 += carry[2]
+ s2 -= carry[2] << 21
+ carry[4] = (s4 + (1 << 20)) >> 21
+ s5 += carry[4]
+ s4 -= carry[4] << 21
+ carry[6] = (s6 + (1 << 20)) >> 21
+ s7 += carry[6]
+ s6 -= carry[6] << 21
+ carry[8] = (s8 + (1 << 20)) >> 21
+ s9 += carry[8]
+ s8 -= carry[8] << 21
+ carry[10] = (s10 + (1 << 20)) >> 21
+ s11 += carry[10]
+ s10 -= carry[10] << 21
+
+ carry[1] = (s1 + (1 << 20)) >> 21
+ s2 += carry[1]
+ s1 -= carry[1] << 21
+ carry[3] = (s3 + (1 << 20)) >> 21
+ s4 += carry[3]
+ s3 -= carry[3] << 21
+ carry[5] = (s5 + (1 << 20)) >> 21
+ s6 += carry[5]
+ s5 -= carry[5] << 21
+ carry[7] = (s7 + (1 << 20)) >> 21
+ s8 += carry[7]
+ s7 -= carry[7] << 21
+ carry[9] = (s9 + (1 << 20)) >> 21
+ s10 += carry[9]
+ s9 -= carry[9] << 21
+ carry[11] = (s11 + (1 << 20)) >> 21
+ s12 += carry[11]
+ s11 -= carry[11] << 21
+
+ s0 += s12 * 666643
+ s1 += s12 * 470296
+ s2 += s12 * 654183
+ s3 -= s12 * 997805
+ s4 += s12 * 136657
+ s5 -= s12 * 683901
+ s12 = 0
+
+ carry[0] = s0 >> 21
+ s1 += carry[0]
+ s0 -= carry[0] << 21
+ carry[1] = s1 >> 21
+ s2 += carry[1]
+ s1 -= carry[1] << 21
+ carry[2] = s2 >> 21
+ s3 += carry[2]
+ s2 -= carry[2] << 21
+ carry[3] = s3 >> 21
+ s4 += carry[3]
+ s3 -= carry[3] << 21
+ carry[4] = s4 >> 21
+ s5 += carry[4]
+ s4 -= carry[4] << 21
+ carry[5] = s5 >> 21
+ s6 += carry[5]
+ s5 -= carry[5] << 21
+ carry[6] = s6 >> 21
+ s7 += carry[6]
+ s6 -= carry[6] << 21
+ carry[7] = s7 >> 21
+ s8 += carry[7]
+ s7 -= carry[7] << 21
+ carry[8] = s8 >> 21
+ s9 += carry[8]
+ s8 -= carry[8] << 21
+ carry[9] = s9 >> 21
+ s10 += carry[9]
+ s9 -= carry[9] << 21
+ carry[10] = s10 >> 21
+ s11 += carry[10]
+ s10 -= carry[10] << 21
+ carry[11] = s11 >> 21
+ s12 += carry[11]
+ s11 -= carry[11] << 21
+
+ s0 += s12 * 666643
+ s1 += s12 * 470296
+ s2 += s12 * 654183
+ s3 -= s12 * 997805
+ s4 += s12 * 136657
+ s5 -= s12 * 683901
+ s12 = 0
+
+ carry[0] = s0 >> 21
+ s1 += carry[0]
+ s0 -= carry[0] << 21
+ carry[1] = s1 >> 21
+ s2 += carry[1]
+ s1 -= carry[1] << 21
+ carry[2] = s2 >> 21
+ s3 += carry[2]
+ s2 -= carry[2] << 21
+ carry[3] = s3 >> 21
+ s4 += carry[3]
+ s3 -= carry[3] << 21
+ carry[4] = s4 >> 21
+ s5 += carry[4]
+ s4 -= carry[4] << 21
+ carry[5] = s5 >> 21
+ s6 += carry[5]
+ s5 -= carry[5] << 21
+ carry[6] = s6 >> 21
+ s7 += carry[6]
+ s6 -= carry[6] << 21
+ carry[7] = s7 >> 21
+ s8 += carry[7]
+ s7 -= carry[7] << 21
+ carry[8] = s8 >> 21
+ s9 += carry[8]
+ s8 -= carry[8] << 21
+ carry[9] = s9 >> 21
+ s10 += carry[9]
+ s9 -= carry[9] << 21
+ carry[10] = s10 >> 21
+ s11 += carry[10]
+ s10 -= carry[10] << 21
+
+ s[0] = byte(s0 >> 0)
+ s[1] = byte(s0 >> 8)
+ s[2] = byte((s0 >> 16) | (s1 << 5))
+ s[3] = byte(s1 >> 3)
+ s[4] = byte(s1 >> 11)
+ s[5] = byte((s1 >> 19) | (s2 << 2))
+ s[6] = byte(s2 >> 6)
+ s[7] = byte((s2 >> 14) | (s3 << 7))
+ s[8] = byte(s3 >> 1)
+ s[9] = byte(s3 >> 9)
+ s[10] = byte((s3 >> 17) | (s4 << 4))
+ s[11] = byte(s4 >> 4)
+ s[12] = byte(s4 >> 12)
+ s[13] = byte((s4 >> 20) | (s5 << 1))
+ s[14] = byte(s5 >> 7)
+ s[15] = byte((s5 >> 15) | (s6 << 6))
+ s[16] = byte(s6 >> 2)
+ s[17] = byte(s6 >> 10)
+ s[18] = byte((s6 >> 18) | (s7 << 3))
+ s[19] = byte(s7 >> 5)
+ s[20] = byte(s7 >> 13)
+ s[21] = byte(s8 >> 0)
+ s[22] = byte(s8 >> 8)
+ s[23] = byte((s8 >> 16) | (s9 << 5))
+ s[24] = byte(s9 >> 3)
+ s[25] = byte(s9 >> 11)
+ s[26] = byte((s9 >> 19) | (s10 << 2))
+ s[27] = byte(s10 >> 6)
+ s[28] = byte((s10 >> 14) | (s11 << 7))
+ s[29] = byte(s11 >> 1)
+ s[30] = byte(s11 >> 9)
+ s[31] = byte(s11 >> 17)
+}
+
+// Input:
+// s[0]+256*s[1]+...+256^63*s[63] = s
+//
+// Output:
+// s[0]+256*s[1]+...+256^31*s[31] = s mod l
+// where l = 2^252 + 27742317777372353535851937790883648493.
+func ScReduce(out *[32]byte, s *[64]byte) {
+ s0 := 2097151 & load3(s[:])
+ s1 := 2097151 & (load4(s[2:]) >> 5)
+ s2 := 2097151 & (load3(s[5:]) >> 2)
+ s3 := 2097151 & (load4(s[7:]) >> 7)
+ s4 := 2097151 & (load4(s[10:]) >> 4)
+ s5 := 2097151 & (load3(s[13:]) >> 1)
+ s6 := 2097151 & (load4(s[15:]) >> 6)
+ s7 := 2097151 & (load3(s[18:]) >> 3)
+ s8 := 2097151 & load3(s[21:])
+ s9 := 2097151 & (load4(s[23:]) >> 5)
+ s10 := 2097151 & (load3(s[26:]) >> 2)
+ s11 := 2097151 & (load4(s[28:]) >> 7)
+ s12 := 2097151 & (load4(s[31:]) >> 4)
+ s13 := 2097151 & (load3(s[34:]) >> 1)
+ s14 := 2097151 & (load4(s[36:]) >> 6)
+ s15 := 2097151 & (load3(s[39:]) >> 3)
+ s16 := 2097151 & load3(s[42:])
+ s17 := 2097151 & (load4(s[44:]) >> 5)
+ s18 := 2097151 & (load3(s[47:]) >> 2)
+ s19 := 2097151 & (load4(s[49:]) >> 7)
+ s20 := 2097151 & (load4(s[52:]) >> 4)
+ s21 := 2097151 & (load3(s[55:]) >> 1)
+ s22 := 2097151 & (load4(s[57:]) >> 6)
+ s23 := (load4(s[60:]) >> 3)
+
+ s11 += s23 * 666643
+ s12 += s23 * 470296
+ s13 += s23 * 654183
+ s14 -= s23 * 997805
+ s15 += s23 * 136657
+ s16 -= s23 * 683901
+ s23 = 0
+
+ s10 += s22 * 666643
+ s11 += s22 * 470296
+ s12 += s22 * 654183
+ s13 -= s22 * 997805
+ s14 += s22 * 136657
+ s15 -= s22 * 683901
+ s22 = 0
+
+ s9 += s21 * 666643
+ s10 += s21 * 470296
+ s11 += s21 * 654183
+ s12 -= s21 * 997805
+ s13 += s21 * 136657
+ s14 -= s21 * 683901
+ s21 = 0
+
+ s8 += s20 * 666643
+ s9 += s20 * 470296
+ s10 += s20 * 654183
+ s11 -= s20 * 997805
+ s12 += s20 * 136657
+ s13 -= s20 * 683901
+ s20 = 0
+
+ s7 += s19 * 666643
+ s8 += s19 * 470296
+ s9 += s19 * 654183
+ s10 -= s19 * 997805
+ s11 += s19 * 136657
+ s12 -= s19 * 683901
+ s19 = 0
+
+ s6 += s18 * 666643
+ s7 += s18 * 470296
+ s8 += s18 * 654183
+ s9 -= s18 * 997805
+ s10 += s18 * 136657
+ s11 -= s18 * 683901
+ s18 = 0
+
+ var carry [17]int64
+
+ carry[6] = (s6 + (1 << 20)) >> 21
+ s7 += carry[6]
+ s6 -= carry[6] << 21
+ carry[8] = (s8 + (1 << 20)) >> 21
+ s9 += carry[8]
+ s8 -= carry[8] << 21
+ carry[10] = (s10 + (1 << 20)) >> 21
+ s11 += carry[10]
+ s10 -= carry[10] << 21
+ carry[12] = (s12 + (1 << 20)) >> 21
+ s13 += carry[12]
+ s12 -= carry[12] << 21
+ carry[14] = (s14 + (1 << 20)) >> 21
+ s15 += carry[14]
+ s14 -= carry[14] << 21
+ carry[16] = (s16 + (1 << 20)) >> 21
+ s17 += carry[16]
+ s16 -= carry[16] << 21
+
+ carry[7] = (s7 + (1 << 20)) >> 21
+ s8 += carry[7]
+ s7 -= carry[7] << 21
+ carry[9] = (s9 + (1 << 20)) >> 21
+ s10 += carry[9]
+ s9 -= carry[9] << 21
+ carry[11] = (s11 + (1 << 20)) >> 21
+ s12 += carry[11]
+ s11 -= carry[11] << 21
+ carry[13] = (s13 + (1 << 20)) >> 21
+ s14 += carry[13]
+ s13 -= carry[13] << 21
+ carry[15] = (s15 + (1 << 20)) >> 21
+ s16 += carry[15]
+ s15 -= carry[15] << 21
+
+ s5 += s17 * 666643
+ s6 += s17 * 470296
+ s7 += s17 * 654183
+ s8 -= s17 * 997805
+ s9 += s17 * 136657
+ s10 -= s17 * 683901
+ s17 = 0
+
+ s4 += s16 * 666643
+ s5 += s16 * 470296
+ s6 += s16 * 654183
+ s7 -= s16 * 997805
+ s8 += s16 * 136657
+ s9 -= s16 * 683901
+ s16 = 0
+
+ s3 += s15 * 666643
+ s4 += s15 * 470296
+ s5 += s15 * 654183
+ s6 -= s15 * 997805
+ s7 += s15 * 136657
+ s8 -= s15 * 683901
+ s15 = 0
+
+ s2 += s14 * 666643
+ s3 += s14 * 470296
+ s4 += s14 * 654183
+ s5 -= s14 * 997805
+ s6 += s14 * 136657
+ s7 -= s14 * 683901
+ s14 = 0
+
+ s1 += s13 * 666643
+ s2 += s13 * 470296
+ s3 += s13 * 654183
+ s4 -= s13 * 997805
+ s5 += s13 * 136657
+ s6 -= s13 * 683901
+ s13 = 0
+
+ s0 += s12 * 666643
+ s1 += s12 * 470296
+ s2 += s12 * 654183
+ s3 -= s12 * 997805
+ s4 += s12 * 136657
+ s5 -= s12 * 683901
+ s12 = 0
+
+ carry[0] = (s0 + (1 << 20)) >> 21
+ s1 += carry[0]
+ s0 -= carry[0] << 21
+ carry[2] = (s2 + (1 << 20)) >> 21
+ s3 += carry[2]
+ s2 -= carry[2] << 21
+ carry[4] = (s4 + (1 << 20)) >> 21
+ s5 += carry[4]
+ s4 -= carry[4] << 21
+ carry[6] = (s6 + (1 << 20)) >> 21
+ s7 += carry[6]
+ s6 -= carry[6] << 21
+ carry[8] = (s8 + (1 << 20)) >> 21
+ s9 += carry[8]
+ s8 -= carry[8] << 21
+ carry[10] = (s10 + (1 << 20)) >> 21
+ s11 += carry[10]
+ s10 -= carry[10] << 21
+
+ carry[1] = (s1 + (1 << 20)) >> 21
+ s2 += carry[1]
+ s1 -= carry[1] << 21
+ carry[3] = (s3 + (1 << 20)) >> 21
+ s4 += carry[3]
+ s3 -= carry[3] << 21
+ carry[5] = (s5 + (1 << 20)) >> 21
+ s6 += carry[5]
+ s5 -= carry[5] << 21
+ carry[7] = (s7 + (1 << 20)) >> 21
+ s8 += carry[7]
+ s7 -= carry[7] << 21
+ carry[9] = (s9 + (1 << 20)) >> 21
+ s10 += carry[9]
+ s9 -= carry[9] << 21
+ carry[11] = (s11 + (1 << 20)) >> 21
+ s12 += carry[11]
+ s11 -= carry[11] << 21
+
+ s0 += s12 * 666643
+ s1 += s12 * 470296
+ s2 += s12 * 654183
+ s3 -= s12 * 997805
+ s4 += s12 * 136657
+ s5 -= s12 * 683901
+ s12 = 0
+
+ carry[0] = s0 >> 21
+ s1 += carry[0]
+ s0 -= carry[0] << 21
+ carry[1] = s1 >> 21
+ s2 += carry[1]
+ s1 -= carry[1] << 21
+ carry[2] = s2 >> 21
+ s3 += carry[2]
+ s2 -= carry[2] << 21
+ carry[3] = s3 >> 21
+ s4 += carry[3]
+ s3 -= carry[3] << 21
+ carry[4] = s4 >> 21
+ s5 += carry[4]
+ s4 -= carry[4] << 21
+ carry[5] = s5 >> 21
+ s6 += carry[5]
+ s5 -= carry[5] << 21
+ carry[6] = s6 >> 21
+ s7 += carry[6]
+ s6 -= carry[6] << 21
+ carry[7] = s7 >> 21
+ s8 += carry[7]
+ s7 -= carry[7] << 21
+ carry[8] = s8 >> 21
+ s9 += carry[8]
+ s8 -= carry[8] << 21
+ carry[9] = s9 >> 21
+ s10 += carry[9]
+ s9 -= carry[9] << 21
+ carry[10] = s10 >> 21
+ s11 += carry[10]
+ s10 -= carry[10] << 21
+ carry[11] = s11 >> 21
+ s12 += carry[11]
+ s11 -= carry[11] << 21
+
+ s0 += s12 * 666643
+ s1 += s12 * 470296
+ s2 += s12 * 654183
+ s3 -= s12 * 997805
+ s4 += s12 * 136657
+ s5 -= s12 * 683901
+ s12 = 0
+
+ carry[0] = s0 >> 21
+ s1 += carry[0]
+ s0 -= carry[0] << 21
+ carry[1] = s1 >> 21
+ s2 += carry[1]
+ s1 -= carry[1] << 21
+ carry[2] = s2 >> 21
+ s3 += carry[2]
+ s2 -= carry[2] << 21
+ carry[3] = s3 >> 21
+ s4 += carry[3]
+ s3 -= carry[3] << 21
+ carry[4] = s4 >> 21
+ s5 += carry[4]
+ s4 -= carry[4] << 21
+ carry[5] = s5 >> 21
+ s6 += carry[5]
+ s5 -= carry[5] << 21
+ carry[6] = s6 >> 21
+ s7 += carry[6]
+ s6 -= carry[6] << 21
+ carry[7] = s7 >> 21
+ s8 += carry[7]
+ s7 -= carry[7] << 21
+ carry[8] = s8 >> 21
+ s9 += carry[8]
+ s8 -= carry[8] << 21
+ carry[9] = s9 >> 21
+ s10 += carry[9]
+ s9 -= carry[9] << 21
+ carry[10] = s10 >> 21
+ s11 += carry[10]
+ s10 -= carry[10] << 21
+
+ out[0] = byte(s0 >> 0)
+ out[1] = byte(s0 >> 8)
+ out[2] = byte((s0 >> 16) | (s1 << 5))
+ out[3] = byte(s1 >> 3)
+ out[4] = byte(s1 >> 11)
+ out[5] = byte((s1 >> 19) | (s2 << 2))
+ out[6] = byte(s2 >> 6)
+ out[7] = byte((s2 >> 14) | (s3 << 7))
+ out[8] = byte(s3 >> 1)
+ out[9] = byte(s3 >> 9)
+ out[10] = byte((s3 >> 17) | (s4 << 4))
+ out[11] = byte(s4 >> 4)
+ out[12] = byte(s4 >> 12)
+ out[13] = byte((s4 >> 20) | (s5 << 1))
+ out[14] = byte(s5 >> 7)
+ out[15] = byte((s5 >> 15) | (s6 << 6))
+ out[16] = byte(s6 >> 2)
+ out[17] = byte(s6 >> 10)
+ out[18] = byte((s6 >> 18) | (s7 << 3))
+ out[19] = byte(s7 >> 5)
+ out[20] = byte(s7 >> 13)
+ out[21] = byte(s8 >> 0)
+ out[22] = byte(s8 >> 8)
+ out[23] = byte((s8 >> 16) | (s9 << 5))
+ out[24] = byte(s9 >> 3)
+ out[25] = byte(s9 >> 11)
+ out[26] = byte((s9 >> 19) | (s10 << 2))
+ out[27] = byte(s10 >> 6)
+ out[28] = byte((s10 >> 14) | (s11 << 7))
+ out[29] = byte(s11 >> 1)
+ out[30] = byte(s11 >> 9)
+ out[31] = byte(s11 >> 17)
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/.gitignore b/Godeps/_workspace/src/github.com/gin-gonic/gin/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..9f48f142567bdaf076758e6a0f300e74352f2d22
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/.gitignore
@@ -0,0 +1,4 @@
+Godeps/*
+!Godeps/Godeps.json
+coverage.out
+count.out
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/.travis.yml b/Godeps/_workspace/src/github.com/gin-gonic/gin/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..695f0b7ecfe20cf5605a35dcc6ebb6e304efb132
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/.travis.yml
@@ -0,0 +1,22 @@
+language: go
+sudo: false
+go:
+ - 1.4
+ - 1.4.2
+ - tip
+
+script:
+ - go get golang.org/x/tools/cmd/cover
+ - go get github.com/mattn/goveralls
+ - go test -v -covermode=count -coverprofile=coverage.out
+
+after_success:
+ - goveralls -coverprofile=coverage.out -service=travis-ci -repotoken yFj7FrCeddvBzUaaCyG33jCLfWXeb93eA
+
+notifications:
+ webhooks:
+ urls:
+ - https://webhooks.gitter.im/e/acc2c57482e94b44f557
+ on_success: change # options: [always|never|change] default: always
+ on_failure: always # options: [always|never|change] default: always
+ on_start: false # default: false
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/AUTHORS.md b/Godeps/_workspace/src/github.com/gin-gonic/gin/AUTHORS.md
new file mode 100644
index 0000000000000000000000000000000000000000..2feaf467768cdbcebeb2aef57f8f9e9014b933d3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/AUTHORS.md
@@ -0,0 +1,229 @@
+List of all the awesome people working to make Gin the best Web Framework in Go.
+
+
+
+##gin 0.x series authors
+
+**Maintainer:** Manu Martinez-Almeida (@manucorporat), Javier Provecho (@javierprovecho)
+
+People and companies, who have contributed, in alphabetical order.
+
+**@858806258 (æ°å“¥)**
+- Fix typo in example
+
+
+**@achedeuzot (Klemen Sever)**
+- Fix newline debug printing
+
+
+**@adammck (Adam Mckaig)**
+- Add MIT license
+
+
+**@AlexanderChen1989 (Alexander)**
+- Typos in README
+
+
+**@alexanderdidenko (Aleksandr Didenko)**
+- Add support multipart/form-data
+
+
+**@alexandernyquist (Alexander Nyquist)**
+- Using template.Must to fix multiple return issue
+- ★ Added support for OPTIONS verb
+- ★ Setting response headers before calling WriteHeader
+- Improved documentation for model binding
+- ★ Added Content.Redirect()
+- ★ Added tons of Unit tests
+
+
+**@austinheap (Austin Heap)**
+- Added travis CI integration
+
+
+**@andredublin (Andre Dublin)**
+- Fix typo in comment
+
+
+**@bredov (Ludwig Valda Vasquez)**
+- Fix html templating in debug mode
+
+
+**@bluele (Jun Kimura)**
+- Fixes code examples in README
+
+
+**@chad-russell**
+- ★ Support for serializing gin.H into XML
+
+
+**@dickeyxxx (Jeff Dickey)**
+- Typos in README
+- Add example about serving static files
+
+
+**@donileo (Adonis)**
+- Add NoMethod handler
+
+
+**@dutchcoders (DutchCoders)**
+- ★ Fix security bug that allows client to spoof ip
+- Fix typo. r.HTMLTemplates -> SetHTMLTemplate
+
+
+**@el3ctro- (Joshua Loper)**
+- Fix typo in example
+
+
+**@ethankan (Ethan Kan)**
+- Unsigned integers in binding
+
+
+**(Evgeny Persienko)**
+- Validate sub structures
+
+
+**@frankbille (Frank Bille)**
+- Add support for HTTP Realm Auth
+
+
+**@fmd (Fareed Dudhia)**
+- Fix typo. SetHTTPTemplate -> SetHTMLTemplate
+
+
+**@ironiridis (Christopher Harrington)**
+- Remove old reference
+
+
+**@jammie-stackhouse (Jamie Stackhouse)**
+- Add more shortcuts for router methods
+
+
+**@jasonrhansen**
+- Fix spelling and grammar errors in documentation
+
+
+**@JasonSoft (Jason Lee)**
+- Fix typo in comment
+
+
+**@joiggama (Ignacio Galindo)**
+- Add utf-8 charset header on renders
+
+
+**@julienschmidt (Julien Schmidt)**
+- gofmt the code examples
+
+
+**@kelcecil (Kel Cecil)**
+- Fix readme typo
+
+
+**@kyledinh (Kyle Dinh)**
+- Adds RunTLS()
+
+
+**@LinusU (Linus Unnebäck)**
+- Small fixes in README
+
+
+**@loongmxbt (Saint Asky)**
+- Fix typo in example
+
+
+**@lucas-clemente (Lucas Clemente)**
+- ★ work around path.Join removing trailing slashes from routes
+
+
+**@mattn (Yasuhiro Matsumoto)**
+- Improve color logger
+
+
+**@mdigger (Dmitry Sedykh)**
+- Fixes Form binding when content-type is x-www-form-urlencoded
+- No repeat call c.Writer.Status() in gin.Logger
+- Fixes Content-Type for json render
+
+
+**@mirzac (Mirza Ceric)**
+- Fix debug printing
+
+
+**@mopemope (Yutaka Matsubara)**
+- ★ Adds Godep support (Dependencies Manager)
+- Fix variadic parameter in the flexible render API
+- Fix Corrupted plain render
+- Add Pluggable View Renderer Example
+
+
+**@msemenistyi (Mykyta Semenistyi)**
+- update Readme.md. Add code to String method
+
+
+**@msoedov (Sasha Myasoedov)**
+- ★ Adds tons of unit tests.
+
+
+**@ngerakines (Nick Gerakines)**
+- ★ Improves API, c.GET() doesn't panic
+- Adds MustGet() method
+
+
+**@r8k (Rajiv Kilaparti)**
+- Fix Port usage in README.
+
+
+**@rayrod2030 (Ray Rodriguez)**
+- Fix typo in example
+
+
+**@rns**
+- Fix typo in example
+
+
+**@RobAWilkinson (Robert Wilkinson)**
+- Add example of forms and params
+
+
+**@rogierlommers (Rogier Lommers)**
+- Add updated static serve example
+
+
+**@se77en (Damon Zhao)**
+- Improve color logging
+
+
+**@silasb (Silas Baronda)**
+- Fixing quotes in README
+
+
+**@SkuliOskarsson (Skuli Oskarsson)**
+- Fixes some texts in README II
+
+
+**@slimmy (Jimmy Pettersson)**
+- Added messages for required bindings
+
+
+**@smira (Andrey Smirnov)**
+- Add support for ignored/unexported fields in binding
+
+
+**@superalsrk (SRK.Lyu)**
+- Update httprouter godeps
+
+
+**@tebeka (Miki Tebeka)**
+- Use net/http constants instead of numeric values
+
+
+**@techjanitor**
+- Update context.go reserved IPs
+
+
+**@yosssi (Keiji Yoshida)**
+- Fix link in README
+
+
+**@yuyabee**
+- Fixed README
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/BENCHMARKS.md b/Godeps/_workspace/src/github.com/gin-gonic/gin/BENCHMARKS.md
new file mode 100644
index 0000000000000000000000000000000000000000..181f75b3683ba5a2211eea5f3b3764942fc0559a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/BENCHMARKS.md
@@ -0,0 +1,298 @@
+**Machine:** intel i7 ivy bridge quad-core. 8GB RAM.
+**Date:** June 4th, 2015
+[https://github.com/gin-gonic/go-http-routing-benchmark](https://github.com/gin-gonic/go-http-routing-benchmark)
+
+```
+BenchmarkAce_Param 5000000 372 ns/op 32 B/op 1 allocs/op
+BenchmarkBear_Param 1000000 1165 ns/op 424 B/op 5 allocs/op
+BenchmarkBeego_Param 1000000 2440 ns/op 720 B/op 10 allocs/op
+BenchmarkBone_Param 1000000 1067 ns/op 384 B/op 3 allocs/op
+BenchmarkDenco_Param 5000000 240 ns/op 32 B/op 1 allocs/op
+BenchmarkEcho_Param 10000000 130 ns/op 0 B/op 0 allocs/op
+BenchmarkGin_Param 10000000 133 ns/op 0 B/op 0 allocs/op
+BenchmarkGocraftWeb_Param 1000000 1826 ns/op 656 B/op 9 allocs/op
+BenchmarkGoji_Param 2000000 957 ns/op 336 B/op 2 allocs/op
+BenchmarkGoJsonRest_Param 1000000 2021 ns/op 657 B/op 14 allocs/op
+BenchmarkGoRestful_Param 200000 8825 ns/op 2496 B/op 31 allocs/op
+BenchmarkGorillaMux_Param 500000 3340 ns/op 784 B/op 9 allocs/op
+BenchmarkHttpRouter_Param 10000000 152 ns/op 32 B/op 1 allocs/op
+BenchmarkHttpTreeMux_Param 2000000 717 ns/op 336 B/op 2 allocs/op
+BenchmarkKocha_Param 3000000 423 ns/op 56 B/op 3 allocs/op
+BenchmarkMacaron_Param 1000000 3410 ns/op 1104 B/op 11 allocs/op
+BenchmarkMartini_Param 200000 7101 ns/op 1152 B/op 12 allocs/op
+BenchmarkPat_Param 1000000 2040 ns/op 656 B/op 14 allocs/op
+BenchmarkPossum_Param 1000000 2048 ns/op 624 B/op 7 allocs/op
+BenchmarkR2router_Param 1000000 1144 ns/op 432 B/op 6 allocs/op
+BenchmarkRevel_Param 200000 6725 ns/op 1672 B/op 28 allocs/op
+BenchmarkRivet_Param 1000000 1121 ns/op 464 B/op 5 allocs/op
+BenchmarkTango_Param 1000000 1479 ns/op 256 B/op 10 allocs/op
+BenchmarkTigerTonic_Param 1000000 3393 ns/op 992 B/op 19 allocs/op
+BenchmarkTraffic_Param 300000 5525 ns/op 1984 B/op 23 allocs/op
+BenchmarkVulcan_Param 2000000 924 ns/op 98 B/op 3 allocs/op
+BenchmarkZeus_Param 1000000 1084 ns/op 368 B/op 3 allocs/op
+BenchmarkAce_Param5 3000000 614 ns/op 160 B/op 1 allocs/op
+BenchmarkBear_Param5 1000000 1617 ns/op 469 B/op 5 allocs/op
+BenchmarkBeego_Param5 1000000 3373 ns/op 992 B/op 13 allocs/op
+BenchmarkBone_Param5 1000000 1478 ns/op 432 B/op 3 allocs/op
+BenchmarkDenco_Param5 3000000 570 ns/op 160 B/op 1 allocs/op
+BenchmarkEcho_Param5 5000000 256 ns/op 0 B/op 0 allocs/op
+BenchmarkGin_Param5 10000000 222 ns/op 0 B/op 0 allocs/op
+BenchmarkGocraftWeb_Param5 1000000 2789 ns/op 928 B/op 12 allocs/op
+BenchmarkGoji_Param5 1000000 1287 ns/op 336 B/op 2 allocs/op
+BenchmarkGoJsonRest_Param5 1000000 3670 ns/op 1105 B/op 17 allocs/op
+BenchmarkGoRestful_Param5 200000 10756 ns/op 2672 B/op 31 allocs/op
+BenchmarkGorillaMux_Param5 300000 5543 ns/op 912 B/op 9 allocs/op
+BenchmarkHttpRouter_Param5 5000000 403 ns/op 160 B/op 1 allocs/op
+BenchmarkHttpTreeMux_Param5 1000000 1089 ns/op 336 B/op 2 allocs/op
+BenchmarkKocha_Param5 1000000 1682 ns/op 440 B/op 10 allocs/op
+BenchmarkMacaron_Param5 300000 4596 ns/op 1376 B/op 14 allocs/op
+BenchmarkMartini_Param5 100000 15703 ns/op 1280 B/op 12 allocs/op
+BenchmarkPat_Param5 300000 5320 ns/op 1008 B/op 42 allocs/op
+BenchmarkPossum_Param5 1000000 2155 ns/op 624 B/op 7 allocs/op
+BenchmarkR2router_Param5 1000000 1559 ns/op 432 B/op 6 allocs/op
+BenchmarkRevel_Param5 200000 8184 ns/op 2024 B/op 35 allocs/op
+BenchmarkRivet_Param5 1000000 1914 ns/op 528 B/op 9 allocs/op
+BenchmarkTango_Param5 1000000 3280 ns/op 944 B/op 18 allocs/op
+BenchmarkTigerTonic_Param5 200000 11638 ns/op 2519 B/op 53 allocs/op
+BenchmarkTraffic_Param5 200000 8941 ns/op 2280 B/op 31 allocs/op
+BenchmarkVulcan_Param5 1000000 1279 ns/op 98 B/op 3 allocs/op
+BenchmarkZeus_Param5 1000000 1574 ns/op 416 B/op 3 allocs/op
+BenchmarkAce_Param20 1000000 1528 ns/op 640 B/op 1 allocs/op
+BenchmarkBear_Param20 300000 4906 ns/op 1633 B/op 5 allocs/op
+BenchmarkBeego_Param20 200000 10529 ns/op 3868 B/op 17 allocs/op
+BenchmarkBone_Param20 300000 7362 ns/op 2539 B/op 5 allocs/op
+BenchmarkDenco_Param20 1000000 1884 ns/op 640 B/op 1 allocs/op
+BenchmarkEcho_Param20 2000000 689 ns/op 0 B/op 0 allocs/op
+BenchmarkGin_Param20 3000000 545 ns/op 0 B/op 0 allocs/op
+BenchmarkGocraftWeb_Param20 200000 9437 ns/op 3804 B/op 16 allocs/op
+BenchmarkGoji_Param20 500000 3987 ns/op 1246 B/op 2 allocs/op
+BenchmarkGoJsonRest_Param20 100000 12799 ns/op 4492 B/op 21 allocs/op
+BenchmarkGoRestful_Param20 100000 19451 ns/op 5244 B/op 33 allocs/op
+BenchmarkGorillaMux_Param20 100000 12456 ns/op 3275 B/op 11 allocs/op
+BenchmarkHttpRouter_Param20 1000000 1333 ns/op 640 B/op 1 allocs/op
+BenchmarkHttpTreeMux_Param20 300000 6490 ns/op 2187 B/op 4 allocs/op
+BenchmarkKocha_Param20 300000 5335 ns/op 1808 B/op 27 allocs/op
+BenchmarkMacaron_Param20 200000 11325 ns/op 4252 B/op 18 allocs/op
+BenchmarkMartini_Param20 20000 64419 ns/op 3644 B/op 14 allocs/op
+BenchmarkPat_Param20 50000 24672 ns/op 4888 B/op 151 allocs/op
+BenchmarkPossum_Param20 1000000 2085 ns/op 624 B/op 7 allocs/op
+BenchmarkR2router_Param20 300000 6809 ns/op 2283 B/op 8 allocs/op
+BenchmarkRevel_Param20 100000 16600 ns/op 5551 B/op 54 allocs/op
+BenchmarkRivet_Param20 200000 8428 ns/op 2620 B/op 26 allocs/op
+BenchmarkTango_Param20 100000 16302 ns/op 8224 B/op 48 allocs/op
+BenchmarkTigerTonic_Param20 30000 46828 ns/op 10538 B/op 178 allocs/op
+BenchmarkTraffic_Param20 50000 28871 ns/op 7998 B/op 66 allocs/op
+BenchmarkVulcan_Param20 1000000 2267 ns/op 98 B/op 3 allocs/op
+BenchmarkZeus_Param20 300000 6828 ns/op 2507 B/op 5 allocs/op
+BenchmarkAce_ParamWrite 3000000 502 ns/op 40 B/op 2 allocs/op
+BenchmarkBear_ParamWrite 1000000 1303 ns/op 424 B/op 5 allocs/op
+BenchmarkBeego_ParamWrite 1000000 2489 ns/op 728 B/op 11 allocs/op
+BenchmarkBone_ParamWrite 1000000 1181 ns/op 384 B/op 3 allocs/op
+BenchmarkDenco_ParamWrite 5000000 315 ns/op 32 B/op 1 allocs/op
+BenchmarkEcho_ParamWrite 10000000 237 ns/op 8 B/op 1 allocs/op
+BenchmarkGin_ParamWrite 5000000 336 ns/op 0 B/op 0 allocs/op
+BenchmarkGocraftWeb_ParamWrite 1000000 2079 ns/op 664 B/op 10 allocs/op
+BenchmarkGoji_ParamWrite 1000000 1092 ns/op 336 B/op 2 allocs/op
+BenchmarkGoJsonRest_ParamWrite 1000000 3329 ns/op 1136 B/op 19 allocs/op
+BenchmarkGoRestful_ParamWrite 200000 9273 ns/op 2504 B/op 32 allocs/op
+BenchmarkGorillaMux_ParamWrite 500000 3919 ns/op 792 B/op 10 allocs/op
+BenchmarkHttpRouter_ParamWrite 10000000 223 ns/op 32 B/op 1 allocs/op
+BenchmarkHttpTreeMux_ParamWrite 2000000 788 ns/op 336 B/op 2 allocs/op
+BenchmarkKocha_ParamWrite 3000000 549 ns/op 56 B/op 3 allocs/op
+BenchmarkMacaron_ParamWrite 500000 4558 ns/op 1216 B/op 16 allocs/op
+BenchmarkMartini_ParamWrite 200000 8850 ns/op 1256 B/op 16 allocs/op
+BenchmarkPat_ParamWrite 500000 3679 ns/op 1088 B/op 19 allocs/op
+BenchmarkPossum_ParamWrite 1000000 2114 ns/op 624 B/op 7 allocs/op
+BenchmarkR2router_ParamWrite 1000000 1320 ns/op 432 B/op 6 allocs/op
+BenchmarkRevel_ParamWrite 200000 8048 ns/op 2128 B/op 33 allocs/op
+BenchmarkRivet_ParamWrite 1000000 1393 ns/op 472 B/op 6 allocs/op
+BenchmarkTango_ParamWrite 2000000 819 ns/op 136 B/op 5 allocs/op
+BenchmarkTigerTonic_ParamWrite 300000 5860 ns/op 1440 B/op 25 allocs/op
+BenchmarkTraffic_ParamWrite 200000 7429 ns/op 2400 B/op 27 allocs/op
+BenchmarkVulcan_ParamWrite 2000000 972 ns/op 98 B/op 3 allocs/op
+BenchmarkZeus_ParamWrite 1000000 1226 ns/op 368 B/op 3 allocs/op
+BenchmarkAce_GithubStatic 5000000 294 ns/op 0 B/op 0 allocs/op
+BenchmarkBear_GithubStatic 3000000 575 ns/op 88 B/op 3 allocs/op
+BenchmarkBeego_GithubStatic 1000000 1561 ns/op 368 B/op 7 allocs/op
+BenchmarkBone_GithubStatic 200000 12301 ns/op 2880 B/op 60 allocs/op
+BenchmarkDenco_GithubStatic 20000000 74.6 ns/op 0 B/op 0 allocs/op
+BenchmarkEcho_GithubStatic 10000000 176 ns/op 0 B/op 0 allocs/op
+BenchmarkGin_GithubStatic 10000000 159 ns/op 0 B/op 0 allocs/op
+BenchmarkGocraftWeb_GithubStatic 1000000 1116 ns/op 304 B/op 6 allocs/op
+BenchmarkGoji_GithubStatic 5000000 413 ns/op 0 B/op 0 allocs/op
+BenchmarkGoRestful_GithubStatic 30000 55200 ns/op 3520 B/op 36 allocs/op
+BenchmarkGoJsonRest_GithubStatic 1000000 1504 ns/op 337 B/op 12 allocs/op
+BenchmarkGorillaMux_GithubStatic 100000 23620 ns/op 464 B/op 8 allocs/op
+BenchmarkHttpRouter_GithubStatic 20000000 78.3 ns/op 0 B/op 0 allocs/op
+BenchmarkHttpTreeMux_GithubStatic 20000000 84.9 ns/op 0 B/op 0 allocs/op
+BenchmarkKocha_GithubStatic 20000000 111 ns/op 0 B/op 0 allocs/op
+BenchmarkMacaron_GithubStatic 1000000 2686 ns/op 752 B/op 8 allocs/op
+BenchmarkMartini_GithubStatic 100000 22244 ns/op 832 B/op 11 allocs/op
+BenchmarkPat_GithubStatic 100000 13278 ns/op 3648 B/op 76 allocs/op
+BenchmarkPossum_GithubStatic 1000000 1429 ns/op 480 B/op 4 allocs/op
+BenchmarkR2router_GithubStatic 2000000 726 ns/op 144 B/op 5 allocs/op
+BenchmarkRevel_GithubStatic 300000 6271 ns/op 1288 B/op 25 allocs/op
+BenchmarkRivet_GithubStatic 3000000 474 ns/op 112 B/op 2 allocs/op
+BenchmarkTango_GithubStatic 1000000 1842 ns/op 256 B/op 10 allocs/op
+BenchmarkTigerTonic_GithubStatic 5000000 361 ns/op 48 B/op 1 allocs/op
+BenchmarkTraffic_GithubStatic 30000 47197 ns/op 18920 B/op 149 allocs/op
+BenchmarkVulcan_GithubStatic 1000000 1415 ns/op 98 B/op 3 allocs/op
+BenchmarkZeus_GithubStatic 1000000 2522 ns/op 512 B/op 11 allocs/op
+BenchmarkAce_GithubParam 3000000 578 ns/op 96 B/op 1 allocs/op
+BenchmarkBear_GithubParam 1000000 1592 ns/op 464 B/op 5 allocs/op
+BenchmarkBeego_GithubParam 1000000 2891 ns/op 784 B/op 11 allocs/op
+BenchmarkBone_GithubParam 300000 6440 ns/op 1456 B/op 16 allocs/op
+BenchmarkDenco_GithubParam 3000000 514 ns/op 128 B/op 1 allocs/op
+BenchmarkEcho_GithubParam 5000000 292 ns/op 0 B/op 0 allocs/op
+BenchmarkGin_GithubParam 10000000 242 ns/op 0 B/op 0 allocs/op
+BenchmarkGocraftWeb_GithubParam 1000000 2343 ns/op 720 B/op 10 allocs/op
+BenchmarkGoji_GithubParam 1000000 1566 ns/op 336 B/op 2 allocs/op
+BenchmarkGoJsonRest_GithubParam 1000000 2828 ns/op 721 B/op 15 allocs/op
+BenchmarkGoRestful_GithubParam 10000 177711 ns/op 2816 B/op 35 allocs/op
+BenchmarkGorillaMux_GithubParam 100000 13591 ns/op 816 B/op 9 allocs/op
+BenchmarkHttpRouter_GithubParam 5000000 352 ns/op 96 B/op 1 allocs/op
+BenchmarkHttpTreeMux_GithubParam 2000000 973 ns/op 336 B/op 2 allocs/op
+BenchmarkKocha_GithubParam 2000000 889 ns/op 128 B/op 5 allocs/op
+BenchmarkMacaron_GithubParam 500000 4047 ns/op 1168 B/op 12 allocs/op
+BenchmarkMartini_GithubParam 50000 28982 ns/op 1184 B/op 12 allocs/op
+BenchmarkPat_GithubParam 200000 8747 ns/op 2480 B/op 56 allocs/op
+BenchmarkPossum_GithubParam 1000000 2158 ns/op 624 B/op 7 allocs/op
+BenchmarkR2router_GithubParam 1000000 1352 ns/op 432 B/op 6 allocs/op
+BenchmarkRevel_GithubParam 200000 7673 ns/op 1784 B/op 30 allocs/op
+BenchmarkRivet_GithubParam 1000000 1573 ns/op 480 B/op 6 allocs/op
+BenchmarkTango_GithubParam 1000000 2418 ns/op 480 B/op 13 allocs/op
+BenchmarkTigerTonic_GithubParam 300000 6048 ns/op 1440 B/op 28 allocs/op
+BenchmarkTraffic_GithubParam 100000 20143 ns/op 6024 B/op 55 allocs/op
+BenchmarkVulcan_GithubParam 1000000 2224 ns/op 98 B/op 3 allocs/op
+BenchmarkZeus_GithubParam 500000 4156 ns/op 1312 B/op 12 allocs/op
+BenchmarkAce_GithubAll 10000 109482 ns/op 13792 B/op 167 allocs/op
+BenchmarkBear_GithubAll 10000 287490 ns/op 79952 B/op 943 allocs/op
+BenchmarkBeego_GithubAll 3000 562184 ns/op 146272 B/op 2092 allocs/op
+BenchmarkBone_GithubAll 500 2578716 ns/op 648016 B/op 8119 allocs/op
+BenchmarkDenco_GithubAll 20000 94955 ns/op 20224 B/op 167 allocs/op
+BenchmarkEcho_GithubAll 30000 58705 ns/op 0 B/op 0 allocs/op
+BenchmarkGin_GithubAll 30000 50991 ns/op 0 B/op 0 allocs/op
+BenchmarkGocraftWeb_GithubAll 5000 449648 ns/op 133280 B/op 1889 allocs/op
+BenchmarkGoji_GithubAll 2000 689748 ns/op 56113 B/op 334 allocs/op
+BenchmarkGoJsonRest_GithubAll 5000 537769 ns/op 135995 B/op 2940 allocs/op
+BenchmarkGoRestful_GithubAll 100 18410628 ns/op 797236 B/op 7725 allocs/op
+BenchmarkGorillaMux_GithubAll 200 8036360 ns/op 153137 B/op 1791 allocs/op
+BenchmarkHttpRouter_GithubAll 20000 63506 ns/op 13792 B/op 167 allocs/op
+BenchmarkHttpTreeMux_GithubAll 10000 165927 ns/op 56112 B/op 334 allocs/op
+BenchmarkKocha_GithubAll 10000 171362 ns/op 23304 B/op 843 allocs/op
+BenchmarkMacaron_GithubAll 2000 817008 ns/op 224960 B/op 2315 allocs/op
+BenchmarkMartini_GithubAll 100 12609209 ns/op 237952 B/op 2686 allocs/op
+BenchmarkPat_GithubAll 300 4830398 ns/op 1504101 B/op 32222 allocs/op
+BenchmarkPossum_GithubAll 10000 301716 ns/op 97440 B/op 812 allocs/op
+BenchmarkR2router_GithubAll 10000 270691 ns/op 77328 B/op 1182 allocs/op
+BenchmarkRevel_GithubAll 1000 1491919 ns/op 345553 B/op 5918 allocs/op
+BenchmarkRivet_GithubAll 10000 283860 ns/op 84272 B/op 1079 allocs/op
+BenchmarkTango_GithubAll 5000 473821 ns/op 87078 B/op 2470 allocs/op
+BenchmarkTigerTonic_GithubAll 2000 1120131 ns/op 241088 B/op 6052 allocs/op
+BenchmarkTraffic_GithubAll 200 8708979 ns/op 2664762 B/op 22390 allocs/op
+BenchmarkVulcan_GithubAll 5000 353392 ns/op 19894 B/op 609 allocs/op
+BenchmarkZeus_GithubAll 2000 944234 ns/op 300688 B/op 2648 allocs/op
+BenchmarkAce_GPlusStatic 5000000 251 ns/op 0 B/op 0 allocs/op
+BenchmarkBear_GPlusStatic 3000000 415 ns/op 72 B/op 3 allocs/op
+BenchmarkBeego_GPlusStatic 1000000 1416 ns/op 352 B/op 7 allocs/op
+BenchmarkBone_GPlusStatic 10000000 192 ns/op 32 B/op 1 allocs/op
+BenchmarkDenco_GPlusStatic 30000000 47.6 ns/op 0 B/op 0 allocs/op
+BenchmarkEcho_GPlusStatic 10000000 131 ns/op 0 B/op 0 allocs/op
+BenchmarkGin_GPlusStatic 10000000 131 ns/op 0 B/op 0 allocs/op
+BenchmarkGocraftWeb_GPlusStatic 1000000 1035 ns/op 288 B/op 6 allocs/op
+BenchmarkGoji_GPlusStatic 5000000 304 ns/op 0 B/op 0 allocs/op
+BenchmarkGoJsonRest_GPlusStatic 1000000 1286 ns/op 337 B/op 12 allocs/op
+BenchmarkGoRestful_GPlusStatic 200000 9649 ns/op 2160 B/op 30 allocs/op
+BenchmarkGorillaMux_GPlusStatic 1000000 2346 ns/op 464 B/op 8 allocs/op
+BenchmarkHttpRouter_GPlusStatic 30000000 42.7 ns/op 0 B/op 0 allocs/op
+BenchmarkHttpTreeMux_GPlusStatic 30000000 49.5 ns/op 0 B/op 0 allocs/op
+BenchmarkKocha_GPlusStatic 20000000 74.8 ns/op 0 B/op 0 allocs/op
+BenchmarkMacaron_GPlusStatic 1000000 2520 ns/op 736 B/op 8 allocs/op
+BenchmarkMartini_GPlusStatic 300000 5310 ns/op 832 B/op 11 allocs/op
+BenchmarkPat_GPlusStatic 5000000 398 ns/op 96 B/op 2 allocs/op
+BenchmarkPossum_GPlusStatic 1000000 1434 ns/op 480 B/op 4 allocs/op
+BenchmarkR2router_GPlusStatic 2000000 646 ns/op 144 B/op 5 allocs/op
+BenchmarkRevel_GPlusStatic 300000 6172 ns/op 1272 B/op 25 allocs/op
+BenchmarkRivet_GPlusStatic 3000000 444 ns/op 112 B/op 2 allocs/op
+BenchmarkTango_GPlusStatic 1000000 1400 ns/op 208 B/op 10 allocs/op
+BenchmarkTigerTonic_GPlusStatic 10000000 213 ns/op 32 B/op 1 allocs/op
+BenchmarkTraffic_GPlusStatic 1000000 3091 ns/op 1208 B/op 16 allocs/op
+BenchmarkVulcan_GPlusStatic 2000000 863 ns/op 98 B/op 3 allocs/op
+BenchmarkZeus_GPlusStatic 10000000 237 ns/op 16 B/op 1 allocs/op
+BenchmarkAce_GPlusParam 3000000 435 ns/op 64 B/op 1 allocs/op
+BenchmarkBear_GPlusParam 1000000 1205 ns/op 448 B/op 5 allocs/op
+BenchmarkBeego_GPlusParam 1000000 2494 ns/op 720 B/op 10 allocs/op
+BenchmarkBone_GPlusParam 1000000 1126 ns/op 384 B/op 3 allocs/op
+BenchmarkDenco_GPlusParam 5000000 325 ns/op 64 B/op 1 allocs/op
+BenchmarkEcho_GPlusParam 10000000 168 ns/op 0 B/op 0 allocs/op
+BenchmarkGin_GPlusParam 10000000 170 ns/op 0 B/op 0 allocs/op
+BenchmarkGocraftWeb_GPlusParam 1000000 1895 ns/op 656 B/op 9 allocs/op
+BenchmarkGoji_GPlusParam 1000000 1071 ns/op 336 B/op 2 allocs/op
+BenchmarkGoJsonRest_GPlusParam 1000000 2282 ns/op 657 B/op 14 allocs/op
+BenchmarkGoRestful_GPlusParam 100000 19400 ns/op 2560 B/op 33 allocs/op
+BenchmarkGorillaMux_GPlusParam 500000 5001 ns/op 784 B/op 9 allocs/op
+BenchmarkHttpRouter_GPlusParam 10000000 240 ns/op 64 B/op 1 allocs/op
+BenchmarkHttpTreeMux_GPlusParam 2000000 797 ns/op 336 B/op 2 allocs/op
+BenchmarkKocha_GPlusParam 3000000 505 ns/op 56 B/op 3 allocs/op
+BenchmarkMacaron_GPlusParam 1000000 3668 ns/op 1104 B/op 11 allocs/op
+BenchmarkMartini_GPlusParam 200000 10672 ns/op 1152 B/op 12 allocs/op
+BenchmarkPat_GPlusParam 1000000 2376 ns/op 704 B/op 14 allocs/op
+BenchmarkPossum_GPlusParam 1000000 2090 ns/op 624 B/op 7 allocs/op
+BenchmarkR2router_GPlusParam 1000000 1233 ns/op 432 B/op 6 allocs/op
+BenchmarkRevel_GPlusParam 200000 6778 ns/op 1704 B/op 28 allocs/op
+BenchmarkRivet_GPlusParam 1000000 1279 ns/op 464 B/op 5 allocs/op
+BenchmarkTango_GPlusParam 1000000 1981 ns/op 272 B/op 10 allocs/op
+BenchmarkTigerTonic_GPlusParam 500000 3893 ns/op 1064 B/op 19 allocs/op
+BenchmarkTraffic_GPlusParam 200000 6585 ns/op 2000 B/op 23 allocs/op
+BenchmarkVulcan_GPlusParam 1000000 1233 ns/op 98 B/op 3 allocs/op
+BenchmarkZeus_GPlusParam 1000000 1350 ns/op 368 B/op 3 allocs/op
+BenchmarkAce_GPlus2Params 3000000 512 ns/op 64 B/op 1 allocs/op
+BenchmarkBear_GPlus2Params 1000000 1564 ns/op 464 B/op 5 allocs/op
+BenchmarkBeego_GPlus2Params 1000000 3043 ns/op 784 B/op 11 allocs/op
+BenchmarkBone_GPlus2Params 1000000 3152 ns/op 736 B/op 7 allocs/op
+BenchmarkDenco_GPlus2Params 3000000 431 ns/op 64 B/op 1 allocs/op
+BenchmarkEcho_GPlus2Params 5000000 247 ns/op 0 B/op 0 allocs/op
+BenchmarkGin_GPlus2Params 10000000 219 ns/op 0 B/op 0 allocs/op
+BenchmarkGocraftWeb_GPlus2Params 1000000 2363 ns/op 720 B/op 10 allocs/op
+BenchmarkGoji_GPlus2Params 1000000 1540 ns/op 336 B/op 2 allocs/op
+BenchmarkGoJsonRest_GPlus2Params 1000000 2872 ns/op 721 B/op 15 allocs/op
+BenchmarkGoRestful_GPlus2Params 100000 23030 ns/op 2720 B/op 35 allocs/op
+BenchmarkGorillaMux_GPlus2Params 200000 10516 ns/op 816 B/op 9 allocs/op
+BenchmarkHttpRouter_GPlus2Params 5000000 273 ns/op 64 B/op 1 allocs/op
+BenchmarkHttpTreeMux_GPlus2Params 2000000 939 ns/op 336 B/op 2 allocs/op
+BenchmarkKocha_GPlus2Params 2000000 844 ns/op 128 B/op 5 allocs/op
+BenchmarkMacaron_GPlus2Params 500000 3914 ns/op 1168 B/op 12 allocs/op
+BenchmarkMartini_GPlus2Params 50000 35759 ns/op 1280 B/op 16 allocs/op
+BenchmarkPat_GPlus2Params 200000 7089 ns/op 2304 B/op 41 allocs/op
+BenchmarkPossum_GPlus2Params 1000000 2093 ns/op 624 B/op 7 allocs/op
+BenchmarkR2router_GPlus2Params 1000000 1320 ns/op 432 B/op 6 allocs/op
+BenchmarkRevel_GPlus2Params 200000 7351 ns/op 1800 B/op 30 allocs/op
+BenchmarkRivet_GPlus2Params 1000000 1485 ns/op 480 B/op 6 allocs/op
+BenchmarkTango_GPlus2Params 1000000 2111 ns/op 448 B/op 12 allocs/op
+BenchmarkTigerTonic_GPlus2Params 300000 6271 ns/op 1528 B/op 28 allocs/op
+BenchmarkTraffic_GPlus2Params 100000 14886 ns/op 3312 B/op 34 allocs/op
+BenchmarkVulcan_GPlus2Params 1000000 1883 ns/op 98 B/op 3 allocs/op
+BenchmarkZeus_GPlus2Params 1000000 2686 ns/op 784 B/op 6 allocs/op
+BenchmarkAce_GPlusAll 300000 5912 ns/op 640 B/op 11 allocs/op
+BenchmarkBear_GPlusAll 100000 16448 ns/op 5072 B/op 61 allocs/op
+BenchmarkBeego_GPlusAll 50000 32916 ns/op 8976 B/op 129 allocs/op
+BenchmarkBone_GPlusAll 50000 25836 ns/op 6992 B/op 76 allocs/op
+BenchmarkDenco_GPlusAll 500000 4462 ns/op 672 B/op 11 allocs/op
+BenchmarkEcho_GPlusAll 500000 2806 ns/op 0 B/op 0 allocs/op
+BenchmarkGin_GPlusAll 500000 2579 ns/op 0 B/op 0 allocs/op
+BenchmarkGocraftWeb_GPlusAll 50000 25223 ns/op 8144 B/op 116 allocs/op
+BenchmarkGoji_GPlusAll 100000 14237 ns/op 3696 B/op 22 allocs/op
+BenchmarkGoJsonRest_GPlusAll 50000 29227 ns/op 8221 B/op 183 allocs/op
+BenchmarkGoRestful_GPlusAll 10000 203144 ns/op 36064 B/op 441 allocs/op
+BenchmarkGorillaMux_GPlusAll 20000 80906 ns/op 9712 B/op 115 allocs/op
+BenchmarkHttpRouter_GPlusAll 500000 3040 ns/op 640 B/op 11 allocs/op
+BenchmarkHttpTreeMux_GPlusAll 200000 9627 ns/op 3696 B/op 22 allocs/op
+BenchmarkKocha_GPlusAll 200000 8108 ns/op 976 B/op 43 allocs/op
+BenchmarkMacaron_GPlusAll 30000 48083 ns/op 13968 B/op 142 allocs/op
+BenchmarkMartini_GPlusAll 10000 196978 ns/op 15072 B/op 178 allocs/op
+BenchmarkPat_GPlusAll 30000 58865 ns/op 16880 B/op 343 allocs/op
+BenchmarkPossum_GPlusAll 100000 19685 ns/op 6240 B/op 52 allocs/op
+BenchmarkR2router_GPlusAll 100000 16251 ns/op 5040 B/op 76 allocs/op
+BenchmarkRevel_GPlusAll 20000 93489 ns/op 21656 B/op 368 allocs/op
+BenchmarkRivet_GPlusAll 100000 16907 ns/op 5408 B/op 64 allocs/op
+```
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/CHANGELOG.md b/Godeps/_workspace/src/github.com/gin-gonic/gin/CHANGELOG.md
new file mode 100644
index 0000000000000000000000000000000000000000..938084c2cd6a03bba18c286e61575422afa16228
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/CHANGELOG.md
@@ -0,0 +1,141 @@
+#CHANGELOG
+
+###Gin 1.0rc2 (...)
+
+- [PERFORMANCE] Fast path for writting Content-Type.
+- [PERFORMANCE] Much faster 404 routing
+- [PERFORMANCE] Allocation optimizations
+- [PERFORMANCE] Faster root tree lookup
+- [PERFORMANCE] Zero overhead, String() and JSON() rendering.
+- [PERFORMANCE] Faster ClientIP parsing
+- [PERFORMANCE] Much faster SSE implementation
+- [NEW] Benchmarks suite
+- [NEW] Bind validation can be disabled and replaced with custom validators.
+- [NEW] More flexible HTML render
+- [FIX] Binding multipart form
+- [FIX] Integration tests
+- [FIX] Crash when binding non struct object in Context.
+- [FIX] RunTLS() implementation
+- [FIX] Logger() unit tests
+- [FIX] Better approach to avoid directory listing in StaticFS()
+- [FIX] Context.ClientIP() always returns the IP with trimmed spaces.
+- [FIX] Better warning when running in debug mode.
+- [FIX] Google App Engine integration. debugPrint does not use os.Stdout
+- [FIX] Fixes integer overflow in error type
+- [FIX] Error implements the json.Marshaller interface
+- [FIX] MIT license in every file
+
+
+###Gin 1.0rc1 (May 22, 2015)
+
+- [PERFORMANCE] Zero allocation router
+- [PERFORMANCE] Faster JSON, XML and text rendering
+- [PERFORMANCE] Custom hand optimized HttpRouter for Gin
+- [PERFORMANCE] Misc code optimizations. Inlining, tail call optimizations
+- [NEW] Built-in support for golang.org/x/net/context
+- [NEW] Any(path, handler). Create a route that matches any path
+- [NEW] Refactored rendering pipeline (faster and static typeded)
+- [NEW] Refactored errors API
+- [NEW] IndentedJSON() prints pretty JSON
+- [NEW] Added gin.DefaultWriter
+- [NEW] UNIX socket support
+- [NEW] RouterGroup.BasePath is exposed
+- [NEW] JSON validation using go-validate-yourself (very powerful options)
+- [NEW] Completed suite of unit tests
+- [NEW] HTTP streaming with c.Stream()
+- [NEW] StaticFile() creates a router for serving just one file.
+- [NEW] StaticFS() has an option to disable directory listing.
+- [NEW] StaticFS() for serving static files through virtual filesystems
+- [NEW] Server-Sent Events native support
+- [NEW] WrapF() and WrapH() helpers for wrapping http.HandlerFunc and http.Handler
+- [NEW] Added LoggerWithWriter() middleware
+- [NEW] Added RecoveryWithWriter() middleware
+- [NEW] Added DefaultPostFormValue()
+- [NEW] Added DefaultFormValue()
+- [NEW] Added DefaultParamValue()
+- [FIX] BasicAuth() when using custom realm
+- [FIX] Bug when serving static files in nested routing group
+- [FIX] Redirect using built-in http.Redirect()
+- [FIX] Logger when printing the requested path
+- [FIX] Documentation typos
+- [FIX] Context.Engine renamed to Context.engine
+- [FIX] Better debugging messages
+- [FIX] ErrorLogger
+- [FIX] Debug HTTP render
+- [FIX] Refactored binding and render modules
+- [FIX] Refactored Context initialization
+- [FIX] Refactored BasicAuth()
+- [FIX] NoMethod/NoRoute handlers
+- [FIX] Hijacking http
+- [FIX] Better support for Google App Engine (using log instead of fmt)
+
+
+###Gin 0.6 (Mar 9, 2015)
+
+- [NEW] Support multipart/form-data
+- [NEW] NoMethod handler
+- [NEW] Validate sub structures
+- [NEW] Support for HTTP Realm Auth
+- [FIX] Unsigned integers in binding
+- [FIX] Improve color logger
+
+
+###Gin 0.5 (Feb 7, 2015)
+
+- [NEW] Content Negotiation
+- [FIX] Solved security bug that allow a client to spoof ip
+- [FIX] Fix unexported/ignored fields in binding
+
+
+###Gin 0.4 (Aug 21, 2014)
+
+- [NEW] Development mode
+- [NEW] Unit tests
+- [NEW] Add Content.Redirect()
+- [FIX] Deferring WriteHeader()
+- [FIX] Improved documentation for model binding
+
+
+###Gin 0.3 (Jul 18, 2014)
+
+- [PERFORMANCE] Normal log and error log are printed in the same call.
+- [PERFORMANCE] Improve performance of NoRouter()
+- [PERFORMANCE] Improve context's memory locality, reduce CPU cache faults.
+- [NEW] Flexible rendering API
+- [NEW] Add Context.File()
+- [NEW] Add shorcut RunTLS() for http.ListenAndServeTLS
+- [FIX] Rename NotFound404() to NoRoute()
+- [FIX] Errors in context are purged
+- [FIX] Adds HEAD method in Static file serving
+- [FIX] Refactors Static() file serving
+- [FIX] Using keyed initialization to fix app-engine integration
+- [FIX] Can't unmarshal JSON array, #63
+- [FIX] Renaming Context.Req to Context.Request
+- [FIX] Check application/x-www-form-urlencoded when parsing form
+
+
+###Gin 0.2b (Jul 08, 2014)
+- [PERFORMANCE] Using sync.Pool to allocatio/gc overhead
+- [NEW] Travis CI integration
+- [NEW] Completely new logger
+- [NEW] New API for serving static files. gin.Static()
+- [NEW] gin.H() can be serialized into XML
+- [NEW] Typed errors. Errors can be typed. Internet/external/custom.
+- [NEW] Support for Godeps
+- [NEW] Travis/Godocs badges in README
+- [NEW] New Bind() and BindWith() methods for parsing request body.
+- [NEW] Add Content.Copy()
+- [NEW] Add context.LastError()
+- [NEW] Add shorcut for OPTIONS HTTP method
+- [FIX] Tons of README fixes
+- [FIX] Header is written before body
+- [FIX] BasicAuth() and changes API a little bit
+- [FIX] Recovery() middleware only prints panics
+- [FIX] Context.Get() does not panic anymore. Use MustGet() instead.
+- [FIX] Multiple http.WriteHeader() in NotFound handlers
+- [FIX] Engine.Run() panics if http server can't be setted up
+- [FIX] Crash when route path doesn't start with '/'
+- [FIX] Do not update header when status code is negative
+- [FIX] Setting response headers before calling WriteHeader in context.String()
+- [FIX] Add MIT license
+- [FIX] Changes behaviour of ErrorLogger() and Logger()
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/Godeps/Godeps.json b/Godeps/_workspace/src/github.com/gin-gonic/gin/Godeps/Godeps.json
new file mode 100644
index 0000000000000000000000000000000000000000..ebda5138a59fb66b5636d796bf62757a4edf6103
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/Godeps/Godeps.json
@@ -0,0 +1,39 @@
+{
+ "ImportPath": "github.com/gin-gonic/gin",
+ "GoVersion": "go1.4.2",
+ "Packages": [
+ "./..."
+ ],
+ "Deps": [
+ {
+ "ImportPath": "github.com/dustin/go-broadcast",
+ "Rev": "3bdf6d4a7164a50bc19d5f230e2981d87d2584f1"
+ },
+ {
+ "ImportPath": "github.com/manucorporat/sse",
+ "Rev": "c142f0f1baea5cef7f98a8a6c222f6134368c1f5"
+ },
+ {
+ "ImportPath": "github.com/manucorporat/stats",
+ "Rev": "8f2d6ace262eba462e9beb552382c98be51d807b"
+ },
+ {
+ "ImportPath": "github.com/mattn/go-colorable",
+ "Rev": "d67e0b7d1797975196499f79bcc322c08b9f218b"
+ },
+ {
+ "ImportPath": "github.com/stretchr/testify/assert",
+ "Comment": "v1.0",
+ "Rev": "232e8563676cd15c3a36ba5e675ad4312ac4cb11"
+ },
+ {
+ "ImportPath": "golang.org/x/net/context",
+ "Rev": "621fff363a1d9ad7fdd0bfa9d80a42881267deb4"
+ },
+ {
+ "ImportPath": "gopkg.in/bluesuncorp/validator.v5",
+ "Comment": "v5.4",
+ "Rev": "07cbdd2e6dfd947b002e83c13b775c7580fab2d5"
+ }
+ ]
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/LICENSE b/Godeps/_workspace/src/github.com/gin-gonic/gin/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..1ff7f370605592e4c09bd16f6775c075631bd9e6
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Manuel MartÃnez-Almeida
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/README.md b/Godeps/_workspace/src/github.com/gin-gonic/gin/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..67c9fa8fe1edd27c76efa4011f7edbe92ce7f08f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/README.md
@@ -0,0 +1,579 @@
+#Gin Web Framework [](https://travis-ci.org/gin-gonic/gin) [](https://coveralls.io/r/gin-gonic/gin?branch=master)
+
+ [](https://godoc.org/github.com/gin-gonic/gin) [](https://gitter.im/gin-gonic/gin?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+Gin is a web framework written in Golang. It features a martini-like API with much better performance, up to 40 times faster thanks to [httprouter](https://github.com/julienschmidt/httprouter). If you need performance and good productivity, you will love Gin.
+
+
+
+```
+$ cat test.go
+```
+```go
+package main
+
+import "github.com/gin-gonic/gin"
+
+func main() {
+ r := gin.Default()
+ r.GET("/ping", func(c *gin.Context) {
+ c.String(200, "pong")
+ })
+ r.Run(":8080") // listen and serve on 0.0.0.0:8080
+}
+```
+
+## Benchmarks
+
+Gin uses a custom version of [HttpRouter](https://github.com/julienschmidt/httprouter)
+
+[See all benchmarks](/BENCHMARKS.md)
+
+
+```
+BenchmarkAce_GithubAll 10000 109482 ns/op 13792 B/op 167 allocs/op
+BenchmarkBear_GithubAll 10000 287490 ns/op 79952 B/op 943 allocs/op
+BenchmarkBeego_GithubAll 3000 562184 ns/op 146272 B/op 2092 allocs/op
+BenchmarkBone_GithubAll 500 2578716 ns/op 648016 B/op 8119 allocs/op
+BenchmarkDenco_GithubAll 20000 94955 ns/op 20224 B/op 167 allocs/op
+BenchmarkEcho_GithubAll 30000 58705 ns/op 0 B/op 0 allocs/op
+BenchmarkGin_GithubAll 30000 50991 ns/op 0 B/op 0 allocs/op
+BenchmarkGocraftWeb_GithubAll 5000 449648 ns/op 133280 B/op 1889 allocs/op
+BenchmarkGoji_GithubAll 2000 689748 ns/op 56113 B/op 334 allocs/op
+BenchmarkGoJsonRest_GithubAll 5000 537769 ns/op 135995 B/op 2940 allocs/op
+BenchmarkGoRestful_GithubAll 100 18410628 ns/op 797236 B/op 7725 allocs/op
+BenchmarkGorillaMux_GithubAll 200 8036360 ns/op 153137 B/op 1791 allocs/op
+BenchmarkHttpRouter_GithubAll 20000 63506 ns/op 13792 B/op 167 allocs/op
+BenchmarkHttpTreeMux_GithubAll 10000 165927 ns/op 56112 B/op 334 allocs/op
+BenchmarkKocha_GithubAll 10000 171362 ns/op 23304 B/op 843 allocs/op
+BenchmarkMacaron_GithubAll 2000 817008 ns/op 224960 B/op 2315 allocs/op
+BenchmarkMartini_GithubAll 100 12609209 ns/op 237952 B/op 2686 allocs/op
+BenchmarkPat_GithubAll 300 4830398 ns/op 1504101 B/op 32222 allocs/op
+BenchmarkPossum_GithubAll 10000 301716 ns/op 97440 B/op 812 allocs/op
+BenchmarkR2router_GithubAll 10000 270691 ns/op 77328 B/op 1182 allocs/op
+BenchmarkRevel_GithubAll 1000 1491919 ns/op 345553 B/op 5918 allocs/op
+BenchmarkRivet_GithubAll 10000 283860 ns/op 84272 B/op 1079 allocs/op
+BenchmarkTango_GithubAll 5000 473821 ns/op 87078 B/op 2470 allocs/op
+BenchmarkTigerTonic_GithubAll 2000 1120131 ns/op 241088 B/op 6052 allocs/op
+BenchmarkTraffic_GithubAll 200 8708979 ns/op 2664762 B/op 22390 allocs/op
+BenchmarkVulcan_GithubAll 5000 353392 ns/op 19894 B/op 609 allocs/op
+BenchmarkZeus_GithubAll 2000 944234 ns/op 300688 B/op 2648 allocs/op
+```
+
+
+##Gin v1. stable
+
+- [x] Zero allocation router.
+- [x] Still the fastest http router and framework. From routing to writing.
+- [x] Complete suite of unit tests
+- [x] Battle tested
+- [x] API frozen, new releases will not break your code.
+
+
+## Start using it
+1. Download and install it:
+
+```sh
+go get github.com/gin-gonic/gin
+```
+2. Import it in your code:
+
+```go
+import "github.com/gin-gonic/gin"
+```
+
+##API Examples
+
+#### Using GET, POST, PUT, PATCH, DELETE and OPTIONS
+
+```go
+func main() {
+ // Creates a gin router with default middlewares:
+ // logger and recovery (crash-free) middlewares
+ router := gin.Default()
+
+ router.GET("/someGet", getting)
+ router.POST("/somePost", posting)
+ router.PUT("/somePut", putting)
+ router.DELETE("/someDelete", deleting)
+ router.PATCH("/somePatch", patching)
+ router.HEAD("/someHead", head)
+ router.OPTIONS("/someOptions", options)
+
+ // Listen and server on 0.0.0.0:8080
+ router.Run(":8080")
+}
+```
+
+#### Parameters in path
+
+```go
+func main() {
+ router := gin.Default()
+
+ // This handler will match /user/john but will not match neither /user/ or /user
+ router.GET("/user/:name", func(c *gin.Context) {
+ name := c.Param("name")
+ c.String(http.StatusOK, "Hello %s", name)
+ })
+
+ // However, this one will match /user/john/ and also /user/john/send
+ // If no other routers match /user/john, it will redirect to /user/join/
+ router.GET("/user/:name/*action", func(c *gin.Context) {
+ name := c.Param("name")
+ action := c.Param("action")
+ message := name + " is " + action
+ c.String(http.StatusOK, message)
+ })
+
+ router.Run(":8080")
+}
+```
+
+#### Querystring parameters
+```go
+func main() {
+ router := gin.Default()
+
+ // Query string parameters are parsed using the existing underlying request object.
+ // The request responds to a url matching: /welcome?firstname=Jane&lastname=Doe
+ router.GET("/welcome", func(c *gin.Context) {
+ firstname := c.DefaultQuery("firstname", "Guest")
+ lastname := c.Query("lastname") // shortcut for c.Request.URL.Query().Get("lastname")
+
+ c.String(http.StatusOK, "Hello %s %s", firstname, lastname)
+ })
+ router.Run(":8080")
+}
+```
+
+### Multipart/Urlencoded Form
+
+```go
+func main() {
+ router := gin.Default()
+
+ router.POST("/form_post", func(c *gin.Context) {
+ message := c.PostForm("message")
+ nick := c.DefaultPostForm("nick", "anonymous")
+
+ c.JSON(200, gin.H{
+ "status": "posted",
+ "message": message,
+ })
+ })
+ router.Run(":8080")
+}
+```
+
+#### Grouping routes
+```go
+func main() {
+ router := gin.Default()
+
+ // Simple group: v1
+ v1 := router.Group("/v1")
+ {
+ v1.POST("/login", loginEndpoint)
+ v1.POST("/submit", submitEndpoint)
+ v1.POST("/read", readEndpoint)
+ }
+
+ // Simple group: v2
+ v2 := router.Group("/v2")
+ {
+ v2.POST("/login", loginEndpoint)
+ v2.POST("/submit", submitEndpoint)
+ v2.POST("/read", readEndpoint)
+ }
+
+ router.Run(":8080")
+}
+```
+
+
+#### Blank Gin without middlewares by default
+
+Use
+
+```go
+r := gin.New()
+```
+instead of
+
+```go
+r := gin.Default()
+```
+
+
+#### Using middlewares
+```go
+func main() {
+ // Creates a router without any middleware by default
+ r := gin.New()
+
+ // Global middlewares
+ r.Use(gin.Logger())
+ r.Use(gin.Recovery())
+
+ // Per route middlewares, you can add as many as you desire.
+ r.GET("/benchmark", MyBenchLogger(), benchEndpoint)
+
+ // Authorization group
+ // authorized := r.Group("/", AuthRequired())
+ // exactly the same than:
+ authorized := r.Group("/")
+ // per group middlewares! in this case we use the custom created
+ // AuthRequired() middleware just in the "authorized" group.
+ authorized.Use(AuthRequired())
+ {
+ authorized.POST("/login", loginEndpoint)
+ authorized.POST("/submit", submitEndpoint)
+ authorized.POST("/read", readEndpoint)
+
+ // nested group
+ testing := authorized.Group("testing")
+ testing.GET("/analytics", analyticsEndpoint)
+ }
+
+ // Listen and server on 0.0.0.0:8080
+ r.Run(":8080")
+}
+```
+
+#### Model binding and validation
+
+To bind a request body into a type, use model binding. We currently support binding of JSON, XML and standard form values (foo=bar&boo=baz).
+
+Note that you need to set the corresponding binding tag on all fields you want to bind. For example, when binding from JSON, set `json:"fieldname"`.
+
+When using the Bind-method, Gin tries to infer the binder depending on the Content-Type header. If you are sure what you are binding, you can use BindWith.
+
+You can also specify that specific fields are required. If a field is decorated with `binding:"required"` and has a empty value when binding, the current request will fail with an error.
+
+```go
+// Binding from JSON
+type LoginJSON struct {
+ User string `json:"user" binding:"required"`
+ Password string `json:"password" binding:"required"`
+}
+
+// Binding from form values
+type LoginForm struct {
+ User string `form:"user" binding:"required"`
+ Password string `form:"password" binding:"required"`
+}
+
+func main() {
+ r := gin.Default()
+
+ // Example for binding JSON ({"user": "manu", "password": "123"})
+ r.POST("/loginJSON", func(c *gin.Context) {
+ var json LoginJSON
+
+ c.Bind(&json) // This will infer what binder to use depending on the content-type header.
+ if json.User == "manu" && json.Password == "123" {
+ c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
+ } else {
+ c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
+ }
+ })
+
+ // Example for binding a HTML form (user=manu&password=123)
+ r.POST("/loginHTML", func(c *gin.Context) {
+ var form LoginForm
+
+ c.BindWith(&form, binding.Form) // You can also specify which binder to use. We support binding.Form, binding.JSON and binding.XML.
+ if form.User == "manu" && form.Password == "123" {
+ c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
+ } else {
+ c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
+ }
+ })
+
+ // Listen and server on 0.0.0.0:8080
+ r.Run(":8080")
+}
+```
+
+
+###Multipart/Urlencoded binding
+```go
+package main
+
+import (
+ "github.com/gin-gonic/gin"
+ "github.com/gin-gonic/gin/binding"
+)
+
+type LoginForm struct {
+ User string `form:"user" binding:"required"`
+ Password string `form:"password" binding:"required"`
+}
+
+func main() {
+
+ router := gin.Default()
+
+ router.POST("/login", func(c *gin.Context) {
+ // you can bind multipart form with explicit binding declaration:
+ // c.BindWith(&form, binding.Form)
+ // or you can simply use autobinding with Bind method:
+ var form LoginForm
+ c.Bind(&form) // in this case proper binding will be automatically selected
+
+ if form.User == "user" && form.Password == "password" {
+ c.JSON(200, gin.H{"status": "you are logged in"})
+ } else {
+ c.JSON(401, gin.H{"status": "unauthorized"})
+ }
+ })
+
+ router.Run(":8080")
+
+}
+```
+
+Test it with:
+```bash
+$ curl -v --form user=user --form password=password http://localhost:8080/login
+```
+
+
+#### XML and JSON rendering
+
+```go
+func main() {
+ r := gin.Default()
+
+ // gin.H is a shortcut for map[string]interface{}
+ r.GET("/someJSON", func(c *gin.Context) {
+ c.JSON(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})
+ })
+
+ r.GET("/moreJSON", func(c *gin.Context) {
+ // You also can use a struct
+ var msg struct {
+ Name string `json:"user"`
+ Message string
+ Number int
+ }
+ msg.Name = "Lena"
+ msg.Message = "hey"
+ msg.Number = 123
+ // Note that msg.Name becomes "user" in the JSON
+ // Will output : {"user": "Lena", "Message": "hey", "Number": 123}
+ c.JSON(http.StatusOK, msg)
+ })
+
+ r.GET("/someXML", func(c *gin.Context) {
+ c.XML(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})
+ })
+
+ // Listen and server on 0.0.0.0:8080
+ r.Run(":8080")
+}
+```
+
+####Serving static files
+
+```go
+func main() {
+ router := gin.Default()
+ router.Static("/assets", "./assets")
+ router.StaticFS("/more_static", http.Dir("my_file_system"))
+ router.StaticFile("/favicon.ico", "./resources/favicon.ico")
+
+ // Listen and server on 0.0.0.0:8080
+ router.Run(":8080")
+}
+```
+
+####HTML rendering
+
+Using LoadHTMLTemplates()
+
+```go
+func main() {
+ router := gin.Default()
+ router.LoadHTMLGlob("templates/*")
+ //router.LoadHTMLFiles("templates/template1.html", "templates/template2.html")
+ router.GET("/index", func(c *gin.Context) {
+ c.HTML(http.StatusOK, "index.tmpl", gin.H{
+ "title": "Main website",
+ })
+ })
+ router.Run(":8080")
+}
+```
+```html
+<html><h1>
+ {{ .title }}
+</h1>
+</html>
+```
+
+You can also use your own html template render
+
+```go
+import "html/template"
+
+func main() {
+ router := gin.Default()
+ html := template.Must(template.ParseFiles("file1", "file2"))
+ router.SetHTMLTemplate(html)
+ router.Run(":8080")
+}
+```
+
+
+#### Redirects
+
+Issuing a HTTP redirect is easy:
+
+```go
+r.GET("/test", func(c *gin.Context) {
+ c.Redirect(http.StatusMovedPermanently, "http://www.google.com/")
+})
+```
+Both internal and external locations are supported.
+
+
+#### Custom Middlewares
+
+```go
+func Logger() gin.HandlerFunc {
+ return func(c *gin.Context) {
+ t := time.Now()
+
+ // Set example variable
+ c.Set("example", "12345")
+
+ // before request
+
+ c.Next()
+
+ // after request
+ latency := time.Since(t)
+ log.Print(latency)
+
+ // access the status we are sending
+ status := c.Writer.Status()
+ log.Println(status)
+ }
+}
+
+func main() {
+ r := gin.New()
+ r.Use(Logger())
+
+ r.GET("/test", func(c *gin.Context) {
+ example := c.MustGet("example").(string)
+
+ // it would print: "12345"
+ log.Println(example)
+ })
+
+ // Listen and server on 0.0.0.0:8080
+ r.Run(":8080")
+}
+```
+
+#### Using BasicAuth() middleware
+```go
+// simulate some private data
+var secrets = gin.H{
+ "foo": gin.H{"email": "foo@bar.com", "phone": "123433"},
+ "austin": gin.H{"email": "austin@example.com", "phone": "666"},
+ "lena": gin.H{"email": "lena@guapa.com", "phone": "523443"},
+}
+
+func main() {
+ r := gin.Default()
+
+ // Group using gin.BasicAuth() middleware
+ // gin.Accounts is a shortcut for map[string]string
+ authorized := r.Group("/admin", gin.BasicAuth(gin.Accounts{
+ "foo": "bar",
+ "austin": "1234",
+ "lena": "hello2",
+ "manu": "4321",
+ }))
+
+ // /admin/secrets endpoint
+ // hit "localhost:8080/admin/secrets
+ authorized.GET("/secrets", func(c *gin.Context) {
+ // get user, it was setted by the BasicAuth middleware
+ user := c.MustGet(gin.AuthUserKey).(string)
+ if secret, ok := secrets[user]; ok {
+ c.JSON(http.StatusOK, gin.H{"user": user, "secret": secret})
+ } else {
+ c.JSON(http.StatusOK, gin.H{"user": user, "secret": "NO SECRET :("})
+ }
+ })
+
+ // Listen and server on 0.0.0.0:8080
+ r.Run(":8080")
+}
+```
+
+
+#### Goroutines inside a middleware
+When starting inside a middleware or handler, you **SHOULD NOT** use the original context inside it, you have to use a read-only copy.
+
+```go
+func main() {
+ r := gin.Default()
+
+ r.GET("/long_async", func(c *gin.Context) {
+ // create copy to be used inside the goroutine
+ c_cp := c.Copy()
+ go func() {
+ // simulate a long task with time.Sleep(). 5 seconds
+ time.Sleep(5 * time.Second)
+
+ // note than you are using the copied context "c_cp", IMPORTANT
+ log.Println("Done! in path " + c_cp.Request.URL.Path)
+ }()
+ })
+
+
+ r.GET("/long_sync", func(c *gin.Context) {
+ // simulate a long task with time.Sleep(). 5 seconds
+ time.Sleep(5 * time.Second)
+
+ // since we are NOT using a goroutine, we do not have to copy the context
+ log.Println("Done! in path " + c.Request.URL.Path)
+ })
+
+ // Listen and server on 0.0.0.0:8080
+ r.Run(":8080")
+}
+```
+
+#### Custom HTTP configuration
+
+Use `http.ListenAndServe()` directly, like this:
+
+```go
+func main() {
+ router := gin.Default()
+ http.ListenAndServe(":8080", router)
+}
+```
+or
+
+```go
+func main() {
+ router := gin.Default()
+
+ s := &http.Server{
+ Addr: ":8080",
+ Handler: router,
+ ReadTimeout: 10 * time.Second,
+ WriteTimeout: 10 * time.Second,
+ MaxHeaderBytes: 1 << 20,
+ }
+ s.ListenAndServe()
+}
+```
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/auth.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/auth.go
new file mode 100644
index 0000000000000000000000000000000000000000..33f8e9a3c5bf77107bd696c20b6dc037c2b42c9b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/auth.go
@@ -0,0 +1,98 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "crypto/subtle"
+ "encoding/base64"
+ "strconv"
+)
+
+const (
+ AuthUserKey = "user"
+)
+
+type (
+ Accounts map[string]string
+ authPair struct {
+ Value string
+ User string
+ }
+ authPairs []authPair
+)
+
+func (a authPairs) searchCredential(authValue string) (string, bool) {
+ if len(authValue) == 0 {
+ return "", false
+ }
+ for _, pair := range a {
+ if pair.Value == authValue {
+ return pair.User, true
+ }
+ }
+ return "", false
+}
+
+// Implements a basic Basic HTTP Authorization. It takes as arguments a map[string]string where
+// the key is the user name and the value is the password, as well as the name of the Realm
+// (see http://tools.ietf.org/html/rfc2617#section-1.2)
+func BasicAuthForRealm(accounts Accounts, realm string) HandlerFunc {
+ if realm == "" {
+ realm = "Authorization Required"
+ }
+ realm = "Basic realm=" + strconv.Quote(realm)
+ pairs := processAccounts(accounts)
+ return func(c *Context) {
+ // Search user in the slice of allowed credentials
+ user, found := pairs.searchCredential(c.Request.Header.Get("Authorization"))
+ if !found {
+ // Credentials doesn't match, we return 401 and abort handlers chain.
+ c.Header("WWW-Authenticate", realm)
+ c.AbortWithStatus(401)
+ } else {
+ // The user credentials was found, set user's id to key AuthUserKey in this context, the userId can be read later using
+ // c.MustGet(gin.AuthUserKey)
+ c.Set(AuthUserKey, user)
+ }
+ }
+}
+
+// Implements a basic Basic HTTP Authorization. It takes as argument a map[string]string where
+// the key is the user name and the value is the password.
+func BasicAuth(accounts Accounts) HandlerFunc {
+ return BasicAuthForRealm(accounts, "")
+}
+
+func processAccounts(accounts Accounts) authPairs {
+ if len(accounts) == 0 {
+ panic("Empty list of authorized credentials")
+ }
+ pairs := make(authPairs, 0, len(accounts))
+ for user, password := range accounts {
+ if len(user) == 0 {
+ panic("User can not be empty")
+ }
+ value := authorizationHeader(user, password)
+ pairs = append(pairs, authPair{
+ Value: value,
+ User: user,
+ })
+ }
+ return pairs
+}
+
+func authorizationHeader(user, password string) string {
+ base := user + ":" + password
+ return "Basic " + base64.StdEncoding.EncodeToString([]byte(base))
+}
+
+func secureCompare(given, actual string) bool {
+ if subtle.ConstantTimeEq(int32(len(given)), int32(len(actual))) == 1 {
+ return subtle.ConstantTimeCompare([]byte(given), []byte(actual)) == 1
+ } else {
+ /* Securely compare actual to itself to keep constant time, but always return false */
+ return subtle.ConstantTimeCompare([]byte(actual), []byte(actual)) == 1 && false
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/auth_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/auth_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..8fc2f233d7a7dd71a0d08c21ffd115645df8e061
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/auth_test.go
@@ -0,0 +1,146 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "encoding/base64"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+func TestBasicAuth(t *testing.T) {
+ pairs := processAccounts(Accounts{
+ "admin": "password",
+ "foo": "bar",
+ "bar": "foo",
+ })
+
+ assert.Len(t, pairs, 3)
+ assert.Contains(t, pairs, authPair{
+ User: "bar",
+ Value: "Basic YmFyOmZvbw==",
+ })
+ assert.Contains(t, pairs, authPair{
+ User: "foo",
+ Value: "Basic Zm9vOmJhcg==",
+ })
+ assert.Contains(t, pairs, authPair{
+ User: "admin",
+ Value: "Basic YWRtaW46cGFzc3dvcmQ=",
+ })
+}
+
+func TestBasicAuthFails(t *testing.T) {
+ assert.Panics(t, func() { processAccounts(nil) })
+ assert.Panics(t, func() {
+ processAccounts(Accounts{
+ "": "password",
+ "foo": "bar",
+ })
+ })
+}
+
+func TestBasicAuthSearchCredential(t *testing.T) {
+ pairs := processAccounts(Accounts{
+ "admin": "password",
+ "foo": "bar",
+ "bar": "foo",
+ })
+
+ user, found := pairs.searchCredential(authorizationHeader("admin", "password"))
+ assert.Equal(t, user, "admin")
+ assert.True(t, found)
+
+ user, found = pairs.searchCredential(authorizationHeader("foo", "bar"))
+ assert.Equal(t, user, "foo")
+ assert.True(t, found)
+
+ user, found = pairs.searchCredential(authorizationHeader("bar", "foo"))
+ assert.Equal(t, user, "bar")
+ assert.True(t, found)
+
+ user, found = pairs.searchCredential(authorizationHeader("admins", "password"))
+ assert.Empty(t, user)
+ assert.False(t, found)
+
+ user, found = pairs.searchCredential(authorizationHeader("foo", "bar "))
+ assert.Empty(t, user)
+ assert.False(t, found)
+
+ user, found = pairs.searchCredential("")
+ assert.Empty(t, user)
+ assert.False(t, found)
+}
+
+func TestBasicAuthAuthorizationHeader(t *testing.T) {
+ assert.Equal(t, authorizationHeader("admin", "password"), "Basic YWRtaW46cGFzc3dvcmQ=")
+}
+
+func TestBasicAuthSecureCompare(t *testing.T) {
+ assert.True(t, secureCompare("1234567890", "1234567890"))
+ assert.False(t, secureCompare("123456789", "1234567890"))
+ assert.False(t, secureCompare("12345678900", "1234567890"))
+ assert.False(t, secureCompare("1234567891", "1234567890"))
+}
+
+func TestBasicAuthSucceed(t *testing.T) {
+ accounts := Accounts{"admin": "password"}
+ router := New()
+ router.Use(BasicAuth(accounts))
+ router.GET("/login", func(c *Context) {
+ c.String(200, c.MustGet(AuthUserKey).(string))
+ })
+
+ w := httptest.NewRecorder()
+ req, _ := http.NewRequest("GET", "/login", nil)
+ req.Header.Set("Authorization", authorizationHeader("admin", "password"))
+ router.ServeHTTP(w, req)
+
+ assert.Equal(t, w.Code, 200)
+ assert.Equal(t, w.Body.String(), "admin")
+}
+
+func TestBasicAuth401(t *testing.T) {
+ called := false
+ accounts := Accounts{"foo": "bar"}
+ router := New()
+ router.Use(BasicAuth(accounts))
+ router.GET("/login", func(c *Context) {
+ called = true
+ c.String(200, c.MustGet(AuthUserKey).(string))
+ })
+
+ w := httptest.NewRecorder()
+ req, _ := http.NewRequest("GET", "/login", nil)
+ req.Header.Set("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte("admin:password")))
+ router.ServeHTTP(w, req)
+
+ assert.False(t, called)
+ assert.Equal(t, w.Code, 401)
+ assert.Equal(t, w.HeaderMap.Get("WWW-Authenticate"), "Basic realm=\"Authorization Required\"")
+}
+
+func TestBasicAuth401WithCustomRealm(t *testing.T) {
+ called := false
+ accounts := Accounts{"foo": "bar"}
+ router := New()
+ router.Use(BasicAuthForRealm(accounts, "My Custom \"Realm\""))
+ router.GET("/login", func(c *Context) {
+ called = true
+ c.String(200, c.MustGet(AuthUserKey).(string))
+ })
+
+ w := httptest.NewRecorder()
+ req, _ := http.NewRequest("GET", "/login", nil)
+ req.Header.Set("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte("admin:password")))
+ router.ServeHTTP(w, req)
+
+ assert.False(t, called)
+ assert.Equal(t, w.Code, 401)
+ assert.Equal(t, w.HeaderMap.Get("WWW-Authenticate"), "Basic realm=\"My Custom \\\"Realm\\\"\"")
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/benchmarks_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/benchmarks_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..8a1c91a96bdaf96093355a3fa35bb1616d813e5d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/benchmarks_test.go
@@ -0,0 +1,157 @@
+package gin
+
+import (
+ "html/template"
+ "net/http"
+ "testing"
+)
+
+func BenchmarkOneRoute(B *testing.B) {
+ router := New()
+ router.GET("/ping", func(c *Context) {})
+ runRequest(B, router, "GET", "/ping")
+}
+
+func BenchmarkRecoveryMiddleware(B *testing.B) {
+ router := New()
+ router.Use(Recovery())
+ router.GET("/", func(c *Context) {})
+ runRequest(B, router, "GET", "/")
+}
+
+func BenchmarkLoggerMiddleware(B *testing.B) {
+ router := New()
+ router.Use(LoggerWithWriter(newMockWriter()))
+ router.GET("/", func(c *Context) {})
+ runRequest(B, router, "GET", "/")
+}
+
+func BenchmarkManyHandlers(B *testing.B) {
+ router := New()
+ router.Use(Recovery(), LoggerWithWriter(newMockWriter()))
+ router.Use(func(c *Context) {})
+ router.Use(func(c *Context) {})
+ router.GET("/ping", func(c *Context) {})
+ runRequest(B, router, "GET", "/ping")
+}
+
+func Benchmark5Params(B *testing.B) {
+ DefaultWriter = newMockWriter()
+ router := New()
+ router.Use(func(c *Context) {})
+ router.GET("/param/:param1/:params2/:param3/:param4/:param5", func(c *Context) {})
+ runRequest(B, router, "GET", "/param/path/to/parameter/john/12345")
+}
+
+func BenchmarkOneRouteJSON(B *testing.B) {
+ router := New()
+ data := struct {
+ Status string `json:"status"`
+ }{"ok"}
+ router.GET("/json", func(c *Context) {
+ c.JSON(200, data)
+ })
+ runRequest(B, router, "GET", "/json")
+}
+
+var htmlContentType = []string{"text/html; charset=utf-8"}
+
+func BenchmarkOneRouteHTML(B *testing.B) {
+ router := New()
+ t := template.Must(template.New("index").Parse(`
+ <html><body><h1>{{.}}</h1></body></html>`))
+ router.SetHTMLTemplate(t)
+
+ router.GET("/html", func(c *Context) {
+ c.HTML(200, "index", "hola")
+ })
+ runRequest(B, router, "GET", "/html")
+}
+
+func BenchmarkOneRouteSet(B *testing.B) {
+ router := New()
+ router.GET("/ping", func(c *Context) {
+ c.Set("key", "value")
+ })
+ runRequest(B, router, "GET", "/ping")
+}
+
+func BenchmarkOneRouteString(B *testing.B) {
+ router := New()
+ router.GET("/text", func(c *Context) {
+ c.String(200, "this is a plain text")
+ })
+ runRequest(B, router, "GET", "/text")
+}
+
+func BenchmarkManyRoutesFist(B *testing.B) {
+ router := New()
+ router.Any("/ping", func(c *Context) {})
+ runRequest(B, router, "GET", "/ping")
+}
+
+func BenchmarkManyRoutesLast(B *testing.B) {
+ router := New()
+ router.Any("/ping", func(c *Context) {})
+ runRequest(B, router, "OPTIONS", "/ping")
+}
+
+func Benchmark404(B *testing.B) {
+ router := New()
+ router.Any("/something", func(c *Context) {})
+ router.NoRoute(func(c *Context) {})
+ runRequest(B, router, "GET", "/ping")
+}
+
+func Benchmark404Many(B *testing.B) {
+ router := New()
+ router.GET("/", func(c *Context) {})
+ router.GET("/path/to/something", func(c *Context) {})
+ router.GET("/post/:id", func(c *Context) {})
+ router.GET("/view/:id", func(c *Context) {})
+ router.GET("/favicon.ico", func(c *Context) {})
+ router.GET("/robots.txt", func(c *Context) {})
+ router.GET("/delete/:id", func(c *Context) {})
+ router.GET("/user/:id/:mode", func(c *Context) {})
+
+ router.NoRoute(func(c *Context) {})
+ runRequest(B, router, "GET", "/viewfake")
+}
+
+type mockWriter struct {
+ headers http.Header
+}
+
+func newMockWriter() *mockWriter {
+ return &mockWriter{
+ http.Header{},
+ }
+}
+
+func (m *mockWriter) Header() (h http.Header) {
+ return m.headers
+}
+
+func (m *mockWriter) Write(p []byte) (n int, err error) {
+ return len(p), nil
+}
+
+func (m *mockWriter) WriteString(s string) (n int, err error) {
+ return len(s), nil
+}
+
+func (m *mockWriter) WriteHeader(int) {}
+
+func runRequest(B *testing.B, r *Engine, method, path string) {
+ // create fake request
+ req, err := http.NewRequest(method, path, nil)
+ if err != nil {
+ panic(err)
+ }
+ w := newMockWriter()
+ B.ReportAllocs()
+ B.ResetTimer()
+ for i := 0; i < B.N; i++ {
+ r.ServeHTTP(w, req)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/binding.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/binding.go
new file mode 100644
index 0000000000000000000000000000000000000000..f719fbc19a5da3b8fd59984990ec4e5d70c76001
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/binding.go
@@ -0,0 +1,61 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import "net/http"
+
+const (
+ MIMEJSON = "application/json"
+ MIMEHTML = "text/html"
+ MIMEXML = "application/xml"
+ MIMEXML2 = "text/xml"
+ MIMEPlain = "text/plain"
+ MIMEPOSTForm = "application/x-www-form-urlencoded"
+ MIMEMultipartPOSTForm = "multipart/form-data"
+)
+
+type Binding interface {
+ Name() string
+ Bind(*http.Request, interface{}) error
+}
+
+type StructValidator interface {
+ // ValidateStruct can receive any kind of type and it should never panic, even if the configuration is not right.
+ // If the received type is not a struct, any validation should be skipped and nil must be returned.
+ // If the received type is a struct or pointer to a struct, the validation should be performed.
+ // If the struct is not valid or the validation itself fails, a descriptive error should be returned.
+ // Otherwise nil must be returned.
+ ValidateStruct(interface{}) error
+}
+
+var Validator StructValidator = &defaultValidator{}
+
+var (
+ JSON = jsonBinding{}
+ XML = xmlBinding{}
+ Form = formBinding{}
+)
+
+func Default(method, contentType string) Binding {
+ if method == "GET" {
+ return Form
+ } else {
+ switch contentType {
+ case MIMEJSON:
+ return JSON
+ case MIMEXML, MIMEXML2:
+ return XML
+ default: //case MIMEPOSTForm, MIMEMultipartPOSTForm:
+ return Form
+ }
+ }
+}
+
+func validate(obj interface{}) error {
+ if Validator == nil {
+ return nil
+ }
+ return Validator.ValidateStruct(obj)
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/binding_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/binding_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..8c25afd980a9f9ac36e0b9e65d9a4cf8285d5c5b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/binding_test.go
@@ -0,0 +1,123 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import (
+ "bytes"
+ "net/http"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+type FooStruct struct {
+ Foo string `json:"foo" form:"foo" xml:"foo" binding:"required"`
+}
+
+type FooBarStruct struct {
+ FooStruct
+ Bar string `json:"bar" form:"bar" xml:"bar" binding:"required"`
+}
+
+func TestBindingDefault(t *testing.T) {
+ assert.Equal(t, Default("GET", ""), Form)
+ assert.Equal(t, Default("GET", MIMEJSON), Form)
+
+ assert.Equal(t, Default("POST", MIMEJSON), JSON)
+ assert.Equal(t, Default("PUT", MIMEJSON), JSON)
+
+ assert.Equal(t, Default("POST", MIMEXML), XML)
+ assert.Equal(t, Default("PUT", MIMEXML2), XML)
+
+ assert.Equal(t, Default("POST", MIMEPOSTForm), Form)
+ assert.Equal(t, Default("PUT", MIMEPOSTForm), Form)
+
+ assert.Equal(t, Default("POST", MIMEMultipartPOSTForm), Form)
+ assert.Equal(t, Default("PUT", MIMEMultipartPOSTForm), Form)
+}
+
+func TestBindingJSON(t *testing.T) {
+ testBodyBinding(t,
+ JSON, "json",
+ "/", "/",
+ `{"foo": "bar"}`, `{"bar": "foo"}`)
+}
+
+func TestBindingForm(t *testing.T) {
+ testFormBinding(t, "POST",
+ "/", "/",
+ "foo=bar&bar=foo", "bar2=foo")
+}
+
+func TestBindingForm2(t *testing.T) {
+ testFormBinding(t, "GET",
+ "/?foo=bar&bar=foo", "/?bar2=foo",
+ "", "")
+}
+
+func TestBindingXML(t *testing.T) {
+ testBodyBinding(t,
+ XML, "xml",
+ "/", "/",
+ "<map><foo>bar</foo></map>", "<map><bar>foo</bar></map>")
+}
+
+func TestValidationFails(t *testing.T) {
+ var obj FooStruct
+ req := requestWithBody("POST", "/", `{"bar": "foo"}`)
+ err := JSON.Bind(req, &obj)
+ assert.Error(t, err)
+}
+
+func TestValidationDisabled(t *testing.T) {
+ backup := Validator
+ Validator = nil
+ defer func() { Validator = backup }()
+
+ var obj FooStruct
+ req := requestWithBody("POST", "/", `{"bar": "foo"}`)
+ err := JSON.Bind(req, &obj)
+ assert.NoError(t, err)
+}
+
+func testFormBinding(t *testing.T, method, path, badPath, body, badBody string) {
+ b := Form
+ assert.Equal(t, b.Name(), "form")
+
+ obj := FooBarStruct{}
+ req := requestWithBody(method, path, body)
+ if method == "POST" {
+ req.Header.Add("Content-Type", MIMEPOSTForm)
+ }
+ err := b.Bind(req, &obj)
+ assert.NoError(t, err)
+ assert.Equal(t, obj.Foo, "bar")
+ assert.Equal(t, obj.Bar, "foo")
+
+ obj = FooBarStruct{}
+ req = requestWithBody(method, badPath, badBody)
+ err = JSON.Bind(req, &obj)
+ assert.Error(t, err)
+}
+
+func testBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
+ assert.Equal(t, b.Name(), name)
+
+ obj := FooStruct{}
+ req := requestWithBody("POST", path, body)
+ err := b.Bind(req, &obj)
+ assert.NoError(t, err)
+ assert.Equal(t, obj.Foo, "bar")
+
+ obj = FooStruct{}
+ req = requestWithBody("POST", badPath, badBody)
+ err = JSON.Bind(req, &obj)
+ assert.Error(t, err)
+}
+
+func requestWithBody(method, path, body string) (req *http.Request) {
+ req, _ = http.NewRequest(method, path, bytes.NewBufferString(body))
+ return
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/default_validator.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/default_validator.go
new file mode 100644
index 0000000000000000000000000000000000000000..d5a6f2e99f223aa316109ee610bdf3191a82e9f5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/default_validator.go
@@ -0,0 +1,40 @@
+package binding
+
+import (
+ "reflect"
+ "sync"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5"
+)
+
+type defaultValidator struct {
+ once sync.Once
+ validate *validator.Validate
+}
+
+var _ StructValidator = &defaultValidator{}
+
+func (v *defaultValidator) ValidateStruct(obj interface{}) error {
+ if kindOfData(obj) == reflect.Struct {
+ v.lazyinit()
+ if err := v.validate.Struct(obj); err != nil {
+ return error(err)
+ }
+ }
+ return nil
+}
+
+func (v *defaultValidator) lazyinit() {
+ v.once.Do(func() {
+ v.validate = validator.New("binding", validator.BakedInValidators)
+ })
+}
+
+func kindOfData(data interface{}) reflect.Kind {
+ value := reflect.ValueOf(data)
+ valueType := value.Kind()
+ if valueType == reflect.Ptr {
+ valueType = value.Elem().Kind()
+ }
+ return valueType
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/form.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/form.go
new file mode 100644
index 0000000000000000000000000000000000000000..ff00b0dfd0d43be067c4a76418cd96eecfde76f9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/form.go
@@ -0,0 +1,24 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import "net/http"
+
+type formBinding struct{}
+
+func (_ formBinding) Name() string {
+ return "form"
+}
+
+func (_ formBinding) Bind(req *http.Request, obj interface{}) error {
+ if err := req.ParseForm(); err != nil {
+ return err
+ }
+ req.ParseMultipartForm(32 << 10) // 32 MB
+ if err := mapForm(obj, req.Form); err != nil {
+ return err
+ }
+ return validate(obj)
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/form_mapping.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/form_mapping.go
new file mode 100644
index 0000000000000000000000000000000000000000..d8b13b1e4ce4b6f78407b717de2a1da8a1d8e3a3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/form_mapping.go
@@ -0,0 +1,151 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import (
+ "errors"
+ "reflect"
+ "strconv"
+)
+
+func mapForm(ptr interface{}, form map[string][]string) error {
+ typ := reflect.TypeOf(ptr).Elem()
+ val := reflect.ValueOf(ptr).Elem()
+ for i := 0; i < typ.NumField(); i++ {
+ typeField := typ.Field(i)
+ structField := val.Field(i)
+ if !structField.CanSet() {
+ continue
+ }
+
+ structFieldKind := structField.Kind()
+ inputFieldName := typeField.Tag.Get("form")
+ if inputFieldName == "" {
+ inputFieldName = typeField.Name
+
+ // if "form" tag is nil, we inspect if the field is a struct.
+ // this would not make sense for JSON parsing but it does for a form
+ // since data is flatten
+ if structFieldKind == reflect.Struct {
+ err := mapForm(structField.Addr().Interface(), form)
+ if err != nil {
+ return err
+ }
+ continue
+ }
+ }
+ inputValue, exists := form[inputFieldName]
+ if !exists {
+ continue
+ }
+
+ numElems := len(inputValue)
+ if structFieldKind == reflect.Slice && numElems > 0 {
+ sliceOf := structField.Type().Elem().Kind()
+ slice := reflect.MakeSlice(structField.Type(), numElems, numElems)
+ for i := 0; i < numElems; i++ {
+ if err := setWithProperType(sliceOf, inputValue[i], slice.Index(i)); err != nil {
+ return err
+ }
+ }
+ val.Field(i).Set(slice)
+ } else {
+ if err := setWithProperType(typeField.Type.Kind(), inputValue[0], structField); err != nil {
+ return err
+ }
+ }
+
+ }
+ return nil
+}
+
+func setWithProperType(valueKind reflect.Kind, val string, structField reflect.Value) error {
+ switch valueKind {
+ case reflect.Int:
+ return setIntField(val, 0, structField)
+ case reflect.Int8:
+ return setIntField(val, 8, structField)
+ case reflect.Int16:
+ return setIntField(val, 16, structField)
+ case reflect.Int32:
+ return setIntField(val, 32, structField)
+ case reflect.Int64:
+ return setIntField(val, 64, structField)
+ case reflect.Uint:
+ return setUintField(val, 0, structField)
+ case reflect.Uint8:
+ return setUintField(val, 8, structField)
+ case reflect.Uint16:
+ return setUintField(val, 16, structField)
+ case reflect.Uint32:
+ return setUintField(val, 32, structField)
+ case reflect.Uint64:
+ return setUintField(val, 64, structField)
+ case reflect.Bool:
+ return setBoolField(val, structField)
+ case reflect.Float32:
+ return setFloatField(val, 32, structField)
+ case reflect.Float64:
+ return setFloatField(val, 64, structField)
+ case reflect.String:
+ structField.SetString(val)
+ default:
+ return errors.New("Unknown type")
+ }
+ return nil
+}
+
+func setIntField(val string, bitSize int, field reflect.Value) error {
+ if val == "" {
+ val = "0"
+ }
+ intVal, err := strconv.ParseInt(val, 10, bitSize)
+ if err == nil {
+ field.SetInt(intVal)
+ }
+ return err
+}
+
+func setUintField(val string, bitSize int, field reflect.Value) error {
+ if val == "" {
+ val = "0"
+ }
+ uintVal, err := strconv.ParseUint(val, 10, bitSize)
+ if err == nil {
+ field.SetUint(uintVal)
+ }
+ return err
+}
+
+func setBoolField(val string, field reflect.Value) error {
+ if val == "" {
+ val = "false"
+ }
+ boolVal, err := strconv.ParseBool(val)
+ if err == nil {
+ field.SetBool(boolVal)
+ }
+ return nil
+}
+
+func setFloatField(val string, bitSize int, field reflect.Value) error {
+ if val == "" {
+ val = "0.0"
+ }
+ floatVal, err := strconv.ParseFloat(val, bitSize)
+ if err == nil {
+ field.SetFloat(floatVal)
+ }
+ return err
+}
+
+// Don't pass in pointers to bind to. Can lead to bugs. See:
+// https://github.com/codegangsta/martini-contrib/issues/40
+// https://github.com/codegangsta/martini-contrib/pull/34#issuecomment-29683659
+func ensureNotPointer(obj interface{}) {
+ if reflect.TypeOf(obj).Kind() == reflect.Ptr {
+ panic("Pointers are not accepted as binding models")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/json.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/json.go
new file mode 100644
index 0000000000000000000000000000000000000000..25c5a06c7a8522704abc4a33ad622ca2b2fd92d2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/json.go
@@ -0,0 +1,25 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import (
+ "encoding/json"
+
+ "net/http"
+)
+
+type jsonBinding struct{}
+
+func (_ jsonBinding) Name() string {
+ return "json"
+}
+
+func (_ jsonBinding) Bind(req *http.Request, obj interface{}) error {
+ decoder := json.NewDecoder(req.Body)
+ if err := decoder.Decode(obj); err != nil {
+ return err
+ }
+ return validate(obj)
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/validate_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/validate_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..8ab0bc5246ace0820bcacb3b6a5d5763124b38c6
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/validate_test.go
@@ -0,0 +1,69 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import (
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+type struct1 struct {
+ Value float64 `binding:"required"`
+}
+
+type struct2 struct {
+ RequiredValue string `binding:"required"`
+ Value float64
+}
+
+type struct3 struct {
+ Integer int
+ String string
+ BasicSlice []int
+ Boolean bool
+
+ RequiredInteger int `binding:"required"`
+ RequiredString string `binding:"required"`
+ RequiredAnotherStruct struct1 `binding:"required"`
+ RequiredBasicSlice []int `binding:"required"`
+ RequiredComplexSlice []struct2 `binding:"required"`
+ RequiredBoolean bool `binding:"required"`
+}
+
+func createStruct() struct3 {
+ return struct3{
+ RequiredInteger: 2,
+ RequiredString: "hello",
+ RequiredAnotherStruct: struct1{1.5},
+ RequiredBasicSlice: []int{1, 2, 3, 4},
+ RequiredComplexSlice: []struct2{
+ {RequiredValue: "A"},
+ {RequiredValue: "B"},
+ },
+ RequiredBoolean: true,
+ }
+}
+
+func TestValidateGoodObject(t *testing.T) {
+ test := createStruct()
+ assert.Nil(t, validate(&test))
+}
+
+type Object map[string]interface{}
+type MyObjects []Object
+
+func TestValidateSlice(t *testing.T) {
+ var obj MyObjects
+ var obj2 Object
+ var nu = 10
+
+ assert.NoError(t, validate(obj))
+ assert.NoError(t, validate(&obj))
+ assert.NoError(t, validate(obj2))
+ assert.NoError(t, validate(&obj2))
+ assert.NoError(t, validate(nu))
+ assert.NoError(t, validate(&nu))
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/xml.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/xml.go
new file mode 100644
index 0000000000000000000000000000000000000000..cac4be89561fc97a1dd68a35b9b6e0dfa71bb203
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/xml.go
@@ -0,0 +1,24 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import (
+ "encoding/xml"
+ "net/http"
+)
+
+type xmlBinding struct{}
+
+func (_ xmlBinding) Name() string {
+ return "xml"
+}
+
+func (_ xmlBinding) Bind(req *http.Request, obj interface{}) error {
+ decoder := xml.NewDecoder(req.Body)
+ if err := decoder.Decode(obj); err != nil {
+ return err
+ }
+ return validate(obj)
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/context.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/context.go
new file mode 100644
index 0000000000000000000000000000000000000000..a5e946ccc5655dc498b5866c0da8cc2fb1b34f49
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/context.go
@@ -0,0 +1,473 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "errors"
+ "io"
+ "math"
+ "net/http"
+ "strings"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin/binding"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin/render"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/manucorporat/sse"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/golang.org/x/net/context"
+)
+
+const (
+ MIMEJSON = binding.MIMEJSON
+ MIMEHTML = binding.MIMEHTML
+ MIMEXML = binding.MIMEXML
+ MIMEXML2 = binding.MIMEXML2
+ MIMEPlain = binding.MIMEPlain
+ MIMEPOSTForm = binding.MIMEPOSTForm
+ MIMEMultipartPOSTForm = binding.MIMEMultipartPOSTForm
+)
+
+const AbortIndex int8 = math.MaxInt8 / 2
+
+// Context is the most important part of gin. It allows us to pass variables between middleware,
+// manage the flow, validate the JSON of a request and render a JSON response for example.
+type Context struct {
+ writermem responseWriter
+ Request *http.Request
+ Writer ResponseWriter
+
+ Params Params
+ handlers HandlersChain
+ index int8
+
+ engine *Engine
+ Keys map[string]interface{}
+ Errors errorMsgs
+ Accepted []string
+}
+
+var _ context.Context = &Context{}
+
+/************************************/
+/********** CONTEXT CREATION ********/
+/************************************/
+
+func (c *Context) reset() {
+ c.Writer = &c.writermem
+ c.Params = c.Params[0:0]
+ c.handlers = nil
+ c.index = -1
+ c.Keys = nil
+ c.Errors = c.Errors[0:0]
+ c.Accepted = nil
+}
+
+func (c *Context) Copy() *Context {
+ var cp Context = *c
+ cp.writermem.ResponseWriter = nil
+ cp.Writer = &cp.writermem
+ cp.index = AbortIndex
+ cp.handlers = nil
+ return &cp
+}
+
+/************************************/
+/*********** FLOW CONTROL ***********/
+/************************************/
+
+// Next should be used only in the middlewares.
+// It executes the pending handlers in the chain inside the calling handler.
+// See example in github.
+func (c *Context) Next() {
+ c.index++
+ s := int8(len(c.handlers))
+ for ; c.index < s; c.index++ {
+ c.handlers[c.index](c)
+ }
+}
+
+// Returns if the currect context was aborted.
+func (c *Context) IsAborted() bool {
+ return c.index == AbortIndex
+}
+
+// Stops the system to continue calling the pending handlers in the chain.
+// Let's say you have an authorization middleware that validates if the request is authorized
+// if the authorization fails (the password does not match). This method (Abort()) should be called
+// in order to stop the execution of the actual handler.
+func (c *Context) Abort() {
+ c.index = AbortIndex
+}
+
+// It calls Abort() and writes the headers with the specified status code.
+// For example, a failed attempt to authentificate a request could use: context.AbortWithStatus(401).
+func (c *Context) AbortWithStatus(code int) {
+ c.Writer.WriteHeader(code)
+ c.Abort()
+}
+
+// It calls AbortWithStatus() and Error() internally. This method stops the chain, writes the status code and
+// pushes the specified error to `c.Errors`.
+// See Context.Error() for more details.
+func (c *Context) AbortWithError(code int, err error) *Error {
+ c.AbortWithStatus(code)
+ return c.Error(err)
+}
+
+/************************************/
+/********* ERROR MANAGEMENT *********/
+/************************************/
+
+// Attaches an error to the current context. The error is pushed to a list of errors.
+// It's a good idea to call Error for each error that occurred during the resolution of a request.
+// A middleware can be used to collect all the errors and push them to a database together, print a log, or append it in the HTTP response.
+func (c *Context) Error(err error) *Error {
+ var parsedError *Error
+ switch err.(type) {
+ case *Error:
+ parsedError = err.(*Error)
+ default:
+ parsedError = &Error{
+ Err: err,
+ Type: ErrorTypePrivate,
+ }
+ }
+ c.Errors = append(c.Errors, parsedError)
+ return parsedError
+}
+
+/************************************/
+/******** METADATA MANAGEMENT********/
+/************************************/
+
+// Sets a new pair key/value just for this context.
+// It also lazy initializes the hashmap if it was not used previously.
+func (c *Context) Set(key string, value interface{}) {
+ if c.Keys == nil {
+ c.Keys = make(map[string]interface{})
+ }
+ c.Keys[key] = value
+}
+
+// Returns the value for the given key, ie: (value, true).
+// If the value does not exists it returns (nil, false)
+func (c *Context) Get(key string) (value interface{}, exists bool) {
+ if c.Keys != nil {
+ value, exists = c.Keys[key]
+ }
+ return
+}
+
+// Returns the value for the given key if it exists, otherwise it panics.
+func (c *Context) MustGet(key string) interface{} {
+ if value, exists := c.Get(key); exists {
+ return value
+ }
+ panic("Key \"" + key + "\" does not exist")
+}
+
+/************************************/
+/************ INPUT DATA ************/
+/************************************/
+
+// Shortcut for c.Request.URL.Query().Get(key)
+func (c *Context) Query(key string) (va string) {
+ va, _ = c.query(key)
+ return
+}
+
+// Shortcut for c.Request.PostFormValue(key)
+func (c *Context) PostForm(key string) (va string) {
+ va, _ = c.postForm(key)
+ return
+}
+
+// Shortcut for c.Params.ByName(key)
+func (c *Context) Param(key string) string {
+ return c.Params.ByName(key)
+}
+
+func (c *Context) DefaultPostForm(key, defaultValue string) string {
+ if va, ok := c.postForm(key); ok {
+ return va
+ }
+ return defaultValue
+}
+
+func (c *Context) DefaultQuery(key, defaultValue string) string {
+ if va, ok := c.query(key); ok {
+ return va
+ }
+ return defaultValue
+}
+
+func (c *Context) query(key string) (string, bool) {
+ req := c.Request
+ if values, ok := req.URL.Query()[key]; ok && len(values) > 0 {
+ return values[0], true
+ }
+ return "", false
+}
+
+func (c *Context) postForm(key string) (string, bool) {
+ req := c.Request
+ req.ParseMultipartForm(32 << 20) // 32 MB
+ if values := req.PostForm[key]; len(values) > 0 {
+ return values[0], true
+ }
+ if req.MultipartForm != nil && req.MultipartForm.File != nil {
+ if values := req.MultipartForm.Value[key]; len(values) > 0 {
+ return values[0], true
+ }
+ }
+ return "", false
+}
+
+// This function checks the Content-Type to select a binding engine automatically,
+// Depending the "Content-Type" header different bindings are used:
+// "application/json" --> JSON binding
+// "application/xml" --> XML binding
+// else --> returns an error
+// if Parses the request's body as JSON if Content-Type == "application/json" using JSON or XML as a JSON input. It decodes the json payload into the struct specified as a pointer.Like ParseBody() but this method also writes a 400 error if the json is not valid.
+func (c *Context) Bind(obj interface{}) error {
+ b := binding.Default(c.Request.Method, c.ContentType())
+ return c.BindWith(obj, b)
+}
+
+// Shortcut for c.BindWith(obj, binding.JSON)
+func (c *Context) BindJSON(obj interface{}) error {
+ return c.BindWith(obj, binding.JSON)
+}
+
+func (c *Context) BindWith(obj interface{}, b binding.Binding) error {
+ if err := b.Bind(c.Request, obj); err != nil {
+ c.AbortWithError(400, err).SetType(ErrorTypeBind)
+ return err
+ }
+ return nil
+}
+
+// Best effort algoritm to return the real client IP, it parses
+// X-Real-IP and X-Forwarded-For in order to work properly with reverse-proxies such us: nginx or haproxy.
+func (c *Context) ClientIP() string {
+ if c.engine.ForwardedByClientIP {
+ clientIP := strings.TrimSpace(c.requestHeader("X-Real-Ip"))
+ if len(clientIP) > 0 {
+ return clientIP
+ }
+ clientIP = c.requestHeader("X-Forwarded-For")
+ if index := strings.IndexByte(clientIP, ','); index >= 0 {
+ clientIP = clientIP[0:index]
+ }
+ clientIP = strings.TrimSpace(clientIP)
+ if len(clientIP) > 0 {
+ return clientIP
+ }
+ }
+ return strings.TrimSpace(c.Request.RemoteAddr)
+}
+
+func (c *Context) ContentType() string {
+ return filterFlags(c.requestHeader("Content-Type"))
+}
+
+func (c *Context) requestHeader(key string) string {
+ if values, _ := c.Request.Header[key]; len(values) > 0 {
+ return values[0]
+ }
+ return ""
+}
+
+/************************************/
+/******** RESPONSE RENDERING ********/
+/************************************/
+
+// Intelligent shortcut for c.Writer.Header().Set(key, value)
+// it writes a header in the response.
+// If value == "", this method removes the header `c.Writer.Header().Del(key)`
+func (c *Context) Header(key, value string) {
+ if len(value) == 0 {
+ c.Writer.Header().Del(key)
+ } else {
+ c.Writer.Header().Set(key, value)
+ }
+}
+
+func (c *Context) Render(code int, r render.Render) {
+ c.writermem.WriteHeader(code)
+ if err := r.Render(c.Writer); err != nil {
+ c.renderError(err)
+ }
+}
+
+func (c *Context) renderError(err error) {
+ debugPrintError(err)
+ c.AbortWithError(500, err).SetType(ErrorTypeRender)
+}
+
+// Renders the HTTP template specified by its file name.
+// It also updates the HTTP code and sets the Content-Type as "text/html".
+// See http://golang.org/doc/articles/wiki/
+func (c *Context) HTML(code int, name string, obj interface{}) {
+ instance := c.engine.HTMLRender.Instance(name, obj)
+ c.Render(code, instance)
+}
+
+// Serializes the given struct as pretty JSON (indented + endlines) into the response body.
+// It also sets the Content-Type as "application/json".
+// WARNING: we recommend to use this only for development propuses since printing pretty JSON is
+// more CPU and bandwidth consuming. Use Context.JSON() instead.
+func (c *Context) IndentedJSON(code int, obj interface{}) {
+ c.Render(code, render.IndentedJSON{Data: obj})
+}
+
+// Serializes the given struct as JSON into the response body.
+// It also sets the Content-Type as "application/json".
+func (c *Context) JSON(code int, obj interface{}) {
+ c.writermem.WriteHeader(code)
+ if err := render.WriteJSON(c.Writer, obj); err != nil {
+ c.renderError(err)
+ }
+}
+
+// Serializes the given struct as XML into the response body.
+// It also sets the Content-Type as "application/xml".
+func (c *Context) XML(code int, obj interface{}) {
+ c.Render(code, render.XML{Data: obj})
+}
+
+// Writes the given string into the response body.
+func (c *Context) String(code int, format string, values ...interface{}) {
+ c.writermem.WriteHeader(code)
+ render.WriteString(c.Writer, format, values)
+}
+
+// Returns a HTTP redirect to the specific location.
+func (c *Context) Redirect(code int, location string) {
+ c.Render(-1, render.Redirect{
+ Code: code,
+ Location: location,
+ Request: c.Request,
+ })
+}
+
+// Writes some data into the body stream and updates the HTTP code.
+func (c *Context) Data(code int, contentType string, data []byte) {
+ c.Render(code, render.Data{
+ ContentType: contentType,
+ Data: data,
+ })
+}
+
+// Writes the specified file into the body stream in a efficient way.
+func (c *Context) File(filepath string) {
+ http.ServeFile(c.Writer, c.Request, filepath)
+}
+
+func (c *Context) SSEvent(name string, message interface{}) {
+ c.Render(-1, sse.Event{
+ Event: name,
+ Data: message,
+ })
+}
+
+func (c *Context) Stream(step func(w io.Writer) bool) {
+ w := c.Writer
+ clientGone := w.CloseNotify()
+ for {
+ select {
+ case <-clientGone:
+ return
+ default:
+ keepopen := step(w)
+ w.Flush()
+ if !keepopen {
+ return
+ }
+ }
+ }
+}
+
+/************************************/
+/******** CONTENT NEGOTIATION *******/
+/************************************/
+
+type Negotiate struct {
+ Offered []string
+ HTMLName string
+ HTMLData interface{}
+ JSONData interface{}
+ XMLData interface{}
+ Data interface{}
+}
+
+func (c *Context) Negotiate(code int, config Negotiate) {
+ switch c.NegotiateFormat(config.Offered...) {
+ case binding.MIMEJSON:
+ data := chooseData(config.JSONData, config.Data)
+ c.JSON(code, data)
+
+ case binding.MIMEHTML:
+ data := chooseData(config.HTMLData, config.Data)
+ c.HTML(code, config.HTMLName, data)
+
+ case binding.MIMEXML:
+ data := chooseData(config.XMLData, config.Data)
+ c.XML(code, data)
+
+ default:
+ c.AbortWithError(http.StatusNotAcceptable, errors.New("the accepted formats are not offered by the server"))
+ }
+}
+
+func (c *Context) NegotiateFormat(offered ...string) string {
+ if len(offered) == 0 {
+ panic("you must provide at least one offer")
+ }
+ if c.Accepted == nil {
+ c.Accepted = parseAccept(c.requestHeader("Accept"))
+ }
+ if len(c.Accepted) == 0 {
+ return offered[0]
+ }
+ for _, accepted := range c.Accepted {
+ for _, offert := range offered {
+ if accepted == offert {
+ return offert
+ }
+ }
+ }
+ return ""
+}
+
+func (c *Context) SetAccepted(formats ...string) {
+ c.Accepted = formats
+}
+
+/************************************/
+/***** GOLANG.ORG/X/NET/CONTEXT *****/
+/************************************/
+
+func (c *Context) Deadline() (deadline time.Time, ok bool) {
+ return
+}
+
+func (c *Context) Done() <-chan struct{} {
+ return nil
+}
+
+func (c *Context) Err() error {
+ return nil
+}
+
+func (c *Context) Value(key interface{}) interface{} {
+ if key == 0 {
+ return c.Request
+ }
+ if keyAsString, ok := key.(string); ok {
+ val, _ := c.Get(keyAsString)
+ return val
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/context_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/context_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..9e9f3dda4b8ea983c96fd42c1b3ff4a302d07414
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/context_test.go
@@ -0,0 +1,555 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "bytes"
+ "errors"
+ "html/template"
+ "mime/multipart"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/manucorporat/sse"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+// Unit tests TODO
+// func (c *Context) File(filepath string) {
+// func (c *Context) Negotiate(code int, config Negotiate) {
+// BAD case: func (c *Context) Render(code int, render render.Render, obj ...interface{}) {
+// test that information is not leaked when reusing Contexts (using the Pool)
+
+func createTestContext() (c *Context, w *httptest.ResponseRecorder, r *Engine) {
+ w = httptest.NewRecorder()
+ r = New()
+ c = r.allocateContext()
+ c.reset()
+ c.writermem.reset(w)
+ return
+}
+
+func createMultipartRequest() *http.Request {
+ boundary := "--testboundary"
+ body := new(bytes.Buffer)
+ mw := multipart.NewWriter(body)
+ defer mw.Close()
+
+ must(mw.SetBoundary(boundary))
+ must(mw.WriteField("foo", "bar"))
+ must(mw.WriteField("bar", "foo"))
+ req, err := http.NewRequest("POST", "/", body)
+ must(err)
+ req.Header.Set("Content-Type", MIMEMultipartPOSTForm+"; boundary="+boundary)
+ return req
+}
+
+func must(err error) {
+ if err != nil {
+ panic(err.Error())
+ }
+}
+
+func TestContextReset(t *testing.T) {
+ router := New()
+ c := router.allocateContext()
+ assert.Equal(t, c.engine, router)
+
+ c.index = 2
+ c.Writer = &responseWriter{ResponseWriter: httptest.NewRecorder()}
+ c.Params = Params{Param{}}
+ c.Error(errors.New("test"))
+ c.Set("foo", "bar")
+ c.reset()
+
+ assert.False(t, c.IsAborted())
+ assert.Nil(t, c.Keys)
+ assert.Nil(t, c.Accepted)
+ assert.Len(t, c.Errors, 0)
+ assert.Empty(t, c.Errors.Errors())
+ assert.Empty(t, c.Errors.ByType(ErrorTypeAny))
+ assert.Len(t, c.Params, 0)
+ assert.EqualValues(t, c.index, -1)
+ assert.Equal(t, c.Writer.(*responseWriter), &c.writermem)
+}
+
+// TestContextSetGet tests that a parameter is set correctly on the
+// current context and can be retrieved using Get.
+func TestContextSetGet(t *testing.T) {
+ c, _, _ := createTestContext()
+ c.Set("foo", "bar")
+
+ value, err := c.Get("foo")
+ assert.Equal(t, value, "bar")
+ assert.True(t, err)
+
+ value, err = c.Get("foo2")
+ assert.Nil(t, value)
+ assert.False(t, err)
+
+ assert.Equal(t, c.MustGet("foo"), "bar")
+ assert.Panics(t, func() { c.MustGet("no_exist") })
+}
+
+func TestContextSetGetValues(t *testing.T) {
+ c, _, _ := createTestContext()
+ c.Set("string", "this is a string")
+ c.Set("int32", int32(-42))
+ c.Set("int64", int64(42424242424242))
+ c.Set("uint64", uint64(42))
+ c.Set("float32", float32(4.2))
+ c.Set("float64", 4.2)
+ var a interface{} = 1
+ c.Set("intInterface", a)
+
+ assert.Exactly(t, c.MustGet("string").(string), "this is a string")
+ assert.Exactly(t, c.MustGet("int32").(int32), int32(-42))
+ assert.Exactly(t, c.MustGet("int64").(int64), int64(42424242424242))
+ assert.Exactly(t, c.MustGet("uint64").(uint64), uint64(42))
+ assert.Exactly(t, c.MustGet("float32").(float32), float32(4.2))
+ assert.Exactly(t, c.MustGet("float64").(float64), 4.2)
+ assert.Exactly(t, c.MustGet("intInterface").(int), 1)
+
+}
+
+func TestContextCopy(t *testing.T) {
+ c, _, _ := createTestContext()
+ c.index = 2
+ c.Request, _ = http.NewRequest("POST", "/hola", nil)
+ c.handlers = HandlersChain{func(c *Context) {}}
+ c.Params = Params{Param{Key: "foo", Value: "bar"}}
+ c.Set("foo", "bar")
+
+ cp := c.Copy()
+ assert.Nil(t, cp.handlers)
+ assert.Nil(t, cp.writermem.ResponseWriter)
+ assert.Equal(t, &cp.writermem, cp.Writer.(*responseWriter))
+ assert.Equal(t, cp.Request, c.Request)
+ assert.Equal(t, cp.index, AbortIndex)
+ assert.Equal(t, cp.Keys, c.Keys)
+ assert.Equal(t, cp.engine, c.engine)
+ assert.Equal(t, cp.Params, c.Params)
+}
+
+func TestContextQuery(t *testing.T) {
+ c, _, _ := createTestContext()
+ c.Request, _ = http.NewRequest("GET", "http://example.com/?foo=bar&page=10", nil)
+
+ assert.Equal(t, c.DefaultQuery("foo", "none"), "bar")
+ assert.Equal(t, c.Query("foo"), "bar")
+ assert.Empty(t, c.PostForm("foo"))
+
+ assert.Equal(t, c.DefaultQuery("page", "0"), "10")
+ assert.Equal(t, c.Query("page"), "10")
+ assert.Empty(t, c.PostForm("page"))
+
+ assert.Equal(t, c.DefaultQuery("NoKey", "nada"), "nada")
+ assert.Empty(t, c.Query("NoKey"))
+ assert.Empty(t, c.PostForm("NoKey"))
+}
+
+func TestContextQueryAndPostForm(t *testing.T) {
+ c, _, _ := createTestContext()
+ body := bytes.NewBufferString("foo=bar&page=11&both=POST")
+ c.Request, _ = http.NewRequest("POST", "/?both=GET&id=main", body)
+ c.Request.Header.Add("Content-Type", MIMEPOSTForm)
+
+ assert.Equal(t, c.DefaultPostForm("foo", "none"), "bar")
+ assert.Equal(t, c.PostForm("foo"), "bar")
+ assert.Empty(t, c.Query("foo"))
+
+ assert.Equal(t, c.DefaultPostForm("page", "0"), "11")
+ assert.Equal(t, c.PostForm("page"), "11")
+ assert.Equal(t, c.Query("page"), "")
+
+ assert.Equal(t, c.PostForm("both"), "POST")
+ assert.Equal(t, c.Query("both"), "GET")
+
+ assert.Equal(t, c.DefaultPostForm("id", "000"), "000")
+ assert.Equal(t, c.Query("id"), "main")
+ assert.Empty(t, c.PostForm("id"))
+
+ assert.Equal(t, c.DefaultPostForm("NoKey", "nada"), "nada")
+ assert.Empty(t, c.PostForm("NoKey"))
+ assert.Empty(t, c.Query("NoKey"))
+
+ var obj struct {
+ Foo string `form:"foo"`
+ Id string `form:"id"`
+ Page string `form:"page"`
+ Both string `form:"both"`
+ }
+ assert.NoError(t, c.Bind(&obj))
+ assert.Equal(t, obj.Foo, "bar")
+ assert.Equal(t, obj.Id, "main")
+ assert.Equal(t, obj.Page, "11")
+ assert.Equal(t, obj.Both, "POST")
+}
+
+func TestContextPostFormMultipart(t *testing.T) {
+ c, _, _ := createTestContext()
+ c.Request = createMultipartRequest()
+
+ var obj struct {
+ Foo string `form:"foo"`
+ Bar string `form:"bar"`
+ }
+ assert.NoError(t, c.Bind(&obj))
+ assert.Equal(t, obj.Bar, "foo")
+ assert.Equal(t, obj.Foo, "bar")
+
+ assert.Empty(t, c.Query("foo"))
+ assert.Empty(t, c.Query("bar"))
+ assert.Equal(t, c.PostForm("foo"), "bar")
+ assert.Equal(t, c.PostForm("bar"), "foo")
+}
+
+// Tests that the response is serialized as JSON
+// and Content-Type is set to application/json
+func TestContextRenderJSON(t *testing.T) {
+ c, w, _ := createTestContext()
+ c.JSON(201, H{"foo": "bar"})
+
+ assert.Equal(t, w.Code, 201)
+ assert.Equal(t, w.Body.String(), "{\"foo\":\"bar\"}\n")
+ assert.Equal(t, w.HeaderMap.Get("Content-Type"), "application/json; charset=utf-8")
+}
+
+// Tests that the response is serialized as JSON
+// we change the content-type before
+func TestContextRenderAPIJSON(t *testing.T) {
+ c, w, _ := createTestContext()
+ c.Header("Content-Type", "application/vnd.api+json")
+ c.JSON(201, H{"foo": "bar"})
+
+ assert.Equal(t, w.Code, 201)
+ assert.Equal(t, w.Body.String(), "{\"foo\":\"bar\"}\n")
+ assert.Equal(t, w.HeaderMap.Get("Content-Type"), "application/vnd.api+json")
+}
+
+// Tests that the response is serialized as JSON
+// and Content-Type is set to application/json
+func TestContextRenderIndentedJSON(t *testing.T) {
+ c, w, _ := createTestContext()
+ c.IndentedJSON(201, H{"foo": "bar", "bar": "foo", "nested": H{"foo": "bar"}})
+
+ assert.Equal(t, w.Code, 201)
+ assert.Equal(t, w.Body.String(), "{\n \"bar\": \"foo\",\n \"foo\": \"bar\",\n \"nested\": {\n \"foo\": \"bar\"\n }\n}")
+ assert.Equal(t, w.HeaderMap.Get("Content-Type"), "application/json; charset=utf-8")
+}
+
+// Tests that the response executes the templates
+// and responds with Content-Type set to text/html
+func TestContextRenderHTML(t *testing.T) {
+ c, w, router := createTestContext()
+ templ := template.Must(template.New("t").Parse(`Hello {{.name}}`))
+ router.SetHTMLTemplate(templ)
+
+ c.HTML(201, "t", H{"name": "alexandernyquist"})
+
+ assert.Equal(t, w.Code, 201)
+ assert.Equal(t, w.Body.String(), "Hello alexandernyquist")
+ assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/html; charset=utf-8")
+}
+
+// TestContextXML tests that the response is serialized as XML
+// and Content-Type is set to application/xml
+func TestContextRenderXML(t *testing.T) {
+ c, w, _ := createTestContext()
+ c.XML(201, H{"foo": "bar"})
+
+ assert.Equal(t, w.Code, 201)
+ assert.Equal(t, w.Body.String(), "<map><foo>bar</foo></map>")
+ assert.Equal(t, w.HeaderMap.Get("Content-Type"), "application/xml; charset=utf-8")
+}
+
+// TestContextString tests that the response is returned
+// with Content-Type set to text/plain
+func TestContextRenderString(t *testing.T) {
+ c, w, _ := createTestContext()
+ c.String(201, "test %s %d", "string", 2)
+
+ assert.Equal(t, w.Code, 201)
+ assert.Equal(t, w.Body.String(), "test string 2")
+ assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/plain; charset=utf-8")
+}
+
+// TestContextString tests that the response is returned
+// with Content-Type set to text/html
+func TestContextRenderHTMLString(t *testing.T) {
+ c, w, _ := createTestContext()
+ c.Header("Content-Type", "text/html; charset=utf-8")
+ c.String(201, "<html>%s %d</html>", "string", 3)
+
+ assert.Equal(t, w.Code, 201)
+ assert.Equal(t, w.Body.String(), "<html>string 3</html>")
+ assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/html; charset=utf-8")
+}
+
+// TestContextData tests that the response can be written from `bytesting`
+// with specified MIME type
+func TestContextRenderData(t *testing.T) {
+ c, w, _ := createTestContext()
+ c.Data(201, "text/csv", []byte(`foo,bar`))
+
+ assert.Equal(t, w.Code, 201)
+ assert.Equal(t, w.Body.String(), "foo,bar")
+ assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/csv")
+}
+
+func TestContextRenderSSE(t *testing.T) {
+ c, w, _ := createTestContext()
+ c.SSEvent("float", 1.5)
+ c.Render(-1, sse.Event{
+ Id: "123",
+ Data: "text",
+ })
+ c.SSEvent("chat", H{
+ "foo": "bar",
+ "bar": "foo",
+ })
+
+ assert.Equal(t, w.Body.String(), "event: float\ndata: 1.5\n\nid: 123\ndata: text\n\nevent: chat\ndata: {\"bar\":\"foo\",\"foo\":\"bar\"}\n\n")
+}
+
+func TestContextRenderFile(t *testing.T) {
+ c, w, _ := createTestContext()
+ c.Request, _ = http.NewRequest("GET", "/", nil)
+ c.File("./gin.go")
+
+ assert.Equal(t, w.Code, 200)
+ assert.Contains(t, w.Body.String(), "func New() *Engine {")
+ assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/plain; charset=utf-8")
+}
+
+func TestContextHeaders(t *testing.T) {
+ c, _, _ := createTestContext()
+ c.Header("Content-Type", "text/plain")
+ c.Header("X-Custom", "value")
+
+ assert.Equal(t, c.Writer.Header().Get("Content-Type"), "text/plain")
+ assert.Equal(t, c.Writer.Header().Get("X-Custom"), "value")
+
+ c.Header("Content-Type", "text/html")
+ c.Header("X-Custom", "")
+
+ assert.Equal(t, c.Writer.Header().Get("Content-Type"), "text/html")
+ _, exist := c.Writer.Header()["X-Custom"]
+ assert.False(t, exist)
+}
+
+// TODO
+func TestContextRenderRedirectWithRelativePath(t *testing.T) {
+ c, w, _ := createTestContext()
+ c.Request, _ = http.NewRequest("POST", "http://example.com", nil)
+ assert.Panics(t, func() { c.Redirect(299, "/new_path") })
+ assert.Panics(t, func() { c.Redirect(309, "/new_path") })
+
+ c.Redirect(302, "/path")
+ c.Writer.WriteHeaderNow()
+ assert.Equal(t, w.Code, 302)
+ assert.Equal(t, w.Header().Get("Location"), "/path")
+}
+
+func TestContextRenderRedirectWithAbsolutePath(t *testing.T) {
+ c, w, _ := createTestContext()
+ c.Request, _ = http.NewRequest("POST", "http://example.com", nil)
+ c.Redirect(302, "http://google.com")
+ c.Writer.WriteHeaderNow()
+
+ assert.Equal(t, w.Code, 302)
+ assert.Equal(t, w.Header().Get("Location"), "http://google.com")
+}
+
+func TestContextNegotiationFormat(t *testing.T) {
+ c, _, _ := createTestContext()
+ c.Request, _ = http.NewRequest("POST", "", nil)
+
+ assert.Panics(t, func() { c.NegotiateFormat() })
+ assert.Equal(t, c.NegotiateFormat(MIMEJSON, MIMEXML), MIMEJSON)
+ assert.Equal(t, c.NegotiateFormat(MIMEHTML, MIMEJSON), MIMEHTML)
+}
+
+func TestContextNegotiationFormatWithAccept(t *testing.T) {
+ c, _, _ := createTestContext()
+ c.Request, _ = http.NewRequest("POST", "/", nil)
+ c.Request.Header.Add("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
+
+ assert.Equal(t, c.NegotiateFormat(MIMEJSON, MIMEXML), MIMEXML)
+ assert.Equal(t, c.NegotiateFormat(MIMEXML, MIMEHTML), MIMEHTML)
+ assert.Equal(t, c.NegotiateFormat(MIMEJSON), "")
+}
+
+func TestContextNegotiationFormatCustum(t *testing.T) {
+ c, _, _ := createTestContext()
+ c.Request, _ = http.NewRequest("POST", "/", nil)
+ c.Request.Header.Add("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
+
+ c.Accepted = nil
+ c.SetAccepted(MIMEJSON, MIMEXML)
+
+ assert.Equal(t, c.NegotiateFormat(MIMEJSON, MIMEXML), MIMEJSON)
+ assert.Equal(t, c.NegotiateFormat(MIMEXML, MIMEHTML), MIMEXML)
+ assert.Equal(t, c.NegotiateFormat(MIMEJSON), MIMEJSON)
+}
+
+// TestContextData tests that the response can be written from `bytesting`
+// with specified MIME type
+func TestContextAbortWithStatus(t *testing.T) {
+ c, w, _ := createTestContext()
+ c.index = 4
+ c.AbortWithStatus(401)
+ c.Writer.WriteHeaderNow()
+
+ assert.Equal(t, c.index, AbortIndex)
+ assert.Equal(t, c.Writer.Status(), 401)
+ assert.Equal(t, w.Code, 401)
+ assert.True(t, c.IsAborted())
+}
+
+func TestContextError(t *testing.T) {
+ c, _, _ := createTestContext()
+ assert.Empty(t, c.Errors)
+
+ c.Error(errors.New("first error"))
+ assert.Len(t, c.Errors, 1)
+ assert.Equal(t, c.Errors.String(), "Error #01: first error\n")
+
+ c.Error(&Error{
+ Err: errors.New("second error"),
+ Meta: "some data 2",
+ Type: ErrorTypePublic,
+ })
+ assert.Len(t, c.Errors, 2)
+
+ assert.Equal(t, c.Errors[0].Err, errors.New("first error"))
+ assert.Nil(t, c.Errors[0].Meta)
+ assert.Equal(t, c.Errors[0].Type, ErrorTypePrivate)
+
+ assert.Equal(t, c.Errors[1].Err, errors.New("second error"))
+ assert.Equal(t, c.Errors[1].Meta, "some data 2")
+ assert.Equal(t, c.Errors[1].Type, ErrorTypePublic)
+
+ assert.Equal(t, c.Errors.Last(), c.Errors[1])
+}
+
+func TestContextTypedError(t *testing.T) {
+ c, _, _ := createTestContext()
+ c.Error(errors.New("externo 0")).SetType(ErrorTypePublic)
+ c.Error(errors.New("interno 0")).SetType(ErrorTypePrivate)
+
+ for _, err := range c.Errors.ByType(ErrorTypePublic) {
+ assert.Equal(t, err.Type, ErrorTypePublic)
+ }
+ for _, err := range c.Errors.ByType(ErrorTypePrivate) {
+ assert.Equal(t, err.Type, ErrorTypePrivate)
+ }
+ assert.Equal(t, c.Errors.Errors(), []string{"externo 0", "interno 0"})
+}
+
+func TestContextAbortWithError(t *testing.T) {
+ c, w, _ := createTestContext()
+ c.AbortWithError(401, errors.New("bad input")).SetMeta("some input")
+ c.Writer.WriteHeaderNow()
+
+ assert.Equal(t, w.Code, 401)
+ assert.Equal(t, c.index, AbortIndex)
+ assert.True(t, c.IsAborted())
+}
+
+func TestContextClientIP(t *testing.T) {
+ c, _, _ := createTestContext()
+ c.Request, _ = http.NewRequest("POST", "/", nil)
+
+ c.Request.Header.Set("X-Real-IP", " 10.10.10.10 ")
+ c.Request.Header.Set("X-Forwarded-For", " 20.20.20.20, 30.30.30.30")
+ c.Request.RemoteAddr = " 40.40.40.40 "
+
+ assert.Equal(t, c.ClientIP(), "10.10.10.10")
+
+ c.Request.Header.Del("X-Real-IP")
+ assert.Equal(t, c.ClientIP(), "20.20.20.20")
+
+ c.Request.Header.Set("X-Forwarded-For", "30.30.30.30 ")
+ assert.Equal(t, c.ClientIP(), "30.30.30.30")
+
+ c.Request.Header.Del("X-Forwarded-For")
+ assert.Equal(t, c.ClientIP(), "40.40.40.40")
+}
+
+func TestContextContentType(t *testing.T) {
+ c, _, _ := createTestContext()
+ c.Request, _ = http.NewRequest("POST", "/", nil)
+ c.Request.Header.Set("Content-Type", "application/json; charset=utf-8")
+
+ assert.Equal(t, c.ContentType(), "application/json")
+}
+
+func TestContextAutoBindJSON(t *testing.T) {
+ c, _, _ := createTestContext()
+ c.Request, _ = http.NewRequest("POST", "/", bytes.NewBufferString("{\"foo\":\"bar\", \"bar\":\"foo\"}"))
+ c.Request.Header.Add("Content-Type", MIMEJSON)
+
+ var obj struct {
+ Foo string `json:"foo"`
+ Bar string `json:"bar"`
+ }
+ assert.NoError(t, c.Bind(&obj))
+ assert.Equal(t, obj.Bar, "foo")
+ assert.Equal(t, obj.Foo, "bar")
+ assert.Empty(t, c.Errors)
+}
+
+func TestContextBindWithJSON(t *testing.T) {
+ c, w, _ := createTestContext()
+ c.Request, _ = http.NewRequest("POST", "/", bytes.NewBufferString("{\"foo\":\"bar\", \"bar\":\"foo\"}"))
+ c.Request.Header.Add("Content-Type", MIMEXML) // set fake content-type
+
+ var obj struct {
+ Foo string `json:"foo"`
+ Bar string `json:"bar"`
+ }
+ assert.NoError(t, c.BindJSON(&obj))
+ assert.Equal(t, obj.Bar, "foo")
+ assert.Equal(t, obj.Foo, "bar")
+ assert.Equal(t, w.Body.Len(), 0)
+}
+
+func TestContextBadAutoBind(t *testing.T) {
+ c, w, _ := createTestContext()
+ c.Request, _ = http.NewRequest("POST", "http://example.com", bytes.NewBufferString("\"foo\":\"bar\", \"bar\":\"foo\"}"))
+ c.Request.Header.Add("Content-Type", MIMEJSON)
+ var obj struct {
+ Foo string `json:"foo"`
+ Bar string `json:"bar"`
+ }
+
+ assert.False(t, c.IsAborted())
+ assert.Error(t, c.Bind(&obj))
+ c.Writer.WriteHeaderNow()
+
+ assert.Empty(t, obj.Bar)
+ assert.Empty(t, obj.Foo)
+ assert.Equal(t, w.Code, 400)
+ assert.True(t, c.IsAborted())
+}
+
+func TestContextGolangContext(t *testing.T) {
+ c, _, _ := createTestContext()
+ c.Request, _ = http.NewRequest("POST", "/", bytes.NewBufferString("{\"foo\":\"bar\", \"bar\":\"foo\"}"))
+ assert.NoError(t, c.Err())
+ assert.Nil(t, c.Done())
+ ti, ok := c.Deadline()
+ assert.Equal(t, ti, time.Time{})
+ assert.False(t, ok)
+ assert.Equal(t, c.Value(0), c.Request)
+ assert.Nil(t, c.Value("foo"))
+
+ c.Set("foo", "bar")
+ assert.Equal(t, c.Value("foo"), "bar")
+ assert.Nil(t, c.Value(1))
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/debug.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/debug.go
new file mode 100644
index 0000000000000000000000000000000000000000..a0b99f43a136bfcefc82343c10e2e3c88c09c009
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/debug.go
@@ -0,0 +1,42 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import "log"
+
+func init() {
+ log.SetFlags(0)
+}
+func IsDebugging() bool {
+ return ginMode == debugCode
+}
+
+func debugPrintRoute(httpMethod, absolutePath string, handlers HandlersChain) {
+ if IsDebugging() {
+ nuHandlers := len(handlers)
+ handlerName := nameOfFunction(handlers[nuHandlers-1])
+ debugPrint("%-5s %-25s --> %s (%d handlers)\n", httpMethod, absolutePath, handlerName, nuHandlers)
+ }
+}
+
+func debugPrint(format string, values ...interface{}) {
+ if IsDebugging() {
+ log.Printf("[GIN-debug] "+format, values...)
+ }
+}
+
+func debugPrintWARNING() {
+ debugPrint(`[WARNING] Running in "debug" mode. Switch to "release" mode in production.
+ - using env: export GIN_MODE=release
+ - using code: gin.SetMode(gin.ReleaseMode)
+
+`)
+}
+
+func debugPrintError(err error) {
+ if err != nil {
+ debugPrint("[ERROR] %v\n", err)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/debug_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/debug_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..ea5896167769f444debeba3e88e60675f641c5a6
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/debug_test.go
@@ -0,0 +1,68 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "bytes"
+ "errors"
+ "io"
+ "log"
+ "os"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+// TODO
+// func debugRoute(httpMethod, absolutePath string, handlers HandlersChain) {
+// func debugPrint(format string, values ...interface{}) {
+
+func TestIsDebugging(t *testing.T) {
+ SetMode(DebugMode)
+ assert.True(t, IsDebugging())
+ SetMode(ReleaseMode)
+ assert.False(t, IsDebugging())
+ SetMode(TestMode)
+ assert.False(t, IsDebugging())
+}
+
+func TestDebugPrint(t *testing.T) {
+ var w bytes.Buffer
+ setup(&w)
+ defer teardown()
+
+ SetMode(ReleaseMode)
+ debugPrint("DEBUG this!")
+ SetMode(TestMode)
+ debugPrint("DEBUG this!")
+ assert.Empty(t, w.String())
+
+ SetMode(DebugMode)
+ debugPrint("these are %d %s\n", 2, "error messages")
+ assert.Equal(t, w.String(), "[GIN-debug] these are 2 error messages\n")
+}
+
+func TestDebugPrintError(t *testing.T) {
+ var w bytes.Buffer
+ setup(&w)
+ defer teardown()
+
+ SetMode(DebugMode)
+ debugPrintError(nil)
+ assert.Empty(t, w.String())
+
+ debugPrintError(errors.New("this is an error"))
+ assert.Equal(t, w.String(), "[GIN-debug] [ERROR] this is an error\n")
+}
+
+func setup(w io.Writer) {
+ SetMode(DebugMode)
+ log.SetOutput(w)
+}
+
+func teardown() {
+ SetMode(TestMode)
+ log.SetOutput(os.Stdout)
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/deprecated.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/deprecated.go
new file mode 100644
index 0000000000000000000000000000000000000000..b2e874f019484770b2654ddd648dbe973378b897
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/deprecated.go
@@ -0,0 +1,5 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/errors.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/errors.go
new file mode 100644
index 0000000000000000000000000000000000000000..982c0267ea241e07c23639ae5f8c25f1e9250408
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/errors.go
@@ -0,0 +1,161 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "reflect"
+)
+
+type ErrorType uint64
+
+const (
+ ErrorTypeBind ErrorType = 1 << 63 // used when c.Bind() fails
+ ErrorTypeRender ErrorType = 1 << 62 // used when c.Render() fails
+ ErrorTypePrivate ErrorType = 1 << 0
+ ErrorTypePublic ErrorType = 1 << 1
+
+ ErrorTypeAny ErrorType = 1<<64 - 1
+ ErrorTypeNu = 2
+)
+
+type (
+ Error struct {
+ Err error
+ Type ErrorType
+ Meta interface{}
+ }
+
+ errorMsgs []*Error
+)
+
+var _ error = &Error{}
+
+func (msg *Error) SetType(flags ErrorType) *Error {
+ msg.Type = flags
+ return msg
+}
+
+func (msg *Error) SetMeta(data interface{}) *Error {
+ msg.Meta = data
+ return msg
+}
+
+func (msg *Error) JSON() interface{} {
+ json := H{}
+ if msg.Meta != nil {
+ value := reflect.ValueOf(msg.Meta)
+ switch value.Kind() {
+ case reflect.Struct:
+ return msg.Meta
+ case reflect.Map:
+ for _, key := range value.MapKeys() {
+ json[key.String()] = value.MapIndex(key).Interface()
+ }
+ default:
+ json["meta"] = msg.Meta
+ }
+ }
+ if _, ok := json["error"]; !ok {
+ json["error"] = msg.Error()
+ }
+ return json
+}
+
+// Implements the json.Marshaller interface
+func (msg *Error) MarshalJSON() ([]byte, error) {
+ return json.Marshal(msg.JSON())
+}
+
+// Implements the error interface
+func (msg *Error) Error() string {
+ return msg.Err.Error()
+}
+
+func (msg *Error) IsType(flags ErrorType) bool {
+ return (msg.Type & flags) > 0
+}
+
+// Returns a readonly copy filterd the byte.
+// ie ByType(gin.ErrorTypePublic) returns a slice of errors with type=ErrorTypePublic
+func (a errorMsgs) ByType(typ ErrorType) errorMsgs {
+ if len(a) == 0 {
+ return nil
+ }
+ if typ == ErrorTypeAny {
+ return a
+ }
+ var result errorMsgs = nil
+ for _, msg := range a {
+ if msg.IsType(typ) {
+ result = append(result, msg)
+ }
+ }
+ return result
+}
+
+// Returns the last error in the slice. It returns nil if the array is empty.
+// Shortcut for errors[len(errors)-1]
+func (a errorMsgs) Last() *Error {
+ length := len(a)
+ if length == 0 {
+ return nil
+ }
+ return a[length-1]
+}
+
+// Returns an array will all the error messages.
+// Example
+// ```
+// c.Error(errors.New("first"))
+// c.Error(errors.New("second"))
+// c.Error(errors.New("third"))
+// c.Errors.Errors() // == []string{"first", "second", "third"}
+// ``
+func (a errorMsgs) Errors() []string {
+ if len(a) == 0 {
+ return nil
+ }
+ errorStrings := make([]string, len(a))
+ for i, err := range a {
+ errorStrings[i] = err.Error()
+ }
+ return errorStrings
+}
+
+func (a errorMsgs) JSON() interface{} {
+ switch len(a) {
+ case 0:
+ return nil
+ case 1:
+ return a.Last().JSON()
+ default:
+ json := make([]interface{}, len(a))
+ for i, err := range a {
+ json[i] = err.JSON()
+ }
+ return json
+ }
+}
+
+func (a errorMsgs) MarshalJSON() ([]byte, error) {
+ return json.Marshal(a.JSON())
+}
+
+func (a errorMsgs) String() string {
+ if len(a) == 0 {
+ return ""
+ }
+ var buffer bytes.Buffer
+ for i, msg := range a {
+ fmt.Fprintf(&buffer, "Error #%02d: %s\n", (i + 1), msg.Err)
+ if msg.Meta != nil {
+ fmt.Fprintf(&buffer, " Meta: %v\n", msg.Meta)
+ }
+ }
+ return buffer.String()
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/errors_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/errors_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..aa7cc3ddc05bbc39c8ea1bf13c4d56e2ef11a39c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/errors_test.go
@@ -0,0 +1,98 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "encoding/json"
+ "errors"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+func TestError(t *testing.T) {
+ baseError := errors.New("test error")
+ err := &Error{
+ Err: baseError,
+ Type: ErrorTypePrivate,
+ }
+ assert.Equal(t, err.Error(), baseError.Error())
+ assert.Equal(t, err.JSON(), H{"error": baseError.Error()})
+
+ assert.Equal(t, err.SetType(ErrorTypePublic), err)
+ assert.Equal(t, err.Type, ErrorTypePublic)
+
+ assert.Equal(t, err.SetMeta("some data"), err)
+ assert.Equal(t, err.Meta, "some data")
+ assert.Equal(t, err.JSON(), H{
+ "error": baseError.Error(),
+ "meta": "some data",
+ })
+
+ jsonBytes, _ := json.Marshal(err)
+ assert.Equal(t, string(jsonBytes), "{\"error\":\"test error\",\"meta\":\"some data\"}")
+
+ err.SetMeta(H{
+ "status": "200",
+ "data": "some data",
+ })
+ assert.Equal(t, err.JSON(), H{
+ "error": baseError.Error(),
+ "status": "200",
+ "data": "some data",
+ })
+
+ err.SetMeta(H{
+ "error": "custom error",
+ "status": "200",
+ "data": "some data",
+ })
+ assert.Equal(t, err.JSON(), H{
+ "error": "custom error",
+ "status": "200",
+ "data": "some data",
+ })
+}
+
+func TestErrorSlice(t *testing.T) {
+ errs := errorMsgs{
+ {Err: errors.New("first"), Type: ErrorTypePrivate},
+ {Err: errors.New("second"), Type: ErrorTypePrivate, Meta: "some data"},
+ {Err: errors.New("third"), Type: ErrorTypePublic, Meta: H{"status": "400"}},
+ }
+
+ assert.Equal(t, errs.Last().Error(), "third")
+ assert.Equal(t, errs.Errors(), []string{"first", "second", "third"})
+ assert.Equal(t, errs.ByType(ErrorTypePublic).Errors(), []string{"third"})
+ assert.Equal(t, errs.ByType(ErrorTypePrivate).Errors(), []string{"first", "second"})
+ assert.Equal(t, errs.ByType(ErrorTypePublic|ErrorTypePrivate).Errors(), []string{"first", "second", "third"})
+ assert.Empty(t, errs.ByType(ErrorTypeBind))
+ assert.Empty(t, errs.ByType(ErrorTypeBind).String())
+
+ assert.Equal(t, errs.String(), `Error #01: first
+Error #02: second
+ Meta: some data
+Error #03: third
+ Meta: map[status:400]
+`)
+ assert.Equal(t, errs.JSON(), []interface{}{
+ H{"error": "first"},
+ H{"error": "second", "meta": "some data"},
+ H{"error": "third", "status": "400"},
+ })
+ jsonBytes, _ := json.Marshal(errs)
+ assert.Equal(t, string(jsonBytes), "[{\"error\":\"first\"},{\"error\":\"second\",\"meta\":\"some data\"},{\"error\":\"third\",\"status\":\"400\"}]")
+ errs = errorMsgs{
+ {Err: errors.New("first"), Type: ErrorTypePrivate},
+ }
+ assert.Equal(t, errs.JSON(), H{"error": "first"})
+ jsonBytes, _ = json.Marshal(errs)
+ assert.Equal(t, string(jsonBytes), "{\"error\":\"first\"}")
+
+ errs = errorMsgs{}
+ assert.Nil(t, errs.Last())
+ assert.Nil(t, errs.JSON())
+ assert.Empty(t, errs.String())
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/app-engine/README.md b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/app-engine/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..48505de83437371b8206b3c4ff8f00dd8fcc7929
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/app-engine/README.md
@@ -0,0 +1,7 @@
+# Guide to run Gin under App Engine LOCAL Development Server
+
+1. Download, install and setup Go in your computer. (That includes setting your `$GOPATH`.)
+2. Download SDK for your platform from here: `https://developers.google.com/appengine/downloads?hl=es#Google_App_Engine_SDK_for_Go`
+3. Download Gin source code using: `$ go get github.com/gin-gonic/gin`
+4. Navigate to examples folder: `$ cd $GOPATH/src/github.com/gin-gonic/gin/examples/`
+5. Run it: `$ goapp serve app-engine/`
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/app-engine/app.yaml b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/app-engine/app.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..5f20cf3f256a49561217bfb28f0b8cb5a8299266
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/app-engine/app.yaml
@@ -0,0 +1,8 @@
+application: hello
+version: 1
+runtime: go
+api_version: go1
+
+handlers:
+- url: /.*
+ script: _go_app
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/app-engine/hello.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/app-engine/hello.go
new file mode 100644
index 0000000000000000000000000000000000000000..2b09841028313a030a5c24a97c57f03635043209
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/app-engine/hello.go
@@ -0,0 +1,23 @@
+package hello
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
+ "net/http"
+)
+
+// This function's name is a must. App Engine uses it to drive the requests properly.
+func init() {
+ // Starts a new Gin instance with no middle-ware
+ r := gin.New()
+
+ // Define your handlers
+ r.GET("/", func(c *gin.Context) {
+ c.String(200, "Hello World!")
+ })
+ r.GET("/ping", func(c *gin.Context) {
+ c.String(200, "pong")
+ })
+
+ // Handle all requests using net/http
+ http.Handle("/", r)
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/basic/main.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/basic/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..b0f1ece7c982d576e76f754f8d8a66390d941c68
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/basic/main.go
@@ -0,0 +1,56 @@
+package main
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
+)
+
+var DB = make(map[string]string)
+
+func main() {
+ r := gin.Default()
+
+ // Ping test
+ r.GET("/ping", func(c *gin.Context) {
+ c.String(200, "pong")
+ })
+
+ // Get user value
+ r.GET("/user/:name", func(c *gin.Context) {
+ user := c.Params.ByName("name")
+ value, ok := DB[user]
+ if ok {
+ c.JSON(200, gin.H{"user": user, "value": value})
+ } else {
+ c.JSON(200, gin.H{"user": user, "status": "no value"})
+ }
+ })
+
+ // Authorized group (uses gin.BasicAuth() middleware)
+ // Same than:
+ // authorized := r.Group("/")
+ // authorized.Use(gin.BasicAuth(gin.Credentials{
+ // "foo": "bar",
+ // "manu": "123",
+ //}))
+ authorized := r.Group("/", gin.BasicAuth(gin.Accounts{
+ "foo": "bar", // user:foo password:bar
+ "manu": "123", // user:manu password:123
+ }))
+
+ authorized.POST("admin", func(c *gin.Context) {
+ user := c.MustGet(gin.AuthUserKey).(string)
+
+ // Parse JSON
+ var json struct {
+ Value string `json:"value" binding:"required"`
+ }
+
+ if c.Bind(&json) == nil {
+ DB[user] = json.Value
+ c.JSON(200, gin.H{"status": "ok"})
+ }
+ })
+
+ // Listen and Server in 0.0.0.0:8080
+ r.Run(":8080")
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/main.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..538cea7456dc31e663483a32d11a54c27926863c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/main.go
@@ -0,0 +1,39 @@
+package main
+
+import (
+ "fmt"
+ "runtime"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
+)
+
+func main() {
+ ConfigRuntime()
+ StartWorkers()
+ StartGin()
+}
+
+func ConfigRuntime() {
+ nuCPU := runtime.NumCPU()
+ runtime.GOMAXPROCS(nuCPU)
+ fmt.Printf("Running with %d CPUs\n", nuCPU)
+}
+
+func StartWorkers() {
+ go statsWorker()
+}
+
+func StartGin() {
+ gin.SetMode(gin.ReleaseMode)
+
+ router := gin.New()
+ router.Use(rateLimit, gin.Recovery())
+ router.LoadHTMLGlob("resources/*.templ.html")
+ router.Static("/static", "resources/static")
+ router.GET("/", index)
+ router.GET("/room/:roomid", roomGET)
+ router.POST("/room-post/:roomid", roomPOST)
+ router.GET("/stream/:roomid", streamRoom)
+
+ router.Run(":80")
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/resources/room_login.templ.html b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/resources/room_login.templ.html
new file mode 100644
index 0000000000000000000000000000000000000000..27dac3879d971dae95c49f9e9215eabb42a873bb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/resources/room_login.templ.html
@@ -0,0 +1,208 @@
+<!DOCTYPE html>
+<html lang="en">
+ <head>
+ <meta charset="utf-8">
+ <meta http-equiv="X-UA-Compatible" content="IE=edge">
+ <meta name="viewport" content="width=device-width, initial-scale=1">
+ <title>Server-Sent Events. Room "{{.roomid}}"</title>
+ <!-- jQuery -->
+ <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.2/jquery.min.js"></script>
+ <script src="http://malsup.github.com/jquery.form.js"></script>
+ <!-- EPOCH -->
+ <script src="http://d3js.org/d3.v3.min.js"></script>
+ <script src="/static/epoch.min.js"></script>
+ <link rel="stylesheet" href="/static/epoch.min.css">
+ <script src="/static/realtime.js"></script>
+ <!-- Latest compiled and minified CSS -->
+ <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css">
+ <!-- Optional theme -->
+ <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap-theme.min.css">
+ <!-- Latest compiled and minified JavaScript -->
+ <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/js/bootstrap.min.js"></script>
+ <!-- Primjs -->
+ <link href="/static/prismjs.min.css" rel="stylesheet" />
+
+ <script type="text/javascript">
+ $(document).ready(function() {
+ StartRealtime({{.roomid}}, {{.timestamp}});
+ });
+ </script>
+ <style>
+ body { padding-top: 50px; }
+ </style>
+ </head>
+ <body>
+ <nav class="navbar navbar-fixed-top navbar-inverse">
+ <div class="container">
+ <div class="navbar-header">
+ <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">
+ <span class="sr-only">Toggle navigation</span>
+ <span class="icon-bar"></span>
+ <span class="icon-bar"></span>
+ <span class="icon-bar"></span>
+ </button>
+ <a class="navbar-brand" href="#">Server-Sent Events</a>
+ </div>
+ <div id="navbar" class="collapse navbar-collapse">
+ <ul class="nav navbar-nav">
+ <li class="active"><a href="#">Demo</a></li>
+ <li><a href="http://www.w3.org/TR/2009/WD-eventsource-20091029/">W3 Standard</a></li>
+ <li><a href="http://caniuse.com/#feat=eventsource">Browser Support</a></li>
+ <li><a href="http://gin-gonic.github.io/gin/">Gin Framework</a></li>
+ <li><a href="https://github.com/gin-gonic/gin/tree/develop/examples/realtime-advanced">Github</a></li>
+ </ul>
+ </div><!-- /.nav-collapse -->
+ </div><!-- /.container -->
+ </nav><!-- /.navbar -->
+ <!-- Main jumbotron for a primary marketing message or call to action -->
+ <div class="jumbotron">
+ <div class="container">
+ <h1>Server-Sent Events in Go</h1>
+ <p>Server-sent events (SSE) is a technology where a browser receives automatic updates from a server via HTTP connection. It is not websockets. <a href="http://www.html5rocks.com/en/tutorials/eventsource/basics/">Learn more.</a></p>
+ <p>The chat and the charts data is provided in realtime using the SSE implemention of <a href="https://github.com/gin-gonic/gin/blob/15b0c49da556d58a3d934b86e3aa552ff224026d/examples/realtime-chat/main.go#L23-L32">Gin Framework</a>.</p>
+ <div class="row">
+ <div class="col-md-8">
+ <div id="chat-scroll" style="overflow-y:scroll; overflow-x:scroll; height:290px">
+ <table id="table-style" class="table" data-show-header="false">
+ <thead>
+ <tr>
+ <th data-field="nick" class="col-md-2">Nick</th>
+ <th data-field="message" class="col-md-8">Message</th>
+ </tr>
+ </thead>
+ <tbody id="chat"></tbody>
+ </table>
+ </div>
+ {{if .nick}}
+ <form autocomplete="off" class="form-inline" id="chat-form" action="/room-post/{{.roomid}}?nick={{.nick}}" method="post">
+ <div class="form-group">
+ <label class="sr-only" for="chat-message">Message</label>
+ <div class="input-group">
+ <div class="input-group-addon">{{.nick}}</div>
+ <input type="text" name="message" id="chat-message" class="form-control" placeholder="a message" value="" />
+ </div>
+ </div>
+ <input type="submit" class="btn btn-primary" value="Send" />
+ </form>
+ {{else}}
+ <form action="" method="get" class="form-inline">
+ <legend>Join the SSE real-time chat</legend>
+ <div class="form-group">
+ <input value='' name="nick" id="nick" placeholder="Your Name" type="text" class="form-control" />
+ </div>
+ <div class="form-group text-center">
+ <input type="submit" class="btn btn-success btn-login-submit" value="Join" />
+ </div>
+ </form>
+ {{end}}
+ </div>
+ <div class="col-md-4">
+ <div id="messagesChart" class="epoch category10"></div>
+ <p>
+ <span style="font-size:20px; color:#1f77b4">◼︎</span> Users<br>
+ <span style="font-size:20px; color:#ff7f0e">◼︎</span> Inbound messages / sec<br>
+ <span style="font-size:20px; color:#2ca02c">◼︎</span> Outbound messages / sec<br>
+ </p>
+ </div>
+ </div>
+ </div>
+ </div>
+ <div class="container">
+ <div class="row">
+ <h2>Realtime server Go stats</h2>
+ <div class="col-md-6">
+ <h3>Memory usage</h3>
+ <p>
+ <div id="heapChart" class="epoch category20c"></div>
+ </p>
+ <p>
+ <span style="font-size:20px; color:#1f77b4">◼︎</span> Heap bytes<br>
+ <span style="font-size:20px; color:#aec7e8">◼︎</span> Stack bytes<br>
+ </p>
+ </div>
+ <div class="col-md-6">
+ <h3>Allocations per second</h3>
+ <p>
+ <div id="mallocsChart" class="epoch category20b"></div>
+ </p>
+ <p>
+ <span style="font-size:20px; color:#393b79">◼︎</span> Mallocs / sec<br>
+ <span style="font-size:20px; color:#5254a3">◼︎</span> Frees / sec<br>
+ </p>
+ </div>
+ </div>
+ <div class="row">
+ <h2>MIT Open Sourced</h2>
+ <ul>
+ <li><a href="https://github.com/gin-gonic/gin/tree/develop/examples/realtime-advanced">This demo website (JS and Go)</a></li>
+ <li><a href="https://github.com/manucorporat/sse">The SSE implementation in Go</a></li>
+ <li><a href="https://github.com/gin-gonic/gin">The Web Framework (Gin)</a></li>
+ </ul>
+ <div class="col-md-6">
+ <script src="/static/prismjs.min.js"></script>
+ <h3>Server-side (Go)</h3>
+ <pre><code class="language-go">func streamRoom(c *gin.Context) {
+ roomid := c.ParamValue("roomid")
+ listener := openListener(roomid)
+ statsTicker := time.NewTicker(1 * time.Second)
+ defer closeListener(roomid, listener)
+ defer statsTicker.Stop()
+
+ c.Stream(func(w io.Writer) bool {
+ select {
+ case msg := <-listener:
+ c.SSEvent("message", msg)
+ case <-statsTicker.C:
+ c.SSEvent("stats", Stats())
+ }
+ return true
+ })
+}</code></pre>
+ </div>
+ <div class="col-md-6">
+ <h3>Client-side (JS)</h3>
+ <pre><code class="language-javascript">function StartSSE(roomid) {
+ var source = new EventSource('/stream/'+roomid);
+ source.addEventListener('message', newChatMessage, false);
+ source.addEventListener('stats', stats, false);
+}</code></pre>
+ </div>
+ </div>
+ <div class="row">
+ <div class="col-md-12">
+ <h3>SSE package</h3>
+ <pre><code class="language-go">import "github.com/manucorporat/sse"
+
+func httpHandler(w http.ResponseWriter, req *http.Request) {
+ // data can be a primitive like a string, an integer or a float
+ sse.Encode(w, sse.Event{
+ Event: "message",
+ Data: "some data\nmore data",
+ })
+
+ // also a complex type, like a map, a struct or a slice
+ sse.Encode(w, sse.Event{
+ Id: "124",
+ Event: "message",
+ Data: map[string]interface{}{
+ "user": "manu",
+ "date": time.Now().Unix(),
+ "content": "hi!",
+ },
+ })
+}</code></pre>
+<pre>event: message
+data: some data\\nmore data
+
+id: 124
+event: message
+data: {"content":"hi!","date":1431540810,"user":"manu"}</pre>
+ </div>
+ </div>
+ <hr>
+ <footer>
+ <p>Created with <span class="glyphicon glyphicon-heart"></span> by <a href="https://github.com/manucorporat">Manu Martinez-Almeida</a></p>
+ </footer>
+ </div>
+ </body>
+</html>
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/resources/static/epoch.min.css b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/resources/static/epoch.min.css
new file mode 100644
index 0000000000000000000000000000000000000000..47a80cdc215070fedc33122a5005649320104ccc
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/resources/static/epoch.min.css
@@ -0,0 +1 @@
+.epoch .axis path,.epoch .axis line{shape-rendering:crispEdges;}.epoch .axis.canvas .tick line{shape-rendering:geometricPrecision;}div#_canvas_css_reference{width:0;height:0;position:absolute;top:-1000px;left:-1000px;}div#_canvas_css_reference svg{position:absolute;width:0;height:0;top:-1000px;left:-1000px;}.epoch{font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;font-size:12pt;}.epoch .axis path,.epoch .axis line{fill:none;stroke:#000;}.epoch .axis .tick text{font-size:9pt;}.epoch .line{fill:none;stroke-width:2px;}.epoch.sparklines .line{stroke-width:1px;}.epoch .area{stroke:none;}.epoch .arc.pie{stroke:#fff;stroke-width:1.5px;}.epoch .arc.pie text{stroke:none;fill:white;font-size:9pt;}.epoch .gauge-labels .value{text-anchor:middle;font-size:140%;fill:#666;}.epoch.gauge-tiny{width:120px;height:90px;}.epoch.gauge-tiny .gauge-labels .value{font-size:80%;}.epoch.gauge-tiny .gauge .arc.outer{stroke-width:2px;}.epoch.gauge-small{width:180px;height:135px;}.epoch.gauge-small .gauge-labels .value{font-size:120%;}.epoch.gauge-small .gauge .arc.outer{stroke-width:3px;}.epoch.gauge-medium{width:240px;height:180px;}.epoch.gauge-medium .gauge .arc.outer{stroke-width:3px;}.epoch.gauge-large{width:320px;height:240px;}.epoch.gauge-large .gauge-labels .value{font-size:180%;}.epoch .gauge .arc.outer{stroke-width:4px;stroke:#666;}.epoch .gauge .arc.inner{stroke-width:1px;stroke:#555;}.epoch .gauge .tick{stroke-width:1px;stroke:#555;}.epoch .gauge .needle{fill:orange;}.epoch .gauge .needle-base{fill:#666;}.epoch div.ref.category1,.epoch.category10 div.ref.category1{background-color:#1f77b4;}.epoch .category1 .line,.epoch.category10 .category1 .line{stroke:#1f77b4;}.epoch .category1 .area,.epoch .category1 .dot,.epoch.category10 .category1 .area,.epoch.category10 .category1 .dot{fill:#1f77b4;stroke:rgba(0, 0, 0, 0);}.epoch .arc.category1 path,.epoch.category10 .arc.category1 path{fill:#1f77b4;}.epoch .bar.category1,.epoch.category10 .bar.category1{fill:#1f77b4;}.epoch div.ref.category2,.epoch.category10 div.ref.category2{background-color:#ff7f0e;}.epoch .category2 .line,.epoch.category10 .category2 .line{stroke:#ff7f0e;}.epoch .category2 .area,.epoch .category2 .dot,.epoch.category10 .category2 .area,.epoch.category10 .category2 .dot{fill:#ff7f0e;stroke:rgba(0, 0, 0, 0);}.epoch .arc.category2 path,.epoch.category10 .arc.category2 path{fill:#ff7f0e;}.epoch .bar.category2,.epoch.category10 .bar.category2{fill:#ff7f0e;}.epoch div.ref.category3,.epoch.category10 div.ref.category3{background-color:#2ca02c;}.epoch .category3 .line,.epoch.category10 .category3 .line{stroke:#2ca02c;}.epoch .category3 .area,.epoch .category3 .dot,.epoch.category10 .category3 .area,.epoch.category10 .category3 .dot{fill:#2ca02c;stroke:rgba(0, 0, 0, 0);}.epoch .arc.category3 path,.epoch.category10 .arc.category3 path{fill:#2ca02c;}.epoch .bar.category3,.epoch.category10 .bar.category3{fill:#2ca02c;}.epoch div.ref.category4,.epoch.category10 div.ref.category4{background-color:#d62728;}.epoch .category4 .line,.epoch.category10 .category4 .line{stroke:#d62728;}.epoch .category4 .area,.epoch .category4 .dot,.epoch.category10 .category4 .area,.epoch.category10 .category4 .dot{fill:#d62728;stroke:rgba(0, 0, 0, 0);}.epoch .arc.category4 path,.epoch.category10 .arc.category4 path{fill:#d62728;}.epoch .bar.category4,.epoch.category10 .bar.category4{fill:#d62728;}.epoch div.ref.category5,.epoch.category10 div.ref.category5{background-color:#9467bd;}.epoch .category5 .line,.epoch.category10 .category5 .line{stroke:#9467bd;}.epoch .category5 .area,.epoch .category5 .dot,.epoch.category10 .category5 .area,.epoch.category10 .category5 .dot{fill:#9467bd;stroke:rgba(0, 0, 0, 0);}.epoch .arc.category5 path,.epoch.category10 .arc.category5 path{fill:#9467bd;}.epoch .bar.category5,.epoch.category10 .bar.category5{fill:#9467bd;}.epoch div.ref.category6,.epoch.category10 div.ref.category6{background-color:#8c564b;}.epoch .category6 .line,.epoch.category10 .category6 .line{stroke:#8c564b;}.epoch .category6 .area,.epoch .category6 .dot,.epoch.category10 .category6 .area,.epoch.category10 .category6 .dot{fill:#8c564b;stroke:rgba(0, 0, 0, 0);}.epoch .arc.category6 path,.epoch.category10 .arc.category6 path{fill:#8c564b;}.epoch .bar.category6,.epoch.category10 .bar.category6{fill:#8c564b;}.epoch div.ref.category7,.epoch.category10 div.ref.category7{background-color:#e377c2;}.epoch .category7 .line,.epoch.category10 .category7 .line{stroke:#e377c2;}.epoch .category7 .area,.epoch .category7 .dot,.epoch.category10 .category7 .area,.epoch.category10 .category7 .dot{fill:#e377c2;stroke:rgba(0, 0, 0, 0);}.epoch .arc.category7 path,.epoch.category10 .arc.category7 path{fill:#e377c2;}.epoch .bar.category7,.epoch.category10 .bar.category7{fill:#e377c2;}.epoch div.ref.category8,.epoch.category10 div.ref.category8{background-color:#7f7f7f;}.epoch .category8 .line,.epoch.category10 .category8 .line{stroke:#7f7f7f;}.epoch .category8 .area,.epoch .category8 .dot,.epoch.category10 .category8 .area,.epoch.category10 .category8 .dot{fill:#7f7f7f;stroke:rgba(0, 0, 0, 0);}.epoch .arc.category8 path,.epoch.category10 .arc.category8 path{fill:#7f7f7f;}.epoch .bar.category8,.epoch.category10 .bar.category8{fill:#7f7f7f;}.epoch div.ref.category9,.epoch.category10 div.ref.category9{background-color:#bcbd22;}.epoch .category9 .line,.epoch.category10 .category9 .line{stroke:#bcbd22;}.epoch .category9 .area,.epoch .category9 .dot,.epoch.category10 .category9 .area,.epoch.category10 .category9 .dot{fill:#bcbd22;stroke:rgba(0, 0, 0, 0);}.epoch .arc.category9 path,.epoch.category10 .arc.category9 path{fill:#bcbd22;}.epoch .bar.category9,.epoch.category10 .bar.category9{fill:#bcbd22;}.epoch div.ref.category10,.epoch.category10 div.ref.category10{background-color:#17becf;}.epoch .category10 .line,.epoch.category10 .category10 .line{stroke:#17becf;}.epoch .category10 .area,.epoch .category10 .dot,.epoch.category10 .category10 .area,.epoch.category10 .category10 .dot{fill:#17becf;stroke:rgba(0, 0, 0, 0);}.epoch .arc.category10 path,.epoch.category10 .arc.category10 path{fill:#17becf;}.epoch .bar.category10,.epoch.category10 .bar.category10{fill:#17becf;}.epoch.category20 div.ref.category1{background-color:#1f77b4;}.epoch.category20 .category1 .line{stroke:#1f77b4;}.epoch.category20 .category1 .area,.epoch.category20 .category1 .dot{fill:#1f77b4;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category1 path{fill:#1f77b4;}.epoch.category20 .bar.category1{fill:#1f77b4;}.epoch.category20 div.ref.category2{background-color:#aec7e8;}.epoch.category20 .category2 .line{stroke:#aec7e8;}.epoch.category20 .category2 .area,.epoch.category20 .category2 .dot{fill:#aec7e8;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category2 path{fill:#aec7e8;}.epoch.category20 .bar.category2{fill:#aec7e8;}.epoch.category20 div.ref.category3{background-color:#ff7f0e;}.epoch.category20 .category3 .line{stroke:#ff7f0e;}.epoch.category20 .category3 .area,.epoch.category20 .category3 .dot{fill:#ff7f0e;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category3 path{fill:#ff7f0e;}.epoch.category20 .bar.category3{fill:#ff7f0e;}.epoch.category20 div.ref.category4{background-color:#ffbb78;}.epoch.category20 .category4 .line{stroke:#ffbb78;}.epoch.category20 .category4 .area,.epoch.category20 .category4 .dot{fill:#ffbb78;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category4 path{fill:#ffbb78;}.epoch.category20 .bar.category4{fill:#ffbb78;}.epoch.category20 div.ref.category5{background-color:#2ca02c;}.epoch.category20 .category5 .line{stroke:#2ca02c;}.epoch.category20 .category5 .area,.epoch.category20 .category5 .dot{fill:#2ca02c;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category5 path{fill:#2ca02c;}.epoch.category20 .bar.category5{fill:#2ca02c;}.epoch.category20 div.ref.category6{background-color:#98df8a;}.epoch.category20 .category6 .line{stroke:#98df8a;}.epoch.category20 .category6 .area,.epoch.category20 .category6 .dot{fill:#98df8a;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category6 path{fill:#98df8a;}.epoch.category20 .bar.category6{fill:#98df8a;}.epoch.category20 div.ref.category7{background-color:#d62728;}.epoch.category20 .category7 .line{stroke:#d62728;}.epoch.category20 .category7 .area,.epoch.category20 .category7 .dot{fill:#d62728;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category7 path{fill:#d62728;}.epoch.category20 .bar.category7{fill:#d62728;}.epoch.category20 div.ref.category8{background-color:#ff9896;}.epoch.category20 .category8 .line{stroke:#ff9896;}.epoch.category20 .category8 .area,.epoch.category20 .category8 .dot{fill:#ff9896;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category8 path{fill:#ff9896;}.epoch.category20 .bar.category8{fill:#ff9896;}.epoch.category20 div.ref.category9{background-color:#9467bd;}.epoch.category20 .category9 .line{stroke:#9467bd;}.epoch.category20 .category9 .area,.epoch.category20 .category9 .dot{fill:#9467bd;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category9 path{fill:#9467bd;}.epoch.category20 .bar.category9{fill:#9467bd;}.epoch.category20 div.ref.category10{background-color:#c5b0d5;}.epoch.category20 .category10 .line{stroke:#c5b0d5;}.epoch.category20 .category10 .area,.epoch.category20 .category10 .dot{fill:#c5b0d5;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category10 path{fill:#c5b0d5;}.epoch.category20 .bar.category10{fill:#c5b0d5;}.epoch.category20 div.ref.category11{background-color:#8c564b;}.epoch.category20 .category11 .line{stroke:#8c564b;}.epoch.category20 .category11 .area,.epoch.category20 .category11 .dot{fill:#8c564b;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category11 path{fill:#8c564b;}.epoch.category20 .bar.category11{fill:#8c564b;}.epoch.category20 div.ref.category12{background-color:#c49c94;}.epoch.category20 .category12 .line{stroke:#c49c94;}.epoch.category20 .category12 .area,.epoch.category20 .category12 .dot{fill:#c49c94;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category12 path{fill:#c49c94;}.epoch.category20 .bar.category12{fill:#c49c94;}.epoch.category20 div.ref.category13{background-color:#e377c2;}.epoch.category20 .category13 .line{stroke:#e377c2;}.epoch.category20 .category13 .area,.epoch.category20 .category13 .dot{fill:#e377c2;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category13 path{fill:#e377c2;}.epoch.category20 .bar.category13{fill:#e377c2;}.epoch.category20 div.ref.category14{background-color:#f7b6d2;}.epoch.category20 .category14 .line{stroke:#f7b6d2;}.epoch.category20 .category14 .area,.epoch.category20 .category14 .dot{fill:#f7b6d2;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category14 path{fill:#f7b6d2;}.epoch.category20 .bar.category14{fill:#f7b6d2;}.epoch.category20 div.ref.category15{background-color:#7f7f7f;}.epoch.category20 .category15 .line{stroke:#7f7f7f;}.epoch.category20 .category15 .area,.epoch.category20 .category15 .dot{fill:#7f7f7f;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category15 path{fill:#7f7f7f;}.epoch.category20 .bar.category15{fill:#7f7f7f;}.epoch.category20 div.ref.category16{background-color:#c7c7c7;}.epoch.category20 .category16 .line{stroke:#c7c7c7;}.epoch.category20 .category16 .area,.epoch.category20 .category16 .dot{fill:#c7c7c7;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category16 path{fill:#c7c7c7;}.epoch.category20 .bar.category16{fill:#c7c7c7;}.epoch.category20 div.ref.category17{background-color:#bcbd22;}.epoch.category20 .category17 .line{stroke:#bcbd22;}.epoch.category20 .category17 .area,.epoch.category20 .category17 .dot{fill:#bcbd22;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category17 path{fill:#bcbd22;}.epoch.category20 .bar.category17{fill:#bcbd22;}.epoch.category20 div.ref.category18{background-color:#dbdb8d;}.epoch.category20 .category18 .line{stroke:#dbdb8d;}.epoch.category20 .category18 .area,.epoch.category20 .category18 .dot{fill:#dbdb8d;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category18 path{fill:#dbdb8d;}.epoch.category20 .bar.category18{fill:#dbdb8d;}.epoch.category20 div.ref.category19{background-color:#17becf;}.epoch.category20 .category19 .line{stroke:#17becf;}.epoch.category20 .category19 .area,.epoch.category20 .category19 .dot{fill:#17becf;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category19 path{fill:#17becf;}.epoch.category20 .bar.category19{fill:#17becf;}.epoch.category20 div.ref.category20{background-color:#9edae5;}.epoch.category20 .category20 .line{stroke:#9edae5;}.epoch.category20 .category20 .area,.epoch.category20 .category20 .dot{fill:#9edae5;stroke:rgba(0, 0, 0, 0);}.epoch.category20 .arc.category20 path{fill:#9edae5;}.epoch.category20 .bar.category20{fill:#9edae5;}.epoch.category20b div.ref.category1{background-color:#393b79;}.epoch.category20b .category1 .line{stroke:#393b79;}.epoch.category20b .category1 .area,.epoch.category20b .category1 .dot{fill:#393b79;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category1 path{fill:#393b79;}.epoch.category20b .bar.category1{fill:#393b79;}.epoch.category20b div.ref.category2{background-color:#5254a3;}.epoch.category20b .category2 .line{stroke:#5254a3;}.epoch.category20b .category2 .area,.epoch.category20b .category2 .dot{fill:#5254a3;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category2 path{fill:#5254a3;}.epoch.category20b .bar.category2{fill:#5254a3;}.epoch.category20b div.ref.category3{background-color:#6b6ecf;}.epoch.category20b .category3 .line{stroke:#6b6ecf;}.epoch.category20b .category3 .area,.epoch.category20b .category3 .dot{fill:#6b6ecf;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category3 path{fill:#6b6ecf;}.epoch.category20b .bar.category3{fill:#6b6ecf;}.epoch.category20b div.ref.category4{background-color:#9c9ede;}.epoch.category20b .category4 .line{stroke:#9c9ede;}.epoch.category20b .category4 .area,.epoch.category20b .category4 .dot{fill:#9c9ede;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category4 path{fill:#9c9ede;}.epoch.category20b .bar.category4{fill:#9c9ede;}.epoch.category20b div.ref.category5{background-color:#637939;}.epoch.category20b .category5 .line{stroke:#637939;}.epoch.category20b .category5 .area,.epoch.category20b .category5 .dot{fill:#637939;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category5 path{fill:#637939;}.epoch.category20b .bar.category5{fill:#637939;}.epoch.category20b div.ref.category6{background-color:#8ca252;}.epoch.category20b .category6 .line{stroke:#8ca252;}.epoch.category20b .category6 .area,.epoch.category20b .category6 .dot{fill:#8ca252;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category6 path{fill:#8ca252;}.epoch.category20b .bar.category6{fill:#8ca252;}.epoch.category20b div.ref.category7{background-color:#b5cf6b;}.epoch.category20b .category7 .line{stroke:#b5cf6b;}.epoch.category20b .category7 .area,.epoch.category20b .category7 .dot{fill:#b5cf6b;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category7 path{fill:#b5cf6b;}.epoch.category20b .bar.category7{fill:#b5cf6b;}.epoch.category20b div.ref.category8{background-color:#cedb9c;}.epoch.category20b .category8 .line{stroke:#cedb9c;}.epoch.category20b .category8 .area,.epoch.category20b .category8 .dot{fill:#cedb9c;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category8 path{fill:#cedb9c;}.epoch.category20b .bar.category8{fill:#cedb9c;}.epoch.category20b div.ref.category9{background-color:#8c6d31;}.epoch.category20b .category9 .line{stroke:#8c6d31;}.epoch.category20b .category9 .area,.epoch.category20b .category9 .dot{fill:#8c6d31;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category9 path{fill:#8c6d31;}.epoch.category20b .bar.category9{fill:#8c6d31;}.epoch.category20b div.ref.category10{background-color:#bd9e39;}.epoch.category20b .category10 .line{stroke:#bd9e39;}.epoch.category20b .category10 .area,.epoch.category20b .category10 .dot{fill:#bd9e39;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category10 path{fill:#bd9e39;}.epoch.category20b .bar.category10{fill:#bd9e39;}.epoch.category20b div.ref.category11{background-color:#e7ba52;}.epoch.category20b .category11 .line{stroke:#e7ba52;}.epoch.category20b .category11 .area,.epoch.category20b .category11 .dot{fill:#e7ba52;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category11 path{fill:#e7ba52;}.epoch.category20b .bar.category11{fill:#e7ba52;}.epoch.category20b div.ref.category12{background-color:#e7cb94;}.epoch.category20b .category12 .line{stroke:#e7cb94;}.epoch.category20b .category12 .area,.epoch.category20b .category12 .dot{fill:#e7cb94;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category12 path{fill:#e7cb94;}.epoch.category20b .bar.category12{fill:#e7cb94;}.epoch.category20b div.ref.category13{background-color:#843c39;}.epoch.category20b .category13 .line{stroke:#843c39;}.epoch.category20b .category13 .area,.epoch.category20b .category13 .dot{fill:#843c39;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category13 path{fill:#843c39;}.epoch.category20b .bar.category13{fill:#843c39;}.epoch.category20b div.ref.category14{background-color:#ad494a;}.epoch.category20b .category14 .line{stroke:#ad494a;}.epoch.category20b .category14 .area,.epoch.category20b .category14 .dot{fill:#ad494a;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category14 path{fill:#ad494a;}.epoch.category20b .bar.category14{fill:#ad494a;}.epoch.category20b div.ref.category15{background-color:#d6616b;}.epoch.category20b .category15 .line{stroke:#d6616b;}.epoch.category20b .category15 .area,.epoch.category20b .category15 .dot{fill:#d6616b;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category15 path{fill:#d6616b;}.epoch.category20b .bar.category15{fill:#d6616b;}.epoch.category20b div.ref.category16{background-color:#e7969c;}.epoch.category20b .category16 .line{stroke:#e7969c;}.epoch.category20b .category16 .area,.epoch.category20b .category16 .dot{fill:#e7969c;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category16 path{fill:#e7969c;}.epoch.category20b .bar.category16{fill:#e7969c;}.epoch.category20b div.ref.category17{background-color:#7b4173;}.epoch.category20b .category17 .line{stroke:#7b4173;}.epoch.category20b .category17 .area,.epoch.category20b .category17 .dot{fill:#7b4173;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category17 path{fill:#7b4173;}.epoch.category20b .bar.category17{fill:#7b4173;}.epoch.category20b div.ref.category18{background-color:#a55194;}.epoch.category20b .category18 .line{stroke:#a55194;}.epoch.category20b .category18 .area,.epoch.category20b .category18 .dot{fill:#a55194;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category18 path{fill:#a55194;}.epoch.category20b .bar.category18{fill:#a55194;}.epoch.category20b div.ref.category19{background-color:#ce6dbd;}.epoch.category20b .category19 .line{stroke:#ce6dbd;}.epoch.category20b .category19 .area,.epoch.category20b .category19 .dot{fill:#ce6dbd;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category19 path{fill:#ce6dbd;}.epoch.category20b .bar.category19{fill:#ce6dbd;}.epoch.category20b div.ref.category20{background-color:#de9ed6;}.epoch.category20b .category20 .line{stroke:#de9ed6;}.epoch.category20b .category20 .area,.epoch.category20b .category20 .dot{fill:#de9ed6;stroke:rgba(0, 0, 0, 0);}.epoch.category20b .arc.category20 path{fill:#de9ed6;}.epoch.category20b .bar.category20{fill:#de9ed6;}.epoch.category20c div.ref.category1{background-color:#3182bd;}.epoch.category20c .category1 .line{stroke:#3182bd;}.epoch.category20c .category1 .area,.epoch.category20c .category1 .dot{fill:#3182bd;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category1 path{fill:#3182bd;}.epoch.category20c .bar.category1{fill:#3182bd;}.epoch.category20c div.ref.category2{background-color:#6baed6;}.epoch.category20c .category2 .line{stroke:#6baed6;}.epoch.category20c .category2 .area,.epoch.category20c .category2 .dot{fill:#6baed6;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category2 path{fill:#6baed6;}.epoch.category20c .bar.category2{fill:#6baed6;}.epoch.category20c div.ref.category3{background-color:#9ecae1;}.epoch.category20c .category3 .line{stroke:#9ecae1;}.epoch.category20c .category3 .area,.epoch.category20c .category3 .dot{fill:#9ecae1;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category3 path{fill:#9ecae1;}.epoch.category20c .bar.category3{fill:#9ecae1;}.epoch.category20c div.ref.category4{background-color:#c6dbef;}.epoch.category20c .category4 .line{stroke:#c6dbef;}.epoch.category20c .category4 .area,.epoch.category20c .category4 .dot{fill:#c6dbef;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category4 path{fill:#c6dbef;}.epoch.category20c .bar.category4{fill:#c6dbef;}.epoch.category20c div.ref.category5{background-color:#e6550d;}.epoch.category20c .category5 .line{stroke:#e6550d;}.epoch.category20c .category5 .area,.epoch.category20c .category5 .dot{fill:#e6550d;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category5 path{fill:#e6550d;}.epoch.category20c .bar.category5{fill:#e6550d;}.epoch.category20c div.ref.category6{background-color:#fd8d3c;}.epoch.category20c .category6 .line{stroke:#fd8d3c;}.epoch.category20c .category6 .area,.epoch.category20c .category6 .dot{fill:#fd8d3c;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category6 path{fill:#fd8d3c;}.epoch.category20c .bar.category6{fill:#fd8d3c;}.epoch.category20c div.ref.category7{background-color:#fdae6b;}.epoch.category20c .category7 .line{stroke:#fdae6b;}.epoch.category20c .category7 .area,.epoch.category20c .category7 .dot{fill:#fdae6b;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category7 path{fill:#fdae6b;}.epoch.category20c .bar.category7{fill:#fdae6b;}.epoch.category20c div.ref.category8{background-color:#fdd0a2;}.epoch.category20c .category8 .line{stroke:#fdd0a2;}.epoch.category20c .category8 .area,.epoch.category20c .category8 .dot{fill:#fdd0a2;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category8 path{fill:#fdd0a2;}.epoch.category20c .bar.category8{fill:#fdd0a2;}.epoch.category20c div.ref.category9{background-color:#31a354;}.epoch.category20c .category9 .line{stroke:#31a354;}.epoch.category20c .category9 .area,.epoch.category20c .category9 .dot{fill:#31a354;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category9 path{fill:#31a354;}.epoch.category20c .bar.category9{fill:#31a354;}.epoch.category20c div.ref.category10{background-color:#74c476;}.epoch.category20c .category10 .line{stroke:#74c476;}.epoch.category20c .category10 .area,.epoch.category20c .category10 .dot{fill:#74c476;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category10 path{fill:#74c476;}.epoch.category20c .bar.category10{fill:#74c476;}.epoch.category20c div.ref.category11{background-color:#a1d99b;}.epoch.category20c .category11 .line{stroke:#a1d99b;}.epoch.category20c .category11 .area,.epoch.category20c .category11 .dot{fill:#a1d99b;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category11 path{fill:#a1d99b;}.epoch.category20c .bar.category11{fill:#a1d99b;}.epoch.category20c div.ref.category12{background-color:#c7e9c0;}.epoch.category20c .category12 .line{stroke:#c7e9c0;}.epoch.category20c .category12 .area,.epoch.category20c .category12 .dot{fill:#c7e9c0;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category12 path{fill:#c7e9c0;}.epoch.category20c .bar.category12{fill:#c7e9c0;}.epoch.category20c div.ref.category13{background-color:#756bb1;}.epoch.category20c .category13 .line{stroke:#756bb1;}.epoch.category20c .category13 .area,.epoch.category20c .category13 .dot{fill:#756bb1;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category13 path{fill:#756bb1;}.epoch.category20c .bar.category13{fill:#756bb1;}.epoch.category20c div.ref.category14{background-color:#9e9ac8;}.epoch.category20c .category14 .line{stroke:#9e9ac8;}.epoch.category20c .category14 .area,.epoch.category20c .category14 .dot{fill:#9e9ac8;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category14 path{fill:#9e9ac8;}.epoch.category20c .bar.category14{fill:#9e9ac8;}.epoch.category20c div.ref.category15{background-color:#bcbddc;}.epoch.category20c .category15 .line{stroke:#bcbddc;}.epoch.category20c .category15 .area,.epoch.category20c .category15 .dot{fill:#bcbddc;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category15 path{fill:#bcbddc;}.epoch.category20c .bar.category15{fill:#bcbddc;}.epoch.category20c div.ref.category16{background-color:#dadaeb;}.epoch.category20c .category16 .line{stroke:#dadaeb;}.epoch.category20c .category16 .area,.epoch.category20c .category16 .dot{fill:#dadaeb;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category16 path{fill:#dadaeb;}.epoch.category20c .bar.category16{fill:#dadaeb;}.epoch.category20c div.ref.category17{background-color:#636363;}.epoch.category20c .category17 .line{stroke:#636363;}.epoch.category20c .category17 .area,.epoch.category20c .category17 .dot{fill:#636363;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category17 path{fill:#636363;}.epoch.category20c .bar.category17{fill:#636363;}.epoch.category20c div.ref.category18{background-color:#969696;}.epoch.category20c .category18 .line{stroke:#969696;}.epoch.category20c .category18 .area,.epoch.category20c .category18 .dot{fill:#969696;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category18 path{fill:#969696;}.epoch.category20c .bar.category18{fill:#969696;}.epoch.category20c div.ref.category19{background-color:#bdbdbd;}.epoch.category20c .category19 .line{stroke:#bdbdbd;}.epoch.category20c .category19 .area,.epoch.category20c .category19 .dot{fill:#bdbdbd;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category19 path{fill:#bdbdbd;}.epoch.category20c .bar.category19{fill:#bdbdbd;}.epoch.category20c div.ref.category20{background-color:#d9d9d9;}.epoch.category20c .category20 .line{stroke:#d9d9d9;}.epoch.category20c .category20 .area,.epoch.category20c .category20 .dot{fill:#d9d9d9;stroke:rgba(0, 0, 0, 0);}.epoch.category20c .arc.category20 path{fill:#d9d9d9;}.epoch.category20c .bar.category20{fill:#d9d9d9;}.epoch .category1 .bucket,.epoch.heatmap5 .category1 .bucket{fill:#1f77b4;}.epoch .category2 .bucket,.epoch.heatmap5 .category2 .bucket{fill:#2ca02c;}.epoch .category3 .bucket,.epoch.heatmap5 .category3 .bucket{fill:#d62728;}.epoch .category4 .bucket,.epoch.heatmap5 .category4 .bucket{fill:#8c564b;}.epoch .category5 .bucket,.epoch.heatmap5 .category5 .bucket{fill:#7f7f7f;}.epoch-theme-dark .epoch .axis path,.epoch-theme-dark .epoch .axis line{stroke:#d0d0d0;}.epoch-theme-dark .epoch .axis .tick text{fill:#d0d0d0;}.epoch-theme-dark .arc.pie{stroke:#333;}.epoch-theme-dark .arc.pie text{fill:#333;}.epoch-theme-dark .epoch .gauge-labels .value{fill:#BBB;}.epoch-theme-dark .epoch .gauge .arc.outer{stroke:#999;}.epoch-theme-dark .epoch .gauge .arc.inner{stroke:#AAA;}.epoch-theme-dark .epoch .gauge .tick{stroke:#AAA;}.epoch-theme-dark .epoch .gauge .needle{fill:#F3DE88;}.epoch-theme-dark .epoch .gauge .needle-base{fill:#999;}.epoch-theme-dark .epoch div.ref.category1,.epoch-theme-dark .epoch.category10 div.ref.category1{background-color:#909CFF;}.epoch-theme-dark .epoch .category1 .line,.epoch-theme-dark .epoch.category10 .category1 .line{stroke:#909CFF;}.epoch-theme-dark .epoch .category1 .area,.epoch-theme-dark .epoch .category1 .dot,.epoch-theme-dark .epoch.category10 .category1 .area,.epoch-theme-dark .epoch.category10 .category1 .dot{fill:#909CFF;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch .arc.category1 path,.epoch-theme-dark .epoch.category10 .arc.category1 path{fill:#909CFF;}.epoch-theme-dark .epoch .bar.category1,.epoch-theme-dark .epoch.category10 .bar.category1{fill:#909CFF;}.epoch-theme-dark .epoch div.ref.category2,.epoch-theme-dark .epoch.category10 div.ref.category2{background-color:#FFAC89;}.epoch-theme-dark .epoch .category2 .line,.epoch-theme-dark .epoch.category10 .category2 .line{stroke:#FFAC89;}.epoch-theme-dark .epoch .category2 .area,.epoch-theme-dark .epoch .category2 .dot,.epoch-theme-dark .epoch.category10 .category2 .area,.epoch-theme-dark .epoch.category10 .category2 .dot{fill:#FFAC89;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch .arc.category2 path,.epoch-theme-dark .epoch.category10 .arc.category2 path{fill:#FFAC89;}.epoch-theme-dark .epoch .bar.category2,.epoch-theme-dark .epoch.category10 .bar.category2{fill:#FFAC89;}.epoch-theme-dark .epoch div.ref.category3,.epoch-theme-dark .epoch.category10 div.ref.category3{background-color:#E889E8;}.epoch-theme-dark .epoch .category3 .line,.epoch-theme-dark .epoch.category10 .category3 .line{stroke:#E889E8;}.epoch-theme-dark .epoch .category3 .area,.epoch-theme-dark .epoch .category3 .dot,.epoch-theme-dark .epoch.category10 .category3 .area,.epoch-theme-dark .epoch.category10 .category3 .dot{fill:#E889E8;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch .arc.category3 path,.epoch-theme-dark .epoch.category10 .arc.category3 path{fill:#E889E8;}.epoch-theme-dark .epoch .bar.category3,.epoch-theme-dark .epoch.category10 .bar.category3{fill:#E889E8;}.epoch-theme-dark .epoch div.ref.category4,.epoch-theme-dark .epoch.category10 div.ref.category4{background-color:#78E8D3;}.epoch-theme-dark .epoch .category4 .line,.epoch-theme-dark .epoch.category10 .category4 .line{stroke:#78E8D3;}.epoch-theme-dark .epoch .category4 .area,.epoch-theme-dark .epoch .category4 .dot,.epoch-theme-dark .epoch.category10 .category4 .area,.epoch-theme-dark .epoch.category10 .category4 .dot{fill:#78E8D3;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch .arc.category4 path,.epoch-theme-dark .epoch.category10 .arc.category4 path{fill:#78E8D3;}.epoch-theme-dark .epoch .bar.category4,.epoch-theme-dark .epoch.category10 .bar.category4{fill:#78E8D3;}.epoch-theme-dark .epoch div.ref.category5,.epoch-theme-dark .epoch.category10 div.ref.category5{background-color:#C2FF97;}.epoch-theme-dark .epoch .category5 .line,.epoch-theme-dark .epoch.category10 .category5 .line{stroke:#C2FF97;}.epoch-theme-dark .epoch .category5 .area,.epoch-theme-dark .epoch .category5 .dot,.epoch-theme-dark .epoch.category10 .category5 .area,.epoch-theme-dark .epoch.category10 .category5 .dot{fill:#C2FF97;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch .arc.category5 path,.epoch-theme-dark .epoch.category10 .arc.category5 path{fill:#C2FF97;}.epoch-theme-dark .epoch .bar.category5,.epoch-theme-dark .epoch.category10 .bar.category5{fill:#C2FF97;}.epoch-theme-dark .epoch div.ref.category6,.epoch-theme-dark .epoch.category10 div.ref.category6{background-color:#B7BCD1;}.epoch-theme-dark .epoch .category6 .line,.epoch-theme-dark .epoch.category10 .category6 .line{stroke:#B7BCD1;}.epoch-theme-dark .epoch .category6 .area,.epoch-theme-dark .epoch .category6 .dot,.epoch-theme-dark .epoch.category10 .category6 .area,.epoch-theme-dark .epoch.category10 .category6 .dot{fill:#B7BCD1;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch .arc.category6 path,.epoch-theme-dark .epoch.category10 .arc.category6 path{fill:#B7BCD1;}.epoch-theme-dark .epoch .bar.category6,.epoch-theme-dark .epoch.category10 .bar.category6{fill:#B7BCD1;}.epoch-theme-dark .epoch div.ref.category7,.epoch-theme-dark .epoch.category10 div.ref.category7{background-color:#FF857F;}.epoch-theme-dark .epoch .category7 .line,.epoch-theme-dark .epoch.category10 .category7 .line{stroke:#FF857F;}.epoch-theme-dark .epoch .category7 .area,.epoch-theme-dark .epoch .category7 .dot,.epoch-theme-dark .epoch.category10 .category7 .area,.epoch-theme-dark .epoch.category10 .category7 .dot{fill:#FF857F;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch .arc.category7 path,.epoch-theme-dark .epoch.category10 .arc.category7 path{fill:#FF857F;}.epoch-theme-dark .epoch .bar.category7,.epoch-theme-dark .epoch.category10 .bar.category7{fill:#FF857F;}.epoch-theme-dark .epoch div.ref.category8,.epoch-theme-dark .epoch.category10 div.ref.category8{background-color:#F3DE88;}.epoch-theme-dark .epoch .category8 .line,.epoch-theme-dark .epoch.category10 .category8 .line{stroke:#F3DE88;}.epoch-theme-dark .epoch .category8 .area,.epoch-theme-dark .epoch .category8 .dot,.epoch-theme-dark .epoch.category10 .category8 .area,.epoch-theme-dark .epoch.category10 .category8 .dot{fill:#F3DE88;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch .arc.category8 path,.epoch-theme-dark .epoch.category10 .arc.category8 path{fill:#F3DE88;}.epoch-theme-dark .epoch .bar.category8,.epoch-theme-dark .epoch.category10 .bar.category8{fill:#F3DE88;}.epoch-theme-dark .epoch div.ref.category9,.epoch-theme-dark .epoch.category10 div.ref.category9{background-color:#C9935E;}.epoch-theme-dark .epoch .category9 .line,.epoch-theme-dark .epoch.category10 .category9 .line{stroke:#C9935E;}.epoch-theme-dark .epoch .category9 .area,.epoch-theme-dark .epoch .category9 .dot,.epoch-theme-dark .epoch.category10 .category9 .area,.epoch-theme-dark .epoch.category10 .category9 .dot{fill:#C9935E;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch .arc.category9 path,.epoch-theme-dark .epoch.category10 .arc.category9 path{fill:#C9935E;}.epoch-theme-dark .epoch .bar.category9,.epoch-theme-dark .epoch.category10 .bar.category9{fill:#C9935E;}.epoch-theme-dark .epoch div.ref.category10,.epoch-theme-dark .epoch.category10 div.ref.category10{background-color:#A488FF;}.epoch-theme-dark .epoch .category10 .line,.epoch-theme-dark .epoch.category10 .category10 .line{stroke:#A488FF;}.epoch-theme-dark .epoch .category10 .area,.epoch-theme-dark .epoch .category10 .dot,.epoch-theme-dark .epoch.category10 .category10 .area,.epoch-theme-dark .epoch.category10 .category10 .dot{fill:#A488FF;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch .arc.category10 path,.epoch-theme-dark .epoch.category10 .arc.category10 path{fill:#A488FF;}.epoch-theme-dark .epoch .bar.category10,.epoch-theme-dark .epoch.category10 .bar.category10{fill:#A488FF;}.epoch-theme-dark .epoch.category20 div.ref.category1{background-color:#909CFF;}.epoch-theme-dark .epoch.category20 .category1 .line{stroke:#909CFF;}.epoch-theme-dark .epoch.category20 .category1 .area,.epoch-theme-dark .epoch.category20 .category1 .dot{fill:#909CFF;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category1 path{fill:#909CFF;}.epoch-theme-dark .epoch.category20 .bar.category1{fill:#909CFF;}.epoch-theme-dark .epoch.category20 div.ref.category2{background-color:#626AAD;}.epoch-theme-dark .epoch.category20 .category2 .line{stroke:#626AAD;}.epoch-theme-dark .epoch.category20 .category2 .area,.epoch-theme-dark .epoch.category20 .category2 .dot{fill:#626AAD;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category2 path{fill:#626AAD;}.epoch-theme-dark .epoch.category20 .bar.category2{fill:#626AAD;}.epoch-theme-dark .epoch.category20 div.ref.category3{background-color:#FFAC89;}.epoch-theme-dark .epoch.category20 .category3 .line{stroke:#FFAC89;}.epoch-theme-dark .epoch.category20 .category3 .area,.epoch-theme-dark .epoch.category20 .category3 .dot{fill:#FFAC89;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category3 path{fill:#FFAC89;}.epoch-theme-dark .epoch.category20 .bar.category3{fill:#FFAC89;}.epoch-theme-dark .epoch.category20 div.ref.category4{background-color:#BD7F66;}.epoch-theme-dark .epoch.category20 .category4 .line{stroke:#BD7F66;}.epoch-theme-dark .epoch.category20 .category4 .area,.epoch-theme-dark .epoch.category20 .category4 .dot{fill:#BD7F66;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category4 path{fill:#BD7F66;}.epoch-theme-dark .epoch.category20 .bar.category4{fill:#BD7F66;}.epoch-theme-dark .epoch.category20 div.ref.category5{background-color:#E889E8;}.epoch-theme-dark .epoch.category20 .category5 .line{stroke:#E889E8;}.epoch-theme-dark .epoch.category20 .category5 .area,.epoch-theme-dark .epoch.category20 .category5 .dot{fill:#E889E8;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category5 path{fill:#E889E8;}.epoch-theme-dark .epoch.category20 .bar.category5{fill:#E889E8;}.epoch-theme-dark .epoch.category20 div.ref.category6{background-color:#995A99;}.epoch-theme-dark .epoch.category20 .category6 .line{stroke:#995A99;}.epoch-theme-dark .epoch.category20 .category6 .area,.epoch-theme-dark .epoch.category20 .category6 .dot{fill:#995A99;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category6 path{fill:#995A99;}.epoch-theme-dark .epoch.category20 .bar.category6{fill:#995A99;}.epoch-theme-dark .epoch.category20 div.ref.category7{background-color:#78E8D3;}.epoch-theme-dark .epoch.category20 .category7 .line{stroke:#78E8D3;}.epoch-theme-dark .epoch.category20 .category7 .area,.epoch-theme-dark .epoch.category20 .category7 .dot{fill:#78E8D3;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category7 path{fill:#78E8D3;}.epoch-theme-dark .epoch.category20 .bar.category7{fill:#78E8D3;}.epoch-theme-dark .epoch.category20 div.ref.category8{background-color:#4F998C;}.epoch-theme-dark .epoch.category20 .category8 .line{stroke:#4F998C;}.epoch-theme-dark .epoch.category20 .category8 .area,.epoch-theme-dark .epoch.category20 .category8 .dot{fill:#4F998C;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category8 path{fill:#4F998C;}.epoch-theme-dark .epoch.category20 .bar.category8{fill:#4F998C;}.epoch-theme-dark .epoch.category20 div.ref.category9{background-color:#C2FF97;}.epoch-theme-dark .epoch.category20 .category9 .line{stroke:#C2FF97;}.epoch-theme-dark .epoch.category20 .category9 .area,.epoch-theme-dark .epoch.category20 .category9 .dot{fill:#C2FF97;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category9 path{fill:#C2FF97;}.epoch-theme-dark .epoch.category20 .bar.category9{fill:#C2FF97;}.epoch-theme-dark .epoch.category20 div.ref.category10{background-color:#789E5E;}.epoch-theme-dark .epoch.category20 .category10 .line{stroke:#789E5E;}.epoch-theme-dark .epoch.category20 .category10 .area,.epoch-theme-dark .epoch.category20 .category10 .dot{fill:#789E5E;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category10 path{fill:#789E5E;}.epoch-theme-dark .epoch.category20 .bar.category10{fill:#789E5E;}.epoch-theme-dark .epoch.category20 div.ref.category11{background-color:#B7BCD1;}.epoch-theme-dark .epoch.category20 .category11 .line{stroke:#B7BCD1;}.epoch-theme-dark .epoch.category20 .category11 .area,.epoch-theme-dark .epoch.category20 .category11 .dot{fill:#B7BCD1;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category11 path{fill:#B7BCD1;}.epoch-theme-dark .epoch.category20 .bar.category11{fill:#B7BCD1;}.epoch-theme-dark .epoch.category20 div.ref.category12{background-color:#7F8391;}.epoch-theme-dark .epoch.category20 .category12 .line{stroke:#7F8391;}.epoch-theme-dark .epoch.category20 .category12 .area,.epoch-theme-dark .epoch.category20 .category12 .dot{fill:#7F8391;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category12 path{fill:#7F8391;}.epoch-theme-dark .epoch.category20 .bar.category12{fill:#7F8391;}.epoch-theme-dark .epoch.category20 div.ref.category13{background-color:#CCB889;}.epoch-theme-dark .epoch.category20 .category13 .line{stroke:#CCB889;}.epoch-theme-dark .epoch.category20 .category13 .area,.epoch-theme-dark .epoch.category20 .category13 .dot{fill:#CCB889;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category13 path{fill:#CCB889;}.epoch-theme-dark .epoch.category20 .bar.category13{fill:#CCB889;}.epoch-theme-dark .epoch.category20 div.ref.category14{background-color:#A1906B;}.epoch-theme-dark .epoch.category20 .category14 .line{stroke:#A1906B;}.epoch-theme-dark .epoch.category20 .category14 .area,.epoch-theme-dark .epoch.category20 .category14 .dot{fill:#A1906B;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category14 path{fill:#A1906B;}.epoch-theme-dark .epoch.category20 .bar.category14{fill:#A1906B;}.epoch-theme-dark .epoch.category20 div.ref.category15{background-color:#F3DE88;}.epoch-theme-dark .epoch.category20 .category15 .line{stroke:#F3DE88;}.epoch-theme-dark .epoch.category20 .category15 .area,.epoch-theme-dark .epoch.category20 .category15 .dot{fill:#F3DE88;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category15 path{fill:#F3DE88;}.epoch-theme-dark .epoch.category20 .bar.category15{fill:#F3DE88;}.epoch-theme-dark .epoch.category20 div.ref.category16{background-color:#A89A5E;}.epoch-theme-dark .epoch.category20 .category16 .line{stroke:#A89A5E;}.epoch-theme-dark .epoch.category20 .category16 .area,.epoch-theme-dark .epoch.category20 .category16 .dot{fill:#A89A5E;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category16 path{fill:#A89A5E;}.epoch-theme-dark .epoch.category20 .bar.category16{fill:#A89A5E;}.epoch-theme-dark .epoch.category20 div.ref.category17{background-color:#FF857F;}.epoch-theme-dark .epoch.category20 .category17 .line{stroke:#FF857F;}.epoch-theme-dark .epoch.category20 .category17 .area,.epoch-theme-dark .epoch.category20 .category17 .dot{fill:#FF857F;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category17 path{fill:#FF857F;}.epoch-theme-dark .epoch.category20 .bar.category17{fill:#FF857F;}.epoch-theme-dark .epoch.category20 div.ref.category18{background-color:#BA615D;}.epoch-theme-dark .epoch.category20 .category18 .line{stroke:#BA615D;}.epoch-theme-dark .epoch.category20 .category18 .area,.epoch-theme-dark .epoch.category20 .category18 .dot{fill:#BA615D;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category18 path{fill:#BA615D;}.epoch-theme-dark .epoch.category20 .bar.category18{fill:#BA615D;}.epoch-theme-dark .epoch.category20 div.ref.category19{background-color:#A488FF;}.epoch-theme-dark .epoch.category20 .category19 .line{stroke:#A488FF;}.epoch-theme-dark .epoch.category20 .category19 .area,.epoch-theme-dark .epoch.category20 .category19 .dot{fill:#A488FF;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category19 path{fill:#A488FF;}.epoch-theme-dark .epoch.category20 .bar.category19{fill:#A488FF;}.epoch-theme-dark .epoch.category20 div.ref.category20{background-color:#7662B8;}.epoch-theme-dark .epoch.category20 .category20 .line{stroke:#7662B8;}.epoch-theme-dark .epoch.category20 .category20 .area,.epoch-theme-dark .epoch.category20 .category20 .dot{fill:#7662B8;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20 .arc.category20 path{fill:#7662B8;}.epoch-theme-dark .epoch.category20 .bar.category20{fill:#7662B8;}.epoch-theme-dark .epoch.category20b div.ref.category1{background-color:#909CFF;}.epoch-theme-dark .epoch.category20b .category1 .line{stroke:#909CFF;}.epoch-theme-dark .epoch.category20b .category1 .area,.epoch-theme-dark .epoch.category20b .category1 .dot{fill:#909CFF;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category1 path{fill:#909CFF;}.epoch-theme-dark .epoch.category20b .bar.category1{fill:#909CFF;}.epoch-theme-dark .epoch.category20b div.ref.category2{background-color:#7680D1;}.epoch-theme-dark .epoch.category20b .category2 .line{stroke:#7680D1;}.epoch-theme-dark .epoch.category20b .category2 .area,.epoch-theme-dark .epoch.category20b .category2 .dot{fill:#7680D1;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category2 path{fill:#7680D1;}.epoch-theme-dark .epoch.category20b .bar.category2{fill:#7680D1;}.epoch-theme-dark .epoch.category20b div.ref.category3{background-color:#656DB2;}.epoch-theme-dark .epoch.category20b .category3 .line{stroke:#656DB2;}.epoch-theme-dark .epoch.category20b .category3 .area,.epoch-theme-dark .epoch.category20b .category3 .dot{fill:#656DB2;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category3 path{fill:#656DB2;}.epoch-theme-dark .epoch.category20b .bar.category3{fill:#656DB2;}.epoch-theme-dark .epoch.category20b div.ref.category4{background-color:#525992;}.epoch-theme-dark .epoch.category20b .category4 .line{stroke:#525992;}.epoch-theme-dark .epoch.category20b .category4 .area,.epoch-theme-dark .epoch.category20b .category4 .dot{fill:#525992;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category4 path{fill:#525992;}.epoch-theme-dark .epoch.category20b .bar.category4{fill:#525992;}.epoch-theme-dark .epoch.category20b div.ref.category5{background-color:#FFAC89;}.epoch-theme-dark .epoch.category20b .category5 .line{stroke:#FFAC89;}.epoch-theme-dark .epoch.category20b .category5 .area,.epoch-theme-dark .epoch.category20b .category5 .dot{fill:#FFAC89;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category5 path{fill:#FFAC89;}.epoch-theme-dark .epoch.category20b .bar.category5{fill:#FFAC89;}.epoch-theme-dark .epoch.category20b div.ref.category6{background-color:#D18D71;}.epoch-theme-dark .epoch.category20b .category6 .line{stroke:#D18D71;}.epoch-theme-dark .epoch.category20b .category6 .area,.epoch-theme-dark .epoch.category20b .category6 .dot{fill:#D18D71;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category6 path{fill:#D18D71;}.epoch-theme-dark .epoch.category20b .bar.category6{fill:#D18D71;}.epoch-theme-dark .epoch.category20b div.ref.category7{background-color:#AB735C;}.epoch-theme-dark .epoch.category20b .category7 .line{stroke:#AB735C;}.epoch-theme-dark .epoch.category20b .category7 .area,.epoch-theme-dark .epoch.category20b .category7 .dot{fill:#AB735C;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category7 path{fill:#AB735C;}.epoch-theme-dark .epoch.category20b .bar.category7{fill:#AB735C;}.epoch-theme-dark .epoch.category20b div.ref.category8{background-color:#92624E;}.epoch-theme-dark .epoch.category20b .category8 .line{stroke:#92624E;}.epoch-theme-dark .epoch.category20b .category8 .area,.epoch-theme-dark .epoch.category20b .category8 .dot{fill:#92624E;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category8 path{fill:#92624E;}.epoch-theme-dark .epoch.category20b .bar.category8{fill:#92624E;}.epoch-theme-dark .epoch.category20b div.ref.category9{background-color:#E889E8;}.epoch-theme-dark .epoch.category20b .category9 .line{stroke:#E889E8;}.epoch-theme-dark .epoch.category20b .category9 .area,.epoch-theme-dark .epoch.category20b .category9 .dot{fill:#E889E8;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category9 path{fill:#E889E8;}.epoch-theme-dark .epoch.category20b .bar.category9{fill:#E889E8;}.epoch-theme-dark .epoch.category20b div.ref.category10{background-color:#BA6EBA;}.epoch-theme-dark .epoch.category20b .category10 .line{stroke:#BA6EBA;}.epoch-theme-dark .epoch.category20b .category10 .area,.epoch-theme-dark .epoch.category20b .category10 .dot{fill:#BA6EBA;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category10 path{fill:#BA6EBA;}.epoch-theme-dark .epoch.category20b .bar.category10{fill:#BA6EBA;}.epoch-theme-dark .epoch.category20b div.ref.category11{background-color:#9B5C9B;}.epoch-theme-dark .epoch.category20b .category11 .line{stroke:#9B5C9B;}.epoch-theme-dark .epoch.category20b .category11 .area,.epoch-theme-dark .epoch.category20b .category11 .dot{fill:#9B5C9B;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category11 path{fill:#9B5C9B;}.epoch-theme-dark .epoch.category20b .bar.category11{fill:#9B5C9B;}.epoch-theme-dark .epoch.category20b div.ref.category12{background-color:#7B487B;}.epoch-theme-dark .epoch.category20b .category12 .line{stroke:#7B487B;}.epoch-theme-dark .epoch.category20b .category12 .area,.epoch-theme-dark .epoch.category20b .category12 .dot{fill:#7B487B;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category12 path{fill:#7B487B;}.epoch-theme-dark .epoch.category20b .bar.category12{fill:#7B487B;}.epoch-theme-dark .epoch.category20b div.ref.category13{background-color:#78E8D3;}.epoch-theme-dark .epoch.category20b .category13 .line{stroke:#78E8D3;}.epoch-theme-dark .epoch.category20b .category13 .area,.epoch-theme-dark .epoch.category20b .category13 .dot{fill:#78E8D3;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category13 path{fill:#78E8D3;}.epoch-theme-dark .epoch.category20b .bar.category13{fill:#78E8D3;}.epoch-theme-dark .epoch.category20b div.ref.category14{background-color:#60BAAA;}.epoch-theme-dark .epoch.category20b .category14 .line{stroke:#60BAAA;}.epoch-theme-dark .epoch.category20b .category14 .area,.epoch-theme-dark .epoch.category20b .category14 .dot{fill:#60BAAA;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category14 path{fill:#60BAAA;}.epoch-theme-dark .epoch.category20b .bar.category14{fill:#60BAAA;}.epoch-theme-dark .epoch.category20b div.ref.category15{background-color:#509B8D;}.epoch-theme-dark .epoch.category20b .category15 .line{stroke:#509B8D;}.epoch-theme-dark .epoch.category20b .category15 .area,.epoch-theme-dark .epoch.category20b .category15 .dot{fill:#509B8D;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category15 path{fill:#509B8D;}.epoch-theme-dark .epoch.category20b .bar.category15{fill:#509B8D;}.epoch-theme-dark .epoch.category20b div.ref.category16{background-color:#3F7B70;}.epoch-theme-dark .epoch.category20b .category16 .line{stroke:#3F7B70;}.epoch-theme-dark .epoch.category20b .category16 .area,.epoch-theme-dark .epoch.category20b .category16 .dot{fill:#3F7B70;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category16 path{fill:#3F7B70;}.epoch-theme-dark .epoch.category20b .bar.category16{fill:#3F7B70;}.epoch-theme-dark .epoch.category20b div.ref.category17{background-color:#C2FF97;}.epoch-theme-dark .epoch.category20b .category17 .line{stroke:#C2FF97;}.epoch-theme-dark .epoch.category20b .category17 .area,.epoch-theme-dark .epoch.category20b .category17 .dot{fill:#C2FF97;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category17 path{fill:#C2FF97;}.epoch-theme-dark .epoch.category20b .bar.category17{fill:#C2FF97;}.epoch-theme-dark .epoch.category20b div.ref.category18{background-color:#9FD17C;}.epoch-theme-dark .epoch.category20b .category18 .line{stroke:#9FD17C;}.epoch-theme-dark .epoch.category20b .category18 .area,.epoch-theme-dark .epoch.category20b .category18 .dot{fill:#9FD17C;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category18 path{fill:#9FD17C;}.epoch-theme-dark .epoch.category20b .bar.category18{fill:#9FD17C;}.epoch-theme-dark .epoch.category20b div.ref.category19{background-color:#7DA361;}.epoch-theme-dark .epoch.category20b .category19 .line{stroke:#7DA361;}.epoch-theme-dark .epoch.category20b .category19 .area,.epoch-theme-dark .epoch.category20b .category19 .dot{fill:#7DA361;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category19 path{fill:#7DA361;}.epoch-theme-dark .epoch.category20b .bar.category19{fill:#7DA361;}.epoch-theme-dark .epoch.category20b div.ref.category20{background-color:#65854E;}.epoch-theme-dark .epoch.category20b .category20 .line{stroke:#65854E;}.epoch-theme-dark .epoch.category20b .category20 .area,.epoch-theme-dark .epoch.category20b .category20 .dot{fill:#65854E;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20b .arc.category20 path{fill:#65854E;}.epoch-theme-dark .epoch.category20b .bar.category20{fill:#65854E;}.epoch-theme-dark .epoch.category20c div.ref.category1{background-color:#B7BCD1;}.epoch-theme-dark .epoch.category20c .category1 .line{stroke:#B7BCD1;}.epoch-theme-dark .epoch.category20c .category1 .area,.epoch-theme-dark .epoch.category20c .category1 .dot{fill:#B7BCD1;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category1 path{fill:#B7BCD1;}.epoch-theme-dark .epoch.category20c .bar.category1{fill:#B7BCD1;}.epoch-theme-dark .epoch.category20c div.ref.category2{background-color:#979DAD;}.epoch-theme-dark .epoch.category20c .category2 .line{stroke:#979DAD;}.epoch-theme-dark .epoch.category20c .category2 .area,.epoch-theme-dark .epoch.category20c .category2 .dot{fill:#979DAD;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category2 path{fill:#979DAD;}.epoch-theme-dark .epoch.category20c .bar.category2{fill:#979DAD;}.epoch-theme-dark .epoch.category20c div.ref.category3{background-color:#6E717D;}.epoch-theme-dark .epoch.category20c .category3 .line{stroke:#6E717D;}.epoch-theme-dark .epoch.category20c .category3 .area,.epoch-theme-dark .epoch.category20c .category3 .dot{fill:#6E717D;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category3 path{fill:#6E717D;}.epoch-theme-dark .epoch.category20c .bar.category3{fill:#6E717D;}.epoch-theme-dark .epoch.category20c div.ref.category4{background-color:#595C66;}.epoch-theme-dark .epoch.category20c .category4 .line{stroke:#595C66;}.epoch-theme-dark .epoch.category20c .category4 .area,.epoch-theme-dark .epoch.category20c .category4 .dot{fill:#595C66;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category4 path{fill:#595C66;}.epoch-theme-dark .epoch.category20c .bar.category4{fill:#595C66;}.epoch-theme-dark .epoch.category20c div.ref.category5{background-color:#FF857F;}.epoch-theme-dark .epoch.category20c .category5 .line{stroke:#FF857F;}.epoch-theme-dark .epoch.category20c .category5 .area,.epoch-theme-dark .epoch.category20c .category5 .dot{fill:#FF857F;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category5 path{fill:#FF857F;}.epoch-theme-dark .epoch.category20c .bar.category5{fill:#FF857F;}.epoch-theme-dark .epoch.category20c div.ref.category6{background-color:#DE746E;}.epoch-theme-dark .epoch.category20c .category6 .line{stroke:#DE746E;}.epoch-theme-dark .epoch.category20c .category6 .area,.epoch-theme-dark .epoch.category20c .category6 .dot{fill:#DE746E;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category6 path{fill:#DE746E;}.epoch-theme-dark .epoch.category20c .bar.category6{fill:#DE746E;}.epoch-theme-dark .epoch.category20c div.ref.category7{background-color:#B55F5A;}.epoch-theme-dark .epoch.category20c .category7 .line{stroke:#B55F5A;}.epoch-theme-dark .epoch.category20c .category7 .area,.epoch-theme-dark .epoch.category20c .category7 .dot{fill:#B55F5A;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category7 path{fill:#B55F5A;}.epoch-theme-dark .epoch.category20c .bar.category7{fill:#B55F5A;}.epoch-theme-dark .epoch.category20c div.ref.category8{background-color:#964E4B;}.epoch-theme-dark .epoch.category20c .category8 .line{stroke:#964E4B;}.epoch-theme-dark .epoch.category20c .category8 .area,.epoch-theme-dark .epoch.category20c .category8 .dot{fill:#964E4B;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category8 path{fill:#964E4B;}.epoch-theme-dark .epoch.category20c .bar.category8{fill:#964E4B;}.epoch-theme-dark .epoch.category20c div.ref.category9{background-color:#F3DE88;}.epoch-theme-dark .epoch.category20c .category9 .line{stroke:#F3DE88;}.epoch-theme-dark .epoch.category20c .category9 .area,.epoch-theme-dark .epoch.category20c .category9 .dot{fill:#F3DE88;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category9 path{fill:#F3DE88;}.epoch-theme-dark .epoch.category20c .bar.category9{fill:#F3DE88;}.epoch-theme-dark .epoch.category20c div.ref.category10{background-color:#DBC87B;}.epoch-theme-dark .epoch.category20c .category10 .line{stroke:#DBC87B;}.epoch-theme-dark .epoch.category20c .category10 .area,.epoch-theme-dark .epoch.category20c .category10 .dot{fill:#DBC87B;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category10 path{fill:#DBC87B;}.epoch-theme-dark .epoch.category20c .bar.category10{fill:#DBC87B;}.epoch-theme-dark .epoch.category20c div.ref.category11{background-color:#BAAA68;}.epoch-theme-dark .epoch.category20c .category11 .line{stroke:#BAAA68;}.epoch-theme-dark .epoch.category20c .category11 .area,.epoch-theme-dark .epoch.category20c .category11 .dot{fill:#BAAA68;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category11 path{fill:#BAAA68;}.epoch-theme-dark .epoch.category20c .bar.category11{fill:#BAAA68;}.epoch-theme-dark .epoch.category20c div.ref.category12{background-color:#918551;}.epoch-theme-dark .epoch.category20c .category12 .line{stroke:#918551;}.epoch-theme-dark .epoch.category20c .category12 .area,.epoch-theme-dark .epoch.category20c .category12 .dot{fill:#918551;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category12 path{fill:#918551;}.epoch-theme-dark .epoch.category20c .bar.category12{fill:#918551;}.epoch-theme-dark .epoch.category20c div.ref.category13{background-color:#C9935E;}.epoch-theme-dark .epoch.category20c .category13 .line{stroke:#C9935E;}.epoch-theme-dark .epoch.category20c .category13 .area,.epoch-theme-dark .epoch.category20c .category13 .dot{fill:#C9935E;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category13 path{fill:#C9935E;}.epoch-theme-dark .epoch.category20c .bar.category13{fill:#C9935E;}.epoch-theme-dark .epoch.category20c div.ref.category14{background-color:#B58455;}.epoch-theme-dark .epoch.category20c .category14 .line{stroke:#B58455;}.epoch-theme-dark .epoch.category20c .category14 .area,.epoch-theme-dark .epoch.category20c .category14 .dot{fill:#B58455;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category14 path{fill:#B58455;}.epoch-theme-dark .epoch.category20c .bar.category14{fill:#B58455;}.epoch-theme-dark .epoch.category20c div.ref.category15{background-color:#997048;}.epoch-theme-dark .epoch.category20c .category15 .line{stroke:#997048;}.epoch-theme-dark .epoch.category20c .category15 .area,.epoch-theme-dark .epoch.category20c .category15 .dot{fill:#997048;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category15 path{fill:#997048;}.epoch-theme-dark .epoch.category20c .bar.category15{fill:#997048;}.epoch-theme-dark .epoch.category20c div.ref.category16{background-color:#735436;}.epoch-theme-dark .epoch.category20c .category16 .line{stroke:#735436;}.epoch-theme-dark .epoch.category20c .category16 .area,.epoch-theme-dark .epoch.category20c .category16 .dot{fill:#735436;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category16 path{fill:#735436;}.epoch-theme-dark .epoch.category20c .bar.category16{fill:#735436;}.epoch-theme-dark .epoch.category20c div.ref.category17{background-color:#A488FF;}.epoch-theme-dark .epoch.category20c .category17 .line{stroke:#A488FF;}.epoch-theme-dark .epoch.category20c .category17 .area,.epoch-theme-dark .epoch.category20c .category17 .dot{fill:#A488FF;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category17 path{fill:#A488FF;}.epoch-theme-dark .epoch.category20c .bar.category17{fill:#A488FF;}.epoch-theme-dark .epoch.category20c div.ref.category18{background-color:#8670D1;}.epoch-theme-dark .epoch.category20c .category18 .line{stroke:#8670D1;}.epoch-theme-dark .epoch.category20c .category18 .area,.epoch-theme-dark .epoch.category20c .category18 .dot{fill:#8670D1;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category18 path{fill:#8670D1;}.epoch-theme-dark .epoch.category20c .bar.category18{fill:#8670D1;}.epoch-theme-dark .epoch.category20c div.ref.category19{background-color:#705CAD;}.epoch-theme-dark .epoch.category20c .category19 .line{stroke:#705CAD;}.epoch-theme-dark .epoch.category20c .category19 .area,.epoch-theme-dark .epoch.category20c .category19 .dot{fill:#705CAD;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category19 path{fill:#705CAD;}.epoch-theme-dark .epoch.category20c .bar.category19{fill:#705CAD;}.epoch-theme-dark .epoch.category20c div.ref.category20{background-color:#52447F;}.epoch-theme-dark .epoch.category20c .category20 .line{stroke:#52447F;}.epoch-theme-dark .epoch.category20c .category20 .area,.epoch-theme-dark .epoch.category20c .category20 .dot{fill:#52447F;stroke:rgba(0, 0, 0, 0);}.epoch-theme-dark .epoch.category20c .arc.category20 path{fill:#52447F;}.epoch-theme-dark .epoch.category20c .bar.category20{fill:#52447F;}
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/resources/static/epoch.min.js b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/resources/static/epoch.min.js
new file mode 100644
index 0000000000000000000000000000000000000000..0c654b86665f1256566ae1bc3a1a1d563e62927e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/resources/static/epoch.min.js
@@ -0,0 +1,114 @@
+(function(){var e;null==window.Epoch&&(window.Epoch={});null==(e=window.Epoch).Chart&&(e.Chart={});null==(e=window.Epoch).Time&&(e.Time={});null==(e=window.Epoch).Util&&(e.Util={});null==(e=window.Epoch).Formats&&(e.Formats={});Epoch.warn=function(g){return(console.warn||console.log)("Epoch Warning: "+g)};Epoch.exception=function(g){throw"Epoch Error: "+g;}}).call(this);
+(function(){Epoch.TestContext=function(){function e(){var c,a,d;this._log=[];a=0;for(d=g.length;a<d;a++)c=g[a],this._makeFauxMethod(c)}var g;g="arc arcTo beginPath bezierCurveTo clearRect clip closePath drawImage fill fillRect fillText moveTo quadraticCurveTo rect restore rotate save scale scrollPathIntoView setLineDash setTransform stroke strokeRect strokeText transform translate".split(" ");e.prototype._makeFauxMethod=function(c){return this[c]=function(){var a;return this._log.push(""+c+"("+function(){var d,
+b,h;h=[];d=0;for(b=arguments.length;d<b;d++)a=arguments[d],h.push(a.toString());return h}.apply(this,arguments).join(",")+")")}};e.prototype.getImageData=function(){var c;this._log.push("getImageData("+function(){var a,d,b;b=[];a=0;for(d=arguments.length;a<d;a++)c=arguments[a],b.push(c.toString());return b}.apply(this,arguments).join(",")+")");return{width:0,height:0,resolution:1,data:[]}};return e}()}).call(this);
+(function(){var e,g;e=function(c){return function(a){return Object.prototype.toString.call(a)==="[object "+c+"]"}};Epoch.isArray=null!=(g=Array.isArray)?g:e("Array");Epoch.isObject=e("Object");Epoch.isString=e("String");Epoch.isFunction=e("Function");Epoch.isNumber=e("Number");Epoch.isElement=function(c){return"undefined"!==typeof HTMLElement&&null!==HTMLElement?c instanceof HTMLElement:null!=c&&Epoch.isObject(c)&&1===c.nodeType&&Epoch.isString(c.nodeName)};Epoch.Util.copy=function(c){var a,d,b;if(null==
+c)return null;a={};for(d in c)b=c[d],a[d]=b;return a};Epoch.Util.defaults=function(c,a){var d,b,h,k,f;f=Epoch.Util.copy(c);for(h in a)k=c[h],b=a[h],d=Epoch.isObject(k)&&Epoch.isObject(b),null!=k&&null!=b?d&&!Epoch.isArray(k)?f[h]=Epoch.Util.defaults(k,b):f[h]=k:f[h]=null!=k?k:b;return f};Epoch.Util.formatSI=function(c,a,d){var b,h,k,f;null==a&&(a=1);null==d&&(d=!1);if(1E3>c){if((c|0)!==c||d)c=c.toFixed(a);return c}f="KMGTPEZY".split("");for(h in f)if(k=f[h],b=Math.pow(10,3*((h|0)+1)),c>=b&&c<Math.pow(10,
+3*((h|0)+2))){c/=b;if(0!==c%1||d)c=c.toFixed(a);return""+c+" "+k}};Epoch.Util.formatBytes=function(c,a,d){var b,h,k,f;null==a&&(a=1);null==d&&(d=!1);if(1024>c){if(0!==c%1||d)c=c.toFixed(a);return""+c+" B"}f="KB MB GB TB PB EB ZB YB".split(" ");for(h in f)if(k=f[h],b=Math.pow(1024,(h|0)+1),c>=b&&c<Math.pow(1024,(h|0)+2)){c/=b;if(0!==c%1||d)c=c.toFixed(a);return""+c+" "+k}};Epoch.Util.dasherize=function(c){return Epoch.Util.trim(c).replace("\n","").replace(/\s+/g,"-").toLowerCase()};Epoch.Util.domain=
+function(c,a){var d,b,h,k,f,q,u,m;null==a&&(a="x");h={};d=[];k=0;for(q=c.length;k<q;k++)for(b=c[k],m=b.values,f=0,u=m.length;f<u;f++)b=m[f],null==h[b[a]]&&(d.push(b[a]),h[b[a]]=!0);return d};Epoch.Util.trim=function(c){return Epoch.isString(c)?c.replace(/^\s+/g,"").replace(/\s+$/g,""):null};Epoch.Util.getComputedStyle=function(c,a){if(Epoch.isFunction(window.getComputedStyle))return window.getComputedStyle(c,a);if(null!=c.currentStyle)return c.currentStyle};Epoch.Util.toRGBA=function(c,a){var d,b,
+h;if(d=c.match(/^rgba\(\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*[0-9\.]+\)/))h=d[1],b=d[2],d=d[3],b="rgba("+h+","+b+","+d+","+a+")";else if(d=d3.rgb(c))b="rgba("+d.r+","+d.g+","+d.b+","+a+")";return b};Epoch.Util.getContext=function(c,a){null==a&&(a="2d");return null!=c.getContext?c.getContext(a):new Epoch.TestContext}}).call(this);
+(function(){d3.selection.prototype.width=function(e){return null!=e&&Epoch.isString(e)?this.style("width",e):null!=e&&Epoch.isNumber(e)?this.style("width",""+e+"px"):+Epoch.Util.getComputedStyle(this.node(),null).width.replace("px","")};d3.selection.prototype.height=function(e){return null!=e&&Epoch.isString(e)?this.style("height",e):null!=e&&Epoch.isNumber(e)?this.style("height",""+e+"px"):+Epoch.Util.getComputedStyle(this.node(),null).height.replace("px","")}}).call(this);
+(function(){var e;Epoch.Formats.regular=function(g){return g};Epoch.Formats.si=function(g){return Epoch.Util.formatSI(g)};Epoch.Formats.percent=function(g){return(100*g).toFixed(1)+"%"};Epoch.Formats.seconds=function(g){return e(new Date(1E3*g))};e=d3.time.format("%I:%M:%S %p");Epoch.Formats.bytes=function(g){return Epoch.Util.formatBytes(g)}}).call(this);
+(function(){var e={}.hasOwnProperty,g=function(c,a){function d(){this.constructor=c}for(var b in a)e.call(a,b)&&(c[b]=a[b]);d.prototype=a.prototype;c.prototype=new d;c.__super__=a.prototype;return c};Epoch.Events=function(){function c(){this._events={}}c.prototype.on=function(a,d){var b;if(null!=d)return null==(b=this._events)[a]&&(b[a]=[]),this._events[a].push(d)};c.prototype.onAll=function(a){var d,b,h;if(Epoch.isObject(a)){h=[];for(b in a)d=a[b],h.push(this.on(b,d));return h}};c.prototype.off=
+function(a,d){var b,h;if(Epoch.isArray(this._events[a])){if(null==d)return delete this._events[a];for(h=[];0<=(b=this._events[a].indexOf(d));)h.push(this._events[a].splice(b,1));return h}};c.prototype.offAll=function(a){var d,b,h,k;if(Epoch.isArray(a)){k=[];d=0;for(h=a.length;d<h;d++)b=a[d],k.push(this.off(b));return k}if(Epoch.isObject(a)){h=[];for(b in a)d=a[b],h.push(this.off(b,d));return h}};c.prototype.trigger=function(a){var d,b,h,k,f,q,c,m;if(null!=this._events[a]){d=function(){var a,f,q;q=
+[];k=a=1;for(f=arguments.length;1<=f?a<f:a>f;k=1<=f?++a:--a)q.push(arguments[k]);return q}.apply(this,arguments);c=this._events[a];m=[];f=0;for(q=c.length;f<q;f++)b=c[f],h=null,Epoch.isString(b)?h=this[b]:Epoch.isFunction(b)&&(h=b),null==h&&Epoch.exception("Callback for event '"+a+"' is not a function or reference to a method."),m.push(h.apply(this,d));return m}};return c}();Epoch.Chart.Base=function(c){function a(h){this.options=null!=h?h:{};a.__super__.constructor.call(this);this.setData(this.options.data||
+[]);null!=this.options.el&&(this.el=d3.select(this.options.el));this.width=this.options.width;this.height=this.options.height;null!=this.el?(null==this.width&&(this.width=this.el.width()),null==this.height&&(this.height=this.el.height())):(null==this.width&&(this.width=d.width),null==this.height&&(this.height=d.height));this.onAll(b)}var d,b;g(a,c);d={width:320,height:240};b={"option:width":"dimensionsChanged","option:height":"dimensionsChanged"};a.prototype._getAllOptions=function(){return Epoch.Util.defaults({},
+this.options)};a.prototype._getOption=function(a){var k,f;a=a.split(".");for(k=this.options;a.length&&null!=k;)f=a.shift(),k=k[f];return k};a.prototype._setOption=function(a,k){var f,q,b;f=a.split(".");for(q=this.options;f.length;){b=f.shift();if(0===f.length){q[b]=k;this.trigger("option:"+a);break}null==q[b]&&(q[b]={});q=q[b]}};a.prototype._setManyOptions=function(a,k){var f,q,b;null==k&&(k="");b=[];for(f in a)q=a[f],Epoch.isObject(q)?b.push(this._setManyOptions(q,""+(k+f)+".")):b.push(this._setOption(k+
+f,q));return b};a.prototype.option=function(){if(0===arguments.length)return this._getAllOptions();if(1===arguments.length&&Epoch.isString(arguments[0]))return this._getOption(arguments[0]);if(2===arguments.length&&Epoch.isString(arguments[0]))return this._setOption(arguments[0],arguments[1]);if(1===arguments.length&&Epoch.isObject(arguments[0]))return this._setManyOptions(arguments[0])};a.prototype.setData=function(a){var k,f,b,d,c;k=1;d=0;for(c=a.length;d<c;d++)b=a[d],f=["layer"],f.push("category"+
+k),b.category=k,null!=b.label&&f.push(Epoch.Util.dasherize(b.label)),b.className=f.join(" "),k++;return this.data=a};a.prototype.update=function(a,k){null==k&&(k=!0);this.setData(a);if(k)return this.draw()};a.prototype.draw=function(){return this.trigger("draw")};a.prototype.extent=function(a){return[d3.min(this.data,function(k){return d3.min(k.values,a)}),d3.max(this.data,function(k){return d3.max(k.values,a)})]};a.prototype.dimensionsChanged=function(){this.width=this.option("width")||this.width;
+this.height=this.option("height")||this.height;this.el.width(this.width);return this.el.height(this.height)};return a}(Epoch.Events);Epoch.Chart.SVG=function(c){function a(d){this.options=null!=d?d:{};a.__super__.constructor.call(this,this.options);this.svg=null!=this.el?this.el.append("svg"):d3.select(document.createElement("svg"));this.svg.attr({xmlns:"http://www.w3.org/2000/svg",width:this.width,height:this.height})}g(a,c);a.prototype.dimensionsChanged=function(){a.__super__.dimensionsChanged.call(this);
+return this.svg.attr("width",this.width).attr("height",this.height)};return a}(Epoch.Chart.Base);Epoch.Chart.Canvas=function(c){function a(d){this.options=null!=d?d:{};a.__super__.constructor.call(this,this.options);this.pixelRatio=null!=this.options.pixelRatio?this.options.pixelRatio:null!=window.devicePixelRatio?window.devicePixelRatio:1;this.canvas=d3.select(document.createElement("CANVAS"));this.canvas.style({width:""+this.width+"px",height:""+this.height+"px"});this.canvas.attr({width:this.getWidth(),
+height:this.getHeight()});null!=this.el&&this.el.node().appendChild(this.canvas.node());this.ctx=Epoch.Util.getContext(this.canvas.node())}g(a,c);a.prototype.getWidth=function(){return this.width*this.pixelRatio};a.prototype.getHeight=function(){return this.height*this.pixelRatio};a.prototype.clear=function(){return this.ctx.clearRect(0,0,this.getWidth(),this.getHeight())};a.prototype.getStyles=function(a){return Epoch.QueryCSS.getStyles(a,this.el)};a.prototype.dimensionsChanged=function(){a.__super__.dimensionsChanged.call(this);
+this.canvas.style({width:""+this.width+"px",height:""+this.height+"px"});return this.canvas.attr({width:this.getWidth(),height:this.getHeight()})};return a}(Epoch.Chart.Base)}).call(this);
+(function(){var e;e=function(){function g(){}var c,a,d,b,h;a=0;b=function(){return"epoch-container-"+a++};c=/^([^#. ]+)?(#[^. ]+)?(\.[^# ]+)?$/;d=!1;h=function(a){var f,b;f=a.match(c);if(null==f)return Epoch.error("Query CSS cannot match given selector: "+a);b=f[1];a=f[2];f=f[3];b=(null!=b?b:"div").toUpperCase();b=document.createElement(b);null!=a&&(b.id=a.substr(1));null!=f&&(b.className=f.substr(1).replace(/\./g," "));return b};g.log=function(a){return d=a};g.cache={};g.styleList=["fill","stroke",
+"stroke-width"];g.container=null;g.purge=function(){return g.cache={}};g.getContainer=function(){var a;if(null!=g.container)return g.container;a=document.createElement("DIV");a.id="_canvas_css_reference";document.body.appendChild(a);return g.container=d3.select(a)};g.hash=function(a,f){var d;d=f.attr("data-epoch-container-id");null==d&&(d=b(),f.attr("data-epoch-container-id",d));return""+d+"__"+a};g.getStyles=function(a,f){var b,c,m,l,n,e,r;c=g.hash(a,f);b=g.cache[c];if(null!=b)return b;m=[];for(b=
+f.node().parentNode;null!=b&&"body"!==b.nodeName.toLowerCase();)m.unshift(b),b=b.parentNode;m.push(f.node());b=[];e=0;for(r=m.length;e<r;e++)l=m[e],n=l.nodeName.toLowerCase(),null!=l.id&&0<l.id.length&&(n+="#"+l.id),null!=l.className&&0<l.className.length&&(n+="."+Epoch.Util.trim(l.className).replace(/\s+/g,".")),b.push(n);b.push("svg");e=Epoch.Util.trim(a).split(/\s+/);l=0;for(n=e.length;l<n;l++)m=e[l],b.push(m);d&&console.log(b);for(l=n=h(b.shift());b.length;)m=h(b.shift()),l.appendChild(m),l=m;
+d&&console.log(n);g.getContainer().node().appendChild(n);m=d3.select("#_canvas_css_reference "+a);l={};r=g.styleList;n=0;for(e=r.length;n<e;n++)b=r[n],l[b]=m.style(b);g.cache[c]=l;g.getContainer().html("");return l};return g}();Epoch.QueryCSS=e}).call(this);
+(function(){var e={}.hasOwnProperty,g=function(c,a){function d(){this.constructor=c}for(var b in a)e.call(a,b)&&(c[b]=a[b]);d.prototype=a.prototype;c.prototype=new d;c.__super__=a.prototype;return c};Epoch.Chart.Plot=function(c){function a(k){var f,c,u;this.options=null!=k?k:{};Epoch.Util.copy(this.options.margins);a.__super__.constructor.call(this,this.options=Epoch.Util.defaults(this.options,b));this.margins={};u=["top","right","bottom","left"];f=0;for(c=u.length;f<c;f++)k=u[f],this.margins[k]=
+null!=this.options.margins&&null!=this.options.margins[k]?this.options.margins[k]:this.hasAxis(k)?d[k]:6;this.g=this.svg.append("g").attr("transform","translate("+this.margins.left+", "+this.margins.top+")");this.onAll(h)}var d,b,h;g(a,c);b={domain:null,range:null,axes:["left","bottom"],ticks:{top:14,bottom:14,left:5,right:5},tickFormats:{top:Epoch.Formats.regular,bottom:Epoch.Formats.regular,left:Epoch.Formats.si,right:Epoch.Formats.si}};d={top:25,right:50,bottom:25,left:50};h={"option:margins.top":"marginsChanged",
+"option:margins.right":"marginsChanged","option:margins.bottom":"marginsChanged","option:margins.left":"marginsChanged","option:axes":"axesChanged","option:ticks.top":"ticksChanged","option:ticks.right":"ticksChanged","option:ticks.bottom":"ticksChanged","option:ticks.left":"ticksChanged","option:tickFormats.top":"tickFormatsChanged","option:tickFormats.right":"tickFormatsChanged","option:tickFormats.bottom":"tickFormatsChanged","option:tickFormats.left":"tickFormatsChanged","option:domain":"domainChanged",
+"option:range":"rangeChanged"};a.prototype.setTickFormat=function(a,f){return this.options.tickFormats[a]=f};a.prototype.hasAxis=function(a){return-1<this.options.axes.indexOf(a)};a.prototype.innerWidth=function(){return this.width-(this.margins.left+this.margins.right)};a.prototype.innerHeight=function(){return this.height-(this.margins.top+this.margins.bottom)};a.prototype.x=function(){var a,f;a=null!=(f=this.options.domain)?f:this.extent(function(a){return a.x});return d3.scale.linear().domain(a).range([0,
+this.innerWidth()])};a.prototype.y=function(){var a,f;a=null!=(f=this.options.range)?f:this.extent(function(a){return a.y});return d3.scale.linear().domain(a).range([this.innerHeight(),0])};a.prototype.bottomAxis=function(){return d3.svg.axis().scale(this.x()).orient("bottom").ticks(this.options.ticks.bottom).tickFormat(this.options.tickFormats.bottom)};a.prototype.topAxis=function(){return d3.svg.axis().scale(this.x()).orient("top").ticks(this.options.ticks.top).tickFormat(this.options.tickFormats.top)};
+a.prototype.leftAxis=function(){return d3.svg.axis().scale(this.y()).orient("left").ticks(this.options.ticks.left).tickFormat(this.options.tickFormats.left)};a.prototype.rightAxis=function(){return d3.svg.axis().scale(this.y()).orient("right").ticks(this.options.ticks.right).tickFormat(this.options.tickFormats.right)};a.prototype.draw=function(){this._axesDrawn?this._redrawAxes():this._drawAxes();return a.__super__.draw.call(this)};a.prototype._redrawAxes=function(){this.hasAxis("bottom")&&this.g.selectAll(".x.axis.bottom").transition().duration(500).ease("linear").call(this.bottomAxis());
+this.hasAxis("top")&&this.g.selectAll(".x.axis.top").transition().duration(500).ease("linear").call(this.topAxis());this.hasAxis("left")&&this.g.selectAll(".y.axis.left").transition().duration(500).ease("linear").call(this.leftAxis());if(this.hasAxis("right"))return this.g.selectAll(".y.axis.right").transition().duration(500).ease("linear").call(this.rightAxis())};a.prototype._drawAxes=function(){this.hasAxis("bottom")&&this.g.append("g").attr("class","x axis bottom").attr("transform","translate(0, "+
+this.innerHeight()+")").call(this.bottomAxis());this.hasAxis("top")&&this.g.append("g").attr("class","x axis top").call(this.topAxis());this.hasAxis("left")&&this.g.append("g").attr("class","y axis left").call(this.leftAxis());this.hasAxis("right")&&this.g.append("g").attr("class","y axis right").attr("transform","translate("+this.innerWidth()+", 0)").call(this.rightAxis());return this._axesDrawn=!0};a.prototype.dimensionsChanged=function(){a.__super__.dimensionsChanged.call(this);this.g.selectAll(".axis").remove();
+this._axesDrawn=!1;return this.draw()};a.prototype.marginsChanged=function(){var a,f,b;if(null!=this.options.margins){b=this.options.margins;for(a in b)f=b[a],this.margins[a]=null==f?6:f;this.g.transition().duration(750).attr("transform","translate("+this.margins.left+", "+this.margins.top+")");return this.draw()}};a.prototype.axesChanged=function(){var a,f,b,c;c=["top","right","bottom","left"];f=0;for(b=c.length;f<b;f++)if(a=c[f],null==this.options.margins||null==this.options.margins[a])this.hasAxis(a)?
+this.margins[a]=d[a]:this.margins[a]=6;this.g.transition().duration(750).attr("transform","translate("+this.margins.left+", "+this.margins.top+")");this.g.selectAll(".axis").remove();this._axesDrawn=!1;return this.draw()};a.prototype.ticksChanged=function(){return this.draw()};a.prototype.tickFormatsChanged=function(){return this.draw()};a.prototype.domainChanged=function(){return this.draw()};a.prototype.rangeChanged=function(){return this.draw()};return a}(Epoch.Chart.SVG)}).call(this);
+(function(){var e={}.hasOwnProperty,g=function(c,a){function d(){this.constructor=c}for(var b in a)e.call(a,b)&&(c[b]=a[b]);d.prototype=a.prototype;c.prototype=new d;c.__super__=a.prototype;return c};Epoch.Chart.Area=function(c){function a(){return a.__super__.constructor.apply(this,arguments)}g(a,c);a.prototype.y=function(){var a,b,c,k,f,q,u,m;a=[];q=this.data;k=0;for(f=q.length;k<f;k++)for(b in c=q[k],u=c.values,u)c=u[b],null!=a[b]&&(a[b]+=c.y),null==a[b]&&(a[b]=c.y);return d3.scale.linear().domain(null!=
+(m=this.options.range)?m:[0,d3.max(a)]).range([this.height-this.margins.top-this.margins.bottom,0])};a.prototype.draw=function(){var d,b,c,k;b=[this.x(),this.y()];c=b[0];k=b[1];d=d3.svg.area().x(function(a){return c(a.x)}).y0(function(a){return k(a.y0)}).y1(function(a){return k(a.y0+a.y)});d3.layout.stack().values(function(a){return a.values})(this.data);this.g.selectAll(".layer").remove();b=this.g.selectAll(".layer").data(this.data,function(a){return a.category});b.select(".area").attr("d",function(a){return d(a.values)});
+b.enter().append("g").attr("class",function(a){return a.className});b.append("path").attr("class","area").attr("d",function(a){return d(a.values)});return a.__super__.draw.call(this)};return a}(Epoch.Chart.Plot)}).call(this);
+(function(){var e={}.hasOwnProperty,g=function(c,a){function d(){this.constructor=c}for(var b in a)e.call(a,b)&&(c[b]=a[b]);d.prototype=a.prototype;c.prototype=new d;c.__super__=a.prototype;return c};Epoch.Chart.Bar=function(c){function a(k){this.options=null!=k?k:{};this.options="horizontal"===this.options.orientation?Epoch.Util.defaults(this.options,b):Epoch.Util.defaults(this.options,d);a.__super__.constructor.call(this,this.options);this.onAll(h)}var d,b,h;g(a,c);d={style:"grouped",orientation:"vertical",
+padding:{bar:0.08,group:0.1},outerPadding:{bar:0.08,group:0.1}};b=Epoch.Util.defaults({tickFormats:{top:Epoch.Formats.si,bottom:Epoch.Formats.si,left:Epoch.Formats.regular,right:Epoch.Formats.regular}},d);h={"option:orientation":"orientationChanged","option:padding":"paddingChanged","option:outerPadding":"paddingChanged","option:padding:bar":"paddingChanged","option:padding:group":"paddingChanged","option:outerPadding:bar":"paddingChanged","option:outerPadding:group":"paddingChanged"};a.prototype.x=
+function(){var a;if("vertical"===this.options.orientation)return d3.scale.ordinal().domain(Epoch.Util.domain(this.data)).rangeRoundBands([0,this.innerWidth()],this.options.padding.group,this.options.outerPadding.group);a=this.extent(function(a){return a.y});a[0]=Math.min(0,a[0]);return d3.scale.linear().domain(a).range([0,this.width-this.margins.left-this.margins.right])};a.prototype.x1=function(a){var f;return d3.scale.ordinal().domain(function(){var a,k,b,d;b=this.data;d=[];a=0;for(k=b.length;a<
+k;a++)f=b[a],d.push(f.category);return d}.call(this)).rangeRoundBands([0,a.rangeBand()],this.options.padding.bar,this.options.outerPadding.bar)};a.prototype.y=function(){var a;return"vertical"===this.options.orientation?(a=this.extent(function(a){return a.y}),a[0]=Math.min(0,a[0]),d3.scale.linear().domain(a).range([this.height-this.margins.top-this.margins.bottom,0])):d3.scale.ordinal().domain(Epoch.Util.domain(this.data)).rangeRoundBands([0,this.innerHeight()],this.options.padding.group,this.options.outerPadding.group)};
+a.prototype.y1=function(a){var f;return d3.scale.ordinal().domain(function(){var a,k,b,d;b=this.data;d=[];a=0;for(k=b.length;a<k;a++)f=b[a],d.push(f.category);return d}.call(this)).rangeRoundBands([0,a.rangeBand()],this.options.padding.bar,this.options.outerPadding.bar)};a.prototype._remapData=function(){var a,f,b,d,c,h,n,e,g,s,t,v;c={};t=this.data;h=0;for(e=t.length;h<e;h++)for(d=t[h],a="bar "+d.className.replace(/\s*layer\s*/,""),v=d.values,n=0,g=v.length;n<g;n++)f=v[n],null==c[s=f.x]&&(c[s]=[]),
+c[f.x].push({label:d.category,y:f.y,className:a});f=[];for(b in c)a=c[b],f.push({group:b,values:a});return f};a.prototype.draw=function(){"horizontal"===this.options.orientation?this._drawHorizontal():this._drawVertical();return a.__super__.draw.call(this)};a.prototype._drawVertical=function(){var a,b,d,c,h,l;a=[this.x(),this.y()];c=a[0];l=a[1];h=this.x1(c);b=this.height-this.margins.top-this.margins.bottom;a=this._remapData();a=this.g.selectAll(".layer").data(a,function(a){return a.group});a.transition().duration(750).attr("transform",
+function(a){return"translate("+c(a.group)+", 0)"});a.enter().append("g").attr("class","layer").attr("transform",function(a){return"translate("+c(a.group)+", 0)"});d=a.selectAll("rect").data(function(a){return a.values});d.transition().duration(600).attr("x",function(a){return h(a.label)}).attr("y",function(a){return l(a.y)}).attr("width",h.rangeBand()).attr("height",function(a){return b-l(a.y)});d.enter().append("rect").attr("class",function(a){return a.className}).attr("x",function(a){return h(a.label)}).attr("y",
+function(a){return l(a.y)}).attr("width",h.rangeBand()).attr("height",function(a){return b-l(a.y)});d.exit().transition().duration(150).style("opacity","0").remove();return a.exit().transition().duration(750).style("opacity","0").remove()};a.prototype._drawHorizontal=function(){var a,b,d,c,h;a=[this.x(),this.y()];d=a[0];c=a[1];h=this.y1(c);a=this._remapData();a=this.g.selectAll(".layer").data(a,function(a){return a.group});a.transition().duration(750).attr("transform",function(a){return"translate(0, "+
+c(a.group)+")"});a.enter().append("g").attr("class","layer").attr("transform",function(a){return"translate(0, "+c(a.group)+")"});b=a.selectAll("rect").data(function(a){return a.values});b.transition().duration(600).attr("x",function(a){return 0}).attr("y",function(a){return h(a.label)}).attr("height",h.rangeBand()).attr("width",function(a){return d(a.y)});b.enter().append("rect").attr("class",function(a){return a.className}).attr("x",function(a){return 0}).attr("y",function(a){return h(a.label)}).attr("height",
+h.rangeBand()).attr("width",function(a){return d(a.y)});b.exit().transition().duration(150).style("opacity","0").remove();return a.exit().transition().duration(750).style("opacity","0").remove()};a.prototype.orientationChanged=function(){var a,b,d,c;c=this.options.tickFormats.top;a=this.options.tickFormats.bottom;b=this.options.tickFormats.left;d=this.options.tickFormats.right;this.options.tickFormats.left=c;this.options.tickFormats.right=a;this.options.tickFormats.top=b;this.options.tickFormats.bottom=
+d;return this.draw()};a.prototype.paddingChanged=function(){return this.draw()};return a}(Epoch.Chart.Plot)}).call(this);
+(function(){var e={}.hasOwnProperty,g=function(c,a){function d(){this.constructor=c}for(var b in a)e.call(a,b)&&(c[b]=a[b]);d.prototype=a.prototype;c.prototype=new d;c.__super__=a.prototype;return c};Epoch.Chart.Line=function(c){function a(){return a.__super__.constructor.apply(this,arguments)}g(a,c);a.prototype.line=function(){var a,b,c;c=[this.x(),this.y()];a=c[0];b=c[1];return d3.svg.line().x(function(b){return function(b){return a(b.x)}}(this)).y(function(a){return function(a){return b(a.y)}}(this))};a.prototype.draw=
+function(){var c,b;b=[this.x(),this.y(),this.line()][2];c=this.g.selectAll(".layer").data(this.data,function(a){return a.category});c.select(".line").transition().duration(500).attr("d",function(a){return b(a.values)});c.enter().append("g").attr("class",function(a){return a.className}).append("path").attr("class","line").attr("d",function(a){return b(a.values)});c.exit().transition().duration(750).style("opacity","0").remove();return a.__super__.draw.call(this)};return a}(Epoch.Chart.Plot)}).call(this);
+(function(){var e={}.hasOwnProperty,g=function(c,a){function d(){this.constructor=c}for(var b in a)e.call(a,b)&&(c[b]=a[b]);d.prototype=a.prototype;c.prototype=new d;c.__super__=a.prototype;return c};Epoch.Chart.Pie=function(c){function a(b){this.options=null!=b?b:{};a.__super__.constructor.call(this,this.options=Epoch.Util.defaults(this.options,d));this.pie=d3.layout.pie().sort(null).value(function(a){return a.value});this.arc=d3.svg.arc().outerRadius(function(a){return function(){return Math.max(a.width,
+a.height)/2-a.options.margin}}(this)).innerRadius(function(a){return function(){return a.options.inner}}(this));this.g=this.svg.append("g").attr("transform","translate("+this.width/2+", "+this.height/2+")");this.on("option:margin","marginChanged");this.on("option:inner","innerChanged")}var d;g(a,c);d={margin:10,inner:0};a.prototype.draw=function(){var b;this.g.selectAll(".arc").remove();b=this.g.selectAll(".arc").data(this.pie(this.data),function(a){return a.data.category});b.enter().append("g").attr("class",
+function(a){return"arc pie "+a.data.className});b.select("path").attr("d",this.arc);b.select("text").attr("transform",function(a){return function(b){return"translate("+a.arc.centroid(b)+")"}}(this)).text(function(a){return a.data.label||a.data.category});b.append("path").attr("d",this.arc).each(function(a){return this._current=a});b.append("text").attr("transform",function(a){return function(b){return"translate("+a.arc.centroid(b)+")"}}(this)).attr("dy",".35em").style("text-anchor","middle").text(function(a){return a.data.label||
+a.data.category});return a.__super__.draw.call(this)};a.prototype.marginChanged=function(){return this.draw()};a.prototype.innerChanged=function(){return this.draw()};return a}(Epoch.Chart.SVG)}).call(this);
+(function(){var e={}.hasOwnProperty,g=function(c,a){function d(){this.constructor=c}for(var b in a)e.call(a,b)&&(c[b]=a[b]);d.prototype=a.prototype;c.prototype=new d;c.__super__=a.prototype;return c};Epoch.Chart.Scatter=function(c){function a(b){this.options=null!=b?b:{};a.__super__.constructor.call(this,this.options=Epoch.Util.defaults(this.options,d));this.on("option:radius","radiusChanged")}var d;g(a,c);d={radius:3.5,axes:["top","bottom","left","right"]};a.prototype.draw=function(){var b,c,k,f,
+d;b=[this.x(),this.y()];f=b[0];d=b[1];k=this.options.radius;c=this.g.selectAll(".layer").data(this.data,function(a){return a.category});c.enter().append("g").attr("class",function(a){return a.className});b=c.selectAll(".dot").data(function(a){return a.values});b.transition().duration(500).attr("r",function(a){var b;return null!=(b=a.r)?b:k}).attr("cx",function(a){return f(a.x)}).attr("cy",function(a){return d(a.y)});b.enter().append("circle").attr("class","dot").attr("r",function(a){var b;return null!=
+(b=a.r)?b:k}).attr("cx",function(a){return f(a.x)}).attr("cy",function(a){return d(a.y)});b.exit().transition().duration(750).style("opacity",0).remove();c.exit().transition().duration(750).style("opacity",0).remove();return a.__super__.draw.call(this)};a.prototype.radiusChanged=function(){return this.draw()};return a}(Epoch.Chart.Plot)}).call(this);
+(function(){var e={}.hasOwnProperty,g=function(c,a){function d(){this.constructor=c}for(var b in a)e.call(a,b)&&(c[b]=a[b]);d.prototype=a.prototype;c.prototype=new d;c.__super__=a.prototype;return c};Epoch.Time.Plot=function(c){function a(k){var f,c,u;this.options=k;Epoch.Util.copy(this.options.margins);a.__super__.constructor.call(this,this.options=Epoch.Util.defaults(this.options,b));this._queue=[];this.margins={};u=["top","right","bottom","left"];f=0;for(c=u.length;f<c;f++)k=u[f],this.margins[k]=
+null!=this.options.margins&&null!=this.options.margins[k]?this.options.margins[k]:this.hasAxis(k)?d[k]:6;this.svg=this.el.insert("svg",":first-child").attr("width",this.width).attr("height",this.height).style("z-index","1000");"absolute"!==this.el.style("position")&&"relative"!==this.el.style("position")&&this.el.style("position","relative");this.canvas.style({position:"absolute","z-index":"999"});this._sizeCanvas();this.animation={interval:null,active:!1,delta:function(a){return function(){return-(a.w()/
+a.options.fps)}}(this),tickDelta:function(a){return function(){return-(a.w()/a.pixelRatio/a.options.fps)}}(this),frame:0,duration:this.options.fps};this._buildAxes();this.animationCallback=function(a){return function(){return a._animate()}}(this);this.onAll(h)}var d,b,h;g(a,c);b={fps:24,historySize:120,windowSize:40,queueSize:10,axes:["bottom"],ticks:{time:15,left:5,right:5},tickFormats:{top:Epoch.Formats.seconds,bottom:Epoch.Formats.seconds,left:Epoch.Formats.si,right:Epoch.Formats.si}};d={top:25,
+right:50,bottom:25,left:50};h={"option:margins":"marginsChanged","option:margins.top":"marginsChanged","option:margins.right":"marginsChanged","option:margins.bottom":"marginsChanged","option:margins.left":"marginsChanged","option:axes":"axesChanged","option:ticks":"ticksChanged","option:ticks.top":"ticksChanged","option:ticks.right":"ticksChanged","option:ticks.bottom":"ticksChanged","option:ticks.left":"ticksChanged","option:tickFormats":"tickFormatsChanged","option:tickFormats.top":"tickFormatsChanged",
+"option:tickFormats.right":"tickFormatsChanged","option:tickFormats.bottom":"tickFormatsChanged","option:tickFormats.left":"tickFormatsChanged"};a.prototype._sizeCanvas=function(){this.canvas.attr({width:this.innerWidth(),height:this.innerHeight()});return this.canvas.style({width:""+this.innerWidth()/this.pixelRatio+"px",height:""+this.innerHeight()/this.pixelRatio+"px",top:""+this.margins.top+"px",left:""+this.margins.left+"px"})};a.prototype._buildAxes=function(){this.svg.selectAll(".axis").remove();
+this._prepareTimeAxes();return this._prepareRangeAxes()};a.prototype.setData=function(a){var b,c,d,h,e;this.data=[];e=[];for(d in a)h=a[d],c=Epoch.Util.copy(h),b=Math.max(0,h.values.length-this.options.historySize),c.values=h.values.slice(b),b=["layer"],b.push("category"+((d|0)+1)),null!=h.label&&b.push(Epoch.Util.dasherize(h.label)),c.className=b.join(" "),e.push(this.data.push(c));return e};a.prototype._offsetX=function(){return 0};a.prototype._prepareTimeAxes=function(){var a;this.hasAxis("bottom")&&
+(a=this.bottomAxis=this.svg.append("g").attr("class","x axis bottom canvas").attr("transform","translate("+(this.margins.left-1)+", "+(this.innerHeight()/this.pixelRatio+this.margins.top)+")"),a.append("path").attr("class","domain").attr("d","M0,0H"+(this.innerWidth()/this.pixelRatio+1)));this.hasAxis("top")&&(a=this.topAxis=this.svg.append("g").attr("class","x axis top canvas").attr("transform","translate("+(this.margins.left-1)+", "+this.margins.top+")"),a.append("path").attr("class","domain").attr("d",
+"M0,0H"+(this.innerWidth()/this.pixelRatio+1)));return this._resetInitialTimeTicks()};a.prototype._resetInitialTimeTicks=function(){var a,b,c,d,h;d=this.options.ticks.time;this._ticks=[];this._tickTimer=d;null!=this.bottomAxis&&this.bottomAxis.selectAll(".tick").remove();null!=this.topAxis&&this.topAxis.selectAll(".tick").remove();h=this.data;a=0;for(b=h.length;a<b;a++)if(c=h[a],null!=c.values&&0<c.values.length){b=[this.options.windowSize-1,c.values.length-1];a=b[0];for(b=b[1];0<=a&&0<=b;)this._pushTick(a,
+c.values[b].time,!1,!0),a-=d,b-=d;break}return[]};a.prototype._prepareRangeAxes=function(){this.hasAxis("left")&&this.svg.append("g").attr("class","y axis left").attr("transform","translate("+(this.margins.left-1)+", "+this.margins.top+")").call(this.leftAxis());if(this.hasAxis("right"))return this.svg.append("g").attr("class","y axis right").attr("transform","translate("+(this.width-this.margins.right)+", "+this.margins.top+")").call(this.rightAxis())};a.prototype.leftAxis=function(){var a,b;b=this.options.ticks.left;
+a=d3.svg.axis().scale(this.ySvg()).orient("left").tickFormat(this.options.tickFormats.left);return 2===b?a.tickValues(this.extent(function(a){return a.y})):a.ticks(b)};a.prototype.rightAxis=function(){var a,b;this.extent(function(a){return a.y});b=this.options.ticks.right;a=d3.svg.axis().scale(this.ySvg()).orient("right").tickFormat(this.options.tickFormats.left);return 2===b?a.tickValues(this.extent(function(a){return a.y})):a.ticks(b)};a.prototype.hasAxis=function(a){return-1<this.options.axes.indexOf(a)};
+a.prototype.innerWidth=function(){return(this.width-(this.margins.left+this.margins.right))*this.pixelRatio};a.prototype.innerHeight=function(){return(this.height-(this.margins.top+this.margins.bottom))*this.pixelRatio};a.prototype._prepareEntry=function(a){return a};a.prototype._prepareLayers=function(a){return a};a.prototype._startTransition=function(){if(!0!==this.animation.active&&0!==this._queue.length)return this.trigger("transition:start"),this._shift(),this.animation.active=!0,this.animation.interval=
+setInterval(this.animationCallback,1E3/this.options.fps)};a.prototype._stopTransition=function(){var a,b,c,d;if(this.inTransition()){d=this.data;b=0;for(c=d.length;b<c;b++)a=d[b],a.values.length>this.options.windowSize+1&&a.values.shift();b=[this._ticks[0],this._ticks[this._ticks.length-1]];a=b[0];b=b[1];null!=b&&b.enter&&(b.enter=!1,b.opacity=1);null!=a&&a.exit&&this._shiftTick();this.animation.frame=0;this.trigger("transition:end");if(0<this._queue.length)return this._shift();this.animation.active=
+!1;return clearInterval(this.animation.interval)}};a.prototype.inTransition=function(){return this.animation.active};a.prototype.push=function(a){a=this._prepareLayers(a);this._queue.length>this.options.queueSize&&this._queue.splice(this.options.queueSize,this._queue.length-this.options.queueSize);if(this._queue.length===this.options.queueSize)return!1;this._queue.push(a.map(function(a){return function(b){return a._prepareEntry(b)}}(this)));this.trigger("push");if(!this.inTransition())return this._startTransition()};
+a.prototype._shift=function(){var a,b,c,d;this.trigger("before:shift");a=this._queue.shift();d=this.data;for(b in d)c=d[b],c.values.push(a[b]);this._updateTicks(a[0].time);this._transitionRangeAxes();return this.trigger("after:shift")};a.prototype._transitionRangeAxes=function(){this.hasAxis("left")&&this.svg.selectAll(".y.axis.left").transition().duration(500).ease("linear").call(this.leftAxis());if(this.hasAxis("right"))return this.svg.selectAll(".y.axis.right").transition().duration(500).ease("linear").call(this.rightAxis())};
+a.prototype._animate=function(){if(this.inTransition())return++this.animation.frame===this.animation.duration&&this._stopTransition(),this.draw(this.animation.frame*this.animation.delta()),this._updateTimeAxes()};a.prototype.y=function(){return d3.scale.linear().domain(this.extent(function(a){return a.y})).range([this.innerHeight(),0])};a.prototype.ySvg=function(){return d3.scale.linear().domain(this.extent(function(a){return a.y})).range([this.innerHeight()/this.pixelRatio,0])};a.prototype.w=function(){return this.innerWidth()/
+this.options.windowSize};a.prototype._updateTicks=function(a){if(this.hasAxis("top")||this.hasAxis("bottom"))if(++this._tickTimer%this.options.ticks.time||this._pushTick(this.options.windowSize,a,!0),!(0<=this._ticks[0].x-this.w()/this.pixelRatio))return this._ticks[0].exit=!0};a.prototype._pushTick=function(a,b,c,d){null==c&&(c=!1);null==d&&(d=!1);if(this.hasAxis("top")||this.hasAxis("bottom"))return b={time:b,x:a*(this.w()/this.pixelRatio)+this._offsetX(),opacity:c?0:1,enter:c?!0:!1,exit:!1},this.hasAxis("bottom")&&
+(a=this.bottomAxis.append("g").attr("class","tick major").attr("transform","translate("+(b.x+1)+",0)").style("opacity",b.opacity),a.append("line").attr("y2",6),a.append("text").attr("text-anchor","middle").attr("dy",19).text(this.options.tickFormats.bottom(b.time)),b.bottomEl=a),this.hasAxis("top")&&(a=this.topAxis.append("g").attr("class","tick major").attr("transform","translate("+(b.x+1)+",0)").style("opacity",b.opacity),a.append("line").attr("y2",-6),a.append("text").attr("text-anchor","middle").attr("dy",
+-10).text(this.options.tickFormats.top(b.time)),b.topEl=a),d?this._ticks.unshift(b):this._ticks.push(b),b};a.prototype._shiftTick=function(){var a;if(0<this._ticks.length&&(a=this._ticks.shift(),null!=a.topEl&&a.topEl.remove(),null!=a.bottomEl))return a.bottomEl.remove()};a.prototype._updateTimeAxes=function(){var a,b,c,d,h,e,g;if(this.hasAxis("top")||this.hasAxis("bottom")){a=[this.animation.tickDelta(),1/this.options.fps];b=a[0];a=a[1];e=this._ticks;g=[];d=0;for(h=e.length;d<h;d++)c=e[d],c.x+=b,
+this.hasAxis("bottom")&&c.bottomEl.attr("transform","translate("+(c.x+1)+",0)"),this.hasAxis("top")&&c.topEl.attr("transform","translate("+(c.x+1)+",0)"),c.enter?c.opacity+=a:c.exit&&(c.opacity-=a),c.enter||c.exit?(this.hasAxis("bottom")&&c.bottomEl.style("opacity",c.opacity),this.hasAxis("top")?g.push(c.topEl.style("opacity",c.opacity)):g.push(void 0)):g.push(void 0);return g}};a.prototype.draw=function(b){return a.__super__.draw.call(this)};a.prototype.dimensionsChanged=function(){a.__super__.dimensionsChanged.call(this);
+this.svg.attr("width",this.width).attr("height",this.height);this._sizeCanvas();this._buildAxes();return this.draw(this.animation.frame*this.animation.delta())};a.prototype.axesChanged=function(){var a,b,c,h;h=["top","right","bottom","left"];b=0;for(c=h.length;b<c;b++)if(a=h[b],null==this.options.margins||null==this.options.margins[a])this.hasAxis(a)?this.margins[a]=d[a]:this.margins[a]=6;this._sizeCanvas();this._buildAxes();return this.draw(this.animation.frame*this.animation.delta())};a.prototype.ticksChanged=
+function(){this._resetInitialTimeTicks();this._transitionRangeAxes();return this.draw(this.animation.frame*this.animation.delta())};a.prototype.tickFormatsChanged=function(){this._resetInitialTimeTicks();this._transitionRangeAxes();return this.draw(this.animation.frame*this.animation.delta())};a.prototype.marginsChanged=function(){var a,b,c;if(null!=this.options.margins){c=this.options.margins;for(a in c)b=c[a],this.margins[a]=null==b?6:b;this._sizeCanvas();return this.draw(this.animation.frame*this.animation.delta())}};
+return a}(Epoch.Chart.Canvas);Epoch.Time.Stack=function(c){function a(){return a.__super__.constructor.apply(this,arguments)}g(a,c);a.prototype._prepareLayers=function(a){var b,c,k,f;k=c=0;for(f=a.length;k<f;k++)b=a[k],b.y0=c,c+=b.y;return a};a.prototype.setData=function(c){var b,h,k,f,e;a.__super__.setData.call(this,c);e=[];b=c=0;for(f=this.data[0].values.length;0<=f?c<f:c>f;b=0<=f?++c:--c)k=0,e.push(function(){var a,c,d,f;d=this.data;f=[];a=0;for(c=d.length;a<c;a++)h=d[a],h.values[b].y0=k,f.push(k+=
+h.values[b].y);return f}.call(this));return e};a.prototype.extent=function(){var a,b,c,k,f,e,g,m;a=f=c=0;for(g=this.data[0].values.length;0<=g?f<g:f>g;a=0<=g?++f:--f){b=e=k=0;for(m=this.data.length;0<=m?e<m:e>m;b=0<=m?++e:--e)k+=this.data[b].values[a].y;k>c&&(c=k)}return[0,c]};return a}(Epoch.Time.Plot)}).call(this);
+(function(){var e={}.hasOwnProperty,g=function(c,a){function d(){this.constructor=c}for(var b in a)e.call(a,b)&&(c[b]=a[b]);d.prototype=a.prototype;c.prototype=new d;c.__super__=a.prototype;return c};Epoch.Time.Area=function(c){function a(){return a.__super__.constructor.apply(this,arguments)}g(a,c);a.prototype.setStyles=function(a){a=null!=a.className?this.getStyles("g."+a.className.replace(/\s/g,".")+" path.area"):this.getStyles("g path.area");this.ctx.fillStyle=a.fill;null!=a.stroke&&(this.ctx.strokeStyle=
+a.stroke);if(null!=a["stroke-width"])return this.ctx.lineWidth=a["stroke-width"].replace("px","")};a.prototype._drawAreas=function(a){var b,c,k,f,e,g,m,l,n,p;null==a&&(a=0);g=[this.y(),this.w()];m=g[0];g=g[1];p=[];for(c=l=n=this.data.length-1;0>=n?0>=l:0<=l;c=0>=n?++l:--l){f=this.data[c];this.setStyles(f);this.ctx.beginPath();e=[this.options.windowSize,f.values.length,this.inTransition()];c=e[0];k=e[1];for(e=e[2];-2<=--c&&0<=--k;)b=f.values[k],b=[(c+1)*g+a,m(b.y+b.y0)],e&&(b[0]+=g),c===this.options.windowSize-
+1?this.ctx.moveTo.apply(this.ctx,b):this.ctx.lineTo.apply(this.ctx,b);c=e?(c+3)*g+a:(c+2)*g+a;this.ctx.lineTo(c,this.innerHeight());this.ctx.lineTo(this.width*this.pixelRatio+g+a,this.innerHeight());this.ctx.closePath();p.push(this.ctx.fill())}return p};a.prototype._drawStrokes=function(a){var b,c,k,f,e,g,m,l,n,p;null==a&&(a=0);c=[this.y(),this.w()];m=c[0];g=c[1];p=[];for(c=l=n=this.data.length-1;0>=n?0>=l:0<=l;c=0>=n?++l:--l){f=this.data[c];this.setStyles(f);this.ctx.beginPath();e=[this.options.windowSize,
+f.values.length,this.inTransition()];c=e[0];k=e[1];for(e=e[2];-2<=--c&&0<=--k;)b=f.values[k],b=[(c+1)*g+a,m(b.y+b.y0)],e&&(b[0]+=g),c===this.options.windowSize-1?this.ctx.moveTo.apply(this.ctx,b):this.ctx.lineTo.apply(this.ctx,b);p.push(this.ctx.stroke())}return p};a.prototype.draw=function(c){null==c&&(c=0);this.clear();this._drawAreas(c);this._drawStrokes(c);return a.__super__.draw.call(this)};return a}(Epoch.Time.Stack)}).call(this);
+(function(){var e={}.hasOwnProperty,g=function(c,a){function d(){this.constructor=c}for(var b in a)e.call(a,b)&&(c[b]=a[b]);d.prototype=a.prototype;c.prototype=new d;c.__super__=a.prototype;return c};Epoch.Time.Bar=function(c){function a(){return a.__super__.constructor.apply(this,arguments)}g(a,c);a.prototype._offsetX=function(){return 0.5*this.w()/this.pixelRatio};a.prototype.setStyles=function(a){a=this.getStyles("rect.bar."+a.replace(/\s/g,"."));this.ctx.fillStyle=a.fill;this.ctx.strokeStyle=
+null==a.stroke||"none"===a.stroke?"transparent":a.stroke;if(null!=a["stroke-width"])return this.ctx.lineWidth=a["stroke-width"].replace("px","")};a.prototype.draw=function(c){var b,h,k,f,e,g,m,l,n,p,r,s,t;null==c&&(c=0);this.clear();f=[this.y(),this.w()];p=f[0];n=f[1];t=this.data;r=0;for(s=t.length;r<s;r++)if(m=t[r],0<m.values.length)for(this.setStyles(m.className),e=[this.options.windowSize,m.values.length,this.inTransition()],f=e[0],g=e[1],e=(l=e[2])?-1:0;--f>=e&&0<=--g;)b=m.values[g],k=[f*n+c,
+b.y,b.y0],b=k[0],h=k[1],k=k[2],l&&(b+=n),b=[b+1,p(h+k),n-2,this.innerHeight()-p(h)+0.5*this.pixelRatio],this.ctx.fillRect.apply(this.ctx,b),this.ctx.strokeRect.apply(this.ctx,b);return a.__super__.draw.call(this)};return a}(Epoch.Time.Stack)}).call(this);
+(function(){var e={}.hasOwnProperty,g=function(c,a){function d(){this.constructor=c}for(var b in a)e.call(a,b)&&(c[b]=a[b]);d.prototype=a.prototype;c.prototype=new d;c.__super__=a.prototype;return c};Epoch.Time.Gauge=function(c){function a(c){this.options=null!=c?c:{};a.__super__.constructor.call(this,this.options=Epoch.Util.defaults(this.options,d));this.value=this.options.value||0;"absolute"!==this.el.style("position")&&"relative"!==this.el.style("position")&&this.el.style("position","relative");
+this.svg=this.el.insert("svg",":first-child").attr("width",this.width).attr("height",this.height).attr("class","gauge-labels");this.svg.style({position:"absolute","z-index":"1"});this.svg.append("g").attr("transform","translate("+this.textX()+", "+this.textY()+")").append("text").attr("class","value").text(this.options.format(this.value));this.animation={interval:null,active:!1,delta:0,target:0};this._animate=function(a){return function(){Math.abs(a.animation.target-a.value)<Math.abs(a.animation.delta)?
+(a.value=a.animation.target,clearInterval(a.animation.interval),a.animation.active=!1):a.value+=a.animation.delta;a.svg.select("text.value").text(a.options.format(a.value));return a.draw()}}(this);this.onAll(b)}var d,b;g(a,c);d={domain:[0,1],ticks:10,tickSize:5,tickOffset:5,fps:34,format:Epoch.Formats.percent};b={"option:domain":"domainChanged","option:ticks":"ticksChanged","option:tickSize":"tickSizeChanged","option:tickOffset":"tickOffsetChanged","option:format":"formatChanged"};a.prototype.update=
+function(a){this.animation.target=a;this.animation.delta=(a-this.value)/this.options.fps;if(!this.animation.active)return this.animation.interval=setInterval(this._animate,1E3/this.options.fps),this.animation.active=!0};a.prototype.push=function(a){return this.update(a)};a.prototype.radius=function(){return this.getHeight()/1.58};a.prototype.centerX=function(){return this.getWidth()/2};a.prototype.centerY=function(){return 0.68*this.getHeight()};a.prototype.textX=function(){return this.width/2};a.prototype.textY=
+function(){return 0.48*this.height};a.prototype.getAngle=function(a){var b,c;c=this.options.domain;b=c[0];return(a-b)/(c[1]-b)*(Math.PI+2*Math.PI/8)-Math.PI/2-Math.PI/8};a.prototype.setStyles=function(a){a=this.getStyles(a);this.ctx.fillStyle=a.fill;this.ctx.strokeStyle=a.stroke;if(null!=a["stroke-width"])return this.ctx.lineWidth=a["stroke-width"].replace("px","")};a.prototype.draw=function(){var b,c,d,e,g,m,l,n,p,r,s,t;g=[this.centerX(),this.centerY(),this.radius()];d=g[0];e=g[1];g=g[2];l=[this.options.tickOffset,
+this.options.tickSize];n=l[0];p=l[1];this.clear();l=d3.scale.linear().domain([0,this.options.ticks]).range([-1.125*Math.PI,Math.PI/8]);this.setStyles(".epoch .gauge .tick");this.ctx.beginPath();b=s=0;for(t=this.options.ticks;0<=t?s<=t:s>=t;b=0<=t?++s:--s)b=l(b),b=[Math.cos(b),Math.sin(b)],c=b[0],m=b[1],b=c*(g-n)+d,r=m*(g-n)+e,c=c*(g-n-p)+d,m=m*(g-n-p)+e,this.ctx.moveTo(b,r),this.ctx.lineTo(c,m);this.ctx.stroke();this.setStyles(".epoch .gauge .arc.outer");this.ctx.beginPath();this.ctx.arc(d,e,g,-1.125*
+Math.PI,0.125*Math.PI,!1);this.ctx.stroke();this.setStyles(".epoch .gauge .arc.inner");this.ctx.beginPath();this.ctx.arc(d,e,g-10,-1.125*Math.PI,0.125*Math.PI,!1);this.ctx.stroke();this.drawNeedle();return a.__super__.draw.call(this)};a.prototype.drawNeedle=function(){var a,b,c;c=[this.centerX(),this.centerY(),this.radius()];a=c[0];b=c[1];c=c[2];this.setStyles(".epoch .gauge .needle");this.ctx.beginPath();this.ctx.save();this.ctx.translate(a,b);this.ctx.rotate(this.getAngle(this.value));this.ctx.moveTo(4*
+this.pixelRatio,0);this.ctx.lineTo(-4*this.pixelRatio,0);this.ctx.lineTo(-1*this.pixelRatio,19-c);this.ctx.lineTo(1,19-c);this.ctx.fill();this.setStyles(".epoch .gauge .needle-base");this.ctx.beginPath();this.ctx.arc(0,0,this.getWidth()/25,0,2*Math.PI);this.ctx.fill();return this.ctx.restore()};a.prototype.domainChanged=function(){return this.draw()};a.prototype.ticksChanged=function(){return this.draw()};a.prototype.tickSizeChanged=function(){return this.draw()};a.prototype.tickOffsetChanged=function(){return this.draw()};
+a.prototype.formatChanged=function(){return this.svg.select("text.value").text(this.options.format(this.value))};return a}(Epoch.Chart.Canvas)}).call(this);
+(function(){var e={}.hasOwnProperty,g=function(c,a){function d(){this.constructor=c}for(var b in a)e.call(a,b)&&(c[b]=a[b]);d.prototype=a.prototype;c.prototype=new d;c.__super__=a.prototype;return c};Epoch.Time.Heatmap=function(c){function a(c){this.options=c;a.__super__.constructor.call(this,this.options=Epoch.Util.defaults(this.options,b));this._setOpacityFunction();this._setupPaintCanvas();this.onAll(e)}var d,b,e;g(a,c);b={buckets:10,bucketRange:[0,100],opacity:"linear",bucketPadding:2,paintZeroValues:!1,
+cutOutliers:!1};d={root:function(a,b){return Math.pow(a/b,0.5)},linear:function(a,b){return a/b},quadratic:function(a,b){return Math.pow(a/b,2)},cubic:function(a,b){return Math.pow(a/b,3)},quartic:function(a,b){return Math.pow(a/b,4)},quintic:function(a,b){return Math.pow(a/b,5)}};e={"option:buckets":"bucketsChanged","option:bucketRange":"bucketRangeChanged","option:opacity":"opacityChanged","option:bucketPadding":"bucketPaddingChanged","option:paintZeroValues":"paintZeroValuesChanged","option:cutOutliers":"cutOutliersChanged"};
+a.prototype._setOpacityFunction=function(){if(Epoch.isString(this.options.opacity)){if(this._opacityFn=d[this.options.opacity],null==this._opacityFn)return Epoch.exception("Unknown coloring function provided '"+this.options.opacity+"'")}else return Epoch.isFunction(this.options.opacity)?this._opacityFn=this.options.opacity:Epoch.exception("Unknown type for provided coloring function.")};a.prototype.setData=function(b){var c,d,e,g;a.__super__.setData.call(this,b);e=this.data;g=[];c=0;for(d=e.length;c<
+d;c++)b=e[c],g.push(b.values=b.values.map(function(a){return function(b){return a._prepareEntry(b)}}(this)));return g};a.prototype._getBuckets=function(a){var b,c,d,e,g;e=a.time;g=[];b=0;for(d=this.options.buckets;0<=d?b<d:b>d;0<=d?++b:--b)g.push(0);e={time:e,max:0,buckets:g};b=(this.options.bucketRange[1]-this.options.bucketRange[0])/this.options.buckets;g=a.histogram;for(c in g)a=g[c],d=parseInt((c-this.options.bucketRange[0])/b),this.options.cutOutliers&&(0>d||d>=this.options.buckets)||(0>d?d=
+0:d>=this.options.buckets&&(d=this.options.buckets-1),e.buckets[d]+=parseInt(a));c=a=0;for(b=e.buckets.length;0<=b?a<b:a>b;c=0<=b?++a:--a)e.max=Math.max(e.max,e.buckets[c]);return e};a.prototype.y=function(){return d3.scale.linear().domain(this.options.bucketRange).range([this.innerHeight(),0])};a.prototype.ySvg=function(){return d3.scale.linear().domain(this.options.bucketRange).range([this.innerHeight()/this.pixelRatio,0])};a.prototype.h=function(){return this.innerHeight()/this.options.buckets};
+a.prototype._offsetX=function(){return 0.5*this.w()/this.pixelRatio};a.prototype._setupPaintCanvas=function(){this.paintWidth=(this.options.windowSize+1)*this.w();this.paintHeight=this.height*this.pixelRatio;this.paint=document.createElement("CANVAS");this.paint.width=this.paintWidth;this.paint.height=this.paintHeight;this.p=Epoch.Util.getContext(this.paint);this.redraw();this.on("after:shift","_paintEntry");this.on("transition:end","_shiftPaintCanvas");return this.on("transition:end",function(a){return function(){return a.draw(a.animation.frame*
+a.animation.delta())}}(this))};a.prototype.redraw=function(){var a,b;b=this.data[0].values.length;a=this.options.windowSize;for(this.inTransition()&&a++;0<=--b&&0<=--a;)this._paintEntry(b,a);return this.draw(this.animation.frame*this.animation.delta())};a.prototype._computeColor=function(a,b,c){return Epoch.Util.toRGBA(c,this._opacityFn(a,b))};a.prototype._paintEntry=function(a,b){var c,d,e,g,h,p,r,s,t,v,y,w,A,z;null==a&&(a=null);null==b&&(b=null);g=[this.w(),this.h()];y=g[0];p=g[1];null==a&&(a=this.data[0].values.length-
+1);null==b&&(b=this.options.windowSize);g=[];var x;x=[];h=0;for(v=this.options.buckets;0<=v?h<v:h>v;0<=v?++h:--h)x.push(0);v=0;t=this.data;d=0;for(r=t.length;d<r;d++){s=t[d];h=this._getBuckets(s.values[a]);w=h.buckets;for(c in w)e=w[c],x[c]+=e;v+=h.max;e=this.getStyles("."+s.className.split(" ").join(".")+" rect.bucket");h.color=e.fill;g.push(h)}s=b*y;this.p.clearRect(s,0,y,this.paintHeight);r=this.options.buckets;z=[];for(c in x){e=x[c];d=this._avgLab(g,c);w=t=0;for(A=g.length;w<A;w++)h=g[w],t+=
+h.buckets[c]/e*v;if(0<e||this.options.paintZeroValues)this.p.fillStyle=this._computeColor(e,t,d),this.p.fillRect(s,(r-1)*p,y-this.options.bucketPadding,p-this.options.bucketPadding);z.push(r--)}return z};a.prototype._shiftPaintCanvas=function(){var a;a=this.p.getImageData(this.w(),0,this.paintWidth-this.w(),this.paintHeight);return this.p.putImageData(a,0,0)};a.prototype._avgLab=function(a,b){var c,d,e,g,h,p,r,s;r=[0,0,0,0];h=r[0];c=r[1];d=r[2];r=r[3];p=0;for(s=a.length;p<s;p++)e=a[p],null!=e.buckets[b]&&
+(r+=e.buckets[b]);for(g in a)e=a[g],p=null!=e.buckets[b]?e.buckets[b]|0:0,p/=r,e=d3.lab(e.color),h+=p*e.l,c+=p*e.a,d+=p*e.b;return d3.lab(h,c,d).toString()};a.prototype.draw=function(b){null==b&&(b=0);this.clear();this.ctx.drawImage(this.paint,b,0);return a.__super__.draw.call(this)};a.prototype.bucketsChanged=function(){return this.redraw()};a.prototype.bucketRangeChanged=function(){this._transitionRangeAxes();return this.redraw()};a.prototype.opacityChanged=function(){this._setOpacityFunction();
+return this.redraw()};a.prototype.bucketPaddingChanged=function(){return this.redraw()};a.prototype.paintZeroValuesChanged=function(){return this.redraw()};a.prototype.cutOutliersChanged=function(){return this.redraw()};return a}(Epoch.Time.Plot)}).call(this);
+(function(){var e={}.hasOwnProperty,g=function(c,a){function d(){this.constructor=c}for(var b in a)e.call(a,b)&&(c[b]=a[b]);d.prototype=a.prototype;c.prototype=new d;c.__super__=a.prototype;return c};Epoch.Time.Line=function(c){function a(){return a.__super__.constructor.apply(this,arguments)}g(a,c);a.prototype.setStyles=function(a){a=this.getStyles("g."+a.replace(/\s/g,".")+" path.line");this.ctx.fillStyle=a.fill;this.ctx.strokeStyle=a.stroke;return this.ctx.lineWidth=this.pixelRatio*a["stroke-width"].replace("px",
+"")};a.prototype.y=function(){return d3.scale.linear().domain(this.extent(function(a){return a.y})).range([this.innerHeight()-this.pixelRatio/2,this.pixelRatio])};a.prototype.draw=function(c){var b,e,g,f,q,u,m,l,n,p;null==c&&(c=0);this.clear();e=[this.y(),this.w()];m=e[0];u=e[1];p=this.data;l=0;for(n=p.length;l<n;l++)if(f=p[l],0<f.values.length){this.setStyles(f.className);this.ctx.beginPath();q=[this.options.windowSize,f.values.length,this.inTransition()];e=q[0];g=q[1];for(q=q[2];-2<=--e&&0<=--g;)b=
+f.values[g],b=[(e+1)*u+c,m(b.y)],q&&(b[0]+=u),e===this.options.windowSize-1?this.ctx.moveTo.apply(this.ctx,b):this.ctx.lineTo.apply(this.ctx,b);this.ctx.stroke()}return a.__super__.draw.call(this)};return a}(Epoch.Time.Plot)}).call(this);(function(){Epoch._typeMap={area:Epoch.Chart.Area,bar:Epoch.Chart.Bar,line:Epoch.Chart.Line,pie:Epoch.Chart.Pie,scatter:Epoch.Chart.Scatter,"time.area":Epoch.Time.Area,"time.bar":Epoch.Time.Bar,"time.line":Epoch.Time.Line,"time.gauge":Epoch.Time.Gauge,"time.heatmap":Epoch.Time.Heatmap}}).call(this);
+(function(){null!=window.MooTools&&function(){return Element.implement("epoch",function(e){var g,c;c=$$(this);null==(g=c.retrieve("epoch-chart")[0])&&(e.el=this,g=Epoch._typeMap[e.type],null==g&&Epoch.exception("Unknown chart type '"+e.type+"'"),c.store("epoch-chart",g=new g(e)),g.draw());return g})}()}).call(this);
+(function(){var e;e=function(e){return e.fn.epoch=function(c){var a;c.el=this.get(0);null==(a=this.data("epoch-chart"))&&(a=Epoch._typeMap[c.type],null==a&&Epoch.exception("Unknown chart type '"+c.type+"'"),this.data("epoch-chart",a=new a(c)),a.draw());return a}};null!=window.jQuery&&e(jQuery)}).call(this);
+(function(){var e;e=function(e){var c,a,d;a={};c=0;d=function(){return"epoch-chart-"+ ++c};return e.extend(e.fn,{epoch:function(b){var c,e;if(null!=(c=this.data("epoch-chart")))return a[c];b.el=this.get(0);e=Epoch._typeMap[b.type];null==e&&Epoch.exception("Unknown chart type '"+b.type+"'");this.data("epoch-chart",c=d());b=new e(b);a[c]=b;b.draw();return b}})};null!=window.Zepto&&e(Zepto)}).call(this);
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/resources/static/prismjs.min.css b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/resources/static/prismjs.min.css
new file mode 100644
index 0000000000000000000000000000000000000000..0d9d8fb13fd81be4e6ee408915f5a48f99245bf1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/resources/static/prismjs.min.css
@@ -0,0 +1,137 @@
+/* http://prismjs.com/download.html?themes=prism&languages=clike+javascript+go */
+/**
+ * prism.js default theme for JavaScript, CSS and HTML
+ * Based on dabblet (http://dabblet.com)
+ * @author Lea Verou
+ */
+
+code[class*="language-"],
+pre[class*="language-"] {
+ color: black;
+ text-shadow: 0 1px white;
+ font-family: Consolas, Monaco, 'Andale Mono', monospace;
+ direction: ltr;
+ text-align: left;
+ white-space: pre;
+ word-spacing: normal;
+ word-break: normal;
+ line-height: 1.5;
+
+ -moz-tab-size: 4;
+ -o-tab-size: 4;
+ tab-size: 4;
+
+ -webkit-hyphens: none;
+ -moz-hyphens: none;
+ -ms-hyphens: none;
+ hyphens: none;
+}
+
+pre[class*="language-"]::-moz-selection, pre[class*="language-"] ::-moz-selection,
+code[class*="language-"]::-moz-selection, code[class*="language-"] ::-moz-selection {
+ text-shadow: none;
+ background: #b3d4fc;
+}
+
+pre[class*="language-"]::selection, pre[class*="language-"] ::selection,
+code[class*="language-"]::selection, code[class*="language-"] ::selection {
+ text-shadow: none;
+ background: #b3d4fc;
+}
+
+@media print {
+ code[class*="language-"],
+ pre[class*="language-"] {
+ text-shadow: none;
+ }
+}
+
+/* Code blocks */
+pre[class*="language-"] {
+ padding: 1em;
+ margin: .5em 0;
+ overflow: auto;
+}
+
+:not(pre) > code[class*="language-"],
+pre[class*="language-"] {
+ background: #f5f2f0;
+}
+
+/* Inline code */
+:not(pre) > code[class*="language-"] {
+ padding: .1em;
+ border-radius: .3em;
+}
+
+.token.comment,
+.token.prolog,
+.token.doctype,
+.token.cdata {
+ color: slategray;
+}
+
+.token.punctuation {
+ color: #999;
+}
+
+.namespace {
+ opacity: .7;
+}
+
+.token.property,
+.token.tag,
+.token.boolean,
+.token.number,
+.token.constant,
+.token.symbol,
+.token.deleted {
+ color: #905;
+}
+
+.token.selector,
+.token.attr-name,
+.token.string,
+.token.char,
+.token.builtin,
+.token.inserted {
+ color: #690;
+}
+
+.token.operator,
+.token.entity,
+.token.url,
+.language-css .token.string,
+.style .token.string {
+ color: #a67f59;
+ background: hsla(0, 0%, 100%, .5);
+}
+
+.token.atrule,
+.token.attr-value,
+.token.keyword {
+ color: #07a;
+}
+
+.token.function {
+ color: #DD4A68;
+}
+
+.token.regex,
+.token.important,
+.token.variable {
+ color: #e90;
+}
+
+.token.important,
+.token.bold {
+ font-weight: bold;
+}
+.token.italic {
+ font-style: italic;
+}
+
+.token.entity {
+ cursor: help;
+}
+
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/resources/static/prismjs.min.js b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/resources/static/prismjs.min.js
new file mode 100644
index 0000000000000000000000000000000000000000..a6855a787da2675e812ce390222b9ec222330227
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/resources/static/prismjs.min.js
@@ -0,0 +1,5 @@
+/* http://prismjs.com/download.html?themes=prism&languages=clike+javascript+go */
+self="undefined"!=typeof window?window:"undefined"!=typeof WorkerGlobalScope&&self instanceof WorkerGlobalScope?self:{};var Prism=function(){var e=/\blang(?:uage)?-(?!\*)(\w+)\b/i,t=self.Prism={util:{encode:function(e){return e instanceof n?new n(e.type,t.util.encode(e.content),e.alias):"Array"===t.util.type(e)?e.map(t.util.encode):e.replace(/&/g,"&").replace(/</g,"<").replace(/\u00a0/g," ")},type:function(e){return Object.prototype.toString.call(e).match(/\[object (\w+)\]/)[1]},clone:function(e){var n=t.util.type(e);switch(n){case"Object":var a={};for(var r in e)e.hasOwnProperty(r)&&(a[r]=t.util.clone(e[r]));return a;case"Array":return e.map(function(e){return t.util.clone(e)})}return e}},languages:{extend:function(e,n){var a=t.util.clone(t.languages[e]);for(var r in n)a[r]=n[r];return a},insertBefore:function(e,n,a,r){r=r||t.languages;var i=r[e];if(2==arguments.length){a=arguments[1];for(var l in a)a.hasOwnProperty(l)&&(i[l]=a[l]);return i}var s={};for(var o in i)if(i.hasOwnProperty(o)){if(o==n)for(var l in a)a.hasOwnProperty(l)&&(s[l]=a[l]);s[o]=i[o]}return t.languages.DFS(t.languages,function(t,n){n===r[e]&&t!=e&&(this[t]=s)}),r[e]=s},DFS:function(e,n,a){for(var r in e)e.hasOwnProperty(r)&&(n.call(e,r,e[r],a||r),"Object"===t.util.type(e[r])?t.languages.DFS(e[r],n):"Array"===t.util.type(e[r])&&t.languages.DFS(e[r],n,r))}},highlightAll:function(e,n){for(var a,r=document.querySelectorAll('code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'),i=0;a=r[i++];)t.highlightElement(a,e===!0,n)},highlightElement:function(a,r,i){for(var l,s,o=a;o&&!e.test(o.className);)o=o.parentNode;if(o&&(l=(o.className.match(e)||[,""])[1],s=t.languages[l]),s){a.className=a.className.replace(e,"").replace(/\s+/g," ")+" language-"+l,o=a.parentNode,/pre/i.test(o.nodeName)&&(o.className=o.className.replace(e,"").replace(/\s+/g," ")+" language-"+l);var u=a.textContent;if(u){u=u.replace(/^(?:\r?\n|\r)/,"");var g={element:a,language:l,grammar:s,code:u};if(t.hooks.run("before-highlight",g),r&&self.Worker){var c=new Worker(t.filename);c.onmessage=function(e){g.highlightedCode=n.stringify(JSON.parse(e.data),l),t.hooks.run("before-insert",g),g.element.innerHTML=g.highlightedCode,i&&i.call(g.element),t.hooks.run("after-highlight",g)},c.postMessage(JSON.stringify({language:g.language,code:g.code}))}else g.highlightedCode=t.highlight(g.code,g.grammar,g.language),t.hooks.run("before-insert",g),g.element.innerHTML=g.highlightedCode,i&&i.call(a),t.hooks.run("after-highlight",g)}}},highlight:function(e,a,r){var i=t.tokenize(e,a);return n.stringify(t.util.encode(i),r)},tokenize:function(e,n){var a=t.Token,r=[e],i=n.rest;if(i){for(var l in i)n[l]=i[l];delete n.rest}e:for(var l in n)if(n.hasOwnProperty(l)&&n[l]){var s=n[l];s="Array"===t.util.type(s)?s:[s];for(var o=0;o<s.length;++o){var u=s[o],g=u.inside,c=!!u.lookbehind,f=0,h=u.alias;u=u.pattern||u;for(var p=0;p<r.length;p++){var d=r[p];if(r.length>e.length)break e;if(!(d instanceof a)){u.lastIndex=0;var m=u.exec(d);if(m){c&&(f=m[1].length);var y=m.index-1+f,m=m[0].slice(f),v=m.length,k=y+v,b=d.slice(0,y+1),w=d.slice(k+1),N=[p,1];b&&N.push(b);var O=new a(l,g?t.tokenize(m,g):m,h);N.push(O),w&&N.push(w),Array.prototype.splice.apply(r,N)}}}}}return r},hooks:{all:{},add:function(e,n){var a=t.hooks.all;a[e]=a[e]||[],a[e].push(n)},run:function(e,n){var a=t.hooks.all[e];if(a&&a.length)for(var r,i=0;r=a[i++];)r(n)}}},n=t.Token=function(e,t,n){this.type=e,this.content=t,this.alias=n};if(n.stringify=function(e,a,r){if("string"==typeof e)return e;if("Array"===t.util.type(e))return e.map(function(t){return n.stringify(t,a,e)}).join("");var i={type:e.type,content:n.stringify(e.content,a,r),tag:"span",classes:["token",e.type],attributes:{},language:a,parent:r};if("comment"==i.type&&(i.attributes.spellcheck="true"),e.alias){var l="Array"===t.util.type(e.alias)?e.alias:[e.alias];Array.prototype.push.apply(i.classes,l)}t.hooks.run("wrap",i);var s="";for(var o in i.attributes)s+=o+'="'+(i.attributes[o]||"")+'"';return"<"+i.tag+' class="'+i.classes.join(" ")+'" '+s+">"+i.content+"</"+i.tag+">"},!self.document)return self.addEventListener?(self.addEventListener("message",function(e){var n=JSON.parse(e.data),a=n.language,r=n.code;self.postMessage(JSON.stringify(t.util.encode(t.tokenize(r,t.languages[a])))),self.close()},!1),self.Prism):self.Prism;var a=document.getElementsByTagName("script");return a=a[a.length-1],a&&(t.filename=a.src,document.addEventListener&&!a.hasAttribute("data-manual")&&document.addEventListener("DOMContentLoaded",t.highlightAll)),self.Prism}();"undefined"!=typeof module&&module.exports&&(module.exports=Prism);;
+Prism.languages.clike={comment:[{pattern:/(^|[^\\])\/\*[\w\W]*?\*\//,lookbehind:!0},{pattern:/(^|[^\\:])\/\/.*/,lookbehind:!0}],string:/("|')(\\\n|\\?.)*?\1/,"class-name":{pattern:/((?:(?:class|interface|extends|implements|trait|instanceof|new)\s+)|(?:catch\s+\())[a-z0-9_\.\\]+/i,lookbehind:!0,inside:{punctuation:/(\.|\\)/}},keyword:/\b(if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/,"boolean":/\b(true|false)\b/,"function":{pattern:/[a-z0-9_]+\(/i,inside:{punctuation:/\(/}},number:/\b-?(0x[\dA-Fa-f]+|\d*\.?\d+([Ee]-?\d+)?)\b/,operator:/[-+]{1,2}|!|<=?|>=?|={1,3}|&{1,2}|\|?\||\?|\*|\/|~|\^|%/,ignore:/&(lt|gt|amp);/i,punctuation:/[{}[\];(),.:]/};;
+Prism.languages.javascript=Prism.languages.extend("clike",{keyword:/\b(break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|get|if|implements|import|in|instanceof|interface|let|new|null|package|private|protected|public|return|set|static|super|switch|this|throw|true|try|typeof|var|void|while|with|yield)\b/,number:/\b-?(0x[\dA-Fa-f]+|\d*\.?\d+([Ee][+-]?\d+)?|NaN|-?Infinity)\b/,"function":/(?!\d)[a-z0-9_$]+(?=\()/i}),Prism.languages.insertBefore("javascript","keyword",{regex:{pattern:/(^|[^/])\/(?!\/)(\[.+?]|\\.|[^/\r\n])+\/[gim]{0,3}(?=\s*($|[\r\n,.;})]))/,lookbehind:!0}}),Prism.languages.markup&&Prism.languages.insertBefore("markup","tag",{script:{pattern:/<script[\w\W]*?>[\w\W]*?<\/script>/i,inside:{tag:{pattern:/<script[\w\W]*?>|<\/script>/i,inside:Prism.languages.markup.tag.inside},rest:Prism.languages.javascript},alias:"language-javascript"}});;
+Prism.languages.go=Prism.languages.extend("clike",{keyword:/\b(break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/,builtin:/\b(bool|byte|complex(64|128)|error|float(32|64)|rune|string|u?int(8|16|32|64|)|uintptr|append|cap|close|complex|copy|delete|imag|len|make|new|panic|print(ln)?|real|recover)\b/,"boolean":/\b(_|iota|nil|true|false)\b/,operator:/([(){}\[\]]|[*\/%^!]=?|\+[=+]?|-[>=-]?|\|[=|]?|>[=>]?|<(<|[=-])?|==?|&(&|=|^=?)?|\.(\.\.)?|[,;]|:=?)/,number:/\b(-?(0x[a-f\d]+|(\d+\.?\d*|\.\d+)(e[-+]?\d+)?)i?)\b/i,string:/("|'|`)(\\?.|\r|\n)*?\1/}),delete Prism.languages.go["class-name"];;
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/resources/static/realtime.js b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/resources/static/realtime.js
new file mode 100644
index 0000000000000000000000000000000000000000..919dae26c42e08efb1428122ea72ee327e3f3a22
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/resources/static/realtime.js
@@ -0,0 +1,144 @@
+
+
+function StartRealtime(roomid, timestamp) {
+ StartEpoch(timestamp);
+ StartSSE(roomid);
+ StartForm();
+}
+
+function StartForm() {
+ $('#chat-message').focus();
+ $('#chat-form').ajaxForm(function() {
+ $('#chat-message').val('');
+ $('#chat-message').focus();
+ });
+}
+
+function StartEpoch(timestamp) {
+ var windowSize = 60;
+ var height = 200;
+ var defaultData = histogram(windowSize, timestamp);
+
+ window.heapChart = $('#heapChart').epoch({
+ type: 'time.area',
+ axes: ['bottom', 'left'],
+ height: height,
+ historySize: 10,
+ data: [
+ {values: defaultData},
+ {values: defaultData}
+ ]
+ });
+
+ window.mallocsChart = $('#mallocsChart').epoch({
+ type: 'time.area',
+ axes: ['bottom', 'left'],
+ height: height,
+ historySize: 10,
+ data: [
+ {values: defaultData},
+ {values: defaultData}
+ ]
+ });
+
+ window.messagesChart = $('#messagesChart').epoch({
+ type: 'time.line',
+ axes: ['bottom', 'left'],
+ height: 240,
+ historySize: 10,
+ data: [
+ {values: defaultData},
+ {values: defaultData},
+ {values: defaultData}
+ ]
+ });
+}
+
+function StartSSE(roomid) {
+ if (!window.EventSource) {
+ alert("EventSource is not enabled in this browser");
+ return;
+ }
+ var source = new EventSource('/stream/'+roomid);
+ source.addEventListener('message', newChatMessage, false);
+ source.addEventListener('stats', stats, false);
+}
+
+function stats(e) {
+ var data = parseJSONStats(e.data);
+ heapChart.push(data.heap);
+ mallocsChart.push(data.mallocs);
+ messagesChart.push(data.messages);
+}
+
+function parseJSONStats(e) {
+ var data = jQuery.parseJSON(e);
+ var timestamp = data.timestamp;
+
+ var heap = [
+ {time: timestamp, y: data.HeapInuse},
+ {time: timestamp, y: data.StackInuse}
+ ];
+
+ var mallocs = [
+ {time: timestamp, y: data.Mallocs},
+ {time: timestamp, y: data.Frees}
+ ];
+ var messages = [
+ {time: timestamp, y: data.Connected},
+ {time: timestamp, y: data.Inbound},
+ {time: timestamp, y: data.Outbound}
+ ];
+
+ return {
+ heap: heap,
+ mallocs: mallocs,
+ messages: messages
+ }
+}
+
+function newChatMessage(e) {
+ var data = jQuery.parseJSON(e.data);
+ var nick = data.nick;
+ var message = data.message;
+ var style = rowStyle(nick);
+ var html = "<tr class=\""+style+"\"><td>"+nick+"</td><td>"+message+"</td></tr>";
+ $('#chat').append(html);
+
+ $("#chat-scroll").scrollTop($("#chat-scroll")[0].scrollHeight);
+}
+
+function histogram(windowSize, timestamp) {
+ var entries = new Array(windowSize);
+ for(var i = 0; i < windowSize; i++) {
+ entries[i] = {time: (timestamp-windowSize+i-1), y:0};
+ }
+ return entries;
+}
+
+var entityMap = {
+ "&": "&",
+ "<": "<",
+ ">": ">",
+ '"': '"',
+ "'": ''',
+ "/": '/'
+};
+
+function rowStyle(nick) {
+ var classes = ['active', 'success', 'info', 'warning', 'danger'];
+ var index = hashCode(nick)%5;
+ return classes[index];
+}
+
+function hashCode(s){
+ return Math.abs(s.split("").reduce(function(a,b){a=((a<<5)-a)+b.charCodeAt(0);return a&a},0));
+}
+
+function escapeHtml(string) {
+ return String(string).replace(/[&<>"'\/]/g, function (s) {
+ return entityMap[s];
+ });
+}
+
+window.StartRealtime = StartRealtime
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/rooms.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/rooms.go
new file mode 100644
index 0000000000000000000000000000000000000000..82396ba3797bcc3f155777714f107525298d5720
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/rooms.go
@@ -0,0 +1,25 @@
+package main
+
+import "github.com/dustin/go-broadcast"
+
+var roomChannels = make(map[string]broadcast.Broadcaster)
+
+func openListener(roomid string) chan interface{} {
+ listener := make(chan interface{})
+ room(roomid).Register(listener)
+ return listener
+}
+
+func closeListener(roomid string, listener chan interface{}) {
+ room(roomid).Unregister(listener)
+ close(listener)
+}
+
+func room(roomid string) broadcast.Broadcaster {
+ b, ok := roomChannels[roomid]
+ if !ok {
+ b = broadcast.NewBroadcaster(10)
+ roomChannels[roomid] = b
+ }
+ return b
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/routes.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/routes.go
new file mode 100644
index 0000000000000000000000000000000000000000..cc7c008794caa87208dac752f38f5d9bed2ce1d5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/routes.go
@@ -0,0 +1,96 @@
+package main
+
+import (
+ "fmt"
+ "html"
+ "io"
+ "strings"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
+)
+
+func rateLimit(c *gin.Context) {
+
+ ip := c.ClientIP()
+ value := int(ips.Add(ip, 1))
+ if value%50 == 0 {
+ fmt.Printf("ip: %s, count: %d\n", ip, value)
+ }
+ if value >= 200 {
+ if value%200 == 0 {
+ fmt.Println("ip blocked")
+ }
+ c.Abort()
+ c.String(503, "you were automatically banned :)")
+ }
+}
+
+func index(c *gin.Context) {
+ c.Redirect(301, "/room/hn")
+}
+
+func roomGET(c *gin.Context) {
+ roomid := c.Param("roomid")
+ nick := c.Query("nick")
+ if len(nick) < 2 {
+ nick = ""
+ }
+ if len(nick) > 13 {
+ nick = nick[0:12] + "..."
+ }
+ c.HTML(200, "room_login.templ.html", gin.H{
+ "roomid": roomid,
+ "nick": nick,
+ "timestamp": time.Now().Unix(),
+ })
+
+}
+
+func roomPOST(c *gin.Context) {
+ roomid := c.Param("roomid")
+ nick := c.Query("nick")
+ message := c.PostForm("message")
+ message = strings.TrimSpace(message)
+
+ validMessage := len(message) > 1 && len(message) < 200
+ validNick := len(nick) > 1 && len(nick) < 14
+ if !validMessage || !validNick {
+ c.JSON(400, gin.H{
+ "status": "failed",
+ "error": "the message or nickname is too long",
+ })
+ return
+ }
+
+ post := gin.H{
+ "nick": html.EscapeString(nick),
+ "message": html.EscapeString(message),
+ }
+ messages.Add("inbound", 1)
+ room(roomid).Submit(post)
+ c.JSON(200, post)
+}
+
+func streamRoom(c *gin.Context) {
+ roomid := c.Param("roomid")
+ listener := openListener(roomid)
+ ticker := time.NewTicker(1 * time.Second)
+ users.Add("connected", 1)
+ defer func() {
+ closeListener(roomid, listener)
+ ticker.Stop()
+ users.Add("disconnected", 1)
+ }()
+
+ c.Stream(func(w io.Writer) bool {
+ select {
+ case msg := <-listener:
+ messages.Add("outbound", 1)
+ c.SSEvent("message", msg)
+ case <-ticker.C:
+ c.SSEvent("stats", Stats())
+ }
+ return true
+ })
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/stats.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/stats.go
new file mode 100644
index 0000000000000000000000000000000000000000..c36ecc781d52b488d697021ab117c55d97c2f201
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-advanced/stats.go
@@ -0,0 +1,56 @@
+package main
+
+import (
+ "runtime"
+ "sync"
+ "time"
+
+ "github.com/manucorporat/stats"
+)
+
+var ips = stats.New()
+var messages = stats.New()
+var users = stats.New()
+var mutexStats sync.RWMutex
+var savedStats map[string]uint64
+
+func statsWorker() {
+ c := time.Tick(1 * time.Second)
+ var lastMallocs uint64 = 0
+ var lastFrees uint64 = 0
+ for _ = range c {
+ var stats runtime.MemStats
+ runtime.ReadMemStats(&stats)
+
+ mutexStats.Lock()
+ savedStats = map[string]uint64{
+ "timestamp": uint64(time.Now().Unix()),
+ "HeapInuse": stats.HeapInuse,
+ "StackInuse": stats.StackInuse,
+ "Mallocs": (stats.Mallocs - lastMallocs),
+ "Frees": (stats.Frees - lastFrees),
+ "Inbound": uint64(messages.Get("inbound")),
+ "Outbound": uint64(messages.Get("outbound")),
+ "Connected": connectedUsers(),
+ }
+ lastMallocs = stats.Mallocs
+ lastFrees = stats.Frees
+ messages.Reset()
+ mutexStats.Unlock()
+ }
+}
+
+func connectedUsers() uint64 {
+ connected := users.Get("connected") - users.Get("disconnected")
+ if connected < 0 {
+ return 0
+ }
+ return uint64(connected)
+}
+
+func Stats() map[string]uint64 {
+ mutexStats.RLock()
+ defer mutexStats.RUnlock()
+
+ return savedStats
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-chat/main.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-chat/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..8f7f473fd3bb6454b3e1bb5e8f3b1aea3ef48455
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-chat/main.go
@@ -0,0 +1,58 @@
+package main
+
+import (
+ "fmt"
+ "io"
+ "math/rand"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
+)
+
+func main() {
+ router := gin.Default()
+ router.SetHTMLTemplate(html)
+
+ router.GET("/room/:roomid", roomGET)
+ router.POST("/room/:roomid", roomPOST)
+ router.DELETE("/room/:roomid", roomDELETE)
+ router.GET("/stream/:roomid", stream)
+
+ router.Run(":8080")
+}
+
+func stream(c *gin.Context) {
+ roomid := c.Param("roomid")
+ listener := openListener(roomid)
+ defer closeListener(roomid, listener)
+
+ c.Stream(func(w io.Writer) bool {
+ c.SSEvent("message", <-listener)
+ return true
+ })
+}
+
+func roomGET(c *gin.Context) {
+ roomid := c.Param("roomid")
+ userid := fmt.Sprint(rand.Int31())
+ c.HTML(200, "chat_room", gin.H{
+ "roomid": roomid,
+ "userid": userid,
+ })
+}
+
+func roomPOST(c *gin.Context) {
+ roomid := c.Param("roomid")
+ userid := c.PostForm("user")
+ message := c.PostForm("message")
+ room(roomid).Submit(userid + ": " + message)
+
+ c.JSON(200, gin.H{
+ "status": "success",
+ "message": message,
+ })
+}
+
+func roomDELETE(c *gin.Context) {
+ roomid := c.Param("roomid")
+ deleteBroadcast(roomid)
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-chat/rooms.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-chat/rooms.go
new file mode 100644
index 0000000000000000000000000000000000000000..8c62bece1e63275aafe2d17364c7d3e63973368d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-chat/rooms.go
@@ -0,0 +1,33 @@
+package main
+
+import "github.com/dustin/go-broadcast"
+
+var roomChannels = make(map[string]broadcast.Broadcaster)
+
+func openListener(roomid string) chan interface{} {
+ listener := make(chan interface{})
+ room(roomid).Register(listener)
+ return listener
+}
+
+func closeListener(roomid string, listener chan interface{}) {
+ room(roomid).Unregister(listener)
+ close(listener)
+}
+
+func deleteBroadcast(roomid string) {
+ b, ok := roomChannels[roomid]
+ if ok {
+ b.Close()
+ delete(roomChannels, roomid)
+ }
+}
+
+func room(roomid string) broadcast.Broadcaster {
+ b, ok := roomChannels[roomid]
+ if !ok {
+ b = broadcast.NewBroadcaster(10)
+ roomChannels[roomid] = b
+ }
+ return b
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-chat/template.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-chat/template.go
new file mode 100644
index 0000000000000000000000000000000000000000..b9024de6da4804535c8c50290c38454cc2c6609c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/examples/realtime-chat/template.go
@@ -0,0 +1,44 @@
+package main
+
+import "html/template"
+
+var html = template.Must(template.New("chat_room").Parse(`
+<html>
+<head>
+ <title>{{.roomid}}</title>
+ <link rel="stylesheet" type="text/css" href="http://meyerweb.com/eric/tools/css/reset/reset.css"/>
+ <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7/jquery.js"></script>
+ <script src="http://malsup.github.com/jquery.form.js"></script>
+ <script>
+ $('#message_form').focus();
+ $(document).ready(function() {
+ // bind 'myForm' and provide a simple callback function
+ $('#myForm').ajaxForm(function() {
+ $('#message_form').val('');
+ $('#message_form').focus();
+ });
+
+ if (!!window.EventSource) {
+ var source = new EventSource('/stream/{{.roomid}}');
+ source.addEventListener('message', function(e) {
+ $('#messages').append(e.data + "</br>");
+ $('html, body').animate({scrollTop:$(document).height()}, 'slow');
+
+ }, false);
+ } else {
+ alert("NOT SUPPORTED");
+ }
+ });
+ </script>
+ </head>
+ <body>
+ <h1>Welcome to {{.roomid}} room</h1>
+ <div id="messages"></div>
+ <form id="myForm" action="/room/{{.roomid}}" method="post">
+ User: <input id="user_form" name="user" value="{{.userid}}"></input>
+ Message: <input id="message_form" name="message"></input>
+ <input type="submit" value="Submit" />
+ </form>
+</body>
+</html>
+`))
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/fs.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/fs.go
new file mode 100644
index 0000000000000000000000000000000000000000..f95dc84afdedb5a69f132a015c95527d0add5f31
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/fs.go
@@ -0,0 +1,43 @@
+package gin
+
+import (
+ "net/http"
+ "os"
+)
+
+type (
+ onlyfilesFS struct {
+ fs http.FileSystem
+ }
+ neuteredReaddirFile struct {
+ http.File
+ }
+)
+
+// It returns a http.Filesystem that can be used by http.FileServer(). It is used interally
+// in router.Static().
+// if listDirectory == true, then it works the same as http.Dir() otherwise it returns
+// a filesystem that prevents http.FileServer() to list the directory files.
+func Dir(root string, listDirectory bool) http.FileSystem {
+ fs := http.Dir(root)
+ if listDirectory {
+ return fs
+ } else {
+ return &onlyfilesFS{fs}
+ }
+}
+
+// Conforms to http.Filesystem
+func (fs onlyfilesFS) Open(name string) (http.File, error) {
+ f, err := fs.fs.Open(name)
+ if err != nil {
+ return nil, err
+ }
+ return neuteredReaddirFile{f}, nil
+}
+
+// Overrides the http.File default implementation
+func (f neuteredReaddirFile) Readdir(count int) ([]os.FileInfo, error) {
+ // this disables directory listing
+ return nil, nil
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/gin.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/gin.go
new file mode 100644
index 0000000000000000000000000000000000000000..dc0a08966545b0e393155f84bdbdb35244871d32
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/gin.go
@@ -0,0 +1,335 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "html/template"
+ "net"
+ "net/http"
+ "os"
+ "sync"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin/render"
+)
+
+const Version = "v1.0rc2"
+
+var default404Body = []byte("404 page not found")
+var default405Body = []byte("405 method not allowed")
+
+type (
+ HandlerFunc func(*Context)
+ HandlersChain []HandlerFunc
+
+ // Represents the web framework, it wraps the blazing fast httprouter multiplexer and a list of global middlewares.
+ Engine struct {
+ RouterGroup
+ HTMLRender render.HTMLRender
+ allNoRoute HandlersChain
+ allNoMethod HandlersChain
+ noRoute HandlersChain
+ noMethod HandlersChain
+ pool sync.Pool
+ trees methodTrees
+
+ // Enables automatic redirection if the current route can't be matched but a
+ // handler for the path with (without) the trailing slash exists.
+ // For example if /foo/ is requested but a route only exists for /foo, the
+ // client is redirected to /foo with http status code 301 for GET requests
+ // and 307 for all other request methods.
+ RedirectTrailingSlash bool
+
+ // If enabled, the router tries to fix the current request path, if no
+ // handle is registered for it.
+ // First superfluous path elements like ../ or // are removed.
+ // Afterwards the router does a case-insensitive lookup of the cleaned path.
+ // If a handle can be found for this route, the router makes a redirection
+ // to the corrected path with status code 301 for GET requests and 307 for
+ // all other request methods.
+ // For example /FOO and /..//Foo could be redirected to /foo.
+ // RedirectTrailingSlash is independent of this option.
+ RedirectFixedPath bool
+
+ // If enabled, the router checks if another method is allowed for the
+ // current route, if the current request can not be routed.
+ // If this is the case, the request is answered with 'Method Not Allowed'
+ // and HTTP status code 405.
+ // If no other Method is allowed, the request is delegated to the NotFound
+ // handler.
+ HandleMethodNotAllowed bool
+ ForwardedByClientIP bool
+ }
+)
+
+// Returns a new blank Engine instance without any middleware attached.
+// The most basic configuration
+func New() *Engine {
+ debugPrintWARNING()
+ engine := &Engine{
+ RouterGroup: RouterGroup{
+ Handlers: nil,
+ BasePath: "/",
+ root: true,
+ },
+ RedirectTrailingSlash: true,
+ RedirectFixedPath: false,
+ HandleMethodNotAllowed: false,
+ ForwardedByClientIP: true,
+ trees: make(methodTrees, 0, 9),
+ }
+ engine.RouterGroup.engine = engine
+ engine.pool.New = func() interface{} {
+ return engine.allocateContext()
+ }
+ return engine
+}
+
+// Returns a Engine instance with the Logger and Recovery already attached.
+func Default() *Engine {
+ engine := New()
+ engine.Use(Recovery(), Logger())
+ return engine
+}
+
+func (engine *Engine) allocateContext() *Context {
+ return &Context{engine: engine}
+}
+
+func (engine *Engine) LoadHTMLGlob(pattern string) {
+ if IsDebugging() {
+ engine.HTMLRender = render.HTMLDebug{Glob: pattern}
+ } else {
+ templ := template.Must(template.ParseGlob(pattern))
+ engine.SetHTMLTemplate(templ)
+ }
+}
+
+func (engine *Engine) LoadHTMLFiles(files ...string) {
+ if IsDebugging() {
+ engine.HTMLRender = render.HTMLDebug{Files: files}
+ } else {
+ templ := template.Must(template.ParseFiles(files...))
+ engine.SetHTMLTemplate(templ)
+ }
+}
+
+func (engine *Engine) SetHTMLTemplate(templ *template.Template) {
+ if len(engine.trees) > 0 {
+ debugPrint(`[WARNING] Since SetHTMLTemplate() is NOT thread-safe. It should only be called
+at initialization. ie. before any route is registered or the router is listening in a socket:
+
+ router := gin.Default()
+ router.SetHTMLTemplate(template) // << good place
+`)
+ }
+ engine.HTMLRender = render.HTMLProduction{Template: templ}
+}
+
+// Adds handlers for NoRoute. It return a 404 code by default.
+func (engine *Engine) NoRoute(handlers ...HandlerFunc) {
+ engine.noRoute = handlers
+ engine.rebuild404Handlers()
+}
+
+// Sets the handlers called when... TODO
+func (engine *Engine) NoMethod(handlers ...HandlerFunc) {
+ engine.noMethod = handlers
+ engine.rebuild405Handlers()
+}
+
+// Attachs a global middleware to the router. ie. the middlewares attached though Use() will be
+// included in the handlers chain for every single request. Even 404, 405, static files...
+// For example, this is the right place for a logger or error management middleware.
+func (engine *Engine) Use(middlewares ...HandlerFunc) routesInterface {
+ engine.RouterGroup.Use(middlewares...)
+ engine.rebuild404Handlers()
+ engine.rebuild405Handlers()
+ return engine
+}
+
+func (engine *Engine) rebuild404Handlers() {
+ engine.allNoRoute = engine.combineHandlers(engine.noRoute)
+}
+
+func (engine *Engine) rebuild405Handlers() {
+ engine.allNoMethod = engine.combineHandlers(engine.noMethod)
+}
+
+func (engine *Engine) addRoute(method, path string, handlers HandlersChain) {
+ debugPrintRoute(method, path, handlers)
+
+ if path[0] != '/' {
+ panic("path must begin with '/'")
+ }
+ if method == "" {
+ panic("HTTP method can not be empty")
+ }
+ if len(handlers) == 0 {
+ panic("there must be at least one handler")
+ }
+
+ root := engine.trees.get(method)
+ if root == nil {
+ root = new(node)
+ engine.trees = append(engine.trees, methodTree{
+ method: method,
+ root: root,
+ })
+ }
+ root.addRoute(path, handlers)
+}
+
+// The router is attached to a http.Server and starts listening and serving HTTP requests.
+// It is a shortcut for http.ListenAndServe(addr, router)
+// Note: this method will block the calling goroutine undefinitelly unless an error happens.
+func (engine *Engine) Run(addr string) (err error) {
+ debugPrint("Listening and serving HTTP on %s\n", addr)
+ defer func() { debugPrintError(err) }()
+
+ err = http.ListenAndServe(addr, engine)
+ return
+}
+
+// The router is attached to a http.Server and starts listening and serving HTTPS requests.
+// It is a shortcut for http.ListenAndServeTLS(addr, certFile, keyFile, router)
+// Note: this method will block the calling goroutine undefinitelly unless an error happens.
+func (engine *Engine) RunTLS(addr string, certFile string, keyFile string) (err error) {
+ debugPrint("Listening and serving HTTPS on %s\n", addr)
+ defer func() { debugPrintError(err) }()
+
+ err = http.ListenAndServeTLS(addr, certFile, keyFile, engine)
+ return
+}
+
+// The router is attached to a http.Server and starts listening and serving HTTP requests
+// through the specified unix socket (ie. a file)
+// Note: this method will block the calling goroutine undefinitelly unless an error happens.
+func (engine *Engine) RunUnix(file string) (err error) {
+ debugPrint("Listening and serving HTTP on unix:/%s", file)
+ defer func() { debugPrintError(err) }()
+
+ os.Remove(file)
+ listener, err := net.Listen("unix", file)
+ if err != nil {
+ return
+ }
+ defer listener.Close()
+ err = http.Serve(listener, engine)
+ return
+}
+
+// Conforms to the http.Handler interface.
+func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+ c := engine.pool.Get().(*Context)
+ c.writermem.reset(w)
+ c.Request = req
+ c.reset()
+
+ engine.handleHTTPRequest(c)
+
+ engine.pool.Put(c)
+}
+
+func (engine *Engine) handleHTTPRequest(context *Context) {
+ httpMethod := context.Request.Method
+ path := context.Request.URL.Path
+
+ // Find root of the tree for the given HTTP method
+ t := engine.trees
+ for i, tl := 0, len(t); i < tl; i++ {
+ if t[i].method == httpMethod {
+ root := t[i].root
+ // Find route in tree
+ handlers, params, tsr := root.getValue(path, context.Params)
+ if handlers != nil {
+ context.handlers = handlers
+ context.Params = params
+ context.Next()
+ context.writermem.WriteHeaderNow()
+ return
+
+ } else if httpMethod != "CONNECT" && path != "/" {
+ if tsr && engine.RedirectFixedPath {
+ redirectTrailingSlash(context)
+ return
+ }
+ if engine.RedirectFixedPath && redirectFixedPath(context, root, engine.RedirectFixedPath) {
+ return
+ }
+ }
+ break
+ }
+ }
+
+ // TODO: unit test
+ if engine.HandleMethodNotAllowed {
+ for _, tree := range engine.trees {
+ if tree.method != httpMethod {
+ if handlers, _, _ := tree.root.getValue(path, nil); handlers != nil {
+ context.handlers = engine.allNoMethod
+ serveError(context, 405, default405Body)
+ return
+ }
+ }
+ }
+ }
+ context.handlers = engine.allNoRoute
+ serveError(context, 404, default404Body)
+}
+
+var mimePlain = []string{MIMEPlain}
+
+func serveError(c *Context, code int, defaultMessage []byte) {
+ c.writermem.status = code
+ c.Next()
+ if !c.writermem.Written() {
+ if c.writermem.Status() == code {
+ c.writermem.Header()["Content-Type"] = mimePlain
+ c.Writer.Write(defaultMessage)
+ } else {
+ c.writermem.WriteHeaderNow()
+ }
+ }
+}
+
+func redirectTrailingSlash(c *Context) {
+ req := c.Request
+ path := req.URL.Path
+ code := 301 // Permanent redirect, request with GET method
+ if req.Method != "GET" {
+ code = 307
+ }
+
+ if len(path) > 1 && path[len(path)-1] == '/' {
+ req.URL.Path = path[:len(path)-1]
+ } else {
+ req.URL.Path = path + "/"
+ }
+ debugPrint("redirecting request %d: %s --> %s", code, path, req.URL.String())
+ http.Redirect(c.Writer, req, req.URL.String(), code)
+ c.writermem.WriteHeaderNow()
+}
+
+func redirectFixedPath(c *Context, root *node, trailingSlash bool) bool {
+ req := c.Request
+ path := req.URL.Path
+
+ fixedPath, found := root.findCaseInsensitivePath(
+ cleanPath(path),
+ trailingSlash,
+ )
+ if found {
+ code := 301 // Permanent redirect, request with GET method
+ if req.Method != "GET" {
+ code = 307
+ }
+ req.URL.Path = string(fixedPath)
+ debugPrint("redirecting request %d: %s --> %s", code, path, req.URL.String())
+ http.Redirect(c.Writer, req, req.URL.String(), code)
+ c.writermem.WriteHeaderNow()
+ return true
+ }
+ return false
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/gin_integration_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/gin_integration_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..fe2fe754249a0cf4762696477f67ca7b8467582a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/gin_integration_test.go
@@ -0,0 +1,69 @@
+package gin
+
+import (
+ "bufio"
+ "bytes"
+ "fmt"
+ "io/ioutil"
+ "net"
+ "net/http"
+ "testing"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+func TestRun(t *testing.T) {
+ buffer := new(bytes.Buffer)
+ router := New()
+ go func() {
+ router.Use(LoggerWithWriter(buffer))
+ router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
+ router.Run(":5150")
+ }()
+ // have to wait for the goroutine to start and run the server
+ // otherwise the main thread will complete
+ time.Sleep(5 * time.Millisecond)
+
+ assert.Error(t, router.Run(":5150"))
+
+ resp, err := http.Get("http://localhost:5150/example")
+ defer resp.Body.Close()
+ assert.NoError(t, err)
+
+ body, ioerr := ioutil.ReadAll(resp.Body)
+ assert.NoError(t, ioerr)
+ assert.Equal(t, "it worked", string(body[:]), "resp body should match")
+ assert.Equal(t, "200 OK", resp.Status, "should get a 200")
+}
+
+func TestUnixSocket(t *testing.T) {
+ buffer := new(bytes.Buffer)
+ router := New()
+
+ go func() {
+ router.Use(LoggerWithWriter(buffer))
+ router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
+ router.RunUnix("/tmp/unix_unit_test")
+ }()
+ // have to wait for the goroutine to start and run the server
+ // otherwise the main thread will complete
+ time.Sleep(5 * time.Millisecond)
+
+ c, err := net.Dial("unix", "/tmp/unix_unit_test")
+ assert.NoError(t, err)
+
+ fmt.Fprintf(c, "GET /example HTTP/1.0\r\n\r\n")
+ scanner := bufio.NewScanner(c)
+ var response string
+ for scanner.Scan() {
+ response += scanner.Text()
+ }
+ assert.Contains(t, response, "HTTP/1.0 200", "should get a 200")
+ assert.Contains(t, response, "it worked", "resp body should match")
+}
+
+func TestBadUnixSocket(t *testing.T) {
+ router := New()
+ assert.Error(t, router.RunUnix("#/tmp/unix_unit_test"))
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/gin_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/gin_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..34659ef7c654a96e8f14174b36eb58b29a170660
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/gin_test.go
@@ -0,0 +1,182 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "reflect"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+//TODO
+// func (engine *Engine) LoadHTMLGlob(pattern string) {
+// func (engine *Engine) LoadHTMLFiles(files ...string) {
+// func (engine *Engine) Run(addr string) error {
+// func (engine *Engine) RunTLS(addr string, cert string, key string) error {
+
+func init() {
+ SetMode(TestMode)
+}
+
+func TestCreateEngine(t *testing.T) {
+ router := New()
+ assert.Equal(t, "/", router.BasePath)
+ assert.Equal(t, router.engine, router)
+ assert.Empty(t, router.Handlers)
+}
+
+func TestAddRoute(t *testing.T) {
+ router := New()
+ router.addRoute("GET", "/", HandlersChain{func(_ *Context) {}})
+
+ assert.Len(t, router.trees, 1)
+ assert.NotNil(t, router.trees.get("GET"))
+ assert.Nil(t, router.trees.get("POST"))
+
+ router.addRoute("POST", "/", HandlersChain{func(_ *Context) {}})
+
+ assert.Len(t, router.trees, 2)
+ assert.NotNil(t, router.trees.get("GET"))
+ assert.NotNil(t, router.trees.get("POST"))
+
+ router.addRoute("POST", "/post", HandlersChain{func(_ *Context) {}})
+ assert.Len(t, router.trees, 2)
+}
+
+func TestAddRouteFails(t *testing.T) {
+ router := New()
+ assert.Panics(t, func() { router.addRoute("", "/", HandlersChain{func(_ *Context) {}}) })
+ assert.Panics(t, func() { router.addRoute("GET", "a", HandlersChain{func(_ *Context) {}}) })
+ assert.Panics(t, func() { router.addRoute("GET", "/", HandlersChain{}) })
+
+ router.addRoute("POST", "/post", HandlersChain{func(_ *Context) {}})
+ assert.Panics(t, func() {
+ router.addRoute("POST", "/post", HandlersChain{func(_ *Context) {}})
+ })
+}
+
+func TestCreateDefaultRouter(t *testing.T) {
+ router := Default()
+ assert.Len(t, router.Handlers, 2)
+}
+
+func TestNoRouteWithoutGlobalHandlers(t *testing.T) {
+ var middleware0 HandlerFunc = func(c *Context) {}
+ var middleware1 HandlerFunc = func(c *Context) {}
+
+ router := New()
+
+ router.NoRoute(middleware0)
+ assert.Nil(t, router.Handlers)
+ assert.Len(t, router.noRoute, 1)
+ assert.Len(t, router.allNoRoute, 1)
+ compareFunc(t, router.noRoute[0], middleware0)
+ compareFunc(t, router.allNoRoute[0], middleware0)
+
+ router.NoRoute(middleware1, middleware0)
+ assert.Len(t, router.noRoute, 2)
+ assert.Len(t, router.allNoRoute, 2)
+ compareFunc(t, router.noRoute[0], middleware1)
+ compareFunc(t, router.allNoRoute[0], middleware1)
+ compareFunc(t, router.noRoute[1], middleware0)
+ compareFunc(t, router.allNoRoute[1], middleware0)
+}
+
+func TestNoRouteWithGlobalHandlers(t *testing.T) {
+ var middleware0 HandlerFunc = func(c *Context) {}
+ var middleware1 HandlerFunc = func(c *Context) {}
+ var middleware2 HandlerFunc = func(c *Context) {}
+
+ router := New()
+ router.Use(middleware2)
+
+ router.NoRoute(middleware0)
+ assert.Len(t, router.allNoRoute, 2)
+ assert.Len(t, router.Handlers, 1)
+ assert.Len(t, router.noRoute, 1)
+
+ compareFunc(t, router.Handlers[0], middleware2)
+ compareFunc(t, router.noRoute[0], middleware0)
+ compareFunc(t, router.allNoRoute[0], middleware2)
+ compareFunc(t, router.allNoRoute[1], middleware0)
+
+ router.Use(middleware1)
+ assert.Len(t, router.allNoRoute, 3)
+ assert.Len(t, router.Handlers, 2)
+ assert.Len(t, router.noRoute, 1)
+
+ compareFunc(t, router.Handlers[0], middleware2)
+ compareFunc(t, router.Handlers[1], middleware1)
+ compareFunc(t, router.noRoute[0], middleware0)
+ compareFunc(t, router.allNoRoute[0], middleware2)
+ compareFunc(t, router.allNoRoute[1], middleware1)
+ compareFunc(t, router.allNoRoute[2], middleware0)
+}
+
+func TestNoMethodWithoutGlobalHandlers(t *testing.T) {
+ var middleware0 HandlerFunc = func(c *Context) {}
+ var middleware1 HandlerFunc = func(c *Context) {}
+
+ router := New()
+
+ router.NoMethod(middleware0)
+ assert.Empty(t, router.Handlers)
+ assert.Len(t, router.noMethod, 1)
+ assert.Len(t, router.allNoMethod, 1)
+ compareFunc(t, router.noMethod[0], middleware0)
+ compareFunc(t, router.allNoMethod[0], middleware0)
+
+ router.NoMethod(middleware1, middleware0)
+ assert.Len(t, router.noMethod, 2)
+ assert.Len(t, router.allNoMethod, 2)
+ compareFunc(t, router.noMethod[0], middleware1)
+ compareFunc(t, router.allNoMethod[0], middleware1)
+ compareFunc(t, router.noMethod[1], middleware0)
+ compareFunc(t, router.allNoMethod[1], middleware0)
+}
+
+func TestRebuild404Handlers(t *testing.T) {
+
+}
+
+func TestNoMethodWithGlobalHandlers(t *testing.T) {
+ var middleware0 HandlerFunc = func(c *Context) {}
+ var middleware1 HandlerFunc = func(c *Context) {}
+ var middleware2 HandlerFunc = func(c *Context) {}
+
+ router := New()
+ router.Use(middleware2)
+
+ router.NoMethod(middleware0)
+ assert.Len(t, router.allNoMethod, 2)
+ assert.Len(t, router.Handlers, 1)
+ assert.Len(t, router.noMethod, 1)
+
+ compareFunc(t, router.Handlers[0], middleware2)
+ compareFunc(t, router.noMethod[0], middleware0)
+ compareFunc(t, router.allNoMethod[0], middleware2)
+ compareFunc(t, router.allNoMethod[1], middleware0)
+
+ router.Use(middleware1)
+ assert.Len(t, router.allNoMethod, 3)
+ assert.Len(t, router.Handlers, 2)
+ assert.Len(t, router.noMethod, 1)
+
+ compareFunc(t, router.Handlers[0], middleware2)
+ compareFunc(t, router.Handlers[1], middleware1)
+ compareFunc(t, router.noMethod[0], middleware0)
+ compareFunc(t, router.allNoMethod[0], middleware2)
+ compareFunc(t, router.allNoMethod[1], middleware1)
+ compareFunc(t, router.allNoMethod[2], middleware0)
+}
+
+func compareFunc(t *testing.T, a, b interface{}) {
+ sf1 := reflect.ValueOf(a)
+ sf2 := reflect.ValueOf(b)
+ if sf1.Pointer() != sf2.Pointer() {
+ t.Error("different functions")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/githubapi_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/githubapi_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..fe2328246665397d8cbb28ec0547c708a78e3919
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/githubapi_test.go
@@ -0,0 +1,389 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "bytes"
+ "fmt"
+ "math/rand"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+type route struct {
+ method string
+ path string
+}
+
+// http://developer.github.com/v3/
+var githubAPI = []route{
+ // OAuth Authorizations
+ {"GET", "/authorizations"},
+ {"GET", "/authorizations/:id"},
+ {"POST", "/authorizations"},
+ //{"PUT", "/authorizations/clients/:client_id"},
+ //{"PATCH", "/authorizations/:id"},
+ {"DELETE", "/authorizations/:id"},
+ {"GET", "/applications/:client_id/tokens/:access_token"},
+ {"DELETE", "/applications/:client_id/tokens"},
+ {"DELETE", "/applications/:client_id/tokens/:access_token"},
+
+ // Activity
+ {"GET", "/events"},
+ {"GET", "/repos/:owner/:repo/events"},
+ {"GET", "/networks/:owner/:repo/events"},
+ {"GET", "/orgs/:org/events"},
+ {"GET", "/users/:user/received_events"},
+ {"GET", "/users/:user/received_events/public"},
+ {"GET", "/users/:user/events"},
+ {"GET", "/users/:user/events/public"},
+ {"GET", "/users/:user/events/orgs/:org"},
+ {"GET", "/feeds"},
+ {"GET", "/notifications"},
+ {"GET", "/repos/:owner/:repo/notifications"},
+ {"PUT", "/notifications"},
+ {"PUT", "/repos/:owner/:repo/notifications"},
+ {"GET", "/notifications/threads/:id"},
+ //{"PATCH", "/notifications/threads/:id"},
+ {"GET", "/notifications/threads/:id/subscription"},
+ {"PUT", "/notifications/threads/:id/subscription"},
+ {"DELETE", "/notifications/threads/:id/subscription"},
+ {"GET", "/repos/:owner/:repo/stargazers"},
+ {"GET", "/users/:user/starred"},
+ {"GET", "/user/starred"},
+ {"GET", "/user/starred/:owner/:repo"},
+ {"PUT", "/user/starred/:owner/:repo"},
+ {"DELETE", "/user/starred/:owner/:repo"},
+ {"GET", "/repos/:owner/:repo/subscribers"},
+ {"GET", "/users/:user/subscriptions"},
+ {"GET", "/user/subscriptions"},
+ {"GET", "/repos/:owner/:repo/subscription"},
+ {"PUT", "/repos/:owner/:repo/subscription"},
+ {"DELETE", "/repos/:owner/:repo/subscription"},
+ {"GET", "/user/subscriptions/:owner/:repo"},
+ {"PUT", "/user/subscriptions/:owner/:repo"},
+ {"DELETE", "/user/subscriptions/:owner/:repo"},
+
+ // Gists
+ {"GET", "/users/:user/gists"},
+ {"GET", "/gists"},
+ //{"GET", "/gists/public"},
+ //{"GET", "/gists/starred"},
+ {"GET", "/gists/:id"},
+ {"POST", "/gists"},
+ //{"PATCH", "/gists/:id"},
+ {"PUT", "/gists/:id/star"},
+ {"DELETE", "/gists/:id/star"},
+ {"GET", "/gists/:id/star"},
+ {"POST", "/gists/:id/forks"},
+ {"DELETE", "/gists/:id"},
+
+ // Git Data
+ {"GET", "/repos/:owner/:repo/git/blobs/:sha"},
+ {"POST", "/repos/:owner/:repo/git/blobs"},
+ {"GET", "/repos/:owner/:repo/git/commits/:sha"},
+ {"POST", "/repos/:owner/:repo/git/commits"},
+ //{"GET", "/repos/:owner/:repo/git/refs/*ref"},
+ {"GET", "/repos/:owner/:repo/git/refs"},
+ {"POST", "/repos/:owner/:repo/git/refs"},
+ //{"PATCH", "/repos/:owner/:repo/git/refs/*ref"},
+ //{"DELETE", "/repos/:owner/:repo/git/refs/*ref"},
+ {"GET", "/repos/:owner/:repo/git/tags/:sha"},
+ {"POST", "/repos/:owner/:repo/git/tags"},
+ {"GET", "/repos/:owner/:repo/git/trees/:sha"},
+ {"POST", "/repos/:owner/:repo/git/trees"},
+
+ // Issues
+ {"GET", "/issues"},
+ {"GET", "/user/issues"},
+ {"GET", "/orgs/:org/issues"},
+ {"GET", "/repos/:owner/:repo/issues"},
+ {"GET", "/repos/:owner/:repo/issues/:number"},
+ {"POST", "/repos/:owner/:repo/issues"},
+ //{"PATCH", "/repos/:owner/:repo/issues/:number"},
+ {"GET", "/repos/:owner/:repo/assignees"},
+ {"GET", "/repos/:owner/:repo/assignees/:assignee"},
+ {"GET", "/repos/:owner/:repo/issues/:number/comments"},
+ //{"GET", "/repos/:owner/:repo/issues/comments"},
+ //{"GET", "/repos/:owner/:repo/issues/comments/:id"},
+ {"POST", "/repos/:owner/:repo/issues/:number/comments"},
+ //{"PATCH", "/repos/:owner/:repo/issues/comments/:id"},
+ //{"DELETE", "/repos/:owner/:repo/issues/comments/:id"},
+ {"GET", "/repos/:owner/:repo/issues/:number/events"},
+ //{"GET", "/repos/:owner/:repo/issues/events"},
+ //{"GET", "/repos/:owner/:repo/issues/events/:id"},
+ {"GET", "/repos/:owner/:repo/labels"},
+ {"GET", "/repos/:owner/:repo/labels/:name"},
+ {"POST", "/repos/:owner/:repo/labels"},
+ //{"PATCH", "/repos/:owner/:repo/labels/:name"},
+ {"DELETE", "/repos/:owner/:repo/labels/:name"},
+ {"GET", "/repos/:owner/:repo/issues/:number/labels"},
+ {"POST", "/repos/:owner/:repo/issues/:number/labels"},
+ {"DELETE", "/repos/:owner/:repo/issues/:number/labels/:name"},
+ {"PUT", "/repos/:owner/:repo/issues/:number/labels"},
+ {"DELETE", "/repos/:owner/:repo/issues/:number/labels"},
+ {"GET", "/repos/:owner/:repo/milestones/:number/labels"},
+ {"GET", "/repos/:owner/:repo/milestones"},
+ {"GET", "/repos/:owner/:repo/milestones/:number"},
+ {"POST", "/repos/:owner/:repo/milestones"},
+ //{"PATCH", "/repos/:owner/:repo/milestones/:number"},
+ {"DELETE", "/repos/:owner/:repo/milestones/:number"},
+
+ // Miscellaneous
+ {"GET", "/emojis"},
+ {"GET", "/gitignore/templates"},
+ {"GET", "/gitignore/templates/:name"},
+ {"POST", "/markdown"},
+ {"POST", "/markdown/raw"},
+ {"GET", "/meta"},
+ {"GET", "/rate_limit"},
+
+ // Organizations
+ {"GET", "/users/:user/orgs"},
+ {"GET", "/user/orgs"},
+ {"GET", "/orgs/:org"},
+ //{"PATCH", "/orgs/:org"},
+ {"GET", "/orgs/:org/members"},
+ {"GET", "/orgs/:org/members/:user"},
+ {"DELETE", "/orgs/:org/members/:user"},
+ {"GET", "/orgs/:org/public_members"},
+ {"GET", "/orgs/:org/public_members/:user"},
+ {"PUT", "/orgs/:org/public_members/:user"},
+ {"DELETE", "/orgs/:org/public_members/:user"},
+ {"GET", "/orgs/:org/teams"},
+ {"GET", "/teams/:id"},
+ {"POST", "/orgs/:org/teams"},
+ //{"PATCH", "/teams/:id"},
+ {"DELETE", "/teams/:id"},
+ {"GET", "/teams/:id/members"},
+ {"GET", "/teams/:id/members/:user"},
+ {"PUT", "/teams/:id/members/:user"},
+ {"DELETE", "/teams/:id/members/:user"},
+ {"GET", "/teams/:id/repos"},
+ {"GET", "/teams/:id/repos/:owner/:repo"},
+ {"PUT", "/teams/:id/repos/:owner/:repo"},
+ {"DELETE", "/teams/:id/repos/:owner/:repo"},
+ {"GET", "/user/teams"},
+
+ // Pull Requests
+ {"GET", "/repos/:owner/:repo/pulls"},
+ {"GET", "/repos/:owner/:repo/pulls/:number"},
+ {"POST", "/repos/:owner/:repo/pulls"},
+ //{"PATCH", "/repos/:owner/:repo/pulls/:number"},
+ {"GET", "/repos/:owner/:repo/pulls/:number/commits"},
+ {"GET", "/repos/:owner/:repo/pulls/:number/files"},
+ {"GET", "/repos/:owner/:repo/pulls/:number/merge"},
+ {"PUT", "/repos/:owner/:repo/pulls/:number/merge"},
+ {"GET", "/repos/:owner/:repo/pulls/:number/comments"},
+ //{"GET", "/repos/:owner/:repo/pulls/comments"},
+ //{"GET", "/repos/:owner/:repo/pulls/comments/:number"},
+ {"PUT", "/repos/:owner/:repo/pulls/:number/comments"},
+ //{"PATCH", "/repos/:owner/:repo/pulls/comments/:number"},
+ //{"DELETE", "/repos/:owner/:repo/pulls/comments/:number"},
+
+ // Repositories
+ {"GET", "/user/repos"},
+ {"GET", "/users/:user/repos"},
+ {"GET", "/orgs/:org/repos"},
+ {"GET", "/repositories"},
+ {"POST", "/user/repos"},
+ {"POST", "/orgs/:org/repos"},
+ {"GET", "/repos/:owner/:repo"},
+ //{"PATCH", "/repos/:owner/:repo"},
+ {"GET", "/repos/:owner/:repo/contributors"},
+ {"GET", "/repos/:owner/:repo/languages"},
+ {"GET", "/repos/:owner/:repo/teams"},
+ {"GET", "/repos/:owner/:repo/tags"},
+ {"GET", "/repos/:owner/:repo/branches"},
+ {"GET", "/repos/:owner/:repo/branches/:branch"},
+ {"DELETE", "/repos/:owner/:repo"},
+ {"GET", "/repos/:owner/:repo/collaborators"},
+ {"GET", "/repos/:owner/:repo/collaborators/:user"},
+ {"PUT", "/repos/:owner/:repo/collaborators/:user"},
+ {"DELETE", "/repos/:owner/:repo/collaborators/:user"},
+ {"GET", "/repos/:owner/:repo/comments"},
+ {"GET", "/repos/:owner/:repo/commits/:sha/comments"},
+ {"POST", "/repos/:owner/:repo/commits/:sha/comments"},
+ {"GET", "/repos/:owner/:repo/comments/:id"},
+ //{"PATCH", "/repos/:owner/:repo/comments/:id"},
+ {"DELETE", "/repos/:owner/:repo/comments/:id"},
+ {"GET", "/repos/:owner/:repo/commits"},
+ {"GET", "/repos/:owner/:repo/commits/:sha"},
+ {"GET", "/repos/:owner/:repo/readme"},
+ //{"GET", "/repos/:owner/:repo/contents/*path"},
+ //{"PUT", "/repos/:owner/:repo/contents/*path"},
+ //{"DELETE", "/repos/:owner/:repo/contents/*path"},
+ //{"GET", "/repos/:owner/:repo/:archive_format/:ref"},
+ {"GET", "/repos/:owner/:repo/keys"},
+ {"GET", "/repos/:owner/:repo/keys/:id"},
+ {"POST", "/repos/:owner/:repo/keys"},
+ //{"PATCH", "/repos/:owner/:repo/keys/:id"},
+ {"DELETE", "/repos/:owner/:repo/keys/:id"},
+ {"GET", "/repos/:owner/:repo/downloads"},
+ {"GET", "/repos/:owner/:repo/downloads/:id"},
+ {"DELETE", "/repos/:owner/:repo/downloads/:id"},
+ {"GET", "/repos/:owner/:repo/forks"},
+ {"POST", "/repos/:owner/:repo/forks"},
+ {"GET", "/repos/:owner/:repo/hooks"},
+ {"GET", "/repos/:owner/:repo/hooks/:id"},
+ {"POST", "/repos/:owner/:repo/hooks"},
+ //{"PATCH", "/repos/:owner/:repo/hooks/:id"},
+ {"POST", "/repos/:owner/:repo/hooks/:id/tests"},
+ {"DELETE", "/repos/:owner/:repo/hooks/:id"},
+ {"POST", "/repos/:owner/:repo/merges"},
+ {"GET", "/repos/:owner/:repo/releases"},
+ {"GET", "/repos/:owner/:repo/releases/:id"},
+ {"POST", "/repos/:owner/:repo/releases"},
+ //{"PATCH", "/repos/:owner/:repo/releases/:id"},
+ {"DELETE", "/repos/:owner/:repo/releases/:id"},
+ {"GET", "/repos/:owner/:repo/releases/:id/assets"},
+ {"GET", "/repos/:owner/:repo/stats/contributors"},
+ {"GET", "/repos/:owner/:repo/stats/commit_activity"},
+ {"GET", "/repos/:owner/:repo/stats/code_frequency"},
+ {"GET", "/repos/:owner/:repo/stats/participation"},
+ {"GET", "/repos/:owner/:repo/stats/punch_card"},
+ {"GET", "/repos/:owner/:repo/statuses/:ref"},
+ {"POST", "/repos/:owner/:repo/statuses/:ref"},
+
+ // Search
+ {"GET", "/search/repositories"},
+ {"GET", "/search/code"},
+ {"GET", "/search/issues"},
+ {"GET", "/search/users"},
+ {"GET", "/legacy/issues/search/:owner/:repository/:state/:keyword"},
+ {"GET", "/legacy/repos/search/:keyword"},
+ {"GET", "/legacy/user/search/:keyword"},
+ {"GET", "/legacy/user/email/:email"},
+
+ // Users
+ {"GET", "/users/:user"},
+ {"GET", "/user"},
+ //{"PATCH", "/user"},
+ {"GET", "/users"},
+ {"GET", "/user/emails"},
+ {"POST", "/user/emails"},
+ {"DELETE", "/user/emails"},
+ {"GET", "/users/:user/followers"},
+ {"GET", "/user/followers"},
+ {"GET", "/users/:user/following"},
+ {"GET", "/user/following"},
+ {"GET", "/user/following/:user"},
+ {"GET", "/users/:user/following/:target_user"},
+ {"PUT", "/user/following/:user"},
+ {"DELETE", "/user/following/:user"},
+ {"GET", "/users/:user/keys"},
+ {"GET", "/user/keys"},
+ {"GET", "/user/keys/:id"},
+ {"POST", "/user/keys"},
+ //{"PATCH", "/user/keys/:id"},
+ {"DELETE", "/user/keys/:id"},
+}
+
+func githubConfigRouter(router *Engine) {
+ for _, route := range githubAPI {
+ router.Handle(route.method, route.path, func(c *Context) {
+ output := make(map[string]string, len(c.Params)+1)
+ output["status"] = "good"
+ for _, param := range c.Params {
+ output[param.Key] = param.Value
+ }
+ c.JSON(200, output)
+ })
+ }
+}
+
+func TestGithubAPI(t *testing.T) {
+ DefaultWriter = newMockWriter()
+ router := Default()
+ githubConfigRouter(router)
+
+ for _, route := range githubAPI {
+ path, values := exampleFromPath(route.path)
+ w := performRequest(router, route.method, path)
+
+ // TEST
+ assert.Contains(t, w.Body.String(), "\"status\":\"good\"")
+ for _, value := range values {
+ str := fmt.Sprintf("\"%s\":\"%s\"", value.Key, value.Value)
+ assert.Contains(t, w.Body.String(), str)
+ }
+ }
+}
+
+func exampleFromPath(path string) (string, Params) {
+ output := new(bytes.Buffer)
+ params := make(Params, 0, 6)
+ start := -1
+ for i, c := range path {
+ if c == ':' {
+ start = i + 1
+ }
+ if start >= 0 {
+ if c == '/' {
+ value := fmt.Sprint(rand.Intn(100000))
+ params = append(params, Param{
+ Key: path[start:i],
+ Value: value,
+ })
+ output.WriteString(value)
+ output.WriteRune(c)
+ start = -1
+ }
+ } else {
+ output.WriteRune(c)
+ }
+ }
+ if start >= 0 {
+ value := fmt.Sprint(rand.Intn(100000))
+ params = append(params, Param{
+ Key: path[start:len(path)],
+ Value: value,
+ })
+ output.WriteString(value)
+ }
+
+ return output.String(), params
+}
+
+func BenchmarkGithub(b *testing.B) {
+ router := New()
+ githubConfigRouter(router)
+ runRequest(b, router, "GET", "/legacy/issues/search/:owner/:repository/:state/:keyword")
+}
+
+func BenchmarkParallelGithub(b *testing.B) {
+ DefaultWriter = newMockWriter()
+ router := New()
+ githubConfigRouter(router)
+
+ req, _ := http.NewRequest("POST", "/repos/manucorporat/sse/git/blobs", nil)
+
+ b.RunParallel(func(pb *testing.PB) {
+ // Each goroutine has its own bytes.Buffer.
+ for pb.Next() {
+ w := httptest.NewRecorder()
+ router.ServeHTTP(w, req)
+ }
+ })
+}
+
+func BenchmarkParallelGithubDefault(b *testing.B) {
+ DefaultWriter = newMockWriter()
+ router := Default()
+ githubConfigRouter(router)
+
+ req, _ := http.NewRequest("POST", "/repos/manucorporat/sse/git/blobs", nil)
+
+ b.RunParallel(func(pb *testing.PB) {
+ // Each goroutine has its own bytes.Buffer.
+ for pb.Next() {
+ w := httptest.NewRecorder()
+ router.ServeHTTP(w, req)
+ }
+ })
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/logger.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/logger.go
new file mode 100644
index 0000000000000000000000000000000000000000..e0f9b36738631ba4aa5d1c4e389ab91773aa9af8
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/logger.go
@@ -0,0 +1,113 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "fmt"
+ "io"
+ "time"
+)
+
+var (
+ green = string([]byte{27, 91, 57, 55, 59, 52, 50, 109})
+ white = string([]byte{27, 91, 57, 48, 59, 52, 55, 109})
+ yellow = string([]byte{27, 91, 57, 55, 59, 52, 51, 109})
+ red = string([]byte{27, 91, 57, 55, 59, 52, 49, 109})
+ blue = string([]byte{27, 91, 57, 55, 59, 52, 52, 109})
+ magenta = string([]byte{27, 91, 57, 55, 59, 52, 53, 109})
+ cyan = string([]byte{27, 91, 57, 55, 59, 52, 54, 109})
+ reset = string([]byte{27, 91, 48, 109})
+)
+
+func ErrorLogger() HandlerFunc {
+ return ErrorLoggerT(ErrorTypeAny)
+}
+
+func ErrorLoggerT(typ ErrorType) HandlerFunc {
+ return func(c *Context) {
+ c.Next()
+ // avoid writting if we already wrote into the response body
+ if !c.Writer.Written() {
+ errors := c.Errors.ByType(typ)
+ if len(errors) > 0 {
+ c.JSON(-1, errors)
+ }
+ }
+ }
+}
+
+// Instances a Logger middleware that will write the logs to gin.DefaultWriter
+// By default gin.DefaultWriter = os.Stdout
+func Logger() HandlerFunc {
+ return LoggerWithWriter(DefaultWriter)
+}
+
+// Instance a Logger middleware with the specified writter buffer.
+// Example: os.Stdout, a file opened in write mode, a socket...
+func LoggerWithWriter(out io.Writer) HandlerFunc {
+ return func(c *Context) {
+ // Start timer
+ start := time.Now()
+ path := c.Request.URL.Path
+
+ // Process request
+ c.Next()
+
+ // Stop timer
+ end := time.Now()
+ latency := end.Sub(start)
+
+ clientIP := c.ClientIP()
+ method := c.Request.Method
+ statusCode := c.Writer.Status()
+ statusColor := colorForStatus(statusCode)
+ methodColor := colorForMethod(method)
+ comment := c.Errors.ByType(ErrorTypePrivate).String()
+
+ fmt.Fprintf(out, "[GIN] %v |%s %3d %s| %13v | %s |%s %s %-7s %s\n%s",
+ end.Format("2006/01/02 - 15:04:05"),
+ statusColor, statusCode, reset,
+ latency,
+ clientIP,
+ methodColor, reset, method,
+ path,
+ comment,
+ )
+ }
+}
+
+func colorForStatus(code int) string {
+ switch {
+ case code >= 200 && code < 300:
+ return green
+ case code >= 300 && code < 400:
+ return white
+ case code >= 400 && code < 500:
+ return yellow
+ default:
+ return red
+ }
+}
+
+func colorForMethod(method string) string {
+ switch method {
+ case "GET":
+ return blue
+ case "POST":
+ return cyan
+ case "PUT":
+ return yellow
+ case "DELETE":
+ return red
+ case "PATCH":
+ return green
+ case "HEAD":
+ return magenta
+ case "OPTIONS":
+ return white
+ default:
+ return reset
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/logger_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/logger_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..1d4755ec79903e774e1d0b452af8659174ef02be
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/logger_test.go
@@ -0,0 +1,98 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "bytes"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+//TODO
+// func (engine *Engine) LoadHTMLGlob(pattern string) {
+// func (engine *Engine) LoadHTMLFiles(files ...string) {
+// func (engine *Engine) Run(addr string) error {
+// func (engine *Engine) RunTLS(addr string, cert string, key string) error {
+
+func init() {
+ SetMode(TestMode)
+}
+
+func TestLogger(t *testing.T) {
+ buffer := new(bytes.Buffer)
+ router := New()
+ router.Use(LoggerWithWriter(buffer))
+ router.GET("/example", func(c *Context) {})
+ router.POST("/example", func(c *Context) {})
+ router.PUT("/example", func(c *Context) {})
+ router.DELETE("/example", func(c *Context) {})
+ router.PATCH("/example", func(c *Context) {})
+ router.HEAD("/example", func(c *Context) {})
+ router.OPTIONS("/example", func(c *Context) {})
+
+ performRequest(router, "GET", "/example")
+ assert.Contains(t, buffer.String(), "200")
+ assert.Contains(t, buffer.String(), "GET")
+ assert.Contains(t, buffer.String(), "/example")
+
+ // I wrote these first (extending the above) but then realized they are more
+ // like integration tests because they test the whole logging process rather
+ // than individual functions. Im not sure where these should go.
+
+ performRequest(router, "POST", "/example")
+ assert.Contains(t, buffer.String(), "200")
+ assert.Contains(t, buffer.String(), "POST")
+ assert.Contains(t, buffer.String(), "/example")
+
+ performRequest(router, "PUT", "/example")
+ assert.Contains(t, buffer.String(), "200")
+ assert.Contains(t, buffer.String(), "PUT")
+ assert.Contains(t, buffer.String(), "/example")
+
+ performRequest(router, "DELETE", "/example")
+ assert.Contains(t, buffer.String(), "200")
+ assert.Contains(t, buffer.String(), "DELETE")
+ assert.Contains(t, buffer.String(), "/example")
+
+ performRequest(router, "PATCH", "/example")
+ assert.Contains(t, buffer.String(), "200")
+ assert.Contains(t, buffer.String(), "PATCH")
+ assert.Contains(t, buffer.String(), "/example")
+
+ performRequest(router, "HEAD", "/example")
+ assert.Contains(t, buffer.String(), "200")
+ assert.Contains(t, buffer.String(), "HEAD")
+ assert.Contains(t, buffer.String(), "/example")
+
+ performRequest(router, "OPTIONS", "/example")
+ assert.Contains(t, buffer.String(), "200")
+ assert.Contains(t, buffer.String(), "OPTIONS")
+ assert.Contains(t, buffer.String(), "/example")
+
+ performRequest(router, "GET", "/notfound")
+ assert.Contains(t, buffer.String(), "404")
+ assert.Contains(t, buffer.String(), "GET")
+ assert.Contains(t, buffer.String(), "/notfound")
+
+}
+
+func TestColorForMethod(t *testing.T) {
+ assert.Equal(t, colorForMethod("GET"), string([]byte{27, 91, 57, 55, 59, 52, 52, 109}), "get should be blue")
+ assert.Equal(t, colorForMethod("POST"), string([]byte{27, 91, 57, 55, 59, 52, 54, 109}), "post should be cyan")
+ assert.Equal(t, colorForMethod("PUT"), string([]byte{27, 91, 57, 55, 59, 52, 51, 109}), "put should be yellow")
+ assert.Equal(t, colorForMethod("DELETE"), string([]byte{27, 91, 57, 55, 59, 52, 49, 109}), "delete should be red")
+ assert.Equal(t, colorForMethod("PATCH"), string([]byte{27, 91, 57, 55, 59, 52, 50, 109}), "patch should be green")
+ assert.Equal(t, colorForMethod("HEAD"), string([]byte{27, 91, 57, 55, 59, 52, 53, 109}), "head should be magenta")
+ assert.Equal(t, colorForMethod("OPTIONS"), string([]byte{27, 91, 57, 48, 59, 52, 55, 109}), "options should be white")
+ assert.Equal(t, colorForMethod("TRACE"), string([]byte{27, 91, 48, 109}), "trace is not defined and should be the reset color")
+}
+
+func TestColorForStatus(t *testing.T) {
+ assert.Equal(t, colorForStatus(200), string([]byte{27, 91, 57, 55, 59, 52, 50, 109}), "2xx should be green")
+ assert.Equal(t, colorForStatus(301), string([]byte{27, 91, 57, 48, 59, 52, 55, 109}), "3xx should be white")
+ assert.Equal(t, colorForStatus(404), string([]byte{27, 91, 57, 55, 59, 52, 51, 109}), "4xx should be yellow")
+ assert.Equal(t, colorForStatus(2), string([]byte{27, 91, 57, 55, 59, 52, 49, 109}), "other things should be red")
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/middleware_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/middleware_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..8af80d333d5b88142131abf6673c550775adc7f6
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/middleware_test.go
@@ -0,0 +1,255 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "errors"
+
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/manucorporat/sse"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+func TestMiddlewareGeneralCase(t *testing.T) {
+ signature := ""
+ router := New()
+ router.Use(func(c *Context) {
+ signature += "A"
+ c.Next()
+ signature += "B"
+ })
+ router.Use(func(c *Context) {
+ signature += "C"
+ })
+ router.GET("/", func(c *Context) {
+ signature += "D"
+ })
+ router.NoRoute(func(c *Context) {
+ signature += " X "
+ })
+ router.NoMethod(func(c *Context) {
+ signature += " XX "
+ })
+ // RUN
+ w := performRequest(router, "GET", "/")
+
+ // TEST
+ assert.Equal(t, w.Code, 200)
+ assert.Equal(t, signature, "ACDB")
+}
+
+func TestMiddlewareNoRoute(t *testing.T) {
+ signature := ""
+ router := New()
+ router.Use(func(c *Context) {
+ signature += "A"
+ c.Next()
+ signature += "B"
+ })
+ router.Use(func(c *Context) {
+ signature += "C"
+ c.Next()
+ c.Next()
+ c.Next()
+ c.Next()
+ signature += "D"
+ })
+ router.NoRoute(func(c *Context) {
+ signature += "E"
+ c.Next()
+ signature += "F"
+ }, func(c *Context) {
+ signature += "G"
+ c.Next()
+ signature += "H"
+ })
+ router.NoMethod(func(c *Context) {
+ signature += " X "
+ })
+ // RUN
+ w := performRequest(router, "GET", "/")
+
+ // TEST
+ assert.Equal(t, w.Code, 404)
+ assert.Equal(t, signature, "ACEGHFDB")
+}
+
+func TestMiddlewareNoMethodEnabled(t *testing.T) {
+ signature := ""
+ router := New()
+ router.HandleMethodNotAllowed = true
+ router.Use(func(c *Context) {
+ signature += "A"
+ c.Next()
+ signature += "B"
+ })
+ router.Use(func(c *Context) {
+ signature += "C"
+ c.Next()
+ signature += "D"
+ })
+ router.NoMethod(func(c *Context) {
+ signature += "E"
+ c.Next()
+ signature += "F"
+ }, func(c *Context) {
+ signature += "G"
+ c.Next()
+ signature += "H"
+ })
+ router.NoRoute(func(c *Context) {
+ signature += " X "
+ })
+ router.POST("/", func(c *Context) {
+ signature += " XX "
+ })
+ // RUN
+ w := performRequest(router, "GET", "/")
+
+ // TEST
+ assert.Equal(t, w.Code, 405)
+ assert.Equal(t, signature, "ACEGHFDB")
+}
+
+func TestMiddlewareNoMethodDisabled(t *testing.T) {
+ signature := ""
+ router := New()
+ router.HandleMethodNotAllowed = false
+ router.Use(func(c *Context) {
+ signature += "A"
+ c.Next()
+ signature += "B"
+ })
+ router.Use(func(c *Context) {
+ signature += "C"
+ c.Next()
+ signature += "D"
+ })
+ router.NoMethod(func(c *Context) {
+ signature += "E"
+ c.Next()
+ signature += "F"
+ }, func(c *Context) {
+ signature += "G"
+ c.Next()
+ signature += "H"
+ })
+ router.NoRoute(func(c *Context) {
+ signature += " X "
+ })
+ router.POST("/", func(c *Context) {
+ signature += " XX "
+ })
+ // RUN
+ w := performRequest(router, "GET", "/")
+
+ // TEST
+ assert.Equal(t, w.Code, 404)
+ assert.Equal(t, signature, "AC X DB")
+}
+
+func TestMiddlewareAbort(t *testing.T) {
+ signature := ""
+ router := New()
+ router.Use(func(c *Context) {
+ signature += "A"
+ })
+ router.Use(func(c *Context) {
+ signature += "C"
+ c.AbortWithStatus(401)
+ c.Next()
+ signature += "D"
+ })
+ router.GET("/", func(c *Context) {
+ signature += " X "
+ c.Next()
+ signature += " XX "
+ })
+
+ // RUN
+ w := performRequest(router, "GET", "/")
+
+ // TEST
+ assert.Equal(t, w.Code, 401)
+ assert.Equal(t, signature, "ACD")
+}
+
+func TestMiddlewareAbortHandlersChainAndNext(t *testing.T) {
+ signature := ""
+ router := New()
+ router.Use(func(c *Context) {
+ signature += "A"
+ c.Next()
+ c.AbortWithStatus(410)
+ signature += "B"
+
+ })
+ router.GET("/", func(c *Context) {
+ signature += "C"
+ c.Next()
+ })
+ // RUN
+ w := performRequest(router, "GET", "/")
+
+ // TEST
+ assert.Equal(t, w.Code, 410)
+ assert.Equal(t, signature, "ACB")
+}
+
+// TestFailHandlersChain - ensure that Fail interrupt used middlewares in fifo order as
+// as well as Abort
+func TestMiddlewareFailHandlersChain(t *testing.T) {
+ // SETUP
+ signature := ""
+ router := New()
+ router.Use(func(context *Context) {
+ signature += "A"
+ context.AbortWithError(500, errors.New("foo"))
+ })
+ router.Use(func(context *Context) {
+ signature += "B"
+ context.Next()
+ signature += "C"
+ })
+ // RUN
+ w := performRequest(router, "GET", "/")
+
+ // TEST
+ assert.Equal(t, w.Code, 500)
+ assert.Equal(t, signature, "A")
+}
+
+func TestMiddlewareWrite(t *testing.T) {
+ router := New()
+ router.Use(func(c *Context) {
+ c.String(400, "hola\n")
+ })
+ router.Use(func(c *Context) {
+ c.XML(400, H{"foo": "bar"})
+ })
+ router.Use(func(c *Context) {
+ c.JSON(400, H{"foo": "bar"})
+ })
+ router.GET("/", func(c *Context) {
+ c.JSON(400, H{"foo": "bar"})
+ }, func(c *Context) {
+ c.Render(400, sse.Event{
+ Event: "test",
+ Data: "message",
+ })
+ })
+
+ w := performRequest(router, "GET", "/")
+
+ assert.Equal(t, w.Code, 400)
+ assert.Equal(t, w.Body.String(), `hola
+<map><foo>bar</foo></map>{"foo":"bar"}
+{"foo":"bar"}
+event: test
+data: message
+
+`)
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/mode.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/mode.go
new file mode 100644
index 0000000000000000000000000000000000000000..5dcf4e85a2385fdbf6c4f5f61af2485236b84b5b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/mode.go
@@ -0,0 +1,61 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "io"
+ "os"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin/binding"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/mattn/go-colorable"
+)
+
+const ENV_GIN_MODE = "GIN_MODE"
+
+const (
+ DebugMode string = "debug"
+ ReleaseMode string = "release"
+ TestMode string = "test"
+)
+const (
+ debugCode = iota
+ releaseCode = iota
+ testCode = iota
+)
+
+var DefaultWriter io.Writer = colorable.NewColorableStdout()
+var ginMode int = debugCode
+var modeName string = DebugMode
+
+func init() {
+ mode := os.Getenv(ENV_GIN_MODE)
+ if len(mode) == 0 {
+ SetMode(DebugMode)
+ } else {
+ SetMode(mode)
+ }
+}
+
+func SetMode(value string) {
+ switch value {
+ case DebugMode:
+ ginMode = debugCode
+ case ReleaseMode:
+ ginMode = releaseCode
+ case TestMode:
+ ginMode = testCode
+ default:
+ panic("gin mode unknown: " + value)
+ }
+ modeName = value
+}
+
+func DisableBindValidation() {
+ binding.Validator = nil
+}
+
+func Mode() string {
+ return modeName
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/mode_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/mode_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..8fd7a43b898cfef11a209e6243422396179b1ef1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/mode_test.go
@@ -0,0 +1,31 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+func init() {
+ SetMode(TestMode)
+}
+
+func TestSetMode(t *testing.T) {
+ SetMode(DebugMode)
+ assert.Equal(t, ginMode, debugCode)
+ assert.Equal(t, Mode(), DebugMode)
+
+ SetMode(ReleaseMode)
+ assert.Equal(t, ginMode, releaseCode)
+ assert.Equal(t, Mode(), ReleaseMode)
+
+ SetMode(TestMode)
+ assert.Equal(t, ginMode, testCode)
+ assert.Equal(t, Mode(), TestMode)
+
+ assert.Panics(t, func() { SetMode("unknown") })
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/path.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/path.go
new file mode 100644
index 0000000000000000000000000000000000000000..43cdd0472f8bb5e56ab71fec2b882e5dbbe12614
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/path.go
@@ -0,0 +1,123 @@
+// Copyright 2013 Julien Schmidt. All rights reserved.
+// Based on the path package, Copyright 2009 The Go Authors.
+// Use of this source code is governed by a BSD-style license that can be found
+// in the LICENSE file.
+
+package gin
+
+// CleanPath is the URL version of path.Clean, it returns a canonical URL path
+// for p, eliminating . and .. elements.
+//
+// The following rules are applied iteratively until no further processing can
+// be done:
+// 1. Replace multiple slashes with a single slash.
+// 2. Eliminate each . path name element (the current directory).
+// 3. Eliminate each inner .. path name element (the parent directory)
+// along with the non-.. element that precedes it.
+// 4. Eliminate .. elements that begin a rooted path:
+// that is, replace "/.." by "/" at the beginning of a path.
+//
+// If the result of this process is an empty string, "/" is returned
+func cleanPath(p string) string {
+ // Turn empty string into "/"
+ if p == "" {
+ return "/"
+ }
+
+ n := len(p)
+ var buf []byte
+
+ // Invariants:
+ // reading from path; r is index of next byte to process.
+ // writing to buf; w is index of next byte to write.
+
+ // path must start with '/'
+ r := 1
+ w := 1
+
+ if p[0] != '/' {
+ r = 0
+ buf = make([]byte, n+1)
+ buf[0] = '/'
+ }
+
+ trailing := n > 2 && p[n-1] == '/'
+
+ // A bit more clunky without a 'lazybuf' like the path package, but the loop
+ // gets completely inlined (bufApp). So in contrast to the path package this
+ // loop has no expensive function calls (except 1x make)
+
+ for r < n {
+ switch {
+ case p[r] == '/':
+ // empty path element, trailing slash is added after the end
+ r++
+
+ case p[r] == '.' && r+1 == n:
+ trailing = true
+ r++
+
+ case p[r] == '.' && p[r+1] == '/':
+ // . element
+ r++
+
+ case p[r] == '.' && p[r+1] == '.' && (r+2 == n || p[r+2] == '/'):
+ // .. element: remove to last /
+ r += 2
+
+ if w > 1 {
+ // can backtrack
+ w--
+
+ if buf == nil {
+ for w > 1 && p[w] != '/' {
+ w--
+ }
+ } else {
+ for w > 1 && buf[w] != '/' {
+ w--
+ }
+ }
+ }
+
+ default:
+ // real path element.
+ // add slash if needed
+ if w > 1 {
+ bufApp(&buf, p, w, '/')
+ w++
+ }
+
+ // copy element
+ for r < n && p[r] != '/' {
+ bufApp(&buf, p, w, p[r])
+ w++
+ r++
+ }
+ }
+ }
+
+ // re-append trailing slash
+ if trailing && w > 1 {
+ bufApp(&buf, p, w, '/')
+ w++
+ }
+
+ if buf == nil {
+ return p[:w]
+ }
+ return string(buf[:w])
+}
+
+// internal helper to lazily create a buffer if necessary
+func bufApp(buf *[]byte, s string, w int, c byte) {
+ if *buf == nil {
+ if s[w] == c {
+ return
+ }
+
+ *buf = make([]byte, len(s))
+ copy(*buf, s[:w])
+ }
+ (*buf)[w] = c
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/path_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/path_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..16eb439bdd50fb674223d60479f1e83a4603a5ab
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/path_test.go
@@ -0,0 +1,88 @@
+// Copyright 2013 Julien Schmidt. All rights reserved.
+// Based on the path package, Copyright 2009 The Go Authors.
+// Use of this source code is governed by a BSD-style license that can be found
+// in the LICENSE file.
+
+package gin
+
+import (
+ "runtime"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+var cleanTests = []struct {
+ path, result string
+}{
+ // Already clean
+ {"/", "/"},
+ {"/abc", "/abc"},
+ {"/a/b/c", "/a/b/c"},
+ {"/abc/", "/abc/"},
+ {"/a/b/c/", "/a/b/c/"},
+
+ // missing root
+ {"", "/"},
+ {"abc", "/abc"},
+ {"abc/def", "/abc/def"},
+ {"a/b/c", "/a/b/c"},
+
+ // Remove doubled slash
+ {"//", "/"},
+ {"/abc//", "/abc/"},
+ {"/abc/def//", "/abc/def/"},
+ {"/a/b/c//", "/a/b/c/"},
+ {"/abc//def//ghi", "/abc/def/ghi"},
+ {"//abc", "/abc"},
+ {"///abc", "/abc"},
+ {"//abc//", "/abc/"},
+
+ // Remove . elements
+ {".", "/"},
+ {"./", "/"},
+ {"/abc/./def", "/abc/def"},
+ {"/./abc/def", "/abc/def"},
+ {"/abc/.", "/abc/"},
+
+ // Remove .. elements
+ {"..", "/"},
+ {"../", "/"},
+ {"../../", "/"},
+ {"../..", "/"},
+ {"../../abc", "/abc"},
+ {"/abc/def/ghi/../jkl", "/abc/def/jkl"},
+ {"/abc/def/../ghi/../jkl", "/abc/jkl"},
+ {"/abc/def/..", "/abc"},
+ {"/abc/def/../..", "/"},
+ {"/abc/def/../../..", "/"},
+ {"/abc/def/../../..", "/"},
+ {"/abc/def/../../../ghi/jkl/../../../mno", "/mno"},
+
+ // Combinations
+ {"abc/./../def", "/def"},
+ {"abc//./../def", "/def"},
+ {"abc/../../././../def", "/def"},
+}
+
+func TestPathClean(t *testing.T) {
+ for _, test := range cleanTests {
+ assert.Equal(t, cleanPath(test.path), test.result)
+ assert.Equal(t, cleanPath(test.result), test.result)
+ }
+}
+
+func TestPathCleanMallocs(t *testing.T) {
+ if testing.Short() {
+ t.Skip("skipping malloc count in short mode")
+ }
+ if runtime.GOMAXPROCS(0) > 1 {
+ t.Log("skipping AllocsPerRun checks; GOMAXPROCS>1")
+ return
+ }
+
+ for _, test := range cleanTests {
+ allocs := testing.AllocsPerRun(100, func() { cleanPath(test.result) })
+ assert.EqualValues(t, allocs, 0)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/recovery.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/recovery.go
new file mode 100644
index 0000000000000000000000000000000000000000..e296e3390566fd67d66c911973e2ed1d4f6413b3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/recovery.go
@@ -0,0 +1,106 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "log"
+ "runtime"
+)
+
+var (
+ dunno = []byte("???")
+ centerDot = []byte("·")
+ dot = []byte(".")
+ slash = []byte("/")
+)
+
+// Recovery returns a middleware that recovers from any panics and writes a 500 if there was one.
+func Recovery() HandlerFunc {
+ return RecoveryWithWriter(DefaultWriter)
+}
+
+func RecoveryWithWriter(out io.Writer) HandlerFunc {
+ var logger *log.Logger
+ if out != nil {
+ logger = log.New(out, "", log.LstdFlags)
+ }
+ return func(c *Context) {
+ defer func() {
+ if err := recover(); err != nil {
+ if logger != nil {
+ stack := stack(3)
+ logger.Printf("Panic recovery -> %s\n%s\n", err, stack)
+ }
+ c.AbortWithStatus(500)
+ }
+ }()
+ c.Next()
+ }
+}
+
+// stack returns a nicely formated stack frame, skipping skip frames
+func stack(skip int) []byte {
+ buf := new(bytes.Buffer) // the returned data
+ // As we loop, we open files and read them. These variables record the currently
+ // loaded file.
+ var lines [][]byte
+ var lastFile string
+ for i := skip; ; i++ { // Skip the expected number of frames
+ pc, file, line, ok := runtime.Caller(i)
+ if !ok {
+ break
+ }
+ // Print this much at least. If we can't find the source, it won't show.
+ fmt.Fprintf(buf, "%s:%d (0x%x)\n", file, line, pc)
+ if file != lastFile {
+ data, err := ioutil.ReadFile(file)
+ if err != nil {
+ continue
+ }
+ lines = bytes.Split(data, []byte{'\n'})
+ lastFile = file
+ }
+ fmt.Fprintf(buf, "\t%s: %s\n", function(pc), source(lines, line))
+ }
+ return buf.Bytes()
+}
+
+// source returns a space-trimmed slice of the n'th line.
+func source(lines [][]byte, n int) []byte {
+ n-- // in stack trace, lines are 1-indexed but our array is 0-indexed
+ if n < 0 || n >= len(lines) {
+ return dunno
+ }
+ return bytes.TrimSpace(lines[n])
+}
+
+// function returns, if possible, the name of the function containing the PC.
+func function(pc uintptr) []byte {
+ fn := runtime.FuncForPC(pc)
+ if fn == nil {
+ return dunno
+ }
+ name := []byte(fn.Name())
+ // The name includes the path name to the package, which is unnecessary
+ // since the file name is already included. Plus, it has center dots.
+ // That is, we see
+ // runtime/debug.*T·ptrmethod
+ // and want
+ // *T.ptrmethod
+ // Also the package path might contains dot (e.g. code.google.com/...),
+ // so first eliminate the path prefix
+ if lastslash := bytes.LastIndex(name, slash); lastslash >= 0 {
+ name = name[lastslash+1:]
+ }
+ if period := bytes.Index(name, dot); period >= 0 {
+ name = name[period+1:]
+ }
+ name = bytes.Replace(name, centerDot, dot, -1)
+ return name
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/recovery_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/recovery_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..aae0ef2c0097207d09e7f74ed1533bb7db8f1b9d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/recovery_test.go
@@ -0,0 +1,42 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "bytes"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+// TestPanicInHandler assert that panic has been recovered.
+func TestPanicInHandler(t *testing.T) {
+ buffer := new(bytes.Buffer)
+ router := New()
+ router.Use(RecoveryWithWriter(buffer))
+ router.GET("/recovery", func(_ *Context) {
+ panic("Oupps, Houston, we have a problem")
+ })
+ // RUN
+ w := performRequest(router, "GET", "/recovery")
+ // TEST
+ assert.Equal(t, w.Code, 500)
+ assert.Contains(t, buffer.String(), "Panic recovery -> Oupps, Houston, we have a problem")
+ assert.Contains(t, buffer.String(), "TestPanicInHandler")
+}
+
+// TestPanicWithAbort assert that panic has been recovered even if context.Abort was used.
+func TestPanicWithAbort(t *testing.T) {
+ router := New()
+ router.Use(RecoveryWithWriter(nil))
+ router.GET("/recovery", func(c *Context) {
+ c.AbortWithStatus(400)
+ panic("Oupps, Houston, we have a problem")
+ })
+ // RUN
+ w := performRequest(router, "GET", "/recovery")
+ // TEST
+ assert.Equal(t, w.Code, 500) // NOT SURE
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/render/data.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/render/data.go
new file mode 100644
index 0000000000000000000000000000000000000000..efa75d559983687d531cdfa5b8b0a6aa80dc4cf1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/render/data.go
@@ -0,0 +1,20 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import "net/http"
+
+type Data struct {
+ ContentType string
+ Data []byte
+}
+
+func (r Data) Render(w http.ResponseWriter) error {
+ if len(r.ContentType) > 0 {
+ w.Header()["Content-Type"] = []string{r.ContentType}
+ }
+ w.Write(r.Data)
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/render/html.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/render/html.go
new file mode 100644
index 0000000000000000000000000000000000000000..01f6bf2207fad7c1fb4c9c82c428d7f5db6f0903
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/render/html.go
@@ -0,0 +1,67 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import (
+ "html/template"
+ "net/http"
+)
+
+type (
+ HTMLRender interface {
+ Instance(string, interface{}) Render
+ }
+
+ HTMLProduction struct {
+ Template *template.Template
+ }
+
+ HTMLDebug struct {
+ Files []string
+ Glob string
+ }
+
+ HTML struct {
+ Template *template.Template
+ Name string
+ Data interface{}
+ }
+)
+
+var htmlContentType = []string{"text/html; charset=utf-8"}
+
+func (r HTMLProduction) Instance(name string, data interface{}) Render {
+ return HTML{
+ Template: r.Template,
+ Name: name,
+ Data: data,
+ }
+}
+
+func (r HTMLDebug) Instance(name string, data interface{}) Render {
+ return HTML{
+ Template: r.loadTemplate(),
+ Name: name,
+ Data: data,
+ }
+}
+func (r HTMLDebug) loadTemplate() *template.Template {
+ if len(r.Files) > 0 {
+ return template.Must(template.ParseFiles(r.Files...))
+ }
+ if len(r.Glob) > 0 {
+ return template.Must(template.ParseGlob(r.Glob))
+ }
+ panic("the HTML debug render was created without files or glob pattern")
+}
+
+func (r HTML) Render(w http.ResponseWriter) error {
+ writeContentType(w, htmlContentType)
+ if len(r.Name) == 0 {
+ return r.Template.Execute(w, r.Data)
+ } else {
+ return r.Template.ExecuteTemplate(w, r.Name, r.Data)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/render/json.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/render/json.go
new file mode 100644
index 0000000000000000000000000000000000000000..32e6058db6ac3a45395d39e2649ddd7cca096382
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/render/json.go
@@ -0,0 +1,41 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import (
+ "encoding/json"
+ "net/http"
+)
+
+type (
+ JSON struct {
+ Data interface{}
+ }
+
+ IndentedJSON struct {
+ Data interface{}
+ }
+)
+
+var jsonContentType = []string{"application/json; charset=utf-8"}
+
+func (r JSON) Render(w http.ResponseWriter) error {
+ return WriteJSON(w, r.Data)
+}
+
+func (r IndentedJSON) Render(w http.ResponseWriter) error {
+ writeContentType(w, jsonContentType)
+ jsonBytes, err := json.MarshalIndent(r.Data, "", " ")
+ if err != nil {
+ return err
+ }
+ w.Write(jsonBytes)
+ return nil
+}
+
+func WriteJSON(w http.ResponseWriter, obj interface{}) error {
+ writeContentType(w, jsonContentType)
+ return json.NewEncoder(w).Encode(obj)
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/render/redirect.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/render/redirect.go
new file mode 100644
index 0000000000000000000000000000000000000000..d64e4d75ed8c7f32d0944882014f1fa52bf3e88f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/render/redirect.go
@@ -0,0 +1,24 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import (
+ "fmt"
+ "net/http"
+)
+
+type Redirect struct {
+ Code int
+ Request *http.Request
+ Location string
+}
+
+func (r Redirect) Render(w http.ResponseWriter) error {
+ if r.Code < 300 || r.Code > 308 {
+ panic(fmt.Sprintf("Cannot redirect with status code %d", r.Code))
+ }
+ http.Redirect(w, r.Request, r.Location, r.Code)
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/render/render.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/render/render.go
new file mode 100644
index 0000000000000000000000000000000000000000..994fcd7c7f6cad764d2e0baf8f19707acdbb8543
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/render/render.go
@@ -0,0 +1,30 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import "net/http"
+
+type Render interface {
+ Render(http.ResponseWriter) error
+}
+
+var (
+ _ Render = JSON{}
+ _ Render = IndentedJSON{}
+ _ Render = XML{}
+ _ Render = String{}
+ _ Render = Redirect{}
+ _ Render = Data{}
+ _ Render = HTML{}
+ _ HTMLRender = HTMLDebug{}
+ _ HTMLRender = HTMLProduction{}
+)
+
+func writeContentType(w http.ResponseWriter, value []string) {
+ header := w.Header()
+ if val := header["Content-Type"]; len(val) == 0 {
+ header["Content-Type"] = value
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/render/render_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/render/render_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..8be5220ca911c79cf95020d891d729301653b2ed
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/render/render_test.go
@@ -0,0 +1,130 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import (
+ "encoding/xml"
+ "html/template"
+ "net/http/httptest"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+// TODO unit tests
+// test errors
+
+func TestRenderJSON(t *testing.T) {
+ w := httptest.NewRecorder()
+ data := map[string]interface{}{
+ "foo": "bar",
+ }
+
+ err := (JSON{data}).Render(w)
+
+ assert.NoError(t, err)
+ assert.Equal(t, w.Body.String(), "{\"foo\":\"bar\"}\n")
+ assert.Equal(t, w.Header().Get("Content-Type"), "application/json; charset=utf-8")
+}
+
+func TestRenderIndentedJSON(t *testing.T) {
+ w := httptest.NewRecorder()
+ data := map[string]interface{}{
+ "foo": "bar",
+ "bar": "foo",
+ }
+
+ err := (IndentedJSON{data}).Render(w)
+
+ assert.NoError(t, err)
+ assert.Equal(t, w.Body.String(), "{\n \"bar\": \"foo\",\n \"foo\": \"bar\"\n}")
+ assert.Equal(t, w.Header().Get("Content-Type"), "application/json; charset=utf-8")
+}
+
+type xmlmap map[string]interface{}
+
+// Allows type H to be used with xml.Marshal
+func (h xmlmap) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+ start.Name = xml.Name{
+ Space: "",
+ Local: "map",
+ }
+ if err := e.EncodeToken(start); err != nil {
+ return err
+ }
+ for key, value := range h {
+ elem := xml.StartElement{
+ Name: xml.Name{Space: "", Local: key},
+ Attr: []xml.Attr{},
+ }
+ if err := e.EncodeElement(value, elem); err != nil {
+ return err
+ }
+ }
+ if err := e.EncodeToken(xml.EndElement{Name: start.Name}); err != nil {
+ return err
+ }
+ return nil
+}
+
+func TestRenderXML(t *testing.T) {
+ w := httptest.NewRecorder()
+ data := xmlmap{
+ "foo": "bar",
+ }
+
+ err := (XML{data}).Render(w)
+
+ assert.NoError(t, err)
+ assert.Equal(t, w.Body.String(), "<map><foo>bar</foo></map>")
+ assert.Equal(t, w.Header().Get("Content-Type"), "application/xml; charset=utf-8")
+}
+
+func TestRenderRedirect(t *testing.T) {
+ // TODO
+}
+
+func TestRenderData(t *testing.T) {
+ w := httptest.NewRecorder()
+ data := []byte("#!PNG some raw data")
+
+ err := (Data{
+ ContentType: "image/png",
+ Data: data,
+ }).Render(w)
+
+ assert.NoError(t, err)
+ assert.Equal(t, w.Body.String(), "#!PNG some raw data")
+ assert.Equal(t, w.Header().Get("Content-Type"), "image/png")
+}
+
+func TestRenderString(t *testing.T) {
+ w := httptest.NewRecorder()
+
+ err := (String{
+ Format: "hola %s %d",
+ Data: []interface{}{"manu", 2},
+ }).Render(w)
+
+ assert.NoError(t, err)
+ assert.Equal(t, w.Body.String(), "hola manu 2")
+ assert.Equal(t, w.Header().Get("Content-Type"), "text/plain; charset=utf-8")
+}
+
+func TestRenderHTMLTemplate(t *testing.T) {
+ w := httptest.NewRecorder()
+ templ := template.Must(template.New("t").Parse(`Hello {{.name}}`))
+
+ htmlRender := HTMLProduction{Template: templ}
+ instance := htmlRender.Instance("t", map[string]interface{}{
+ "name": "alexandernyquist",
+ })
+
+ err := instance.Render(w)
+
+ assert.NoError(t, err)
+ assert.Equal(t, w.Body.String(), "Hello alexandernyquist")
+ assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/render/text.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/render/text.go
new file mode 100644
index 0000000000000000000000000000000000000000..5a9e280bdd2bfc4ca7229ab65b0959ddce31c2be
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/render/text.go
@@ -0,0 +1,33 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import (
+ "fmt"
+ "io"
+ "net/http"
+)
+
+type String struct {
+ Format string
+ Data []interface{}
+}
+
+var plainContentType = []string{"text/plain; charset=utf-8"}
+
+func (r String) Render(w http.ResponseWriter) error {
+ WriteString(w, r.Format, r.Data)
+ return nil
+}
+
+func WriteString(w http.ResponseWriter, format string, data []interface{}) {
+ writeContentType(w, plainContentType)
+
+ if len(data) > 0 {
+ fmt.Fprintf(w, format, data...)
+ } else {
+ io.WriteString(w, format)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/render/xml.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/render/xml.go
new file mode 100644
index 0000000000000000000000000000000000000000..be22e6f2166347708037901ed35fbb2b839fbcdc
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/render/xml.go
@@ -0,0 +1,21 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import (
+ "encoding/xml"
+ "net/http"
+)
+
+type XML struct {
+ Data interface{}
+}
+
+var xmlContentType = []string{"application/xml; charset=utf-8"}
+
+func (r XML) Render(w http.ResponseWriter) error {
+ writeContentType(w, xmlContentType)
+ return xml.NewEncoder(w).Encode(r.Data)
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/response_writer.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/response_writer.go
new file mode 100644
index 0000000000000000000000000000000000000000..5a75335f8d07b53d4e896b30b4380aae215fc1b5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/response_writer.go
@@ -0,0 +1,106 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "bufio"
+ "io"
+ "net"
+ "net/http"
+)
+
+const (
+ noWritten = -1
+ defaultStatus = 200
+)
+
+type (
+ ResponseWriter interface {
+ http.ResponseWriter
+ http.Hijacker
+ http.Flusher
+ http.CloseNotifier
+
+ Status() int
+ Size() int
+ WriteString(string) (int, error)
+ Written() bool
+ WriteHeaderNow()
+ }
+
+ responseWriter struct {
+ http.ResponseWriter
+ size int
+ status int
+ }
+)
+
+var _ ResponseWriter = &responseWriter{}
+
+func (w *responseWriter) reset(writer http.ResponseWriter) {
+ w.ResponseWriter = writer
+ w.size = noWritten
+ w.status = defaultStatus
+}
+
+func (w *responseWriter) WriteHeader(code int) {
+ if code > 0 && w.status != code {
+ if w.Written() {
+ debugPrint("[WARNING] Headers were already written. Wanted to override status code %d with %d", w.status, code)
+ }
+ w.status = code
+ }
+}
+
+func (w *responseWriter) WriteHeaderNow() {
+ if !w.Written() {
+ w.size = 0
+ w.ResponseWriter.WriteHeader(w.status)
+ }
+}
+
+func (w *responseWriter) Write(data []byte) (n int, err error) {
+ w.WriteHeaderNow()
+ n, err = w.ResponseWriter.Write(data)
+ w.size += n
+ return
+}
+
+func (w *responseWriter) WriteString(s string) (n int, err error) {
+ w.WriteHeaderNow()
+ n, err = io.WriteString(w.ResponseWriter, s)
+ w.size += n
+ return
+}
+
+func (w *responseWriter) Status() int {
+ return w.status
+}
+
+func (w *responseWriter) Size() int {
+ return w.size
+}
+
+func (w *responseWriter) Written() bool {
+ return w.size != noWritten
+}
+
+// Implements the http.Hijacker interface
+func (w *responseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+ if w.size < 0 {
+ w.size = 0
+ }
+ return w.ResponseWriter.(http.Hijacker).Hijack()
+}
+
+// Implements the http.CloseNotify interface
+func (w *responseWriter) CloseNotify() <-chan bool {
+ return w.ResponseWriter.(http.CloseNotifier).CloseNotify()
+}
+
+// Implements the http.Flush interface
+func (w *responseWriter) Flush() {
+ w.ResponseWriter.(http.Flusher).Flush()
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/response_writer_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/response_writer_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..ec7133a80d58d24b2cb6176fe610315bf3c139d3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/response_writer_test.go
@@ -0,0 +1,115 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+// TODO
+// func (w *responseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+// func (w *responseWriter) CloseNotify() <-chan bool {
+// func (w *responseWriter) Flush() {
+
+var _ ResponseWriter = &responseWriter{}
+var _ http.ResponseWriter = &responseWriter{}
+var _ http.ResponseWriter = ResponseWriter(&responseWriter{})
+var _ http.Hijacker = ResponseWriter(&responseWriter{})
+var _ http.Flusher = ResponseWriter(&responseWriter{})
+var _ http.CloseNotifier = ResponseWriter(&responseWriter{})
+
+func init() {
+ SetMode(TestMode)
+}
+
+func TestResponseWriterReset(t *testing.T) {
+ testWritter := httptest.NewRecorder()
+ writer := &responseWriter{}
+ var w ResponseWriter = writer
+
+ writer.reset(testWritter)
+ assert.Equal(t, writer.size, -1)
+ assert.Equal(t, writer.status, 200)
+ assert.Equal(t, writer.ResponseWriter, testWritter)
+ assert.Equal(t, w.Size(), -1)
+ assert.Equal(t, w.Status(), 200)
+ assert.False(t, w.Written())
+}
+
+func TestResponseWriterWriteHeader(t *testing.T) {
+ testWritter := httptest.NewRecorder()
+ writer := &responseWriter{}
+ writer.reset(testWritter)
+ w := ResponseWriter(writer)
+
+ w.WriteHeader(300)
+ assert.False(t, w.Written())
+ assert.Equal(t, w.Status(), 300)
+ assert.NotEqual(t, testWritter.Code, 300)
+
+ w.WriteHeader(-1)
+ assert.Equal(t, w.Status(), 300)
+}
+
+func TestResponseWriterWriteHeadersNow(t *testing.T) {
+ testWritter := httptest.NewRecorder()
+ writer := &responseWriter{}
+ writer.reset(testWritter)
+ w := ResponseWriter(writer)
+
+ w.WriteHeader(300)
+ w.WriteHeaderNow()
+
+ assert.True(t, w.Written())
+ assert.Equal(t, w.Size(), 0)
+ assert.Equal(t, testWritter.Code, 300)
+
+ writer.size = 10
+ w.WriteHeaderNow()
+ assert.Equal(t, w.Size(), 10)
+}
+
+func TestResponseWriterWrite(t *testing.T) {
+ testWritter := httptest.NewRecorder()
+ writer := &responseWriter{}
+ writer.reset(testWritter)
+ w := ResponseWriter(writer)
+
+ n, err := w.Write([]byte("hola"))
+ assert.Equal(t, n, 4)
+ assert.Equal(t, w.Size(), 4)
+ assert.Equal(t, w.Status(), 200)
+ assert.Equal(t, testWritter.Code, 200)
+ assert.Equal(t, testWritter.Body.String(), "hola")
+ assert.NoError(t, err)
+
+ n, err = w.Write([]byte(" adios"))
+ assert.Equal(t, n, 6)
+ assert.Equal(t, w.Size(), 10)
+ assert.Equal(t, testWritter.Body.String(), "hola adios")
+ assert.NoError(t, err)
+}
+
+func TestResponseWriterHijack(t *testing.T) {
+ testWritter := httptest.NewRecorder()
+ writer := &responseWriter{}
+ writer.reset(testWritter)
+ w := ResponseWriter(writer)
+
+ assert.Panics(t, func() {
+ w.Hijack()
+ })
+ assert.True(t, w.Written())
+
+ assert.Panics(t, func() {
+ w.CloseNotify()
+ })
+
+ w.Flush()
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/routergroup.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/routergroup.go
new file mode 100644
index 0000000000000000000000000000000000000000..20122cb5ec4b4504caa07100a36e6d21f73a595d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/routergroup.go
@@ -0,0 +1,198 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "net/http"
+ "path"
+ "regexp"
+ "strings"
+)
+
+type routesInterface interface {
+ Use(...HandlerFunc) routesInterface
+
+ Handle(string, string, ...HandlerFunc) routesInterface
+ Any(string, ...HandlerFunc) routesInterface
+ GET(string, ...HandlerFunc) routesInterface
+ POST(string, ...HandlerFunc) routesInterface
+ DELETE(string, ...HandlerFunc) routesInterface
+ PATCH(string, ...HandlerFunc) routesInterface
+ PUT(string, ...HandlerFunc) routesInterface
+ OPTIONS(string, ...HandlerFunc) routesInterface
+ HEAD(string, ...HandlerFunc) routesInterface
+
+ StaticFile(string, string) routesInterface
+ Static(string, string) routesInterface
+ StaticFS(string, http.FileSystem) routesInterface
+}
+
+// Used internally to configure router, a RouterGroup is associated with a prefix
+// and an array of handlers (middlewares)
+type RouterGroup struct {
+ Handlers HandlersChain
+ BasePath string
+ engine *Engine
+ root bool
+}
+
+// Adds middlewares to the group, see example code in github.
+func (group *RouterGroup) Use(middlewares ...HandlerFunc) routesInterface {
+ group.Handlers = append(group.Handlers, middlewares...)
+ return group.returnObj()
+}
+
+// Creates a new router group. You should add all the routes that have common middlwares or the same path prefix.
+// For example, all the routes that use a common middlware for authorization could be grouped.
+func (group *RouterGroup) Group(relativePath string, handlers ...HandlerFunc) *RouterGroup {
+ return &RouterGroup{
+ Handlers: group.combineHandlers(handlers),
+ BasePath: group.calculateAbsolutePath(relativePath),
+ engine: group.engine,
+ }
+}
+
+// Handle registers a new request handle and middlewares with the given path and method.
+// The last handler should be the real handler, the other ones should be middlewares that can and should be shared among different routes.
+// See the example code in github.
+//
+// For GET, POST, PUT, PATCH and DELETE requests the respective shortcut
+// functions can be used.
+//
+// This function is intended for bulk loading and to allow the usage of less
+// frequently used, non-standardized or custom methods (e.g. for internal
+// communication with a proxy).
+func (group *RouterGroup) handle(httpMethod, relativePath string, handlers HandlersChain) routesInterface {
+ absolutePath := group.calculateAbsolutePath(relativePath)
+ handlers = group.combineHandlers(handlers)
+ group.engine.addRoute(httpMethod, absolutePath, handlers)
+ return group.returnObj()
+}
+
+func (group *RouterGroup) Handle(httpMethod, relativePath string, handlers ...HandlerFunc) routesInterface {
+ if matches, err := regexp.MatchString("^[A-Z]+$", httpMethod); !matches || err != nil {
+ panic("http method " + httpMethod + " is not valid")
+ }
+ return group.handle(httpMethod, relativePath, handlers)
+}
+
+// POST is a shortcut for router.Handle("POST", path, handle)
+func (group *RouterGroup) POST(relativePath string, handlers ...HandlerFunc) routesInterface {
+ return group.handle("POST", relativePath, handlers)
+}
+
+// GET is a shortcut for router.Handle("GET", path, handle)
+func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) routesInterface {
+ return group.handle("GET", relativePath, handlers)
+}
+
+// DELETE is a shortcut for router.Handle("DELETE", path, handle)
+func (group *RouterGroup) DELETE(relativePath string, handlers ...HandlerFunc) routesInterface {
+ return group.handle("DELETE", relativePath, handlers)
+}
+
+// PATCH is a shortcut for router.Handle("PATCH", path, handle)
+func (group *RouterGroup) PATCH(relativePath string, handlers ...HandlerFunc) routesInterface {
+ return group.handle("PATCH", relativePath, handlers)
+}
+
+// PUT is a shortcut for router.Handle("PUT", path, handle)
+func (group *RouterGroup) PUT(relativePath string, handlers ...HandlerFunc) routesInterface {
+ return group.handle("PUT", relativePath, handlers)
+}
+
+// OPTIONS is a shortcut for router.Handle("OPTIONS", path, handle)
+func (group *RouterGroup) OPTIONS(relativePath string, handlers ...HandlerFunc) routesInterface {
+ return group.handle("OPTIONS", relativePath, handlers)
+}
+
+// HEAD is a shortcut for router.Handle("HEAD", path, handle)
+func (group *RouterGroup) HEAD(relativePath string, handlers ...HandlerFunc) routesInterface {
+ return group.handle("HEAD", relativePath, handlers)
+}
+
+func (group *RouterGroup) Any(relativePath string, handlers ...HandlerFunc) routesInterface {
+ // GET, POST, PUT, PATCH, HEAD, OPTIONS, DELETE, CONNECT, TRACE
+ group.handle("GET", relativePath, handlers)
+ group.handle("POST", relativePath, handlers)
+ group.handle("PUT", relativePath, handlers)
+ group.handle("PATCH", relativePath, handlers)
+ group.handle("HEAD", relativePath, handlers)
+ group.handle("OPTIONS", relativePath, handlers)
+ group.handle("DELETE", relativePath, handlers)
+ group.handle("CONNECT", relativePath, handlers)
+ group.handle("TRACE", relativePath, handlers)
+ return group.returnObj()
+}
+
+func (group *RouterGroup) StaticFile(relativePath, filepath string) routesInterface {
+ if strings.Contains(relativePath, ":") || strings.Contains(relativePath, "*") {
+ panic("URL parameters can not be used when serving a static file")
+ }
+ handler := func(c *Context) {
+ c.File(filepath)
+ }
+ group.GET(relativePath, handler)
+ group.HEAD(relativePath, handler)
+ return group.returnObj()
+}
+
+// Static serves files from the given file system root.
+// Internally a http.FileServer is used, therefore http.NotFound is used instead
+// of the Router's NotFound handler.
+// To use the operating system's file system implementation,
+// use :
+// router.Static("/static", "/var/www")
+func (group *RouterGroup) Static(relativePath, root string) routesInterface {
+ return group.StaticFS(relativePath, Dir(root, false))
+}
+
+func (group *RouterGroup) StaticFS(relativePath string, fs http.FileSystem) routesInterface {
+ if strings.Contains(relativePath, ":") || strings.Contains(relativePath, "*") {
+ panic("URL parameters can not be used when serving a static folder")
+ }
+ handler := group.createStaticHandler(relativePath, fs)
+ urlPattern := path.Join(relativePath, "/*filepath")
+
+ // Register GET and HEAD handlers
+ group.GET(urlPattern, handler)
+ group.HEAD(urlPattern, handler)
+ return group.returnObj()
+}
+
+func (group *RouterGroup) createStaticHandler(relativePath string, fs http.FileSystem) HandlerFunc {
+ absolutePath := group.calculateAbsolutePath(relativePath)
+ fileServer := http.StripPrefix(absolutePath, http.FileServer(fs))
+ _, nolisting := fs.(*onlyfilesFS)
+ return func(c *Context) {
+ if nolisting {
+ c.Writer.WriteHeader(404)
+ }
+ fileServer.ServeHTTP(c.Writer, c.Request)
+ }
+}
+
+func (group *RouterGroup) combineHandlers(handlers HandlersChain) HandlersChain {
+ finalSize := len(group.Handlers) + len(handlers)
+ if finalSize >= int(AbortIndex) {
+ panic("too many handlers")
+ }
+ mergedHandlers := make(HandlersChain, finalSize)
+ copy(mergedHandlers, group.Handlers)
+ copy(mergedHandlers[len(group.Handlers):], handlers)
+ return mergedHandlers
+}
+
+func (group *RouterGroup) calculateAbsolutePath(relativePath string) string {
+ return joinPaths(group.BasePath, relativePath)
+}
+
+func (group *RouterGroup) returnObj() routesInterface {
+ if group.root {
+ return group.engine
+ } else {
+ return group
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/routergroup_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/routergroup_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..67f7f8e60e9d8ff8425ace26d93d49f60bc3eb81
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/routergroup_test.go
@@ -0,0 +1,177 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+func init() {
+ SetMode(TestMode)
+}
+
+func TestRouterGroupBasic(t *testing.T) {
+ router := New()
+ group := router.Group("/hola", func(c *Context) {})
+ group.Use(func(c *Context) {})
+
+ assert.Len(t, group.Handlers, 2)
+ assert.Equal(t, group.BasePath, "/hola")
+ assert.Equal(t, group.engine, router)
+
+ group2 := group.Group("manu")
+ group2.Use(func(c *Context) {}, func(c *Context) {})
+
+ assert.Len(t, group2.Handlers, 4)
+ assert.Equal(t, group2.BasePath, "/hola/manu")
+ assert.Equal(t, group2.engine, router)
+}
+
+func TestRouterGroupBasicHandle(t *testing.T) {
+ performRequestInGroup(t, "GET")
+ performRequestInGroup(t, "POST")
+ performRequestInGroup(t, "PUT")
+ performRequestInGroup(t, "PATCH")
+ performRequestInGroup(t, "DELETE")
+ performRequestInGroup(t, "HEAD")
+ performRequestInGroup(t, "OPTIONS")
+}
+
+func performRequestInGroup(t *testing.T, method string) {
+ router := New()
+ v1 := router.Group("v1", func(c *Context) {})
+ assert.Equal(t, v1.BasePath, "/v1")
+
+ login := v1.Group("/login/", func(c *Context) {}, func(c *Context) {})
+ assert.Equal(t, login.BasePath, "/v1/login/")
+
+ handler := func(c *Context) {
+ c.String(400, "the method was %s and index %d", c.Request.Method, c.index)
+ }
+
+ switch method {
+ case "GET":
+ v1.GET("/test", handler)
+ login.GET("/test", handler)
+ case "POST":
+ v1.POST("/test", handler)
+ login.POST("/test", handler)
+ case "PUT":
+ v1.PUT("/test", handler)
+ login.PUT("/test", handler)
+ case "PATCH":
+ v1.PATCH("/test", handler)
+ login.PATCH("/test", handler)
+ case "DELETE":
+ v1.DELETE("/test", handler)
+ login.DELETE("/test", handler)
+ case "HEAD":
+ v1.HEAD("/test", handler)
+ login.HEAD("/test", handler)
+ case "OPTIONS":
+ v1.OPTIONS("/test", handler)
+ login.OPTIONS("/test", handler)
+ default:
+ panic("unknown method")
+ }
+
+ w := performRequest(router, method, "/v1/login/test")
+ assert.Equal(t, w.Code, 400)
+ assert.Equal(t, w.Body.String(), "the method was "+method+" and index 3")
+
+ w = performRequest(router, method, "/v1/test")
+ assert.Equal(t, w.Code, 400)
+ assert.Equal(t, w.Body.String(), "the method was "+method+" and index 1")
+}
+
+func TestRouterGroupInvalidStatic(t *testing.T) {
+ router := New()
+ assert.Panics(t, func() {
+ router.Static("/path/:param", "/")
+ })
+
+ assert.Panics(t, func() {
+ router.Static("/path/*param", "/")
+ })
+}
+
+func TestRouterGroupInvalidStaticFile(t *testing.T) {
+ router := New()
+ assert.Panics(t, func() {
+ router.StaticFile("/path/:param", "favicon.ico")
+ })
+
+ assert.Panics(t, func() {
+ router.StaticFile("/path/*param", "favicon.ico")
+ })
+}
+
+func TestRouterGroupTooManyHandlers(t *testing.T) {
+ router := New()
+ handlers1 := make([]HandlerFunc, 40)
+ router.Use(handlers1...)
+
+ handlers2 := make([]HandlerFunc, 26)
+ assert.Panics(t, func() {
+ router.Use(handlers2...)
+ })
+ assert.Panics(t, func() {
+ router.GET("/", handlers2...)
+ })
+}
+
+func TestRouterGroupBadMethod(t *testing.T) {
+ router := New()
+ assert.Panics(t, func() {
+ router.Handle("get", "/")
+ })
+ assert.Panics(t, func() {
+ router.Handle(" GET", "/")
+ })
+ assert.Panics(t, func() {
+ router.Handle("GET ", "/")
+ })
+ assert.Panics(t, func() {
+ router.Handle("", "/")
+ })
+ assert.Panics(t, func() {
+ router.Handle("PO ST", "/")
+ })
+ assert.Panics(t, func() {
+ router.Handle("1GET", "/")
+ })
+ assert.Panics(t, func() {
+ router.Handle("PATCh", "/")
+ })
+}
+
+func TestRouterGroupPipeline(t *testing.T) {
+ router := New()
+ testRoutesInterface(t, router)
+
+ v1 := router.Group("/v1")
+ testRoutesInterface(t, v1)
+}
+
+func testRoutesInterface(t *testing.T, r routesInterface) {
+ handler := func(c *Context) {}
+ assert.Equal(t, r, r.Use(handler))
+
+ assert.Equal(t, r, r.Handle("GET", "/handler", handler))
+ assert.Equal(t, r, r.Any("/any", handler))
+ assert.Equal(t, r, r.GET("/", handler))
+ assert.Equal(t, r, r.POST("/", handler))
+ assert.Equal(t, r, r.DELETE("/", handler))
+ assert.Equal(t, r, r.PATCH("/", handler))
+ assert.Equal(t, r, r.PUT("/", handler))
+ assert.Equal(t, r, r.OPTIONS("/", handler))
+ assert.Equal(t, r, r.HEAD("/", handler))
+
+ assert.Equal(t, r, r.StaticFile("/file", "."))
+ assert.Equal(t, r, r.Static("/static", "."))
+ assert.Equal(t, r, r.StaticFS("/static2", Dir(".", false)))
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/routes_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/routes_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..3f5d23ed4a05dfd05d7c5fd1d76f4490276b9611
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/routes_test.go
@@ -0,0 +1,329 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "fmt"
+ "io/ioutil"
+ "net/http"
+ "net/http/httptest"
+ "os"
+ "path/filepath"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+func performRequest(r http.Handler, method, path string) *httptest.ResponseRecorder {
+ req, _ := http.NewRequest(method, path, nil)
+ w := httptest.NewRecorder()
+ r.ServeHTTP(w, req)
+ return w
+}
+
+func testRouteOK(method string, t *testing.T) {
+ passed := false
+ passedAny := false
+ r := New()
+ r.Any("/test2", func(c *Context) {
+ passedAny = true
+ })
+ r.Handle(method, "/test", func(c *Context) {
+ passed = true
+ })
+
+ w := performRequest(r, method, "/test")
+ assert.True(t, passed)
+ assert.Equal(t, w.Code, http.StatusOK)
+
+ performRequest(r, method, "/test2")
+ assert.True(t, passedAny)
+
+}
+
+// TestSingleRouteOK tests that POST route is correctly invoked.
+func testRouteNotOK(method string, t *testing.T) {
+ passed := false
+ router := New()
+ router.Handle(method, "/test_2", func(c *Context) {
+ passed = true
+ })
+
+ w := performRequest(router, method, "/test")
+
+ assert.False(t, passed)
+ assert.Equal(t, w.Code, http.StatusNotFound)
+}
+
+// TestSingleRouteOK tests that POST route is correctly invoked.
+func testRouteNotOK2(method string, t *testing.T) {
+ passed := false
+ router := New()
+ router.HandleMethodNotAllowed = true
+ var methodRoute string
+ if method == "POST" {
+ methodRoute = "GET"
+ } else {
+ methodRoute = "POST"
+ }
+ router.Handle(methodRoute, "/test", func(c *Context) {
+ passed = true
+ })
+
+ w := performRequest(router, method, "/test")
+
+ assert.False(t, passed)
+ assert.Equal(t, w.Code, http.StatusMethodNotAllowed)
+}
+
+func TestRouterMethod(t *testing.T) {
+ router := New()
+ router.PUT("/hey2", func(c *Context) {
+ c.String(200, "sup2")
+ })
+
+ router.PUT("/hey", func(c *Context) {
+ c.String(200, "called")
+ })
+
+ router.PUT("/hey3", func(c *Context) {
+ c.String(200, "sup3")
+ })
+
+ w := performRequest(router, "PUT", "/hey")
+
+ assert.Equal(t, w.Code, 200)
+ assert.Equal(t, w.Body.String(), "called")
+}
+
+func TestRouterGroupRouteOK(t *testing.T) {
+ testRouteOK("GET", t)
+ testRouteOK("POST", t)
+ testRouteOK("PUT", t)
+ testRouteOK("PATCH", t)
+ testRouteOK("HEAD", t)
+ testRouteOK("OPTIONS", t)
+ testRouteOK("DELETE", t)
+ testRouteOK("CONNECT", t)
+ testRouteOK("TRACE", t)
+}
+
+// TestSingleRouteOK tests that POST route is correctly invoked.
+func TestRouteNotOK(t *testing.T) {
+ testRouteNotOK("GET", t)
+ testRouteNotOK("POST", t)
+ testRouteNotOK("PUT", t)
+ testRouteNotOK("PATCH", t)
+ testRouteNotOK("HEAD", t)
+ testRouteNotOK("OPTIONS", t)
+ testRouteNotOK("DELETE", t)
+ testRouteNotOK("CONNECT", t)
+ testRouteNotOK("TRACE", t)
+}
+
+// TestSingleRouteOK tests that POST route is correctly invoked.
+func TestRouteNotOK2(t *testing.T) {
+ testRouteNotOK2("GET", t)
+ testRouteNotOK2("POST", t)
+ testRouteNotOK2("PUT", t)
+ testRouteNotOK2("PATCH", t)
+ testRouteNotOK2("HEAD", t)
+ testRouteNotOK2("OPTIONS", t)
+ testRouteNotOK2("DELETE", t)
+ testRouteNotOK2("CONNECT", t)
+ testRouteNotOK2("TRACE", t)
+}
+
+// TestContextParamsGet tests that a parameter can be parsed from the URL.
+func TestRouteParamsByName(t *testing.T) {
+ name := ""
+ lastName := ""
+ wild := ""
+ router := New()
+ router.GET("/test/:name/:last_name/*wild", func(c *Context) {
+ name = c.Params.ByName("name")
+ lastName = c.Params.ByName("last_name")
+ var ok bool
+ wild, ok = c.Params.Get("wild")
+
+ assert.True(t, ok)
+ assert.Equal(t, name, c.Param("name"))
+ assert.Equal(t, name, c.Param("name"))
+ assert.Equal(t, lastName, c.Param("last_name"))
+
+ assert.Empty(t, c.Param("wtf"))
+ assert.Empty(t, c.Params.ByName("wtf"))
+
+ wtf, ok := c.Params.Get("wtf")
+ assert.Empty(t, wtf)
+ assert.False(t, ok)
+ })
+
+ w := performRequest(router, "GET", "/test/john/smith/is/super/great")
+
+ assert.Equal(t, w.Code, 200)
+ assert.Equal(t, name, "john")
+ assert.Equal(t, lastName, "smith")
+ assert.Equal(t, wild, "/is/super/great")
+}
+
+// TestHandleStaticFile - ensure the static file handles properly
+func TestRouteStaticFile(t *testing.T) {
+ // SETUP file
+ testRoot, _ := os.Getwd()
+ f, err := ioutil.TempFile(testRoot, "")
+ if err != nil {
+ t.Error(err)
+ }
+ defer os.Remove(f.Name())
+ f.WriteString("Gin Web Framework")
+ f.Close()
+
+ dir, filename := filepath.Split(f.Name())
+
+ // SETUP gin
+ router := New()
+ router.Static("/using_static", dir)
+ router.StaticFile("/result", f.Name())
+
+ w := performRequest(router, "GET", "/using_static/"+filename)
+ w2 := performRequest(router, "GET", "/result")
+
+ assert.Equal(t, w, w2)
+ assert.Equal(t, w.Code, 200)
+ assert.Equal(t, w.Body.String(), "Gin Web Framework")
+ assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/plain; charset=utf-8")
+
+ w3 := performRequest(router, "HEAD", "/using_static/"+filename)
+ w4 := performRequest(router, "HEAD", "/result")
+
+ assert.Equal(t, w3, w4)
+ assert.Equal(t, w3.Code, 200)
+}
+
+// TestHandleStaticDir - ensure the root/sub dir handles properly
+func TestRouteStaticListingDir(t *testing.T) {
+ router := New()
+ router.StaticFS("/", Dir("./", true))
+
+ w := performRequest(router, "GET", "/")
+
+ assert.Equal(t, w.Code, 200)
+ assert.Contains(t, w.Body.String(), "gin.go")
+ assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/html; charset=utf-8")
+}
+
+// TestHandleHeadToDir - ensure the root/sub dir handles properly
+func TestRouteStaticNoListing(t *testing.T) {
+ router := New()
+ router.Static("/", "./")
+
+ w := performRequest(router, "GET", "/")
+
+ assert.Equal(t, w.Code, 404)
+ assert.NotContains(t, w.Body.String(), "gin.go")
+}
+
+func TestRouterMiddlewareAndStatic(t *testing.T) {
+ router := New()
+ static := router.Group("/", func(c *Context) {
+ c.Writer.Header().Add("Last-Modified", "Mon, 02 Jan 2006 15:04:05 MST")
+ c.Writer.Header().Add("Expires", "Mon, 02 Jan 2006 15:04:05 MST")
+ c.Writer.Header().Add("X-GIN", "Gin Framework")
+ })
+ static.Static("/", "./")
+
+ w := performRequest(router, "GET", "/gin.go")
+
+ assert.Equal(t, w.Code, 200)
+ assert.Contains(t, w.Body.String(), "package gin")
+ assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/plain; charset=utf-8")
+ assert.NotEqual(t, w.HeaderMap.Get("Last-Modified"), "Mon, 02 Jan 2006 15:04:05 MST")
+ assert.Equal(t, w.HeaderMap.Get("Expires"), "Mon, 02 Jan 2006 15:04:05 MST")
+ assert.Equal(t, w.HeaderMap.Get("x-GIN"), "Gin Framework")
+}
+
+func TestRouteNotAllowedEnabled(t *testing.T) {
+ router := New()
+ router.HandleMethodNotAllowed = true
+ router.POST("/path", func(c *Context) {})
+ w := performRequest(router, "GET", "/path")
+ assert.Equal(t, w.Code, http.StatusMethodNotAllowed)
+
+ router.NoMethod(func(c *Context) {
+ c.String(http.StatusTeapot, "responseText")
+ })
+ w = performRequest(router, "GET", "/path")
+ assert.Equal(t, w.Body.String(), "responseText")
+ assert.Equal(t, w.Code, http.StatusTeapot)
+}
+
+func TestRouteNotAllowedDisabled(t *testing.T) {
+ router := New()
+ router.HandleMethodNotAllowed = false
+ router.POST("/path", func(c *Context) {})
+ w := performRequest(router, "GET", "/path")
+ assert.Equal(t, w.Code, 404)
+
+ router.NoMethod(func(c *Context) {
+ c.String(http.StatusTeapot, "responseText")
+ })
+ w = performRequest(router, "GET", "/path")
+ assert.Equal(t, w.Body.String(), "404 page not found")
+ assert.Equal(t, w.Code, 404)
+}
+
+func TestRouterNotFound(t *testing.T) {
+ router := New()
+ router.RedirectFixedPath = true
+ router.GET("/path", func(c *Context) {})
+ router.GET("/dir/", func(c *Context) {})
+ router.GET("/", func(c *Context) {})
+
+ testRoutes := []struct {
+ route string
+ code int
+ header string
+ }{
+ {"/path/", 301, "map[Location:[/path]]"}, // TSR -/
+ {"/dir", 301, "map[Location:[/dir/]]"}, // TSR +/
+ {"", 301, "map[Location:[/]]"}, // TSR +/
+ {"/PATH", 301, "map[Location:[/path]]"}, // Fixed Case
+ {"/DIR/", 301, "map[Location:[/dir/]]"}, // Fixed Case
+ {"/PATH/", 301, "map[Location:[/path]]"}, // Fixed Case -/
+ {"/DIR", 301, "map[Location:[/dir/]]"}, // Fixed Case +/
+ {"/../path", 301, "map[Location:[/path]]"}, // CleanPath
+ {"/nope", 404, ""}, // NotFound
+ }
+ for _, tr := range testRoutes {
+ w := performRequest(router, "GET", tr.route)
+ assert.Equal(t, w.Code, tr.code)
+ if w.Code != 404 {
+ assert.Equal(t, fmt.Sprint(w.Header()), tr.header)
+ }
+ }
+
+ // Test custom not found handler
+ var notFound bool
+ router.NoRoute(func(c *Context) {
+ c.AbortWithStatus(404)
+ notFound = true
+ })
+ w := performRequest(router, "GET", "/nope")
+ assert.Equal(t, w.Code, 404)
+ assert.True(t, notFound)
+
+ // Test other method than GET (want 307 instead of 301)
+ router.PATCH("/path", func(c *Context) {})
+ w = performRequest(router, "PATCH", "/path/")
+ assert.Equal(t, w.Code, 307)
+ assert.Equal(t, fmt.Sprint(w.Header()), "map[Location:[/path]]")
+
+ // Test special case where no node for the prefix "/" exists
+ router = New()
+ router.GET("/a", func(c *Context) {})
+ w = performRequest(router, "GET", "/")
+ assert.Equal(t, w.Code, 404)
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/tree.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/tree.go
new file mode 100644
index 0000000000000000000000000000000000000000..c87e0d89b5f9f1287db145a171958a26cbe618c8
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/tree.go
@@ -0,0 +1,596 @@
+// Copyright 2013 Julien Schmidt. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be found
+// in the LICENSE file.
+
+package gin
+
+import (
+ "strings"
+ "unicode"
+)
+
+// Param is a single URL parameter, consisting of a key and a value.
+type Param struct {
+ Key string
+ Value string
+}
+
+// Params is a Param-slice, as returned by the router.
+// The slice is ordered, the first URL parameter is also the first slice value.
+// It is therefore safe to read values by the index.
+type Params []Param
+
+// ByName returns the value of the first Param which key matches the given name.
+// If no matching Param is found, an empty string is returned.
+func (ps Params) Get(name string) (string, bool) {
+ for _, entry := range ps {
+ if entry.Key == name {
+ return entry.Value, true
+ }
+ }
+ return "", false
+}
+
+func (ps Params) ByName(name string) (va string) {
+ va, _ = ps.Get(name)
+ return
+}
+
+type methodTree struct {
+ method string
+ root *node
+}
+
+type methodTrees []methodTree
+
+func (trees methodTrees) get(method string) *node {
+ for _, tree := range trees {
+ if tree.method == method {
+ return tree.root
+ }
+ }
+ return nil
+}
+
+func min(a, b int) int {
+ if a <= b {
+ return a
+ }
+ return b
+}
+
+func countParams(path string) uint8 {
+ var n uint
+ for i := 0; i < len(path); i++ {
+ if path[i] != ':' && path[i] != '*' {
+ continue
+ }
+ n++
+ }
+ if n >= 255 {
+ return 255
+ }
+ return uint8(n)
+}
+
+type nodeType uint8
+
+const (
+ static nodeType = 0
+ param nodeType = 1
+ catchAll nodeType = 2
+)
+
+type node struct {
+ path string
+ wildChild bool
+ nType nodeType
+ maxParams uint8
+ indices string
+ children []*node
+ handlers HandlersChain
+ priority uint32
+}
+
+// increments priority of the given child and reorders if necessary
+func (n *node) incrementChildPrio(pos int) int {
+ n.children[pos].priority++
+ prio := n.children[pos].priority
+
+ // adjust position (move to front)
+ newPos := pos
+ for newPos > 0 && n.children[newPos-1].priority < prio {
+ // swap node positions
+ tmpN := n.children[newPos-1]
+ n.children[newPos-1] = n.children[newPos]
+ n.children[newPos] = tmpN
+
+ newPos--
+ }
+
+ // build new index char string
+ if newPos != pos {
+ n.indices = n.indices[:newPos] + // unchanged prefix, might be empty
+ n.indices[pos:pos+1] + // the index char we move
+ n.indices[newPos:pos] + n.indices[pos+1:] // rest without char at 'pos'
+ }
+
+ return newPos
+}
+
+// addRoute adds a node with the given handle to the path.
+// Not concurrency-safe!
+func (n *node) addRoute(path string, handlers HandlersChain) {
+ fullPath := path
+ n.priority++
+ numParams := countParams(path)
+
+ // non-empty tree
+ if len(n.path) > 0 || len(n.children) > 0 {
+ walk:
+ for {
+ // Update maxParams of the current node
+ if numParams > n.maxParams {
+ n.maxParams = numParams
+ }
+
+ // Find the longest common prefix.
+ // This also implies that the common prefix contains no ':' or '*'
+ // since the existing key can't contain those chars.
+ i := 0
+ max := min(len(path), len(n.path))
+ for i < max && path[i] == n.path[i] {
+ i++
+ }
+
+ // Split edge
+ if i < len(n.path) {
+ child := node{
+ path: n.path[i:],
+ wildChild: n.wildChild,
+ indices: n.indices,
+ children: n.children,
+ handlers: n.handlers,
+ priority: n.priority - 1,
+ }
+
+ // Update maxParams (max of all children)
+ for i := range child.children {
+ if child.children[i].maxParams > child.maxParams {
+ child.maxParams = child.children[i].maxParams
+ }
+ }
+
+ n.children = []*node{&child}
+ // []byte for proper unicode char conversion, see #65
+ n.indices = string([]byte{n.path[i]})
+ n.path = path[:i]
+ n.handlers = nil
+ n.wildChild = false
+ }
+
+ // Make new node a child of this node
+ if i < len(path) {
+ path = path[i:]
+
+ if n.wildChild {
+ n = n.children[0]
+ n.priority++
+
+ // Update maxParams of the child node
+ if numParams > n.maxParams {
+ n.maxParams = numParams
+ }
+ numParams--
+
+ // Check if the wildcard matches
+ if len(path) >= len(n.path) && n.path == path[:len(n.path)] {
+ // check for longer wildcard, e.g. :name and :names
+ if len(n.path) >= len(path) || path[len(n.path)] == '/' {
+ continue walk
+ }
+ }
+
+ panic("path segment '" + path +
+ "' conflicts with existing wildcard '" + n.path +
+ "' in path '" + fullPath + "'")
+ }
+
+ c := path[0]
+
+ // slash after param
+ if n.nType == param && c == '/' && len(n.children) == 1 {
+ n = n.children[0]
+ n.priority++
+ continue walk
+ }
+
+ // Check if a child with the next path byte exists
+ for i := 0; i < len(n.indices); i++ {
+ if c == n.indices[i] {
+ i = n.incrementChildPrio(i)
+ n = n.children[i]
+ continue walk
+ }
+ }
+
+ // Otherwise insert it
+ if c != ':' && c != '*' {
+ // []byte for proper unicode char conversion, see #65
+ n.indices += string([]byte{c})
+ child := &node{
+ maxParams: numParams,
+ }
+ n.children = append(n.children, child)
+ n.incrementChildPrio(len(n.indices) - 1)
+ n = child
+ }
+ n.insertChild(numParams, path, fullPath, handlers)
+ return
+
+ } else if i == len(path) { // Make node a (in-path) leaf
+ if n.handlers != nil {
+ panic("handlers are already registered for path ''" + fullPath + "'")
+ }
+ n.handlers = handlers
+ }
+ return
+ }
+ } else { // Empty tree
+ n.insertChild(numParams, path, fullPath, handlers)
+ }
+}
+
+func (n *node) insertChild(numParams uint8, path string, fullPath string, handlers HandlersChain) {
+ var offset int // already handled bytes of the path
+
+ // find prefix until first wildcard (beginning with ':'' or '*'')
+ for i, max := 0, len(path); numParams > 0; i++ {
+ c := path[i]
+ if c != ':' && c != '*' {
+ continue
+ }
+
+ // find wildcard end (either '/' or path end)
+ end := i + 1
+ for end < max && path[end] != '/' {
+ switch path[end] {
+ // the wildcard name must not contain ':' and '*'
+ case ':', '*':
+ panic("only one wildcard per path segment is allowed, has: '" +
+ path[i:] + "' in path '" + fullPath + "'")
+ default:
+ end++
+ }
+ }
+
+ // check if this Node existing children which would be
+ // unreachable if we insert the wildcard here
+ if len(n.children) > 0 {
+ panic("wildcard route '" + path[i:end] +
+ "' conflicts with existing children in path '" + fullPath + "'")
+ }
+
+ // check if the wildcard has a name
+ if end-i < 2 {
+ panic("wildcards must be named with a non-empty name in path '" + fullPath + "'")
+ }
+
+ if c == ':' { // param
+ // split path at the beginning of the wildcard
+ if i > 0 {
+ n.path = path[offset:i]
+ offset = i
+ }
+
+ child := &node{
+ nType: param,
+ maxParams: numParams,
+ }
+ n.children = []*node{child}
+ n.wildChild = true
+ n = child
+ n.priority++
+ numParams--
+
+ // if the path doesn't end with the wildcard, then there
+ // will be another non-wildcard subpath starting with '/'
+ if end < max {
+ n.path = path[offset:end]
+ offset = end
+
+ child := &node{
+ maxParams: numParams,
+ priority: 1,
+ }
+ n.children = []*node{child}
+ n = child
+ }
+
+ } else { // catchAll
+ if end != max || numParams > 1 {
+ panic("catch-all routes are only allowed at the end of the path in path '" + fullPath + "'")
+ }
+
+ if len(n.path) > 0 && n.path[len(n.path)-1] == '/' {
+ panic("catch-all conflicts with existing handle for the path segment root in path '" + fullPath + "'")
+ }
+
+ // currently fixed width 1 for '/'
+ i--
+ if path[i] != '/' {
+ panic("no / before catch-all in path '" + fullPath + "'")
+ }
+
+ n.path = path[offset:i]
+
+ // first node: catchAll node with empty path
+ child := &node{
+ wildChild: true,
+ nType: catchAll,
+ maxParams: 1,
+ }
+ n.children = []*node{child}
+ n.indices = string(path[i])
+ n = child
+ n.priority++
+
+ // second node: node holding the variable
+ child = &node{
+ path: path[i:],
+ nType: catchAll,
+ maxParams: 1,
+ handlers: handlers,
+ priority: 1,
+ }
+ n.children = []*node{child}
+
+ return
+ }
+ }
+
+ // insert remaining path part and handle to the leaf
+ n.path = path[offset:]
+ n.handlers = handlers
+}
+
+// Returns the handle registered with the given path (key). The values of
+// wildcards are saved to a map.
+// If no handle can be found, a TSR (trailing slash redirect) recommendation is
+// made if a handle exists with an extra (without the) trailing slash for the
+// given path.
+func (n *node) getValue(path string, po Params) (handlers HandlersChain, p Params, tsr bool) {
+ p = po
+walk: // Outer loop for walking the tree
+ for {
+ if len(path) > len(n.path) {
+ if path[:len(n.path)] == n.path {
+ path = path[len(n.path):]
+ // If this node does not have a wildcard (param or catchAll)
+ // child, we can just look up the next child node and continue
+ // to walk down the tree
+ if !n.wildChild {
+ c := path[0]
+ for i := 0; i < len(n.indices); i++ {
+ if c == n.indices[i] {
+ n = n.children[i]
+ continue walk
+ }
+ }
+
+ // Nothing found.
+ // We can recommend to redirect to the same URL without a
+ // trailing slash if a leaf exists for that path.
+ tsr = (path == "/" && n.handlers != nil)
+ return
+ }
+
+ // handle wildcard child
+ n = n.children[0]
+ switch n.nType {
+ case param:
+ // find param end (either '/' or path end)
+ end := 0
+ for end < len(path) && path[end] != '/' {
+ end++
+ }
+
+ // save param value
+ if cap(p) < int(n.maxParams) {
+ p = make(Params, 0, n.maxParams)
+ }
+ i := len(p)
+ p = p[:i+1] // expand slice within preallocated capacity
+ p[i].Key = n.path[1:]
+ p[i].Value = path[:end]
+
+ // we need to go deeper!
+ if end < len(path) {
+ if len(n.children) > 0 {
+ path = path[end:]
+ n = n.children[0]
+ continue walk
+ }
+
+ // ... but we can't
+ tsr = (len(path) == end+1)
+ return
+ }
+
+ if handlers = n.handlers; handlers != nil {
+ return
+ } else if len(n.children) == 1 {
+ // No handle found. Check if a handle for this path + a
+ // trailing slash exists for TSR recommendation
+ n = n.children[0]
+ tsr = (n.path == "/" && n.handlers != nil)
+ }
+
+ return
+
+ case catchAll:
+ // save param value
+ if cap(p) < int(n.maxParams) {
+ p = make(Params, 0, n.maxParams)
+ }
+ i := len(p)
+ p = p[:i+1] // expand slice within preallocated capacity
+ p[i].Key = n.path[2:]
+ p[i].Value = path
+
+ handlers = n.handlers
+ return
+
+ default:
+ panic("invalid node type")
+ }
+ }
+ } else if path == n.path {
+ // We should have reached the node containing the handle.
+ // Check if this node has a handle registered.
+ if handlers = n.handlers; handlers != nil {
+ return
+ }
+
+ // No handle found. Check if a handle for this path + a
+ // trailing slash exists for trailing slash recommendation
+ for i := 0; i < len(n.indices); i++ {
+ if n.indices[i] == '/' {
+ n = n.children[i]
+ tsr = (len(n.path) == 1 && n.handlers != nil) ||
+ (n.nType == catchAll && n.children[0].handlers != nil)
+ return
+ }
+ }
+
+ return
+ }
+
+ // Nothing found. We can recommend to redirect to the same URL with an
+ // extra trailing slash if a leaf exists for that path
+ tsr = (path == "/") ||
+ (len(n.path) == len(path)+1 && n.path[len(path)] == '/' &&
+ path == n.path[:len(n.path)-1] && n.handlers != nil)
+ return
+ }
+}
+
+// Makes a case-insensitive lookup of the given path and tries to find a handler.
+// It can optionally also fix trailing slashes.
+// It returns the case-corrected path and a bool indicating whether the lookup
+// was successful.
+func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (ciPath []byte, found bool) {
+ ciPath = make([]byte, 0, len(path)+1) // preallocate enough memory
+
+ // Outer loop for walking the tree
+ for len(path) >= len(n.path) && strings.ToLower(path[:len(n.path)]) == strings.ToLower(n.path) {
+ path = path[len(n.path):]
+ ciPath = append(ciPath, n.path...)
+
+ if len(path) > 0 {
+ // If this node does not have a wildcard (param or catchAll) child,
+ // we can just look up the next child node and continue to walk down
+ // the tree
+ if !n.wildChild {
+ r := unicode.ToLower(rune(path[0]))
+ for i, index := range n.indices {
+ // must use recursive approach since both index and
+ // ToLower(index) could exist. We must check both.
+ if r == unicode.ToLower(index) {
+ out, found := n.children[i].findCaseInsensitivePath(path, fixTrailingSlash)
+ if found {
+ return append(ciPath, out...), true
+ }
+ }
+ }
+
+ // Nothing found. We can recommend to redirect to the same URL
+ // without a trailing slash if a leaf exists for that path
+ found = (fixTrailingSlash && path == "/" && n.handlers != nil)
+ return
+ }
+
+ n = n.children[0]
+ switch n.nType {
+ case param:
+ // find param end (either '/' or path end)
+ k := 0
+ for k < len(path) && path[k] != '/' {
+ k++
+ }
+
+ // add param value to case insensitive path
+ ciPath = append(ciPath, path[:k]...)
+
+ // we need to go deeper!
+ if k < len(path) {
+ if len(n.children) > 0 {
+ path = path[k:]
+ n = n.children[0]
+ continue
+ }
+
+ // ... but we can't
+ if fixTrailingSlash && len(path) == k+1 {
+ return ciPath, true
+ }
+ return
+ }
+
+ if n.handlers != nil {
+ return ciPath, true
+ } else if fixTrailingSlash && len(n.children) == 1 {
+ // No handle found. Check if a handle for this path + a
+ // trailing slash exists
+ n = n.children[0]
+ if n.path == "/" && n.handlers != nil {
+ return append(ciPath, '/'), true
+ }
+ }
+ return
+
+ case catchAll:
+ return append(ciPath, path...), true
+
+ default:
+ panic("invalid node type")
+ }
+ } else {
+ // We should have reached the node containing the handle.
+ // Check if this node has a handle registered.
+ if n.handlers != nil {
+ return ciPath, true
+ }
+
+ // No handle found.
+ // Try to fix the path by adding a trailing slash
+ if fixTrailingSlash {
+ for i := 0; i < len(n.indices); i++ {
+ if n.indices[i] == '/' {
+ n = n.children[i]
+ if (len(n.path) == 1 && n.handlers != nil) ||
+ (n.nType == catchAll && n.children[0].handlers != nil) {
+ return append(ciPath, '/'), true
+ }
+ return
+ }
+ }
+ }
+ return
+ }
+ }
+
+ // Nothing found.
+ // Try to fix the path by adding / removing a trailing slash
+ if fixTrailingSlash {
+ if path == "/" {
+ return ciPath, true
+ }
+ if len(path)+1 == len(n.path) && n.path[len(path)] == '/' &&
+ strings.ToLower(path) == strings.ToLower(n.path[:len(path)]) &&
+ n.handlers != nil {
+ return append(ciPath, n.path...), true
+ }
+ }
+ return
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/tree_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/tree_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..4e2cb7f6993544a07b2572a9a29194c0ce0815a1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/tree_test.go
@@ -0,0 +1,608 @@
+// Copyright 2013 Julien Schmidt. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be found
+// in the LICENSE file.
+
+package gin
+
+import (
+ "fmt"
+ "reflect"
+ "strings"
+ "testing"
+)
+
+func printChildren(n *node, prefix string) {
+ fmt.Printf(" %02d:%02d %s%s[%d] %v %t %d \r\n", n.priority, n.maxParams, prefix, n.path, len(n.children), n.handlers, n.wildChild, n.nType)
+ for l := len(n.path); l > 0; l-- {
+ prefix += " "
+ }
+ for _, child := range n.children {
+ printChildren(child, prefix)
+ }
+}
+
+// Used as a workaround since we can't compare functions or their adresses
+var fakeHandlerValue string
+
+func fakeHandler(val string) HandlersChain {
+ return HandlersChain{func(c *Context) {
+ fakeHandlerValue = val
+ }}
+}
+
+type testRequests []struct {
+ path string
+ nilHandler bool
+ route string
+ ps Params
+}
+
+func checkRequests(t *testing.T, tree *node, requests testRequests) {
+ for _, request := range requests {
+ handler, ps, _ := tree.getValue(request.path, nil)
+
+ if handler == nil {
+ if !request.nilHandler {
+ t.Errorf("handle mismatch for route '%s': Expected non-nil handle", request.path)
+ }
+ } else if request.nilHandler {
+ t.Errorf("handle mismatch for route '%s': Expected nil handle", request.path)
+ } else {
+ handler[0](nil)
+ if fakeHandlerValue != request.route {
+ t.Errorf("handle mismatch for route '%s': Wrong handle (%s != %s)", request.path, fakeHandlerValue, request.route)
+ }
+ }
+
+ if !reflect.DeepEqual(ps, request.ps) {
+ t.Errorf("Params mismatch for route '%s'", request.path)
+ }
+ }
+}
+
+func checkPriorities(t *testing.T, n *node) uint32 {
+ var prio uint32
+ for i := range n.children {
+ prio += checkPriorities(t, n.children[i])
+ }
+
+ if n.handlers != nil {
+ prio++
+ }
+
+ if n.priority != prio {
+ t.Errorf(
+ "priority mismatch for node '%s': is %d, should be %d",
+ n.path, n.priority, prio,
+ )
+ }
+
+ return prio
+}
+
+func checkMaxParams(t *testing.T, n *node) uint8 {
+ var maxParams uint8
+ for i := range n.children {
+ params := checkMaxParams(t, n.children[i])
+ if params > maxParams {
+ maxParams = params
+ }
+ }
+ if n.nType != static && !n.wildChild {
+ maxParams++
+ }
+
+ if n.maxParams != maxParams {
+ t.Errorf(
+ "maxParams mismatch for node '%s': is %d, should be %d",
+ n.path, n.maxParams, maxParams,
+ )
+ }
+
+ return maxParams
+}
+
+func TestCountParams(t *testing.T) {
+ if countParams("/path/:param1/static/*catch-all") != 2 {
+ t.Fail()
+ }
+ if countParams(strings.Repeat("/:param", 256)) != 255 {
+ t.Fail()
+ }
+}
+
+func TestTreeAddAndGet(t *testing.T) {
+ tree := &node{}
+
+ routes := [...]string{
+ "/hi",
+ "/contact",
+ "/co",
+ "/c",
+ "/a",
+ "/ab",
+ "/doc/",
+ "/doc/go_faq.html",
+ "/doc/go1.html",
+ "/α",
+ "/β",
+ }
+ for _, route := range routes {
+ tree.addRoute(route, fakeHandler(route))
+ }
+
+ //printChildren(tree, "")
+
+ checkRequests(t, tree, testRequests{
+ {"/a", false, "/a", nil},
+ {"/", true, "", nil},
+ {"/hi", false, "/hi", nil},
+ {"/contact", false, "/contact", nil},
+ {"/co", false, "/co", nil},
+ {"/con", true, "", nil}, // key mismatch
+ {"/cona", true, "", nil}, // key mismatch
+ {"/no", true, "", nil}, // no matching child
+ {"/ab", false, "/ab", nil},
+ {"/α", false, "/α", nil},
+ {"/β", false, "/β", nil},
+ })
+
+ checkPriorities(t, tree)
+ checkMaxParams(t, tree)
+}
+
+func TestTreeWildcard(t *testing.T) {
+ tree := &node{}
+
+ routes := [...]string{
+ "/",
+ "/cmd/:tool/:sub",
+ "/cmd/:tool/",
+ "/src/*filepath",
+ "/search/",
+ "/search/:query",
+ "/user_:name",
+ "/user_:name/about",
+ "/files/:dir/*filepath",
+ "/doc/",
+ "/doc/go_faq.html",
+ "/doc/go1.html",
+ "/info/:user/public",
+ "/info/:user/project/:project",
+ }
+ for _, route := range routes {
+ tree.addRoute(route, fakeHandler(route))
+ }
+
+ //printChildren(tree, "")
+
+ checkRequests(t, tree, testRequests{
+ {"/", false, "/", nil},
+ {"/cmd/test/", false, "/cmd/:tool/", Params{Param{"tool", "test"}}},
+ {"/cmd/test", true, "", Params{Param{"tool", "test"}}},
+ {"/cmd/test/3", false, "/cmd/:tool/:sub", Params{Param{"tool", "test"}, Param{"sub", "3"}}},
+ {"/src/", false, "/src/*filepath", Params{Param{"filepath", "/"}}},
+ {"/src/some/file.png", false, "/src/*filepath", Params{Param{"filepath", "/some/file.png"}}},
+ {"/search/", false, "/search/", nil},
+ {"/search/someth!ng+in+ünìcodé", false, "/search/:query", Params{Param{"query", "someth!ng+in+ünìcodé"}}},
+ {"/search/someth!ng+in+ünìcodé/", true, "", Params{Param{"query", "someth!ng+in+ünìcodé"}}},
+ {"/user_gopher", false, "/user_:name", Params{Param{"name", "gopher"}}},
+ {"/user_gopher/about", false, "/user_:name/about", Params{Param{"name", "gopher"}}},
+ {"/files/js/inc/framework.js", false, "/files/:dir/*filepath", Params{Param{"dir", "js"}, Param{"filepath", "/inc/framework.js"}}},
+ {"/info/gordon/public", false, "/info/:user/public", Params{Param{"user", "gordon"}}},
+ {"/info/gordon/project/go", false, "/info/:user/project/:project", Params{Param{"user", "gordon"}, Param{"project", "go"}}},
+ })
+
+ checkPriorities(t, tree)
+ checkMaxParams(t, tree)
+}
+
+func catchPanic(testFunc func()) (recv interface{}) {
+ defer func() {
+ recv = recover()
+ }()
+
+ testFunc()
+ return
+}
+
+type testRoute struct {
+ path string
+ conflict bool
+}
+
+func testRoutes(t *testing.T, routes []testRoute) {
+ tree := &node{}
+
+ for _, route := range routes {
+ recv := catchPanic(func() {
+ tree.addRoute(route.path, nil)
+ })
+
+ if route.conflict {
+ if recv == nil {
+ t.Errorf("no panic for conflicting route '%s'", route.path)
+ }
+ } else if recv != nil {
+ t.Errorf("unexpected panic for route '%s': %v", route.path, recv)
+ }
+ }
+
+ //printChildren(tree, "")
+}
+
+func TestTreeWildcardConflict(t *testing.T) {
+ routes := []testRoute{
+ {"/cmd/:tool/:sub", false},
+ {"/cmd/vet", true},
+ {"/src/*filepath", false},
+ {"/src/*filepathx", true},
+ {"/src/", true},
+ {"/src1/", false},
+ {"/src1/*filepath", true},
+ {"/src2*filepath", true},
+ {"/search/:query", false},
+ {"/search/invalid", true},
+ {"/user_:name", false},
+ {"/user_x", true},
+ {"/user_:name", false},
+ {"/id:id", false},
+ {"/id/:id", true},
+ }
+ testRoutes(t, routes)
+}
+
+func TestTreeChildConflict(t *testing.T) {
+ routes := []testRoute{
+ {"/cmd/vet", false},
+ {"/cmd/:tool/:sub", true},
+ {"/src/AUTHORS", false},
+ {"/src/*filepath", true},
+ {"/user_x", false},
+ {"/user_:name", true},
+ {"/id/:id", false},
+ {"/id:id", true},
+ {"/:id", true},
+ {"/*filepath", true},
+ }
+ testRoutes(t, routes)
+}
+
+func TestTreeDupliatePath(t *testing.T) {
+ tree := &node{}
+
+ routes := [...]string{
+ "/",
+ "/doc/",
+ "/src/*filepath",
+ "/search/:query",
+ "/user_:name",
+ }
+ for _, route := range routes {
+ recv := catchPanic(func() {
+ tree.addRoute(route, fakeHandler(route))
+ })
+ if recv != nil {
+ t.Fatalf("panic inserting route '%s': %v", route, recv)
+ }
+
+ // Add again
+ recv = catchPanic(func() {
+ tree.addRoute(route, nil)
+ })
+ if recv == nil {
+ t.Fatalf("no panic while inserting duplicate route '%s", route)
+ }
+ }
+
+ //printChildren(tree, "")
+
+ checkRequests(t, tree, testRequests{
+ {"/", false, "/", nil},
+ {"/doc/", false, "/doc/", nil},
+ {"/src/some/file.png", false, "/src/*filepath", Params{Param{"filepath", "/some/file.png"}}},
+ {"/search/someth!ng+in+ünìcodé", false, "/search/:query", Params{Param{"query", "someth!ng+in+ünìcodé"}}},
+ {"/user_gopher", false, "/user_:name", Params{Param{"name", "gopher"}}},
+ })
+}
+
+func TestEmptyWildcardName(t *testing.T) {
+ tree := &node{}
+
+ routes := [...]string{
+ "/user:",
+ "/user:/",
+ "/cmd/:/",
+ "/src/*",
+ }
+ for _, route := range routes {
+ recv := catchPanic(func() {
+ tree.addRoute(route, nil)
+ })
+ if recv == nil {
+ t.Fatalf("no panic while inserting route with empty wildcard name '%s", route)
+ }
+ }
+}
+
+func TestTreeCatchAllConflict(t *testing.T) {
+ routes := []testRoute{
+ {"/src/*filepath/x", true},
+ {"/src2/", false},
+ {"/src2/*filepath/x", true},
+ }
+ testRoutes(t, routes)
+}
+
+func TestTreeCatchAllConflictRoot(t *testing.T) {
+ routes := []testRoute{
+ {"/", false},
+ {"/*filepath", true},
+ }
+ testRoutes(t, routes)
+}
+
+func TestTreeDoubleWildcard(t *testing.T) {
+ const panicMsg = "only one wildcard per path segment is allowed"
+
+ routes := [...]string{
+ "/:foo:bar",
+ "/:foo:bar/",
+ "/:foo*bar",
+ }
+
+ for _, route := range routes {
+ tree := &node{}
+ recv := catchPanic(func() {
+ tree.addRoute(route, nil)
+ })
+
+ if rs, ok := recv.(string); !ok || !strings.HasPrefix(rs, panicMsg) {
+ t.Fatalf(`"Expected panic "%s" for route '%s', got "%v"`, panicMsg, route, recv)
+ }
+ }
+}
+
+/*func TestTreeDuplicateWildcard(t *testing.T) {
+ tree := &node{}
+
+ routes := [...]string{
+ "/:id/:name/:id",
+ }
+ for _, route := range routes {
+ ...
+ }
+}*/
+
+func TestTreeTrailingSlashRedirect(t *testing.T) {
+ tree := &node{}
+
+ routes := [...]string{
+ "/hi",
+ "/b/",
+ "/search/:query",
+ "/cmd/:tool/",
+ "/src/*filepath",
+ "/x",
+ "/x/y",
+ "/y/",
+ "/y/z",
+ "/0/:id",
+ "/0/:id/1",
+ "/1/:id/",
+ "/1/:id/2",
+ "/aa",
+ "/a/",
+ "/doc",
+ "/doc/go_faq.html",
+ "/doc/go1.html",
+ "/no/a",
+ "/no/b",
+ "/api/hello/:name",
+ }
+ for _, route := range routes {
+ recv := catchPanic(func() {
+ tree.addRoute(route, fakeHandler(route))
+ })
+ if recv != nil {
+ t.Fatalf("panic inserting route '%s': %v", route, recv)
+ }
+ }
+
+ //printChildren(tree, "")
+
+ tsrRoutes := [...]string{
+ "/hi/",
+ "/b",
+ "/search/gopher/",
+ "/cmd/vet",
+ "/src",
+ "/x/",
+ "/y",
+ "/0/go/",
+ "/1/go",
+ "/a",
+ "/doc/",
+ }
+ for _, route := range tsrRoutes {
+ handler, _, tsr := tree.getValue(route, nil)
+ if handler != nil {
+ t.Fatalf("non-nil handler for TSR route '%s", route)
+ } else if !tsr {
+ t.Errorf("expected TSR recommendation for route '%s'", route)
+ }
+ }
+
+ noTsrRoutes := [...]string{
+ "/",
+ "/no",
+ "/no/",
+ "/_",
+ "/_/",
+ "/api/world/abc",
+ }
+ for _, route := range noTsrRoutes {
+ handler, _, tsr := tree.getValue(route, nil)
+ if handler != nil {
+ t.Fatalf("non-nil handler for No-TSR route '%s", route)
+ } else if tsr {
+ t.Errorf("expected no TSR recommendation for route '%s'", route)
+ }
+ }
+}
+
+func TestTreeFindCaseInsensitivePath(t *testing.T) {
+ tree := &node{}
+
+ routes := [...]string{
+ "/hi",
+ "/b/",
+ "/ABC/",
+ "/search/:query",
+ "/cmd/:tool/",
+ "/src/*filepath",
+ "/x",
+ "/x/y",
+ "/y/",
+ "/y/z",
+ "/0/:id",
+ "/0/:id/1",
+ "/1/:id/",
+ "/1/:id/2",
+ "/aa",
+ "/a/",
+ "/doc",
+ "/doc/go_faq.html",
+ "/doc/go1.html",
+ "/doc/go/away",
+ "/no/a",
+ "/no/b",
+ }
+
+ for _, route := range routes {
+ recv := catchPanic(func() {
+ tree.addRoute(route, fakeHandler(route))
+ })
+ if recv != nil {
+ t.Fatalf("panic inserting route '%s': %v", route, recv)
+ }
+ }
+
+ // Check out == in for all registered routes
+ // With fixTrailingSlash = true
+ for _, route := range routes {
+ out, found := tree.findCaseInsensitivePath(route, true)
+ if !found {
+ t.Errorf("Route '%s' not found!", route)
+ } else if string(out) != route {
+ t.Errorf("Wrong result for route '%s': %s", route, string(out))
+ }
+ }
+ // With fixTrailingSlash = false
+ for _, route := range routes {
+ out, found := tree.findCaseInsensitivePath(route, false)
+ if !found {
+ t.Errorf("Route '%s' not found!", route)
+ } else if string(out) != route {
+ t.Errorf("Wrong result for route '%s': %s", route, string(out))
+ }
+ }
+
+ tests := []struct {
+ in string
+ out string
+ found bool
+ slash bool
+ }{
+ {"/HI", "/hi", true, false},
+ {"/HI/", "/hi", true, true},
+ {"/B", "/b/", true, true},
+ {"/B/", "/b/", true, false},
+ {"/abc", "/ABC/", true, true},
+ {"/abc/", "/ABC/", true, false},
+ {"/aBc", "/ABC/", true, true},
+ {"/aBc/", "/ABC/", true, false},
+ {"/abC", "/ABC/", true, true},
+ {"/abC/", "/ABC/", true, false},
+ {"/SEARCH/QUERY", "/search/QUERY", true, false},
+ {"/SEARCH/QUERY/", "/search/QUERY", true, true},
+ {"/CMD/TOOL/", "/cmd/TOOL/", true, false},
+ {"/CMD/TOOL", "/cmd/TOOL/", true, true},
+ {"/SRC/FILE/PATH", "/src/FILE/PATH", true, false},
+ {"/x/Y", "/x/y", true, false},
+ {"/x/Y/", "/x/y", true, true},
+ {"/X/y", "/x/y", true, false},
+ {"/X/y/", "/x/y", true, true},
+ {"/X/Y", "/x/y", true, false},
+ {"/X/Y/", "/x/y", true, true},
+ {"/Y/", "/y/", true, false},
+ {"/Y", "/y/", true, true},
+ {"/Y/z", "/y/z", true, false},
+ {"/Y/z/", "/y/z", true, true},
+ {"/Y/Z", "/y/z", true, false},
+ {"/Y/Z/", "/y/z", true, true},
+ {"/y/Z", "/y/z", true, false},
+ {"/y/Z/", "/y/z", true, true},
+ {"/Aa", "/aa", true, false},
+ {"/Aa/", "/aa", true, true},
+ {"/AA", "/aa", true, false},
+ {"/AA/", "/aa", true, true},
+ {"/aA", "/aa", true, false},
+ {"/aA/", "/aa", true, true},
+ {"/A/", "/a/", true, false},
+ {"/A", "/a/", true, true},
+ {"/DOC", "/doc", true, false},
+ {"/DOC/", "/doc", true, true},
+ {"/NO", "", false, true},
+ {"/DOC/GO", "", false, true},
+ }
+ // With fixTrailingSlash = true
+ for _, test := range tests {
+ out, found := tree.findCaseInsensitivePath(test.in, true)
+ if found != test.found || (found && (string(out) != test.out)) {
+ t.Errorf("Wrong result for '%s': got %s, %t; want %s, %t",
+ test.in, string(out), found, test.out, test.found)
+ return
+ }
+ }
+ // With fixTrailingSlash = false
+ for _, test := range tests {
+ out, found := tree.findCaseInsensitivePath(test.in, false)
+ if test.slash {
+ if found { // test needs a trailingSlash fix. It must not be found!
+ t.Errorf("Found without fixTrailingSlash: %s; got %s", test.in, string(out))
+ }
+ } else {
+ if found != test.found || (found && (string(out) != test.out)) {
+ t.Errorf("Wrong result for '%s': got %s, %t; want %s, %t",
+ test.in, string(out), found, test.out, test.found)
+ return
+ }
+ }
+ }
+}
+
+func TestTreeInvalidNodeType(t *testing.T) {
+ tree := &node{}
+ tree.addRoute("/", fakeHandler("/"))
+ tree.addRoute("/:page", fakeHandler("/:page"))
+
+ // set invalid node type
+ tree.children[0].nType = 42
+
+ // normal lookup
+ recv := catchPanic(func() {
+ tree.getValue("/test", nil)
+ })
+ if rs, ok := recv.(string); !ok || rs != "invalid node type" {
+ t.Fatalf(`Expected panic "invalid node type", got "%v"`, recv)
+ }
+
+ // case-insensitive lookup
+ recv = catchPanic(func() {
+ tree.findCaseInsensitivePath("/test", true)
+ })
+ if rs, ok := recv.(string); !ok || rs != "invalid node type" {
+ t.Fatalf(`Expected panic "invalid node type", got "%v"`, recv)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/utils.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/utils.go
new file mode 100644
index 0000000000000000000000000000000000000000..7e646876881b3469d57909670ff3f57f3241690f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/utils.go
@@ -0,0 +1,131 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "encoding/xml"
+ "net/http"
+ "path"
+ "reflect"
+ "runtime"
+ "strings"
+)
+
+const BindKey = "_gin-gonic/gin/bindkey"
+
+func Bind(val interface{}) HandlerFunc {
+ value := reflect.ValueOf(val)
+ if value.Kind() == reflect.Ptr {
+ panic(`Bind struct can not be a pointer. Example:
+ Use: gin.Bind(Struct{}) instead of gin.Bind(&Struct{})
+`)
+ }
+ typ := value.Type()
+
+ return func(c *Context) {
+ obj := reflect.New(typ).Interface()
+ if c.Bind(obj) == nil {
+ c.Set(BindKey, obj)
+ }
+ }
+}
+
+func WrapF(f http.HandlerFunc) HandlerFunc {
+ return func(c *Context) {
+ f(c.Writer, c.Request)
+ }
+}
+
+func WrapH(h http.Handler) HandlerFunc {
+ return func(c *Context) {
+ h.ServeHTTP(c.Writer, c.Request)
+ }
+}
+
+type H map[string]interface{}
+
+// Allows type H to be used with xml.Marshal
+func (h H) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+ start.Name = xml.Name{
+ Space: "",
+ Local: "map",
+ }
+ if err := e.EncodeToken(start); err != nil {
+ return err
+ }
+ for key, value := range h {
+ elem := xml.StartElement{
+ Name: xml.Name{Space: "", Local: key},
+ Attr: []xml.Attr{},
+ }
+ if err := e.EncodeElement(value, elem); err != nil {
+ return err
+ }
+ }
+ if err := e.EncodeToken(xml.EndElement{Name: start.Name}); err != nil {
+ return err
+ }
+ return nil
+}
+
+func filterFlags(content string) string {
+ for i, char := range content {
+ if char == ' ' || char == ';' {
+ return content[:i]
+ }
+ }
+ return content
+}
+
+func chooseData(custom, wildcard interface{}) interface{} {
+ if custom == nil {
+ if wildcard == nil {
+ panic("negotiation config is invalid")
+ }
+ return wildcard
+ }
+ return custom
+}
+
+func parseAccept(acceptHeader string) []string {
+ parts := strings.Split(acceptHeader, ",")
+ out := make([]string, 0, len(parts))
+ for _, part := range parts {
+ index := strings.IndexByte(part, ';')
+ if index >= 0 {
+ part = part[0:index]
+ }
+ part = strings.TrimSpace(part)
+ if len(part) > 0 {
+ out = append(out, part)
+ }
+ }
+ return out
+}
+
+func lastChar(str string) uint8 {
+ size := len(str)
+ if size == 0 {
+ panic("The length of the string can't be 0")
+ }
+ return str[size-1]
+}
+
+func nameOfFunction(f interface{}) string {
+ return runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name()
+}
+
+func joinPaths(absolutePath, relativePath string) string {
+ if len(relativePath) == 0 {
+ return absolutePath
+ }
+
+ finalPath := path.Join(absolutePath, relativePath)
+ appendSlash := lastChar(relativePath) == '/' && lastChar(finalPath) != '/'
+ if appendSlash {
+ return finalPath + "/"
+ }
+ return finalPath
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/utils_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/utils_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..e2fcf4f4ad3f821708706f54c0c0bd8a976a01d3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/utils_test.go
@@ -0,0 +1,99 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+ "fmt"
+ "net/http"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+func init() {
+ SetMode(TestMode)
+}
+
+type testStruct struct {
+ T *testing.T
+}
+
+func (t *testStruct) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+ assert.Equal(t.T, req.Method, "POST")
+ assert.Equal(t.T, req.URL.Path, "/path")
+ w.WriteHeader(500)
+ fmt.Fprint(w, "hello")
+}
+
+func TestWrap(t *testing.T) {
+ router := New()
+ router.POST("/path", WrapH(&testStruct{t}))
+ router.GET("/path2", WrapF(func(w http.ResponseWriter, req *http.Request) {
+ assert.Equal(t, req.Method, "GET")
+ assert.Equal(t, req.URL.Path, "/path2")
+ w.WriteHeader(400)
+ fmt.Fprint(w, "hola!")
+ }))
+
+ w := performRequest(router, "POST", "/path")
+ assert.Equal(t, w.Code, 500)
+ assert.Equal(t, w.Body.String(), "hello")
+
+ w = performRequest(router, "GET", "/path2")
+ assert.Equal(t, w.Code, 400)
+ assert.Equal(t, w.Body.String(), "hola!")
+}
+
+func TestLastChar(t *testing.T) {
+ assert.Equal(t, lastChar("hola"), uint8('a'))
+ assert.Equal(t, lastChar("adios"), uint8('s'))
+ assert.Panics(t, func() { lastChar("") })
+}
+
+func TestParseAccept(t *testing.T) {
+ parts := parseAccept("text/html , application/xhtml+xml,application/xml;q=0.9, */* ;q=0.8")
+ assert.Len(t, parts, 4)
+ assert.Equal(t, parts[0], "text/html")
+ assert.Equal(t, parts[1], "application/xhtml+xml")
+ assert.Equal(t, parts[2], "application/xml")
+ assert.Equal(t, parts[3], "*/*")
+}
+
+func TestChooseData(t *testing.T) {
+ A := "a"
+ B := "b"
+ assert.Equal(t, chooseData(A, B), A)
+ assert.Equal(t, chooseData(nil, B), B)
+ assert.Panics(t, func() { chooseData(nil, nil) })
+}
+
+func TestFilterFlags(t *testing.T) {
+ result := filterFlags("text/html ")
+ assert.Equal(t, result, "text/html")
+
+ result = filterFlags("text/html;")
+ assert.Equal(t, result, "text/html")
+}
+
+func TestFunctionName(t *testing.T) {
+ assert.Equal(t, nameOfFunction(somefunction), "github.com/gin-gonic/gin.somefunction")
+}
+
+func somefunction() {
+ // this empty function is used by TestFunctionName()
+}
+
+func TestJoinPaths(t *testing.T) {
+ assert.Equal(t, joinPaths("", ""), "")
+ assert.Equal(t, joinPaths("", "/"), "/")
+ assert.Equal(t, joinPaths("/a", ""), "/a")
+ assert.Equal(t, joinPaths("/a/", ""), "/a/")
+ assert.Equal(t, joinPaths("/a/", "/"), "/a/")
+ assert.Equal(t, joinPaths("/a", "/"), "/a/")
+ assert.Equal(t, joinPaths("/a", "/hola"), "/a/hola")
+ assert.Equal(t, joinPaths("/a/", "/hola"), "/a/hola")
+ assert.Equal(t, joinPaths("/a/", "/hola/"), "/a/hola/")
+ assert.Equal(t, joinPaths("/a/", "/hola//"), "/a/hola/")
+}
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/wercker.yml b/Godeps/_workspace/src/github.com/gin-gonic/gin/wercker.yml
new file mode 100644
index 0000000000000000000000000000000000000000..3ab8084cc6a62d0ba8d24f7d5d1d92d5a4279ae9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/wercker.yml
@@ -0,0 +1 @@
+box: wercker/default
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/.gitignore b/Godeps/_workspace/src/github.com/gorilla/websocket/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..00268614f04567605359c96e714e834db9cebab6
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/.gitignore
@@ -0,0 +1,22 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/.travis.yml b/Godeps/_workspace/src/github.com/gorilla/websocket/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..8687342e9d402af86d5b33b1a146d65275695366
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/.travis.yml
@@ -0,0 +1,6 @@
+language: go
+
+go:
+ - 1.1
+ - 1.2
+ - tip
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/AUTHORS b/Godeps/_workspace/src/github.com/gorilla/websocket/AUTHORS
new file mode 100644
index 0000000000000000000000000000000000000000..b003eca0ca187243683ea444142d4465dd77b619
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/AUTHORS
@@ -0,0 +1,8 @@
+# This is the official list of Gorilla WebSocket authors for copyright
+# purposes.
+#
+# Please keep the list sorted.
+
+Gary Burd <gary@beagledreams.com>
+Joachim Bauch <mail@joachim-bauch.de>
+
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/LICENSE b/Godeps/_workspace/src/github.com/gorilla/websocket/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..9171c972252257cf416925ddff4be6cb73973a82
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/LICENSE
@@ -0,0 +1,22 @@
+Copyright (c) 2013 The Gorilla WebSocket Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+ 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.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER 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.
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/README.md b/Godeps/_workspace/src/github.com/gorilla/websocket/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9ad75a0f5e91c8bebc49836567ddc4961e456b59
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/README.md
@@ -0,0 +1,59 @@
+# Gorilla WebSocket
+
+Gorilla WebSocket is a [Go](http://golang.org/) implementation of the
+[WebSocket](http://www.rfc-editor.org/rfc/rfc6455.txt) protocol.
+
+### Documentation
+
+* [API Reference](http://godoc.org/github.com/gorilla/websocket)
+* [Chat example](https://github.com/gorilla/websocket/tree/master/examples/chat)
+* [File watch example](https://github.com/gorilla/websocket/tree/master/examples/filewatch)
+
+### Status
+
+The Gorilla WebSocket package provides a complete and tested implementation of
+the [WebSocket](http://www.rfc-editor.org/rfc/rfc6455.txt) protocol. The
+package API is stable.
+
+### Installation
+
+ go get github.com/gorilla/websocket
+
+### Protocol Compliance
+
+The Gorilla WebSocket package passes the server tests in the [Autobahn Test
+Suite](http://autobahn.ws/testsuite) using the application in the [examples/autobahn
+subdirectory](https://github.com/gorilla/websocket/tree/master/examples/autobahn).
+
+### Gorilla WebSocket compared with other packages
+
+<table>
+<tr>
+<th></th>
+<th><a href="http://godoc.org/github.com/gorilla/websocket">github.com/gorilla</a></th>
+<th><a href="http://godoc.org/golang.org/x/net/websocket">golang.org/x/net</a></th>
+</tr>
+<tr>
+<tr><td colspan="3"><a href="http://tools.ietf.org/html/rfc6455">RFC 6455</a> Features</td></tr>
+<tr><td>Passes <a href="http://autobahn.ws/testsuite/">Autobahn Test Suite</a></td><td><a href="https://github.com/gorilla/websocket/tree/master/examples/autobahn">Yes</a></td><td>No</td></tr>
+<tr><td>Receive <a href="https://tools.ietf.org/html/rfc6455#section-5.4">fragmented</a> message<td>Yes</td><td><a href="https://code.google.com/p/go/issues/detail?id=7632">No</a>, see note 1</td></tr>
+<tr><td>Send <a href="https://tools.ietf.org/html/rfc6455#section-5.5.1">close</a> message</td><td><a href="http://godoc.org/github.com/gorilla/websocket#hdr-Control_Messages">Yes</a></td><td><a href="https://code.google.com/p/go/issues/detail?id=4588">No</a></td></tr>
+<tr><td>Send <a href="https://tools.ietf.org/html/rfc6455#section-5.5.2">pings</a> and receive <a href="https://tools.ietf.org/html/rfc6455#section-5.5.3">pongs</a></td><td><a href="http://godoc.org/github.com/gorilla/websocket#hdr-Control_Messages">Yes</a></td><td>No</td></tr>
+<tr><td>Get the <a href="https://tools.ietf.org/html/rfc6455#section-5.6">type</a> of a received data message</td><td>Yes</td><td>Yes, see note 2</td></tr>
+<tr><td colspan="3">Other Features</tr></td>
+<tr><td>Limit size of received message</td><td><a href="http://godoc.org/github.com/gorilla/websocket#Conn.SetReadLimit">Yes</a></td><td><a href="https://code.google.com/p/go/issues/detail?id=5082">No</a></td></tr>
+<tr><td>Read message using io.Reader</td><td><a href="http://godoc.org/github.com/gorilla/websocket#Conn.NextReader">Yes</a></td><td>No, see note 3</td></tr>
+<tr><td>Write message using io.WriteCloser</td><td><a href="http://godoc.org/github.com/gorilla/websocket#Conn.NextWriter">Yes</a></td><td>No, see note 3</td></tr>
+</table>
+
+Notes:
+
+1. Large messages are fragmented in [Chrome's new WebSocket implementation](http://www.ietf.org/mail-archive/web/hybi/current/msg10503.html).
+2. The application can get the type of a received data message by implementing
+ a [Codec marshal](http://godoc.org/golang.org/x/net/websocket#Codec.Marshal)
+ function.
+3. The go.net io.Reader and io.Writer operate across WebSocket frame boundaries.
+ Read returns when the input buffer is full or a frame boundary is
+ encountered. Each call to Write sends a single frame message. The Gorilla
+ io.Reader and io.WriteCloser operate on a single WebSocket message.
+
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/bench_test.go b/Godeps/_workspace/src/github.com/gorilla/websocket/bench_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..f66fc36bc878c0e29df45beb30ff4d741f8c7bc2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/bench_test.go
@@ -0,0 +1,19 @@
+// Copyright 2014 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "testing"
+)
+
+func BenchmarkMaskBytes(b *testing.B) {
+ var key [4]byte
+ data := make([]byte, 1024)
+ pos := 0
+ for i := 0; i < b.N; i++ {
+ pos = maskBytes(key, pos, data)
+ }
+ b.SetBytes(int64(len(data)))
+}
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/client.go b/Godeps/_workspace/src/github.com/gorilla/websocket/client.go
new file mode 100644
index 0000000000000000000000000000000000000000..5bc27e1932702e3563bca87b3d2aa79e17a09197
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/client.go
@@ -0,0 +1,264 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "bytes"
+ "crypto/tls"
+ "errors"
+ "io"
+ "io/ioutil"
+ "net"
+ "net/http"
+ "net/url"
+ "strings"
+ "time"
+)
+
+// ErrBadHandshake is returned when the server response to opening handshake is
+// invalid.
+var ErrBadHandshake = errors.New("websocket: bad handshake")
+
+// NewClient creates a new client connection using the given net connection.
+// The URL u specifies the host and request URI. Use requestHeader to specify
+// the origin (Origin), subprotocols (Sec-WebSocket-Protocol) and cookies
+// (Cookie). Use the response.Header to get the selected subprotocol
+// (Sec-WebSocket-Protocol) and cookies (Set-Cookie).
+//
+// If the WebSocket handshake fails, ErrBadHandshake is returned along with a
+// non-nil *http.Response so that callers can handle redirects, authentication,
+// etc.
+func NewClient(netConn net.Conn, u *url.URL, requestHeader http.Header, readBufSize, writeBufSize int) (c *Conn, response *http.Response, err error) {
+ challengeKey, err := generateChallengeKey()
+ if err != nil {
+ return nil, nil, err
+ }
+ acceptKey := computeAcceptKey(challengeKey)
+
+ c = newConn(netConn, false, readBufSize, writeBufSize)
+ p := c.writeBuf[:0]
+ p = append(p, "GET "...)
+ p = append(p, u.RequestURI()...)
+ p = append(p, " HTTP/1.1\r\nHost: "...)
+ p = append(p, u.Host...)
+ // "Upgrade" is capitalized for servers that do not use case insensitive
+ // comparisons on header tokens.
+ p = append(p, "\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: "...)
+ p = append(p, challengeKey...)
+ p = append(p, "\r\n"...)
+ for k, vs := range requestHeader {
+ for _, v := range vs {
+ p = append(p, k...)
+ p = append(p, ": "...)
+ p = append(p, v...)
+ p = append(p, "\r\n"...)
+ }
+ }
+ p = append(p, "\r\n"...)
+
+ if _, err := netConn.Write(p); err != nil {
+ return nil, nil, err
+ }
+
+ resp, err := http.ReadResponse(c.br, &http.Request{Method: "GET", URL: u})
+ if err != nil {
+ return nil, nil, err
+ }
+ if resp.StatusCode != 101 ||
+ !strings.EqualFold(resp.Header.Get("Upgrade"), "websocket") ||
+ !strings.EqualFold(resp.Header.Get("Connection"), "upgrade") ||
+ resp.Header.Get("Sec-Websocket-Accept") != acceptKey {
+ return nil, resp, ErrBadHandshake
+ }
+ c.subprotocol = resp.Header.Get("Sec-Websocket-Protocol")
+ return c, resp, nil
+}
+
+// A Dialer contains options for connecting to WebSocket server.
+type Dialer struct {
+ // NetDial specifies the dial function for creating TCP connections. If
+ // NetDial is nil, net.Dial is used.
+ NetDial func(network, addr string) (net.Conn, error)
+
+ // TLSClientConfig specifies the TLS configuration to use with tls.Client.
+ // If nil, the default configuration is used.
+ TLSClientConfig *tls.Config
+
+ // HandshakeTimeout specifies the duration for the handshake to complete.
+ HandshakeTimeout time.Duration
+
+ // Input and output buffer sizes. If the buffer size is zero, then a
+ // default value of 4096 is used.
+ ReadBufferSize, WriteBufferSize int
+
+ // Subprotocols specifies the client's requested subprotocols.
+ Subprotocols []string
+}
+
+var errMalformedURL = errors.New("malformed ws or wss URL")
+
+// parseURL parses the URL. The url.Parse function is not used here because
+// url.Parse mangles the path.
+func parseURL(s string) (*url.URL, error) {
+ // From the RFC:
+ //
+ // ws-URI = "ws:" "//" host [ ":" port ] path [ "?" query ]
+ // wss-URI = "wss:" "//" host [ ":" port ] path [ "?" query ]
+ //
+ // We don't use the net/url parser here because the dialer interface does
+ // not provide a way for applications to work around percent deocding in
+ // the net/url parser.
+
+ var u url.URL
+ switch {
+ case strings.HasPrefix(s, "ws://"):
+ u.Scheme = "ws"
+ s = s[len("ws://"):]
+ case strings.HasPrefix(s, "wss://"):
+ u.Scheme = "wss"
+ s = s[len("wss://"):]
+ default:
+ return nil, errMalformedURL
+ }
+
+ u.Host = s
+ u.Opaque = "/"
+ if i := strings.Index(s, "/"); i >= 0 {
+ u.Host = s[:i]
+ u.Opaque = s[i:]
+ }
+
+ return &u, nil
+}
+
+func hostPortNoPort(u *url.URL) (hostPort, hostNoPort string) {
+ hostPort = u.Host
+ hostNoPort = u.Host
+ if i := strings.LastIndex(u.Host, ":"); i > strings.LastIndex(u.Host, "]") {
+ hostNoPort = hostNoPort[:i]
+ } else {
+ if u.Scheme == "wss" {
+ hostPort += ":443"
+ } else {
+ hostPort += ":80"
+ }
+ }
+ return hostPort, hostNoPort
+}
+
+// DefaultDialer is a dialer with all fields set to the default zero values.
+var DefaultDialer *Dialer
+
+// Dial creates a new client connection. Use requestHeader to specify the
+// origin (Origin), subprotocols (Sec-WebSocket-Protocol) and cookies (Cookie).
+// Use the response.Header to get the selected subprotocol
+// (Sec-WebSocket-Protocol) and cookies (Set-Cookie).
+//
+// If the WebSocket handshake fails, ErrBadHandshake is returned along with a
+// non-nil *http.Response so that callers can handle redirects, authentication,
+// etcetera. The response body may not contain the entire response and does not
+// need to be closed by the application.
+func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (*Conn, *http.Response, error) {
+ u, err := parseURL(urlStr)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ hostPort, hostNoPort := hostPortNoPort(u)
+
+ if d == nil {
+ d = &Dialer{}
+ }
+
+ var deadline time.Time
+ if d.HandshakeTimeout != 0 {
+ deadline = time.Now().Add(d.HandshakeTimeout)
+ }
+
+ netDial := d.NetDial
+ if netDial == nil {
+ netDialer := &net.Dialer{Deadline: deadline}
+ netDial = netDialer.Dial
+ }
+
+ netConn, err := netDial("tcp", hostPort)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ defer func() {
+ if netConn != nil {
+ netConn.Close()
+ }
+ }()
+
+ if err := netConn.SetDeadline(deadline); err != nil {
+ return nil, nil, err
+ }
+
+ if u.Scheme == "wss" {
+ cfg := d.TLSClientConfig
+ if cfg == nil {
+ cfg = &tls.Config{ServerName: hostNoPort}
+ } else if cfg.ServerName == "" {
+ shallowCopy := *cfg
+ cfg = &shallowCopy
+ cfg.ServerName = hostNoPort
+ }
+ tlsConn := tls.Client(netConn, cfg)
+ netConn = tlsConn
+ if err := tlsConn.Handshake(); err != nil {
+ return nil, nil, err
+ }
+ if !cfg.InsecureSkipVerify {
+ if err := tlsConn.VerifyHostname(cfg.ServerName); err != nil {
+ return nil, nil, err
+ }
+ }
+ }
+
+ if len(d.Subprotocols) > 0 {
+ h := http.Header{}
+ for k, v := range requestHeader {
+ h[k] = v
+ }
+ h.Set("Sec-Websocket-Protocol", strings.Join(d.Subprotocols, ", "))
+ requestHeader = h
+ }
+
+ if len(requestHeader["Host"]) > 0 {
+ // This can be used to supply a Host: header which is different from
+ // the dial address.
+ u.Host = requestHeader.Get("Host")
+
+ // Drop "Host" header
+ h := http.Header{}
+ for k, v := range requestHeader {
+ if k == "Host" {
+ continue
+ }
+ h[k] = v
+ }
+ requestHeader = h
+ }
+
+ conn, resp, err := NewClient(netConn, u, requestHeader, d.ReadBufferSize, d.WriteBufferSize)
+
+ if err != nil {
+ if err == ErrBadHandshake {
+ // Before closing the network connection on return from this
+ // function, slurp up some of the response to aid application
+ // debugging.
+ buf := make([]byte, 1024)
+ n, _ := io.ReadFull(resp.Body, buf)
+ resp.Body = ioutil.NopCloser(bytes.NewReader(buf[:n]))
+ }
+ return nil, resp, err
+ }
+
+ netConn.SetDeadline(time.Time{})
+ netConn = nil // to avoid close in defer.
+ return conn, resp, nil
+}
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/client_server_test.go b/Godeps/_workspace/src/github.com/gorilla/websocket/client_server_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..749ef20509ccb54418fee9f78e1d57067d1e4a08
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/client_server_test.go
@@ -0,0 +1,323 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "crypto/tls"
+ "crypto/x509"
+ "io"
+ "io/ioutil"
+ "net"
+ "net/http"
+ "net/http/httptest"
+ "net/url"
+ "reflect"
+ "strings"
+ "testing"
+ "time"
+)
+
+var cstUpgrader = Upgrader{
+ Subprotocols: []string{"p0", "p1"},
+ ReadBufferSize: 1024,
+ WriteBufferSize: 1024,
+ Error: func(w http.ResponseWriter, r *http.Request, status int, reason error) {
+ http.Error(w, reason.Error(), status)
+ },
+}
+
+var cstDialer = Dialer{
+ Subprotocols: []string{"p1", "p2"},
+ ReadBufferSize: 1024,
+ WriteBufferSize: 1024,
+}
+
+type cstHandler struct{ *testing.T }
+
+type cstServer struct {
+ *httptest.Server
+ URL string
+}
+
+func newServer(t *testing.T) *cstServer {
+ var s cstServer
+ s.Server = httptest.NewServer(cstHandler{t})
+ s.URL = makeWsProto(s.Server.URL)
+ return &s
+}
+
+func newTLSServer(t *testing.T) *cstServer {
+ var s cstServer
+ s.Server = httptest.NewTLSServer(cstHandler{t})
+ s.URL = makeWsProto(s.Server.URL)
+ return &s
+}
+
+func (t cstHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ if r.Method != "GET" {
+ t.Logf("method %s not allowed", r.Method)
+ http.Error(w, "method not allowed", 405)
+ return
+ }
+ subprotos := Subprotocols(r)
+ if !reflect.DeepEqual(subprotos, cstDialer.Subprotocols) {
+ t.Logf("subprotols=%v, want %v", subprotos, cstDialer.Subprotocols)
+ http.Error(w, "bad protocol", 400)
+ return
+ }
+ ws, err := cstUpgrader.Upgrade(w, r, http.Header{"Set-Cookie": {"sessionID=1234"}})
+ if err != nil {
+ t.Logf("Upgrade: %v", err)
+ return
+ }
+ defer ws.Close()
+
+ if ws.Subprotocol() != "p1" {
+ t.Logf("Subprotocol() = %s, want p1", ws.Subprotocol())
+ ws.Close()
+ return
+ }
+ op, rd, err := ws.NextReader()
+ if err != nil {
+ t.Logf("NextReader: %v", err)
+ return
+ }
+ wr, err := ws.NextWriter(op)
+ if err != nil {
+ t.Logf("NextWriter: %v", err)
+ return
+ }
+ if _, err = io.Copy(wr, rd); err != nil {
+ t.Logf("NextWriter: %v", err)
+ return
+ }
+ if err := wr.Close(); err != nil {
+ t.Logf("Close: %v", err)
+ return
+ }
+}
+
+func makeWsProto(s string) string {
+ return "ws" + strings.TrimPrefix(s, "http")
+}
+
+func sendRecv(t *testing.T, ws *Conn) {
+ const message = "Hello World!"
+ if err := ws.SetWriteDeadline(time.Now().Add(time.Second)); err != nil {
+ t.Fatalf("SetWriteDeadline: %v", err)
+ }
+ if err := ws.WriteMessage(TextMessage, []byte(message)); err != nil {
+ t.Fatalf("WriteMessage: %v", err)
+ }
+ if err := ws.SetReadDeadline(time.Now().Add(time.Second)); err != nil {
+ t.Fatalf("SetReadDeadline: %v", err)
+ }
+ _, p, err := ws.ReadMessage()
+ if err != nil {
+ t.Fatalf("ReadMessage: %v", err)
+ }
+ if string(p) != message {
+ t.Fatalf("message=%s, want %s", p, message)
+ }
+}
+
+func TestDial(t *testing.T) {
+ s := newServer(t)
+ defer s.Close()
+
+ ws, _, err := cstDialer.Dial(s.URL, nil)
+ if err != nil {
+ t.Fatalf("Dial: %v", err)
+ }
+ defer ws.Close()
+ sendRecv(t, ws)
+}
+
+func TestDialTLS(t *testing.T) {
+ s := newTLSServer(t)
+ defer s.Close()
+
+ certs := x509.NewCertPool()
+ for _, c := range s.TLS.Certificates {
+ roots, err := x509.ParseCertificates(c.Certificate[len(c.Certificate)-1])
+ if err != nil {
+ t.Fatalf("error parsing server's root cert: %v", err)
+ }
+ for _, root := range roots {
+ certs.AddCert(root)
+ }
+ }
+
+ u, _ := url.Parse(s.URL)
+ d := cstDialer
+ d.NetDial = func(network, addr string) (net.Conn, error) { return net.Dial(network, u.Host) }
+ d.TLSClientConfig = &tls.Config{RootCAs: certs}
+ ws, _, err := d.Dial("wss://example.com/", nil)
+ if err != nil {
+ t.Fatalf("Dial: %v", err)
+ }
+ defer ws.Close()
+ sendRecv(t, ws)
+}
+
+func xTestDialTLSBadCert(t *testing.T) {
+ // This test is deactivated because of noisy logging from the net/http package.
+ s := newTLSServer(t)
+ defer s.Close()
+
+ ws, _, err := cstDialer.Dial(s.URL, nil)
+ if err == nil {
+ ws.Close()
+ t.Fatalf("Dial: nil")
+ }
+}
+
+func xTestDialTLSNoVerify(t *testing.T) {
+ s := newTLSServer(t)
+ defer s.Close()
+
+ d := cstDialer
+ d.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
+ ws, _, err := d.Dial(s.URL, nil)
+ if err != nil {
+ t.Fatalf("Dial: %v", err)
+ }
+ defer ws.Close()
+ sendRecv(t, ws)
+}
+
+func TestDialTimeout(t *testing.T) {
+ s := newServer(t)
+ defer s.Close()
+
+ d := cstDialer
+ d.HandshakeTimeout = -1
+ ws, _, err := d.Dial(s.URL, nil)
+ if err == nil {
+ ws.Close()
+ t.Fatalf("Dial: nil")
+ }
+}
+
+func TestDialBadScheme(t *testing.T) {
+ s := newServer(t)
+ defer s.Close()
+
+ ws, _, err := cstDialer.Dial(s.Server.URL, nil)
+ if err == nil {
+ ws.Close()
+ t.Fatalf("Dial: nil")
+ }
+}
+
+func TestDialBadOrigin(t *testing.T) {
+ s := newServer(t)
+ defer s.Close()
+
+ ws, resp, err := cstDialer.Dial(s.URL, http.Header{"Origin": {"bad"}})
+ if err == nil {
+ ws.Close()
+ t.Fatalf("Dial: nil")
+ }
+ if resp == nil {
+ t.Fatalf("resp=nil, err=%v", err)
+ }
+ if resp.StatusCode != http.StatusForbidden {
+ t.Fatalf("status=%d, want %d", resp.StatusCode, http.StatusForbidden)
+ }
+}
+
+func TestHandshake(t *testing.T) {
+ s := newServer(t)
+ defer s.Close()
+
+ ws, resp, err := cstDialer.Dial(s.URL, http.Header{"Origin": {s.URL}})
+ if err != nil {
+ t.Fatalf("Dial: %v", err)
+ }
+ defer ws.Close()
+
+ var sessionID string
+ for _, c := range resp.Cookies() {
+ if c.Name == "sessionID" {
+ sessionID = c.Value
+ }
+ }
+ if sessionID != "1234" {
+ t.Error("Set-Cookie not received from the server.")
+ }
+
+ if ws.Subprotocol() != "p1" {
+ t.Errorf("ws.Subprotocol() = %s, want p1", ws.Subprotocol())
+ }
+ sendRecv(t, ws)
+}
+
+func TestRespOnBadHandshake(t *testing.T) {
+ const expectedStatus = http.StatusGone
+ const expectedBody = "This is the response body."
+
+ s := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(expectedStatus)
+ io.WriteString(w, expectedBody)
+ }))
+ defer s.Close()
+
+ ws, resp, err := cstDialer.Dial(makeWsProto(s.URL), nil)
+ if err == nil {
+ ws.Close()
+ t.Fatalf("Dial: nil")
+ }
+
+ if resp == nil {
+ t.Fatalf("resp=nil, err=%v", err)
+ }
+
+ if resp.StatusCode != expectedStatus {
+ t.Errorf("resp.StatusCode=%d, want %d", resp.StatusCode, expectedStatus)
+ }
+
+ p, err := ioutil.ReadAll(resp.Body)
+ if err != nil {
+ t.Fatalf("ReadFull(resp.Body) returned error %v", err)
+ }
+
+ if string(p) != expectedBody {
+ t.Errorf("resp.Body=%s, want %s", p, expectedBody)
+ }
+}
+
+// If the Host header is specified in `Dial()`, the server must receive it as
+// the `Host:` header.
+func TestHostHeader(t *testing.T) {
+ s := newServer(t)
+ defer s.Close()
+
+ specifiedHost := make(chan string, 1)
+ origHandler := s.Server.Config.Handler
+
+ // Capture the request Host header.
+ s.Server.Config.Handler = http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ specifiedHost <- r.Host
+ origHandler.ServeHTTP(w, r)
+ })
+
+ ws, resp, err := cstDialer.Dial(s.URL, http.Header{"Host": {"testhost"}})
+ if err != nil {
+ t.Fatalf("Dial: %v", err)
+ }
+ defer ws.Close()
+
+ if resp.StatusCode != http.StatusSwitchingProtocols {
+ t.Fatalf("resp.StatusCode = %v, want http.StatusSwitchingProtocols", resp.StatusCode)
+ }
+
+ if gotHost := <-specifiedHost; gotHost != "testhost" {
+ t.Fatalf("gotHost = %q, want \"testhost\"", gotHost)
+ }
+
+ sendRecv(t, ws)
+}
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/client_test.go b/Godeps/_workspace/src/github.com/gorilla/websocket/client_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..d2f2ebd798b2f1834fa2d19b6508b82eb2a77b01
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/client_test.go
@@ -0,0 +1,63 @@
+// Copyright 2014 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "net/url"
+ "reflect"
+ "testing"
+)
+
+var parseURLTests = []struct {
+ s string
+ u *url.URL
+}{
+ {"ws://example.com/", &url.URL{Scheme: "ws", Host: "example.com", Opaque: "/"}},
+ {"ws://example.com", &url.URL{Scheme: "ws", Host: "example.com", Opaque: "/"}},
+ {"ws://example.com:7777/", &url.URL{Scheme: "ws", Host: "example.com:7777", Opaque: "/"}},
+ {"wss://example.com/", &url.URL{Scheme: "wss", Host: "example.com", Opaque: "/"}},
+ {"wss://example.com/a/b", &url.URL{Scheme: "wss", Host: "example.com", Opaque: "/a/b"}},
+ {"ss://example.com/a/b", nil},
+}
+
+func TestParseURL(t *testing.T) {
+ for _, tt := range parseURLTests {
+ u, err := parseURL(tt.s)
+ if tt.u != nil && err != nil {
+ t.Errorf("parseURL(%q) returned error %v", tt.s, err)
+ continue
+ }
+ if tt.u == nil && err == nil {
+ t.Errorf("parseURL(%q) did not return error", tt.s)
+ continue
+ }
+ if !reflect.DeepEqual(u, tt.u) {
+ t.Errorf("parseURL(%q) returned %v, want %v", tt.s, u, tt.u)
+ continue
+ }
+ }
+}
+
+var hostPortNoPortTests = []struct {
+ u *url.URL
+ hostPort, hostNoPort string
+}{
+ {&url.URL{Scheme: "ws", Host: "example.com"}, "example.com:80", "example.com"},
+ {&url.URL{Scheme: "wss", Host: "example.com"}, "example.com:443", "example.com"},
+ {&url.URL{Scheme: "ws", Host: "example.com:7777"}, "example.com:7777", "example.com"},
+ {&url.URL{Scheme: "wss", Host: "example.com:7777"}, "example.com:7777", "example.com"},
+}
+
+func TestHostPortNoPort(t *testing.T) {
+ for _, tt := range hostPortNoPortTests {
+ hostPort, hostNoPort := hostPortNoPort(tt.u)
+ if hostPort != tt.hostPort {
+ t.Errorf("hostPortNoPort(%v) returned hostPort %q, want %q", tt.u, hostPort, tt.hostPort)
+ }
+ if hostNoPort != tt.hostNoPort {
+ t.Errorf("hostPortNoPort(%v) returned hostNoPort %q, want %q", tt.u, hostNoPort, tt.hostNoPort)
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/conn.go b/Godeps/_workspace/src/github.com/gorilla/websocket/conn.go
new file mode 100644
index 0000000000000000000000000000000000000000..e719f1ce63eee37e332a244960df9b126cd407a3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/conn.go
@@ -0,0 +1,825 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "bufio"
+ "encoding/binary"
+ "errors"
+ "io"
+ "io/ioutil"
+ "math/rand"
+ "net"
+ "strconv"
+ "time"
+)
+
+const (
+ maxFrameHeaderSize = 2 + 8 + 4 // Fixed header + length + mask
+ maxControlFramePayloadSize = 125
+ finalBit = 1 << 7
+ maskBit = 1 << 7
+ writeWait = time.Second
+
+ defaultReadBufferSize = 4096
+ defaultWriteBufferSize = 4096
+
+ continuationFrame = 0
+ noFrame = -1
+)
+
+// Close codes defined in RFC 6455, section 11.7.
+const (
+ CloseNormalClosure = 1000
+ CloseGoingAway = 1001
+ CloseProtocolError = 1002
+ CloseUnsupportedData = 1003
+ CloseNoStatusReceived = 1005
+ CloseAbnormalClosure = 1006
+ CloseInvalidFramePayloadData = 1007
+ ClosePolicyViolation = 1008
+ CloseMessageTooBig = 1009
+ CloseMandatoryExtension = 1010
+ CloseInternalServerErr = 1011
+ CloseTLSHandshake = 1015
+)
+
+// The message types are defined in RFC 6455, section 11.8.
+const (
+ // TextMessage denotes a text data message. The text message payload is
+ // interpreted as UTF-8 encoded text data.
+ TextMessage = 1
+
+ // BinaryMessage denotes a binary data message.
+ BinaryMessage = 2
+
+ // CloseMessage denotes a close control message. The optional message
+ // payload contains a numeric code and text. Use the FormatCloseMessage
+ // function to format a close message payload.
+ CloseMessage = 8
+
+ // PingMessage denotes a ping control message. The optional message payload
+ // is UTF-8 encoded text.
+ PingMessage = 9
+
+ // PongMessage denotes a ping control message. The optional message payload
+ // is UTF-8 encoded text.
+ PongMessage = 10
+)
+
+// ErrCloseSent is returned when the application writes a message to the
+// connection after sending a close message.
+var ErrCloseSent = errors.New("websocket: close sent")
+
+// ErrReadLimit is returned when reading a message that is larger than the
+// read limit set for the connection.
+var ErrReadLimit = errors.New("websocket: read limit exceeded")
+
+// netError satisfies the net Error interface.
+type netError struct {
+ msg string
+ temporary bool
+ timeout bool
+}
+
+func (e *netError) Error() string { return e.msg }
+func (e *netError) Temporary() bool { return e.temporary }
+func (e *netError) Timeout() bool { return e.timeout }
+
+// closeError represents close frame.
+type closeError struct {
+ code int
+ text string
+}
+
+func (e *closeError) Error() string {
+ return "websocket: close " + strconv.Itoa(e.code) + " " + e.text
+}
+
+var (
+ errWriteTimeout = &netError{msg: "websocket: write timeout", timeout: true}
+ errUnexpectedEOF = &closeError{code: CloseAbnormalClosure, text: io.ErrUnexpectedEOF.Error()}
+ errBadWriteOpCode = errors.New("websocket: bad write message type")
+ errWriteClosed = errors.New("websocket: write closed")
+ errInvalidControlFrame = errors.New("websocket: invalid control frame")
+)
+
+func hideTempErr(err error) error {
+ if e, ok := err.(net.Error); ok && e.Temporary() {
+ err = &netError{msg: e.Error(), timeout: e.Timeout()}
+ }
+ return err
+}
+
+func isControl(frameType int) bool {
+ return frameType == CloseMessage || frameType == PingMessage || frameType == PongMessage
+}
+
+func isData(frameType int) bool {
+ return frameType == TextMessage || frameType == BinaryMessage
+}
+
+func maskBytes(key [4]byte, pos int, b []byte) int {
+ for i := range b {
+ b[i] ^= key[pos&3]
+ pos++
+ }
+ return pos & 3
+}
+
+func newMaskKey() [4]byte {
+ n := rand.Uint32()
+ return [4]byte{byte(n), byte(n >> 8), byte(n >> 16), byte(n >> 24)}
+}
+
+// Conn represents a WebSocket connection.
+type Conn struct {
+ conn net.Conn
+ isServer bool
+ subprotocol string
+
+ // Write fields
+ mu chan bool // used as mutex to protect write to conn and closeSent
+ closeSent bool // true if close message was sent
+
+ // Message writer fields.
+ writeErr error
+ writeBuf []byte // frame is constructed in this buffer.
+ writePos int // end of data in writeBuf.
+ writeFrameType int // type of the current frame.
+ writeSeq int // incremented to invalidate message writers.
+ writeDeadline time.Time
+
+ // Read fields
+ readErr error
+ br *bufio.Reader
+ readRemaining int64 // bytes remaining in current frame.
+ readFinal bool // true the current message has more frames.
+ readSeq int // incremented to invalidate message readers.
+ readLength int64 // Message size.
+ readLimit int64 // Maximum message size.
+ readMaskPos int
+ readMaskKey [4]byte
+ handlePong func(string) error
+ handlePing func(string) error
+}
+
+func newConn(conn net.Conn, isServer bool, readBufferSize, writeBufferSize int) *Conn {
+ mu := make(chan bool, 1)
+ mu <- true
+
+ if readBufferSize == 0 {
+ readBufferSize = defaultReadBufferSize
+ }
+ if writeBufferSize == 0 {
+ writeBufferSize = defaultWriteBufferSize
+ }
+
+ c := &Conn{
+ isServer: isServer,
+ br: bufio.NewReaderSize(conn, readBufferSize),
+ conn: conn,
+ mu: mu,
+ readFinal: true,
+ writeBuf: make([]byte, writeBufferSize+maxFrameHeaderSize),
+ writeFrameType: noFrame,
+ writePos: maxFrameHeaderSize,
+ }
+ c.SetPingHandler(nil)
+ c.SetPongHandler(nil)
+ return c
+}
+
+// Subprotocol returns the negotiated protocol for the connection.
+func (c *Conn) Subprotocol() string {
+ return c.subprotocol
+}
+
+// Close closes the underlying network connection without sending or waiting for a close frame.
+func (c *Conn) Close() error {
+ return c.conn.Close()
+}
+
+// LocalAddr returns the local network address.
+func (c *Conn) LocalAddr() net.Addr {
+ return c.conn.LocalAddr()
+}
+
+// RemoteAddr returns the remote network address.
+func (c *Conn) RemoteAddr() net.Addr {
+ return c.conn.RemoteAddr()
+}
+
+// Write methods
+
+func (c *Conn) write(frameType int, deadline time.Time, bufs ...[]byte) error {
+ <-c.mu
+ defer func() { c.mu <- true }()
+
+ if c.closeSent {
+ return ErrCloseSent
+ } else if frameType == CloseMessage {
+ c.closeSent = true
+ }
+
+ c.conn.SetWriteDeadline(deadline)
+ for _, buf := range bufs {
+ if len(buf) > 0 {
+ n, err := c.conn.Write(buf)
+ if n != len(buf) {
+ // Close on partial write.
+ c.conn.Close()
+ }
+ if err != nil {
+ return err
+ }
+ }
+ }
+ return nil
+}
+
+// WriteControl writes a control message with the given deadline. The allowed
+// message types are CloseMessage, PingMessage and PongMessage.
+func (c *Conn) WriteControl(messageType int, data []byte, deadline time.Time) error {
+ if !isControl(messageType) {
+ return errBadWriteOpCode
+ }
+ if len(data) > maxControlFramePayloadSize {
+ return errInvalidControlFrame
+ }
+
+ b0 := byte(messageType) | finalBit
+ b1 := byte(len(data))
+ if !c.isServer {
+ b1 |= maskBit
+ }
+
+ buf := make([]byte, 0, maxFrameHeaderSize+maxControlFramePayloadSize)
+ buf = append(buf, b0, b1)
+
+ if c.isServer {
+ buf = append(buf, data...)
+ } else {
+ key := newMaskKey()
+ buf = append(buf, key[:]...)
+ buf = append(buf, data...)
+ maskBytes(key, 0, buf[6:])
+ }
+
+ d := time.Hour * 1000
+ if !deadline.IsZero() {
+ d = deadline.Sub(time.Now())
+ if d < 0 {
+ return errWriteTimeout
+ }
+ }
+
+ timer := time.NewTimer(d)
+ select {
+ case <-c.mu:
+ timer.Stop()
+ case <-timer.C:
+ return errWriteTimeout
+ }
+ defer func() { c.mu <- true }()
+
+ if c.closeSent {
+ return ErrCloseSent
+ } else if messageType == CloseMessage {
+ c.closeSent = true
+ }
+
+ c.conn.SetWriteDeadline(deadline)
+ n, err := c.conn.Write(buf)
+ if n != 0 && n != len(buf) {
+ c.conn.Close()
+ }
+ return err
+}
+
+// NextWriter returns a writer for the next message to send. The writer's
+// Close method flushes the complete message to the network.
+//
+// There can be at most one open writer on a connection. NextWriter closes the
+// previous writer if the application has not already done so.
+//
+// The NextWriter method and the writers returned from the method cannot be
+// accessed by more than one goroutine at a time.
+func (c *Conn) NextWriter(messageType int) (io.WriteCloser, error) {
+ if c.writeErr != nil {
+ return nil, c.writeErr
+ }
+
+ if c.writeFrameType != noFrame {
+ if err := c.flushFrame(true, nil); err != nil {
+ return nil, err
+ }
+ }
+
+ if !isControl(messageType) && !isData(messageType) {
+ return nil, errBadWriteOpCode
+ }
+
+ c.writeFrameType = messageType
+ return messageWriter{c, c.writeSeq}, nil
+}
+
+func (c *Conn) flushFrame(final bool, extra []byte) error {
+ length := c.writePos - maxFrameHeaderSize + len(extra)
+
+ // Check for invalid control frames.
+ if isControl(c.writeFrameType) &&
+ (!final || length > maxControlFramePayloadSize) {
+ c.writeSeq++
+ c.writeFrameType = noFrame
+ c.writePos = maxFrameHeaderSize
+ return errInvalidControlFrame
+ }
+
+ b0 := byte(c.writeFrameType)
+ if final {
+ b0 |= finalBit
+ }
+ b1 := byte(0)
+ if !c.isServer {
+ b1 |= maskBit
+ }
+
+ // Assume that the frame starts at beginning of c.writeBuf.
+ framePos := 0
+ if c.isServer {
+ // Adjust up if mask not included in the header.
+ framePos = 4
+ }
+
+ switch {
+ case length >= 65536:
+ c.writeBuf[framePos] = b0
+ c.writeBuf[framePos+1] = b1 | 127
+ binary.BigEndian.PutUint64(c.writeBuf[framePos+2:], uint64(length))
+ case length > 125:
+ framePos += 6
+ c.writeBuf[framePos] = b0
+ c.writeBuf[framePos+1] = b1 | 126
+ binary.BigEndian.PutUint16(c.writeBuf[framePos+2:], uint16(length))
+ default:
+ framePos += 8
+ c.writeBuf[framePos] = b0
+ c.writeBuf[framePos+1] = b1 | byte(length)
+ }
+
+ if !c.isServer {
+ key := newMaskKey()
+ copy(c.writeBuf[maxFrameHeaderSize-4:], key[:])
+ maskBytes(key, 0, c.writeBuf[maxFrameHeaderSize:c.writePos])
+ if len(extra) > 0 {
+ c.writeErr = errors.New("websocket: internal error, extra used in client mode")
+ return c.writeErr
+ }
+ }
+
+ // Write the buffers to the connection.
+ c.writeErr = c.write(c.writeFrameType, c.writeDeadline, c.writeBuf[framePos:c.writePos], extra)
+
+ // Setup for next frame.
+ c.writePos = maxFrameHeaderSize
+ c.writeFrameType = continuationFrame
+ if final {
+ c.writeSeq++
+ c.writeFrameType = noFrame
+ }
+ return c.writeErr
+}
+
+type messageWriter struct {
+ c *Conn
+ seq int
+}
+
+func (w messageWriter) err() error {
+ c := w.c
+ if c.writeSeq != w.seq {
+ return errWriteClosed
+ }
+ if c.writeErr != nil {
+ return c.writeErr
+ }
+ return nil
+}
+
+func (w messageWriter) ncopy(max int) (int, error) {
+ n := len(w.c.writeBuf) - w.c.writePos
+ if n <= 0 {
+ if err := w.c.flushFrame(false, nil); err != nil {
+ return 0, err
+ }
+ n = len(w.c.writeBuf) - w.c.writePos
+ }
+ if n > max {
+ n = max
+ }
+ return n, nil
+}
+
+func (w messageWriter) write(final bool, p []byte) (int, error) {
+ if err := w.err(); err != nil {
+ return 0, err
+ }
+
+ if len(p) > 2*len(w.c.writeBuf) && w.c.isServer {
+ // Don't buffer large messages.
+ err := w.c.flushFrame(final, p)
+ if err != nil {
+ return 0, err
+ }
+ return len(p), nil
+ }
+
+ nn := len(p)
+ for len(p) > 0 {
+ n, err := w.ncopy(len(p))
+ if err != nil {
+ return 0, err
+ }
+ copy(w.c.writeBuf[w.c.writePos:], p[:n])
+ w.c.writePos += n
+ p = p[n:]
+ }
+ return nn, nil
+}
+
+func (w messageWriter) Write(p []byte) (int, error) {
+ return w.write(false, p)
+}
+
+func (w messageWriter) WriteString(p string) (int, error) {
+ if err := w.err(); err != nil {
+ return 0, err
+ }
+
+ nn := len(p)
+ for len(p) > 0 {
+ n, err := w.ncopy(len(p))
+ if err != nil {
+ return 0, err
+ }
+ copy(w.c.writeBuf[w.c.writePos:], p[:n])
+ w.c.writePos += n
+ p = p[n:]
+ }
+ return nn, nil
+}
+
+func (w messageWriter) ReadFrom(r io.Reader) (nn int64, err error) {
+ if err := w.err(); err != nil {
+ return 0, err
+ }
+ for {
+ if w.c.writePos == len(w.c.writeBuf) {
+ err = w.c.flushFrame(false, nil)
+ if err != nil {
+ break
+ }
+ }
+ var n int
+ n, err = r.Read(w.c.writeBuf[w.c.writePos:])
+ w.c.writePos += n
+ nn += int64(n)
+ if err != nil {
+ if err == io.EOF {
+ err = nil
+ }
+ break
+ }
+ }
+ return nn, err
+}
+
+func (w messageWriter) Close() error {
+ if err := w.err(); err != nil {
+ return err
+ }
+ return w.c.flushFrame(true, nil)
+}
+
+// WriteMessage is a helper method for getting a writer using NextWriter,
+// writing the message and closing the writer.
+func (c *Conn) WriteMessage(messageType int, data []byte) error {
+ wr, err := c.NextWriter(messageType)
+ if err != nil {
+ return err
+ }
+ w := wr.(messageWriter)
+ if _, err := w.write(true, data); err != nil {
+ return err
+ }
+ if c.writeSeq == w.seq {
+ if err := c.flushFrame(true, nil); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// SetWriteDeadline sets the write deadline on the underlying network
+// connection. After a write has timed out, the websocket state is corrupt and
+// all future writes will return an error. A zero value for t means writes will
+// not time out.
+func (c *Conn) SetWriteDeadline(t time.Time) error {
+ c.writeDeadline = t
+ return nil
+}
+
+// Read methods
+
+// readFull is like io.ReadFull except that io.EOF is never returned.
+func (c *Conn) readFull(p []byte) (err error) {
+ var n int
+ for n < len(p) && err == nil {
+ var nn int
+ nn, err = c.br.Read(p[n:])
+ n += nn
+ }
+ if n == len(p) {
+ err = nil
+ } else if err == io.EOF {
+ err = errUnexpectedEOF
+ }
+ return
+}
+
+func (c *Conn) advanceFrame() (int, error) {
+
+ // 1. Skip remainder of previous frame.
+
+ if c.readRemaining > 0 {
+ if _, err := io.CopyN(ioutil.Discard, c.br, c.readRemaining); err != nil {
+ return noFrame, err
+ }
+ }
+
+ // 2. Read and parse first two bytes of frame header.
+
+ var b [8]byte
+ if err := c.readFull(b[:2]); err != nil {
+ return noFrame, err
+ }
+
+ final := b[0]&finalBit != 0
+ frameType := int(b[0] & 0xf)
+ reserved := int((b[0] >> 4) & 0x7)
+ mask := b[1]&maskBit != 0
+ c.readRemaining = int64(b[1] & 0x7f)
+
+ if reserved != 0 {
+ return noFrame, c.handleProtocolError("unexpected reserved bits " + strconv.Itoa(reserved))
+ }
+
+ switch frameType {
+ case CloseMessage, PingMessage, PongMessage:
+ if c.readRemaining > maxControlFramePayloadSize {
+ return noFrame, c.handleProtocolError("control frame length > 125")
+ }
+ if !final {
+ return noFrame, c.handleProtocolError("control frame not final")
+ }
+ case TextMessage, BinaryMessage:
+ if !c.readFinal {
+ return noFrame, c.handleProtocolError("message start before final message frame")
+ }
+ c.readFinal = final
+ case continuationFrame:
+ if c.readFinal {
+ return noFrame, c.handleProtocolError("continuation after final message frame")
+ }
+ c.readFinal = final
+ default:
+ return noFrame, c.handleProtocolError("unknown opcode " + strconv.Itoa(frameType))
+ }
+
+ // 3. Read and parse frame length.
+
+ switch c.readRemaining {
+ case 126:
+ if err := c.readFull(b[:2]); err != nil {
+ return noFrame, err
+ }
+ c.readRemaining = int64(binary.BigEndian.Uint16(b[:2]))
+ case 127:
+ if err := c.readFull(b[:8]); err != nil {
+ return noFrame, err
+ }
+ c.readRemaining = int64(binary.BigEndian.Uint64(b[:8]))
+ }
+
+ // 4. Handle frame masking.
+
+ if mask != c.isServer {
+ return noFrame, c.handleProtocolError("incorrect mask flag")
+ }
+
+ if mask {
+ c.readMaskPos = 0
+ if err := c.readFull(c.readMaskKey[:]); err != nil {
+ return noFrame, err
+ }
+ }
+
+ // 5. For text and binary messages, enforce read limit and return.
+
+ if frameType == continuationFrame || frameType == TextMessage || frameType == BinaryMessage {
+
+ c.readLength += c.readRemaining
+ if c.readLimit > 0 && c.readLength > c.readLimit {
+ c.WriteControl(CloseMessage, FormatCloseMessage(CloseMessageTooBig, ""), time.Now().Add(writeWait))
+ return noFrame, ErrReadLimit
+ }
+
+ return frameType, nil
+ }
+
+ // 6. Read control frame payload.
+
+ var payload []byte
+ if c.readRemaining > 0 {
+ payload = make([]byte, c.readRemaining)
+ c.readRemaining = 0
+ if err := c.readFull(payload); err != nil {
+ return noFrame, err
+ }
+ if c.isServer {
+ maskBytes(c.readMaskKey, 0, payload)
+ }
+ }
+
+ // 7. Process control frame payload.
+
+ switch frameType {
+ case PongMessage:
+ if err := c.handlePong(string(payload)); err != nil {
+ return noFrame, err
+ }
+ case PingMessage:
+ if err := c.handlePing(string(payload)); err != nil {
+ return noFrame, err
+ }
+ case CloseMessage:
+ c.WriteControl(CloseMessage, []byte{}, time.Now().Add(writeWait))
+ closeCode := CloseNoStatusReceived
+ closeText := ""
+ if len(payload) >= 2 {
+ closeCode = int(binary.BigEndian.Uint16(payload))
+ closeText = string(payload[2:])
+ }
+ switch closeCode {
+ case CloseNormalClosure, CloseGoingAway:
+ return noFrame, io.EOF
+ default:
+ return noFrame, &closeError{code: closeCode, text: closeText}
+ }
+ }
+
+ return frameType, nil
+}
+
+func (c *Conn) handleProtocolError(message string) error {
+ c.WriteControl(CloseMessage, FormatCloseMessage(CloseProtocolError, message), time.Now().Add(writeWait))
+ return errors.New("websocket: " + message)
+}
+
+// NextReader returns the next data message received from the peer. The
+// returned messageType is either TextMessage or BinaryMessage.
+//
+// There can be at most one open reader on a connection. NextReader discards
+// the previous message if the application has not already consumed it.
+//
+// The NextReader method and the readers returned from the method cannot be
+// accessed by more than one goroutine at a time.
+func (c *Conn) NextReader() (messageType int, r io.Reader, err error) {
+
+ c.readSeq++
+ c.readLength = 0
+
+ for c.readErr == nil {
+ frameType, err := c.advanceFrame()
+ if err != nil {
+ c.readErr = hideTempErr(err)
+ break
+ }
+ if frameType == TextMessage || frameType == BinaryMessage {
+ return frameType, messageReader{c, c.readSeq}, nil
+ }
+ }
+ return noFrame, nil, c.readErr
+}
+
+type messageReader struct {
+ c *Conn
+ seq int
+}
+
+func (r messageReader) Read(b []byte) (int, error) {
+
+ if r.seq != r.c.readSeq {
+ return 0, io.EOF
+ }
+
+ for r.c.readErr == nil {
+
+ if r.c.readRemaining > 0 {
+ if int64(len(b)) > r.c.readRemaining {
+ b = b[:r.c.readRemaining]
+ }
+ n, err := r.c.br.Read(b)
+ r.c.readErr = hideTempErr(err)
+ if r.c.isServer {
+ r.c.readMaskPos = maskBytes(r.c.readMaskKey, r.c.readMaskPos, b[:n])
+ }
+ r.c.readRemaining -= int64(n)
+ return n, r.c.readErr
+ }
+
+ if r.c.readFinal {
+ r.c.readSeq++
+ return 0, io.EOF
+ }
+
+ frameType, err := r.c.advanceFrame()
+ switch {
+ case err != nil:
+ r.c.readErr = hideTempErr(err)
+ case frameType == TextMessage || frameType == BinaryMessage:
+ r.c.readErr = errors.New("websocket: internal error, unexpected text or binary in Reader")
+ }
+ }
+
+ err := r.c.readErr
+ if err == io.EOF && r.seq == r.c.readSeq {
+ err = errUnexpectedEOF
+ }
+ return 0, err
+}
+
+// ReadMessage is a helper method for getting a reader using NextReader and
+// reading from that reader to a buffer.
+func (c *Conn) ReadMessage() (messageType int, p []byte, err error) {
+ var r io.Reader
+ messageType, r, err = c.NextReader()
+ if err != nil {
+ return messageType, nil, err
+ }
+ p, err = ioutil.ReadAll(r)
+ return messageType, p, err
+}
+
+// SetReadDeadline sets the read deadline on the underlying network connection.
+// After a read has timed out, the websocket connection state is corrupt and
+// all future reads will return an error. A zero value for t means reads will
+// not time out.
+func (c *Conn) SetReadDeadline(t time.Time) error {
+ return c.conn.SetReadDeadline(t)
+}
+
+// SetReadLimit sets the maximum size for a message read from the peer. If a
+// message exceeds the limit, the connection sends a close frame to the peer
+// and returns ErrReadLimit to the application.
+func (c *Conn) SetReadLimit(limit int64) {
+ c.readLimit = limit
+}
+
+// SetPingHandler sets the handler for ping messages received from the peer.
+// The default ping handler sends a pong to the peer.
+func (c *Conn) SetPingHandler(h func(string) error) {
+ if h == nil {
+ h = func(message string) error {
+ c.WriteControl(PongMessage, []byte(message), time.Now().Add(writeWait))
+ return nil
+ }
+ }
+ c.handlePing = h
+}
+
+// SetPongHandler sets the handler for pong messages received from the peer.
+// The default pong handler does nothing.
+func (c *Conn) SetPongHandler(h func(string) error) {
+ if h == nil {
+ h = func(string) error { return nil }
+ }
+ c.handlePong = h
+}
+
+// UnderlyingConn returns the internal net.Conn. This can be used to further
+// modifications to connection specific flags.
+func (c *Conn) UnderlyingConn() net.Conn {
+ return c.conn
+}
+
+// FormatCloseMessage formats closeCode and text as a WebSocket close message.
+func FormatCloseMessage(closeCode int, text string) []byte {
+ buf := make([]byte, 2+len(text))
+ binary.BigEndian.PutUint16(buf, uint16(closeCode))
+ copy(buf[2:], text)
+ return buf
+}
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/conn_test.go b/Godeps/_workspace/src/github.com/gorilla/websocket/conn_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..1f1197e7102fb3a663c373f0b1d929832795d210
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/conn_test.go
@@ -0,0 +1,238 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "net"
+ "testing"
+ "testing/iotest"
+ "time"
+)
+
+var _ net.Error = errWriteTimeout
+
+type fakeNetConn struct {
+ io.Reader
+ io.Writer
+}
+
+func (c fakeNetConn) Close() error { return nil }
+func (c fakeNetConn) LocalAddr() net.Addr { return nil }
+func (c fakeNetConn) RemoteAddr() net.Addr { return nil }
+func (c fakeNetConn) SetDeadline(t time.Time) error { return nil }
+func (c fakeNetConn) SetReadDeadline(t time.Time) error { return nil }
+func (c fakeNetConn) SetWriteDeadline(t time.Time) error { return nil }
+
+func TestFraming(t *testing.T) {
+ frameSizes := []int{0, 1, 2, 124, 125, 126, 127, 128, 129, 65534, 65535, 65536, 65537}
+ var readChunkers = []struct {
+ name string
+ f func(io.Reader) io.Reader
+ }{
+ {"half", iotest.HalfReader},
+ {"one", iotest.OneByteReader},
+ {"asis", func(r io.Reader) io.Reader { return r }},
+ }
+
+ writeBuf := make([]byte, 65537)
+ for i := range writeBuf {
+ writeBuf[i] = byte(i)
+ }
+
+ for _, isServer := range []bool{true, false} {
+ for _, chunker := range readChunkers {
+
+ var connBuf bytes.Buffer
+ wc := newConn(fakeNetConn{Reader: nil, Writer: &connBuf}, isServer, 1024, 1024)
+ rc := newConn(fakeNetConn{Reader: chunker.f(&connBuf), Writer: nil}, !isServer, 1024, 1024)
+
+ for _, n := range frameSizes {
+ for _, iocopy := range []bool{true, false} {
+ name := fmt.Sprintf("s:%v, r:%s, n:%d c:%v", isServer, chunker.name, n, iocopy)
+
+ w, err := wc.NextWriter(TextMessage)
+ if err != nil {
+ t.Errorf("%s: wc.NextWriter() returned %v", name, err)
+ continue
+ }
+ var nn int
+ if iocopy {
+ var n64 int64
+ n64, err = io.Copy(w, bytes.NewReader(writeBuf[:n]))
+ nn = int(n64)
+ } else {
+ nn, err = w.Write(writeBuf[:n])
+ }
+ if err != nil || nn != n {
+ t.Errorf("%s: w.Write(writeBuf[:n]) returned %d, %v", name, nn, err)
+ continue
+ }
+ err = w.Close()
+ if err != nil {
+ t.Errorf("%s: w.Close() returned %v", name, err)
+ continue
+ }
+
+ opCode, r, err := rc.NextReader()
+ if err != nil || opCode != TextMessage {
+ t.Errorf("%s: NextReader() returned %d, r, %v", name, opCode, err)
+ continue
+ }
+ rbuf, err := ioutil.ReadAll(r)
+ if err != nil {
+ t.Errorf("%s: ReadFull() returned rbuf, %v", name, err)
+ continue
+ }
+
+ if len(rbuf) != n {
+ t.Errorf("%s: len(rbuf) is %d, want %d", name, len(rbuf), n)
+ continue
+ }
+
+ for i, b := range rbuf {
+ if byte(i) != b {
+ t.Errorf("%s: bad byte at offset %d", name, i)
+ break
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+func TestControl(t *testing.T) {
+ const message = "this is a ping/pong messsage"
+ for _, isServer := range []bool{true, false} {
+ for _, isWriteControl := range []bool{true, false} {
+ name := fmt.Sprintf("s:%v, wc:%v", isServer, isWriteControl)
+ var connBuf bytes.Buffer
+ wc := newConn(fakeNetConn{Reader: nil, Writer: &connBuf}, isServer, 1024, 1024)
+ rc := newConn(fakeNetConn{Reader: &connBuf, Writer: nil}, !isServer, 1024, 1024)
+ if isWriteControl {
+ wc.WriteControl(PongMessage, []byte(message), time.Now().Add(time.Second))
+ } else {
+ w, err := wc.NextWriter(PongMessage)
+ if err != nil {
+ t.Errorf("%s: wc.NextWriter() returned %v", name, err)
+ continue
+ }
+ if _, err := w.Write([]byte(message)); err != nil {
+ t.Errorf("%s: w.Write() returned %v", name, err)
+ continue
+ }
+ if err := w.Close(); err != nil {
+ t.Errorf("%s: w.Close() returned %v", name, err)
+ continue
+ }
+ var actualMessage string
+ rc.SetPongHandler(func(s string) error { actualMessage = s; return nil })
+ rc.NextReader()
+ if actualMessage != message {
+ t.Errorf("%s: pong=%q, want %q", name, actualMessage, message)
+ continue
+ }
+ }
+ }
+ }
+}
+
+func TestCloseBeforeFinalFrame(t *testing.T) {
+ const bufSize = 512
+
+ var b1, b2 bytes.Buffer
+ wc := newConn(fakeNetConn{Reader: nil, Writer: &b1}, false, 1024, bufSize)
+ rc := newConn(fakeNetConn{Reader: &b1, Writer: &b2}, true, 1024, 1024)
+
+ w, _ := wc.NextWriter(BinaryMessage)
+ w.Write(make([]byte, bufSize+bufSize/2))
+ wc.WriteControl(CloseMessage, FormatCloseMessage(CloseNormalClosure, ""), time.Now().Add(10*time.Second))
+ w.Close()
+
+ op, r, err := rc.NextReader()
+ if op != BinaryMessage || err != nil {
+ t.Fatalf("NextReader() returned %d, %v", op, err)
+ }
+ _, err = io.Copy(ioutil.Discard, r)
+ if err != errUnexpectedEOF {
+ t.Fatalf("io.Copy() returned %v, want %v", err, errUnexpectedEOF)
+ }
+ _, _, err = rc.NextReader()
+ if err != io.EOF {
+ t.Fatalf("NextReader() returned %v, want %v", err, io.EOF)
+ }
+}
+
+func TestEOFBeforeFinalFrame(t *testing.T) {
+ const bufSize = 512
+
+ var b1, b2 bytes.Buffer
+ wc := newConn(fakeNetConn{Reader: nil, Writer: &b1}, false, 1024, bufSize)
+ rc := newConn(fakeNetConn{Reader: &b1, Writer: &b2}, true, 1024, 1024)
+
+ w, _ := wc.NextWriter(BinaryMessage)
+ w.Write(make([]byte, bufSize+bufSize/2))
+
+ op, r, err := rc.NextReader()
+ if op != BinaryMessage || err != nil {
+ t.Fatalf("NextReader() returned %d, %v", op, err)
+ }
+ _, err = io.Copy(ioutil.Discard, r)
+ if err != errUnexpectedEOF {
+ t.Fatalf("io.Copy() returned %v, want %v", err, errUnexpectedEOF)
+ }
+ _, _, err = rc.NextReader()
+ if err != errUnexpectedEOF {
+ t.Fatalf("NextReader() returned %v, want %v", err, errUnexpectedEOF)
+ }
+}
+
+func TestReadLimit(t *testing.T) {
+
+ const readLimit = 512
+ message := make([]byte, readLimit+1)
+
+ var b1, b2 bytes.Buffer
+ wc := newConn(fakeNetConn{Reader: nil, Writer: &b1}, false, 1024, readLimit-2)
+ rc := newConn(fakeNetConn{Reader: &b1, Writer: &b2}, true, 1024, 1024)
+ rc.SetReadLimit(readLimit)
+
+ // Send message at the limit with interleaved pong.
+ w, _ := wc.NextWriter(BinaryMessage)
+ w.Write(message[:readLimit-1])
+ wc.WriteControl(PongMessage, []byte("this is a pong"), time.Now().Add(10*time.Second))
+ w.Write(message[:1])
+ w.Close()
+
+ // Send message larger than the limit.
+ wc.WriteMessage(BinaryMessage, message[:readLimit+1])
+
+ op, _, err := rc.NextReader()
+ if op != BinaryMessage || err != nil {
+ t.Fatalf("1: NextReader() returned %d, %v", op, err)
+ }
+ op, r, err := rc.NextReader()
+ if op != BinaryMessage || err != nil {
+ t.Fatalf("2: NextReader() returned %d, %v", op, err)
+ }
+ _, err = io.Copy(ioutil.Discard, r)
+ if err != ErrReadLimit {
+ t.Fatalf("io.Copy() returned %v", err)
+ }
+}
+
+func TestUnderlyingConn(t *testing.T) {
+ var b1, b2 bytes.Buffer
+ fc := fakeNetConn{Reader: &b1, Writer: &b2}
+ c := newConn(fc, true, 1024, 1024)
+ ul := c.UnderlyingConn()
+ if ul != fc {
+ t.Fatalf("Underlying conn is not what it should be.")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/doc.go b/Godeps/_workspace/src/github.com/gorilla/websocket/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..0d2bd912b3e475e4acff7291130d6b76f9a08d93
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/doc.go
@@ -0,0 +1,148 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package websocket implements the WebSocket protocol defined in RFC 6455.
+//
+// Overview
+//
+// The Conn type represents a WebSocket connection. A server application uses
+// the Upgrade function from an Upgrader object with a HTTP request handler
+// to get a pointer to a Conn:
+//
+// var upgrader = websocket.Upgrader{
+// ReadBufferSize: 1024,
+// WriteBufferSize: 1024,
+// }
+//
+// func handler(w http.ResponseWriter, r *http.Request) {
+// conn, err := upgrader.Upgrade(w, r, nil)
+// if err != nil {
+// log.Println(err)
+// return
+// }
+// ... Use conn to send and receive messages.
+// }
+//
+// Call the connection WriteMessage and ReadMessages methods to send and
+// receive messages as a slice of bytes. This snippet of code shows how to echo
+// messages using these methods:
+//
+// for {
+// messageType, p, err := conn.ReadMessage()
+// if err != nil {
+// return
+// }
+// if err = conn.WriteMessage(messageType, p); err != nil {
+// return err
+// }
+// }
+//
+// In above snippet of code, p is a []byte and messageType is an int with value
+// websocket.BinaryMessage or websocket.TextMessage.
+//
+// An application can also send and receive messages using the io.WriteCloser
+// and io.Reader interfaces. To send a message, call the connection NextWriter
+// method to get an io.WriteCloser, write the message to the writer and close
+// the writer when done. To receive a message, call the connection NextReader
+// method to get an io.Reader and read until io.EOF is returned. This snippet
+// snippet shows how to echo messages using the NextWriter and NextReader
+// methods:
+//
+// for {
+// messageType, r, err := conn.NextReader()
+// if err != nil {
+// return
+// }
+// w, err := conn.NextWriter(messageType)
+// if err != nil {
+// return err
+// }
+// if _, err := io.Copy(w, r); err != nil {
+// return err
+// }
+// if err := w.Close(); err != nil {
+// return err
+// }
+// }
+//
+// Data Messages
+//
+// The WebSocket protocol distinguishes between text and binary data messages.
+// Text messages are interpreted as UTF-8 encoded text. The interpretation of
+// binary messages is left to the application.
+//
+// This package uses the TextMessage and BinaryMessage integer constants to
+// identify the two data message types. The ReadMessage and NextReader methods
+// return the type of the received message. The messageType argument to the
+// WriteMessage and NextWriter methods specifies the type of a sent message.
+//
+// It is the application's responsibility to ensure that text messages are
+// valid UTF-8 encoded text.
+//
+// Control Messages
+//
+// The WebSocket protocol defines three types of control messages: close, ping
+// and pong. Call the connection WriteControl, WriteMessage or NextWriter
+// methods to send a control message to the peer.
+//
+// Connections handle received ping and pong messages by invoking a callback
+// function set with SetPingHandler and SetPongHandler methods. These callback
+// functions can be invoked from the ReadMessage method, the NextReader method
+// or from a call to the data message reader returned from NextReader.
+//
+// Connections handle received close messages by returning an error from the
+// ReadMessage method, the NextReader method or from a call to the data message
+// reader returned from NextReader.
+//
+// Concurrency
+//
+// Connections do not support concurrent calls to the write methods
+// (NextWriter, SetWriteDeadline, WriteMessage) or concurrent calls to the read
+// methods methods (NextReader, SetReadDeadline, ReadMessage). Connections do
+// support a concurrent reader and writer.
+//
+// The Close and WriteControl methods can be called concurrently with all other
+// methods.
+//
+// Read is Required
+//
+// The application must read the connection to process ping and close messages
+// sent from the peer. If the application is not otherwise interested in
+// messages from the peer, then the application should start a goroutine to read
+// and discard messages from the peer. A simple example is:
+//
+// func readLoop(c *websocket.Conn) {
+// for {
+// if _, _, err := c.NextReader(); err != nil {
+// c.Close()
+// break
+// }
+// }
+// }
+//
+// Origin Considerations
+//
+// Web browsers allow Javascript applications to open a WebSocket connection to
+// any host. It's up to the server to enforce an origin policy using the Origin
+// request header sent by the browser.
+//
+// The Upgrader calls the function specified in the CheckOrigin field to check
+// the origin. If the CheckOrigin function returns false, then the Upgrade
+// method fails the WebSocket handshake with HTTP status 403.
+//
+// If the CheckOrigin field is nil, then the Upgrader uses a safe default: fail
+// the handshake if the Origin request header is present and not equal to the
+// Host request header.
+//
+// An application can allow connections from any origin by specifying a
+// function that always returns true:
+//
+// var upgrader = websocket.Upgrader{
+// CheckOrigin: func(r *http.Request) bool { return true },
+// }
+//
+// The deprecated Upgrade function does not enforce an origin policy. It's the
+// application's responsibility to check the Origin header before calling
+// Upgrade.
+package websocket
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/examples/autobahn/README.md b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/autobahn/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..075ac1530a90e873b8eb13f0545f8a19f7658b2c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/autobahn/README.md
@@ -0,0 +1,13 @@
+# Test Server
+
+This package contains a server for the [Autobahn WebSockets Test Suite](http://autobahn.ws/testsuite).
+
+To test the server, run
+
+ go run server.go
+
+and start the client test driver
+
+ wstest -m fuzzingclient -s fuzzingclient.json
+
+When the client completes, it writes a report to reports/clients/index.html.
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/examples/autobahn/fuzzingclient.json b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/autobahn/fuzzingclient.json
new file mode 100644
index 0000000000000000000000000000000000000000..27d5a5b146de3f344819cb5a0368e5d66a0aee4b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/autobahn/fuzzingclient.json
@@ -0,0 +1,14 @@
+
+{
+ "options": {"failByDrop": false},
+ "outdir": "./reports/clients",
+ "servers": [
+ {"agent": "ReadAllWriteMessage", "url": "ws://localhost:9000/m", "options": {"version": 18}},
+ {"agent": "ReadAllWrite", "url": "ws://localhost:9000/r", "options": {"version": 18}},
+ {"agent": "CopyFull", "url": "ws://localhost:9000/f", "options": {"version": 18}},
+ {"agent": "CopyWriterOnly", "url": "ws://localhost:9000/c", "options": {"version": 18}}
+ ],
+ "cases": ["*"],
+ "exclude-cases": [],
+ "exclude-agent-cases": {}
+}
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/examples/autobahn/server.go b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/autobahn/server.go
new file mode 100644
index 0000000000000000000000000000000000000000..b7eed0da47c4cddf21b7fd9d37fc1f6e6dce0218
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/autobahn/server.go
@@ -0,0 +1,246 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Command server is a test server for the Autobahn WebSockets Test Suite.
+package main
+
+import (
+ "errors"
+ "flag"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gorilla/websocket"
+ "io"
+ "log"
+ "net/http"
+ "time"
+ "unicode/utf8"
+)
+
+var upgrader = websocket.Upgrader{
+ ReadBufferSize: 4096,
+ WriteBufferSize: 4096,
+ CheckOrigin: func(r *http.Request) bool {
+ return true
+ },
+}
+
+// echoCopy echoes messages from the client using io.Copy.
+func echoCopy(w http.ResponseWriter, r *http.Request, writerOnly bool) {
+ conn, err := upgrader.Upgrade(w, r, nil)
+ if err != nil {
+ log.Println("Upgrade:", err)
+ return
+ }
+ defer conn.Close()
+ for {
+ mt, r, err := conn.NextReader()
+ if err != nil {
+ if err != io.EOF {
+ log.Println("NextReader:", err)
+ }
+ return
+ }
+ if mt == websocket.TextMessage {
+ r = &validator{r: r}
+ }
+ w, err := conn.NextWriter(mt)
+ if err != nil {
+ log.Println("NextWriter:", err)
+ return
+ }
+ if mt == websocket.TextMessage {
+ r = &validator{r: r}
+ }
+ if writerOnly {
+ _, err = io.Copy(struct{ io.Writer }{w}, r)
+ } else {
+ _, err = io.Copy(w, r)
+ }
+ if err != nil {
+ if err == errInvalidUTF8 {
+ conn.WriteControl(websocket.CloseMessage,
+ websocket.FormatCloseMessage(websocket.CloseInvalidFramePayloadData, ""),
+ time.Time{})
+ }
+ log.Println("Copy:", err)
+ return
+ }
+ err = w.Close()
+ if err != nil {
+ log.Println("Close:", err)
+ return
+ }
+ }
+}
+
+func echoCopyWriterOnly(w http.ResponseWriter, r *http.Request) {
+ echoCopy(w, r, true)
+}
+
+func echoCopyFull(w http.ResponseWriter, r *http.Request) {
+ echoCopy(w, r, false)
+}
+
+// echoReadAll echoes messages from the client by reading the entire message
+// with ioutil.ReadAll.
+func echoReadAll(w http.ResponseWriter, r *http.Request, writeMessage bool) {
+ conn, err := upgrader.Upgrade(w, r, nil)
+ if err != nil {
+ log.Println("Upgrade:", err)
+ return
+ }
+ defer conn.Close()
+ for {
+ mt, b, err := conn.ReadMessage()
+ if err != nil {
+ if err != io.EOF {
+ log.Println("NextReader:", err)
+ }
+ return
+ }
+ if mt == websocket.TextMessage {
+ if !utf8.Valid(b) {
+ conn.WriteControl(websocket.CloseMessage,
+ websocket.FormatCloseMessage(websocket.CloseInvalidFramePayloadData, ""),
+ time.Time{})
+ log.Println("ReadAll: invalid utf8")
+ }
+ }
+ if writeMessage {
+ err = conn.WriteMessage(mt, b)
+ if err != nil {
+ log.Println("WriteMessage:", err)
+ }
+ } else {
+ w, err := conn.NextWriter(mt)
+ if err != nil {
+ log.Println("NextWriter:", err)
+ return
+ }
+ if _, err := w.Write(b); err != nil {
+ log.Println("Writer:", err)
+ return
+ }
+ if err := w.Close(); err != nil {
+ log.Println("Close:", err)
+ return
+ }
+ }
+ }
+}
+
+func echoReadAllWriter(w http.ResponseWriter, r *http.Request) {
+ echoReadAll(w, r, false)
+}
+
+func echoReadAllWriteMessage(w http.ResponseWriter, r *http.Request) {
+ echoReadAll(w, r, true)
+}
+
+func serveHome(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/" {
+ http.Error(w, "Not found.", 404)
+ return
+ }
+ if r.Method != "GET" {
+ http.Error(w, "Method not allowed", 405)
+ return
+ }
+ w.Header().Set("Content-Type", "text/html; charset=utf-8")
+ io.WriteString(w, "<html><body>Echo Server</body></html>")
+}
+
+var addr = flag.String("addr", ":9000", "http service address")
+
+func main() {
+ flag.Parse()
+ http.HandleFunc("/", serveHome)
+ http.HandleFunc("/c", echoCopyWriterOnly)
+ http.HandleFunc("/f", echoCopyFull)
+ http.HandleFunc("/r", echoReadAllWriter)
+ http.HandleFunc("/m", echoReadAllWriteMessage)
+ err := http.ListenAndServe(*addr, nil)
+ if err != nil {
+ log.Fatal("ListenAndServe: ", err)
+ }
+}
+
+type validator struct {
+ state int
+ x rune
+ r io.Reader
+}
+
+var errInvalidUTF8 = errors.New("invalid utf8")
+
+func (r *validator) Read(p []byte) (int, error) {
+ n, err := r.r.Read(p)
+ state := r.state
+ x := r.x
+ for _, b := range p[:n] {
+ state, x = decode(state, x, b)
+ if state == utf8Reject {
+ break
+ }
+ }
+ r.state = state
+ r.x = x
+ if state == utf8Reject || (err == io.EOF && state != utf8Accept) {
+ return n, errInvalidUTF8
+ }
+ return n, err
+}
+
+// UTF-8 decoder from http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+//
+// Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+var utf8d = [...]byte{
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1f
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3f
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5f
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7f
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9f
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // a0..bf
+ 8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // c0..df
+ 0xa, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // e0..ef
+ 0xb, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // f0..ff
+ 0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
+ 1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
+ 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
+ 1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // s7..s8
+}
+
+const (
+ utf8Accept = 0
+ utf8Reject = 1
+)
+
+func decode(state int, x rune, b byte) (int, rune) {
+ t := utf8d[b]
+ if state != utf8Accept {
+ x = rune(b&0x3f) | (x << 6)
+ } else {
+ x = rune((0xff >> t) & b)
+ }
+ state = int(utf8d[256+state*16+int(t)])
+ return state, x
+}
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/examples/chat/README.md b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/chat/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..08fc3e65c65eec2f1ae358a66198244a6f67dd24
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/chat/README.md
@@ -0,0 +1,19 @@
+# Chat Example
+
+This application shows how to use use the
+[websocket](https://github.com/gorilla/websocket) package and
+[jQuery](http://jquery.com) to implement a simple web chat application.
+
+## Running the example
+
+The example requires a working Go development environment. The [Getting
+Started](http://golang.org/doc/install) page describes how to install the
+development environment.
+
+Once you have Go up and running, you can download, build and run the example
+using the following commands.
+
+ $ go get github.com/gorilla/websocket
+ $ cd `go list -f '{{.Dir}}' github.com/gorilla/websocket/examples/chat`
+ $ go run *.go
+
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/examples/chat/conn.go b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/chat/conn.go
new file mode 100644
index 0000000000000000000000000000000000000000..00b4645a47bb9ea0790e2cebf7b3bcd766d720e4
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/chat/conn.go
@@ -0,0 +1,106 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gorilla/websocket"
+ "log"
+ "net/http"
+ "time"
+)
+
+const (
+ // Time allowed to write a message to the peer.
+ writeWait = 10 * time.Second
+
+ // Time allowed to read the next pong message from the peer.
+ pongWait = 60 * time.Second
+
+ // Send pings to peer with this period. Must be less than pongWait.
+ pingPeriod = (pongWait * 9) / 10
+
+ // Maximum message size allowed from peer.
+ maxMessageSize = 512
+)
+
+var upgrader = websocket.Upgrader{
+ ReadBufferSize: 1024,
+ WriteBufferSize: 1024,
+}
+
+// connection is an middleman between the websocket connection and the hub.
+type connection struct {
+ // The websocket connection.
+ ws *websocket.Conn
+
+ // Buffered channel of outbound messages.
+ send chan []byte
+}
+
+// readPump pumps messages from the websocket connection to the hub.
+func (c *connection) readPump() {
+ defer func() {
+ h.unregister <- c
+ c.ws.Close()
+ }()
+ c.ws.SetReadLimit(maxMessageSize)
+ c.ws.SetReadDeadline(time.Now().Add(pongWait))
+ c.ws.SetPongHandler(func(string) error { c.ws.SetReadDeadline(time.Now().Add(pongWait)); return nil })
+ for {
+ _, message, err := c.ws.ReadMessage()
+ if err != nil {
+ break
+ }
+ h.broadcast <- message
+ }
+}
+
+// write writes a message with the given message type and payload.
+func (c *connection) write(mt int, payload []byte) error {
+ c.ws.SetWriteDeadline(time.Now().Add(writeWait))
+ return c.ws.WriteMessage(mt, payload)
+}
+
+// writePump pumps messages from the hub to the websocket connection.
+func (c *connection) writePump() {
+ ticker := time.NewTicker(pingPeriod)
+ defer func() {
+ ticker.Stop()
+ c.ws.Close()
+ }()
+ for {
+ select {
+ case message, ok := <-c.send:
+ if !ok {
+ c.write(websocket.CloseMessage, []byte{})
+ return
+ }
+ if err := c.write(websocket.TextMessage, message); err != nil {
+ return
+ }
+ case <-ticker.C:
+ if err := c.write(websocket.PingMessage, []byte{}); err != nil {
+ return
+ }
+ }
+ }
+}
+
+// serverWs handles websocket requests from the peer.
+func serveWs(w http.ResponseWriter, r *http.Request) {
+ if r.Method != "GET" {
+ http.Error(w, "Method not allowed", 405)
+ return
+ }
+ ws, err := upgrader.Upgrade(w, r, nil)
+ if err != nil {
+ log.Println(err)
+ return
+ }
+ c := &connection{send: make(chan []byte, 256), ws: ws}
+ h.register <- c
+ go c.writePump()
+ c.readPump()
+}
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/examples/chat/home.html b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/chat/home.html
new file mode 100644
index 0000000000000000000000000000000000000000..29599225cb101a3cdd84d873c4a191e52ba8bc9c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/chat/home.html
@@ -0,0 +1,92 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<title>Chat Example</title>
+<script src="//ajax.googleapis.com/ajax/libs/jquery/2.0.3/jquery.min.js"></script>
+<script type="text/javascript">
+ $(function() {
+
+ var conn;
+ var msg = $("#msg");
+ var log = $("#log");
+
+ function appendLog(msg) {
+ var d = log[0]
+ var doScroll = d.scrollTop == d.scrollHeight - d.clientHeight;
+ msg.appendTo(log)
+ if (doScroll) {
+ d.scrollTop = d.scrollHeight - d.clientHeight;
+ }
+ }
+
+ $("#form").submit(function() {
+ if (!conn) {
+ return false;
+ }
+ if (!msg.val()) {
+ return false;
+ }
+ conn.send(msg.val());
+ msg.val("");
+ return false
+ });
+
+ if (window["WebSocket"]) {
+ conn = new WebSocket("ws://{{$}}/ws");
+ conn.onclose = function(evt) {
+ appendLog($("<div><b>Connection closed.</b></div>"))
+ }
+ conn.onmessage = function(evt) {
+ appendLog($("<div/>").text(evt.data))
+ }
+ } else {
+ appendLog($("<div><b>Your browser does not support WebSockets.</b></div>"))
+ }
+ });
+</script>
+<style type="text/css">
+html {
+ overflow: hidden;
+}
+
+body {
+ overflow: hidden;
+ padding: 0;
+ margin: 0;
+ width: 100%;
+ height: 100%;
+ background: gray;
+}
+
+#log {
+ background: white;
+ margin: 0;
+ padding: 0.5em 0.5em 0.5em 0.5em;
+ position: absolute;
+ top: 0.5em;
+ left: 0.5em;
+ right: 0.5em;
+ bottom: 3em;
+ overflow: auto;
+}
+
+#form {
+ padding: 0 0.5em 0 0.5em;
+ margin: 0;
+ position: absolute;
+ bottom: 1em;
+ left: 0px;
+ width: 100%;
+ overflow: hidden;
+}
+
+</style>
+</head>
+<body>
+<div id="log"></div>
+<form id="form">
+ <input type="submit" value="Send" />
+ <input type="text" id="msg" size="64"/>
+</form>
+</body>
+</html>
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/examples/chat/hub.go b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/chat/hub.go
new file mode 100644
index 0000000000000000000000000000000000000000..449ba753d82723a3f0f8ed44179b345b78f9195a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/chat/hub.go
@@ -0,0 +1,51 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+// hub maintains the set of active connections and broadcasts messages to the
+// connections.
+type hub struct {
+ // Registered connections.
+ connections map[*connection]bool
+
+ // Inbound messages from the connections.
+ broadcast chan []byte
+
+ // Register requests from the connections.
+ register chan *connection
+
+ // Unregister requests from connections.
+ unregister chan *connection
+}
+
+var h = hub{
+ broadcast: make(chan []byte),
+ register: make(chan *connection),
+ unregister: make(chan *connection),
+ connections: make(map[*connection]bool),
+}
+
+func (h *hub) run() {
+ for {
+ select {
+ case c := <-h.register:
+ h.connections[c] = true
+ case c := <-h.unregister:
+ if _, ok := h.connections[c]; ok {
+ delete(h.connections, c)
+ close(c.send)
+ }
+ case m := <-h.broadcast:
+ for c := range h.connections {
+ select {
+ case c.send <- m:
+ default:
+ close(c.send)
+ delete(h.connections, c)
+ }
+ }
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/examples/chat/main.go b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/chat/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..3c4448d72d67d7ae5e001ea3f69d548de825747e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/chat/main.go
@@ -0,0 +1,39 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "flag"
+ "log"
+ "net/http"
+ "text/template"
+)
+
+var addr = flag.String("addr", ":8080", "http service address")
+var homeTempl = template.Must(template.ParseFiles("home.html"))
+
+func serveHome(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/" {
+ http.Error(w, "Not found", 404)
+ return
+ }
+ if r.Method != "GET" {
+ http.Error(w, "Method not allowed", 405)
+ return
+ }
+ w.Header().Set("Content-Type", "text/html; charset=utf-8")
+ homeTempl.Execute(w, r.Host)
+}
+
+func main() {
+ flag.Parse()
+ go h.run()
+ http.HandleFunc("/", serveHome)
+ http.HandleFunc("/ws", serveWs)
+ err := http.ListenAndServe(*addr, nil)
+ if err != nil {
+ log.Fatal("ListenAndServe: ", err)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/examples/filewatch/README.md b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/filewatch/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..ca4931f3baf633dbf326ca1fdcfe22f8b1b0848b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/filewatch/README.md
@@ -0,0 +1,9 @@
+# File Watch example.
+
+This example sends a file to the browser client for display whenever the file is modified.
+
+ $ go get github.com/gorilla/websocket
+ $ cd `go list -f '{{.Dir}}' github.com/gorilla/websocket/examples/filewatch`
+ $ go run main.go <name of file to watch>
+ # Open http://localhost:8080/ .
+ # Modify the file to see it update in the browser.
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/examples/filewatch/main.go b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/filewatch/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..37d7433ebf93f58856211f2050caf3ade9059ded
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/examples/filewatch/main.go
@@ -0,0 +1,193 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "flag"
+ "io/ioutil"
+ "log"
+ "net/http"
+ "os"
+ "strconv"
+ "text/template"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gorilla/websocket"
+)
+
+const (
+ // Time allowed to write the file to the client.
+ writeWait = 10 * time.Second
+
+ // Time allowed to read the next pong message from the client.
+ pongWait = 60 * time.Second
+
+ // Send pings to client with this period. Must be less than pongWait.
+ pingPeriod = (pongWait * 9) / 10
+
+ // Poll file for changes with this period.
+ filePeriod = 10 * time.Second
+)
+
+var (
+ addr = flag.String("addr", ":8080", "http service address")
+ homeTempl = template.Must(template.New("").Parse(homeHTML))
+ filename string
+ upgrader = websocket.Upgrader{
+ ReadBufferSize: 1024,
+ WriteBufferSize: 1024,
+ }
+)
+
+func readFileIfModified(lastMod time.Time) ([]byte, time.Time, error) {
+ fi, err := os.Stat(filename)
+ if err != nil {
+ return nil, lastMod, err
+ }
+ if !fi.ModTime().After(lastMod) {
+ return nil, lastMod, nil
+ }
+ p, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, fi.ModTime(), err
+ }
+ return p, fi.ModTime(), nil
+}
+
+func reader(ws *websocket.Conn) {
+ defer ws.Close()
+ ws.SetReadLimit(512)
+ ws.SetReadDeadline(time.Now().Add(pongWait))
+ ws.SetPongHandler(func(string) error { ws.SetReadDeadline(time.Now().Add(pongWait)); return nil })
+ for {
+ _, _, err := ws.ReadMessage()
+ if err != nil {
+ break
+ }
+ }
+}
+
+func writer(ws *websocket.Conn, lastMod time.Time) {
+ lastError := ""
+ pingTicker := time.NewTicker(pingPeriod)
+ fileTicker := time.NewTicker(filePeriod)
+ defer func() {
+ pingTicker.Stop()
+ fileTicker.Stop()
+ ws.Close()
+ }()
+ for {
+ select {
+ case <-fileTicker.C:
+ var p []byte
+ var err error
+
+ p, lastMod, err = readFileIfModified(lastMod)
+
+ if err != nil {
+ if s := err.Error(); s != lastError {
+ lastError = s
+ p = []byte(lastError)
+ }
+ } else {
+ lastError = ""
+ }
+
+ if p != nil {
+ ws.SetWriteDeadline(time.Now().Add(writeWait))
+ if err := ws.WriteMessage(websocket.TextMessage, p); err != nil {
+ return
+ }
+ }
+ case <-pingTicker.C:
+ ws.SetWriteDeadline(time.Now().Add(writeWait))
+ if err := ws.WriteMessage(websocket.PingMessage, []byte{}); err != nil {
+ return
+ }
+ }
+ }
+}
+
+func serveWs(w http.ResponseWriter, r *http.Request) {
+ ws, err := upgrader.Upgrade(w, r, nil)
+ if err != nil {
+ if _, ok := err.(websocket.HandshakeError); !ok {
+ log.Println(err)
+ }
+ return
+ }
+
+ var lastMod time.Time
+ if n, err := strconv.ParseInt(r.FormValue("lastMod"), 16, 64); err != nil {
+ lastMod = time.Unix(0, n)
+ }
+
+ go writer(ws, lastMod)
+ reader(ws)
+}
+
+func serveHome(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/" {
+ http.Error(w, "Not found", 404)
+ return
+ }
+ if r.Method != "GET" {
+ http.Error(w, "Method not allowed", 405)
+ return
+ }
+ w.Header().Set("Content-Type", "text/html; charset=utf-8")
+ p, lastMod, err := readFileIfModified(time.Time{})
+ if err != nil {
+ p = []byte(err.Error())
+ lastMod = time.Unix(0, 0)
+ }
+ var v = struct {
+ Host string
+ Data string
+ LastMod string
+ }{
+ r.Host,
+ string(p),
+ strconv.FormatInt(lastMod.UnixNano(), 16),
+ }
+ homeTempl.Execute(w, &v)
+}
+
+func main() {
+ flag.Parse()
+ if flag.NArg() != 1 {
+ log.Fatal("filename not specified")
+ }
+ filename = flag.Args()[0]
+ http.HandleFunc("/", serveHome)
+ http.HandleFunc("/ws", serveWs)
+ if err := http.ListenAndServe(*addr, nil); err != nil {
+ log.Fatal(err)
+ }
+}
+
+const homeHTML = `<!DOCTYPE html>
+<html lang="en">
+ <head>
+ <title>WebSocket Example</title>
+ </head>
+ <body>
+ <pre id="fileData">{{.Data}}</pre>
+ <script type="text/javascript">
+ (function() {
+ var data = document.getElementById("fileData");
+ var conn = new WebSocket("ws://{{.Host}}/ws?lastMod={{.LastMod}}");
+ conn.onclose = function(evt) {
+ data.textContent = 'Connection closed';
+ }
+ conn.onmessage = function(evt) {
+ console.log('file updated');
+ data.textContent = evt.data;
+ }
+ })();
+ </script>
+ </body>
+</html>
+`
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/json.go b/Godeps/_workspace/src/github.com/gorilla/websocket/json.go
new file mode 100644
index 0000000000000000000000000000000000000000..18e62f2256cbff262fe9273884b59e853c03a0bb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/json.go
@@ -0,0 +1,57 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "encoding/json"
+ "io"
+)
+
+// WriteJSON is deprecated, use c.WriteJSON instead.
+func WriteJSON(c *Conn, v interface{}) error {
+ return c.WriteJSON(v)
+}
+
+// WriteJSON writes the JSON encoding of v to the connection.
+//
+// See the documentation for encoding/json Marshal for details about the
+// conversion of Go values to JSON.
+func (c *Conn) WriteJSON(v interface{}) error {
+ w, err := c.NextWriter(TextMessage)
+ if err != nil {
+ return err
+ }
+ err1 := json.NewEncoder(w).Encode(v)
+ err2 := w.Close()
+ if err1 != nil {
+ return err1
+ }
+ return err2
+}
+
+// ReadJSON is deprecated, use c.ReadJSON instead.
+func ReadJSON(c *Conn, v interface{}) error {
+ return c.ReadJSON(v)
+}
+
+// ReadJSON reads the next JSON-encoded message from the connection and stores
+// it in the value pointed to by v.
+//
+// See the documentation for the encoding/json Unmarshal function for details
+// about the conversion of JSON to a Go value.
+func (c *Conn) ReadJSON(v interface{}) error {
+ _, r, err := c.NextReader()
+ if err != nil {
+ return err
+ }
+ err = json.NewDecoder(r).Decode(v)
+ if err == io.EOF {
+ // Decode returns io.EOF when the message is empty or all whitespace.
+ // Convert to io.ErrUnexpectedEOF so that application can distinguish
+ // between an error reading the JSON value and the connection closing.
+ err = io.ErrUnexpectedEOF
+ }
+ return err
+}
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/json_test.go b/Godeps/_workspace/src/github.com/gorilla/websocket/json_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..1b7a5ec8bd08f5ec4fd101f53a2b9d51476711f9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/json_test.go
@@ -0,0 +1,119 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "bytes"
+ "encoding/json"
+ "io"
+ "reflect"
+ "testing"
+)
+
+func TestJSON(t *testing.T) {
+ var buf bytes.Buffer
+ c := fakeNetConn{&buf, &buf}
+ wc := newConn(c, true, 1024, 1024)
+ rc := newConn(c, false, 1024, 1024)
+
+ var actual, expect struct {
+ A int
+ B string
+ }
+ expect.A = 1
+ expect.B = "hello"
+
+ if err := wc.WriteJSON(&expect); err != nil {
+ t.Fatal("write", err)
+ }
+
+ if err := rc.ReadJSON(&actual); err != nil {
+ t.Fatal("read", err)
+ }
+
+ if !reflect.DeepEqual(&actual, &expect) {
+ t.Fatal("equal", actual, expect)
+ }
+}
+
+func TestPartialJsonRead(t *testing.T) {
+ var buf bytes.Buffer
+ c := fakeNetConn{&buf, &buf}
+ wc := newConn(c, true, 1024, 1024)
+ rc := newConn(c, false, 1024, 1024)
+
+ var v struct {
+ A int
+ B string
+ }
+ v.A = 1
+ v.B = "hello"
+
+ messageCount := 0
+
+ // Partial JSON values.
+
+ data, err := json.Marshal(v)
+ if err != nil {
+ t.Fatal(err)
+ }
+ for i := len(data) - 1; i >= 0; i-- {
+ if err := wc.WriteMessage(TextMessage, data[:i]); err != nil {
+ t.Fatal(err)
+ }
+ messageCount++
+ }
+
+ // Whitespace.
+
+ if err := wc.WriteMessage(TextMessage, []byte(" ")); err != nil {
+ t.Fatal(err)
+ }
+ messageCount++
+
+ // Close.
+
+ if err := wc.WriteMessage(CloseMessage, FormatCloseMessage(CloseNormalClosure, "")); err != nil {
+ t.Fatal(err)
+ }
+
+ for i := 0; i < messageCount; i++ {
+ err := rc.ReadJSON(&v)
+ if err != io.ErrUnexpectedEOF {
+ t.Error("read", i, err)
+ }
+ }
+
+ err = rc.ReadJSON(&v)
+ if err != io.EOF {
+ t.Error("final", err)
+ }
+}
+
+func TestDeprecatedJSON(t *testing.T) {
+ var buf bytes.Buffer
+ c := fakeNetConn{&buf, &buf}
+ wc := newConn(c, true, 1024, 1024)
+ rc := newConn(c, false, 1024, 1024)
+
+ var actual, expect struct {
+ A int
+ B string
+ }
+ expect.A = 1
+ expect.B = "hello"
+
+ if err := WriteJSON(wc, &expect); err != nil {
+ t.Fatal("write", err)
+ }
+
+ if err := ReadJSON(rc, &actual); err != nil {
+ t.Fatal("read", err)
+ }
+
+ if !reflect.DeepEqual(&actual, &expect) {
+ t.Fatal("equal", actual, expect)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/server.go b/Godeps/_workspace/src/github.com/gorilla/websocket/server.go
new file mode 100644
index 0000000000000000000000000000000000000000..e56a004933ad31a9846eda5f8942f11e40990ddd
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/server.go
@@ -0,0 +1,247 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "bufio"
+ "errors"
+ "net"
+ "net/http"
+ "net/url"
+ "strings"
+ "time"
+)
+
+// HandshakeError describes an error with the handshake from the peer.
+type HandshakeError struct {
+ message string
+}
+
+func (e HandshakeError) Error() string { return e.message }
+
+// Upgrader specifies parameters for upgrading an HTTP connection to a
+// WebSocket connection.
+type Upgrader struct {
+ // HandshakeTimeout specifies the duration for the handshake to complete.
+ HandshakeTimeout time.Duration
+
+ // ReadBufferSize and WriteBufferSize specify I/O buffer sizes. If a buffer
+ // size is zero, then a default value of 4096 is used. The I/O buffer sizes
+ // do not limit the size of the messages that can be sent or received.
+ ReadBufferSize, WriteBufferSize int
+
+ // Subprotocols specifies the server's supported protocols in order of
+ // preference. If this field is set, then the Upgrade method negotiates a
+ // subprotocol by selecting the first match in this list with a protocol
+ // requested by the client.
+ Subprotocols []string
+
+ // Error specifies the function for generating HTTP error responses. If Error
+ // is nil, then http.Error is used to generate the HTTP response.
+ Error func(w http.ResponseWriter, r *http.Request, status int, reason error)
+
+ // CheckOrigin returns true if the request Origin header is acceptable. If
+ // CheckOrigin is nil, the host in the Origin header must not be set or
+ // must match the host of the request.
+ CheckOrigin func(r *http.Request) bool
+}
+
+func (u *Upgrader) returnError(w http.ResponseWriter, r *http.Request, status int, reason string) (*Conn, error) {
+ err := HandshakeError{reason}
+ if u.Error != nil {
+ u.Error(w, r, status, err)
+ } else {
+ http.Error(w, http.StatusText(status), status)
+ }
+ return nil, err
+}
+
+// checkSameOrigin returns true if the origin is not set or is equal to the request host.
+func checkSameOrigin(r *http.Request) bool {
+ origin := r.Header["Origin"]
+ if len(origin) == 0 {
+ return true
+ }
+ u, err := url.Parse(origin[0])
+ if err != nil {
+ return false
+ }
+ return u.Host == r.Host
+}
+
+func (u *Upgrader) selectSubprotocol(r *http.Request, responseHeader http.Header) string {
+ if u.Subprotocols != nil {
+ clientProtocols := Subprotocols(r)
+ for _, serverProtocol := range u.Subprotocols {
+ for _, clientProtocol := range clientProtocols {
+ if clientProtocol == serverProtocol {
+ return clientProtocol
+ }
+ }
+ }
+ } else if responseHeader != nil {
+ return responseHeader.Get("Sec-Websocket-Protocol")
+ }
+ return ""
+}
+
+// Upgrade upgrades the HTTP server connection to the WebSocket protocol.
+//
+// The responseHeader is included in the response to the client's upgrade
+// request. Use the responseHeader to specify cookies (Set-Cookie) and the
+// application negotiated subprotocol (Sec-Websocket-Protocol).
+func (u *Upgrader) Upgrade(w http.ResponseWriter, r *http.Request, responseHeader http.Header) (*Conn, error) {
+ if values := r.Header["Sec-Websocket-Version"]; len(values) == 0 || values[0] != "13" {
+ return u.returnError(w, r, http.StatusBadRequest, "websocket: version != 13")
+ }
+
+ if !tokenListContainsValue(r.Header, "Connection", "upgrade") {
+ return u.returnError(w, r, http.StatusBadRequest, "websocket: could not find connection header with token 'upgrade'")
+ }
+
+ if !tokenListContainsValue(r.Header, "Upgrade", "websocket") {
+ return u.returnError(w, r, http.StatusBadRequest, "websocket: could not find upgrade header with token 'websocket'")
+ }
+
+ checkOrigin := u.CheckOrigin
+ if checkOrigin == nil {
+ checkOrigin = checkSameOrigin
+ }
+ if !checkOrigin(r) {
+ return u.returnError(w, r, http.StatusForbidden, "websocket: origin not allowed")
+ }
+
+ challengeKey := r.Header.Get("Sec-Websocket-Key")
+ if challengeKey == "" {
+ return u.returnError(w, r, http.StatusBadRequest, "websocket: key missing or blank")
+ }
+
+ subprotocol := u.selectSubprotocol(r, responseHeader)
+
+ var (
+ netConn net.Conn
+ br *bufio.Reader
+ err error
+ )
+
+ h, ok := w.(http.Hijacker)
+ if !ok {
+ return u.returnError(w, r, http.StatusInternalServerError, "websocket: response does not implement http.Hijacker")
+ }
+ var rw *bufio.ReadWriter
+ netConn, rw, err = h.Hijack()
+ if err != nil {
+ return u.returnError(w, r, http.StatusInternalServerError, err.Error())
+ }
+ br = rw.Reader
+
+ if br.Buffered() > 0 {
+ netConn.Close()
+ return nil, errors.New("websocket: client sent data before handshake is complete")
+ }
+
+ c := newConn(netConn, true, u.ReadBufferSize, u.WriteBufferSize)
+ c.subprotocol = subprotocol
+
+ p := c.writeBuf[:0]
+ p = append(p, "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: "...)
+ p = append(p, computeAcceptKey(challengeKey)...)
+ p = append(p, "\r\n"...)
+ if c.subprotocol != "" {
+ p = append(p, "Sec-Websocket-Protocol: "...)
+ p = append(p, c.subprotocol...)
+ p = append(p, "\r\n"...)
+ }
+ for k, vs := range responseHeader {
+ if k == "Sec-Websocket-Protocol" {
+ continue
+ }
+ for _, v := range vs {
+ p = append(p, k...)
+ p = append(p, ": "...)
+ for i := 0; i < len(v); i++ {
+ b := v[i]
+ if b <= 31 {
+ // prevent response splitting.
+ b = ' '
+ }
+ p = append(p, b)
+ }
+ p = append(p, "\r\n"...)
+ }
+ }
+ p = append(p, "\r\n"...)
+
+ // Clear deadlines set by HTTP server.
+ netConn.SetDeadline(time.Time{})
+
+ if u.HandshakeTimeout > 0 {
+ netConn.SetWriteDeadline(time.Now().Add(u.HandshakeTimeout))
+ }
+ if _, err = netConn.Write(p); err != nil {
+ netConn.Close()
+ return nil, err
+ }
+ if u.HandshakeTimeout > 0 {
+ netConn.SetWriteDeadline(time.Time{})
+ }
+
+ return c, nil
+}
+
+// Upgrade upgrades the HTTP server connection to the WebSocket protocol.
+//
+// This function is deprecated, use websocket.Upgrader instead.
+//
+// The application is responsible for checking the request origin before
+// calling Upgrade. An example implementation of the same origin policy is:
+//
+// if req.Header.Get("Origin") != "http://"+req.Host {
+// http.Error(w, "Origin not allowed", 403)
+// return
+// }
+//
+// If the endpoint supports subprotocols, then the application is responsible
+// for negotiating the protocol used on the connection. Use the Subprotocols()
+// function to get the subprotocols requested by the client. Use the
+// Sec-Websocket-Protocol response header to specify the subprotocol selected
+// by the application.
+//
+// The responseHeader is included in the response to the client's upgrade
+// request. Use the responseHeader to specify cookies (Set-Cookie) and the
+// negotiated subprotocol (Sec-Websocket-Protocol).
+//
+// The connection buffers IO to the underlying network connection. The
+// readBufSize and writeBufSize parameters specify the size of the buffers to
+// use. Messages can be larger than the buffers.
+//
+// If the request is not a valid WebSocket handshake, then Upgrade returns an
+// error of type HandshakeError. Applications should handle this error by
+// replying to the client with an HTTP error response.
+func Upgrade(w http.ResponseWriter, r *http.Request, responseHeader http.Header, readBufSize, writeBufSize int) (*Conn, error) {
+ u := Upgrader{ReadBufferSize: readBufSize, WriteBufferSize: writeBufSize}
+ u.Error = func(w http.ResponseWriter, r *http.Request, status int, reason error) {
+ // don't return errors to maintain backwards compatibility
+ }
+ u.CheckOrigin = func(r *http.Request) bool {
+ // allow all connections by default
+ return true
+ }
+ return u.Upgrade(w, r, responseHeader)
+}
+
+// Subprotocols returns the subprotocols requested by the client in the
+// Sec-Websocket-Protocol header.
+func Subprotocols(r *http.Request) []string {
+ h := strings.TrimSpace(r.Header.Get("Sec-Websocket-Protocol"))
+ if h == "" {
+ return nil
+ }
+ protocols := strings.Split(h, ",")
+ for i := range protocols {
+ protocols[i] = strings.TrimSpace(protocols[i])
+ }
+ return protocols
+}
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/server_test.go b/Godeps/_workspace/src/github.com/gorilla/websocket/server_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..ead0776aff99de2df611ffe1593cab61de434517
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/server_test.go
@@ -0,0 +1,33 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "net/http"
+ "reflect"
+ "testing"
+)
+
+var subprotocolTests = []struct {
+ h string
+ protocols []string
+}{
+ {"", nil},
+ {"foo", []string{"foo"}},
+ {"foo,bar", []string{"foo", "bar"}},
+ {"foo, bar", []string{"foo", "bar"}},
+ {" foo, bar", []string{"foo", "bar"}},
+ {" foo, bar ", []string{"foo", "bar"}},
+}
+
+func TestSubprotocols(t *testing.T) {
+ for _, st := range subprotocolTests {
+ r := http.Request{Header: http.Header{"Sec-Websocket-Protocol": {st.h}}}
+ protocols := Subprotocols(&r)
+ if !reflect.DeepEqual(st.protocols, protocols) {
+ t.Errorf("SubProtocols(%q) returned %#v, want %#v", st.h, protocols, st.protocols)
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/util.go b/Godeps/_workspace/src/github.com/gorilla/websocket/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..ffdc265ed78d0de09639f4767884e7955764f2f4
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/util.go
@@ -0,0 +1,44 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "crypto/rand"
+ "crypto/sha1"
+ "encoding/base64"
+ "io"
+ "net/http"
+ "strings"
+)
+
+// tokenListContainsValue returns true if the 1#token header with the given
+// name contains token.
+func tokenListContainsValue(header http.Header, name string, value string) bool {
+ for _, v := range header[name] {
+ for _, s := range strings.Split(v, ",") {
+ if strings.EqualFold(value, strings.TrimSpace(s)) {
+ return true
+ }
+ }
+ }
+ return false
+}
+
+var keyGUID = []byte("258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
+
+func computeAcceptKey(challengeKey string) string {
+ h := sha1.New()
+ h.Write([]byte(challengeKey))
+ h.Write(keyGUID)
+ return base64.StdEncoding.EncodeToString(h.Sum(nil))
+}
+
+func generateChallengeKey() (string, error) {
+ p := make([]byte, 16)
+ if _, err := io.ReadFull(rand.Reader, p); err != nil {
+ return "", err
+ }
+ return base64.StdEncoding.EncodeToString(p), nil
+}
diff --git a/Godeps/_workspace/src/github.com/gorilla/websocket/util_test.go b/Godeps/_workspace/src/github.com/gorilla/websocket/util_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..91f70ceb03bc0413ce5e90f55c68939ebd67ceed
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/websocket/util_test.go
@@ -0,0 +1,34 @@
+// Copyright 2014 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "net/http"
+ "testing"
+)
+
+var tokenListContainsValueTests = []struct {
+ value string
+ ok bool
+}{
+ {"WebSocket", true},
+ {"WEBSOCKET", true},
+ {"websocket", true},
+ {"websockets", false},
+ {"x websocket", false},
+ {"websocket x", false},
+ {"other,websocket,more", true},
+ {"other, websocket, more", true},
+}
+
+func TestTokenListContainsValue(t *testing.T) {
+ for _, tt := range tokenListContainsValueTests {
+ h := http.Header{"Upgrade": {tt.value}}
+ ok := tokenListContainsValue(h, "Upgrade", "websocket")
+ if ok != tt.ok {
+ t.Errorf("tokenListContainsValue(h, n, %q) = %v, want %v", tt.value, ok, tt.ok)
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/inconshreveable/log15/stack/stack.go b/Godeps/_workspace/src/github.com/inconshreveable/log15/stack/stack.go
new file mode 100644
index 0000000000000000000000000000000000000000..ae3021ccea335c6693b6061661815e31beb25f4b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/inconshreveable/log15/stack/stack.go
@@ -0,0 +1,225 @@
+// Package stack implements utilities to capture, manipulate, and format call
+// stacks.
+package stack
+
+import (
+ "fmt"
+ "path/filepath"
+ "runtime"
+ "strings"
+)
+
+// Call records a single function invocation from a goroutine stack. It is a
+// wrapper for the program counter values returned by runtime.Caller and
+// runtime.Callers and consumed by runtime.FuncForPC.
+type Call uintptr
+
+// Format implements fmt.Formatter with support for the following verbs.
+//
+// %s source file
+// %d line number
+// %n function name
+// %v equivalent to %s:%d
+//
+// It accepts the '+' and '#' flags for most of the verbs as follows.
+//
+// %+s path of source file relative to the compile time GOPATH
+// %#s full path of source file
+// %+n import path qualified function name
+// %+v equivalent to %+s:%d
+// %#v equivalent to %#s:%d
+func (pc Call) Format(s fmt.State, c rune) {
+ // BUG(ChrisHines): Subtracting one from pc is a work around for
+ // https://code.google.com/p/go/issues/detail?id=7690. The idea for this
+ // work around comes from rsc's initial patch at
+ // https://codereview.appspot.com/84100043/#ps20001, but as noted in the
+ // issue discussion, it is not a complete fix since it doesn't handle some
+ // cases involving signals. Just the same, it handles all of the other
+ // cases I have tested.
+ pcFix := uintptr(pc) - 1
+ fn := runtime.FuncForPC(pcFix)
+ if fn == nil {
+ fmt.Fprintf(s, "%%!%c(NOFUNC)", c)
+ return
+ }
+
+ switch c {
+ case 's', 'v':
+ file, line := fn.FileLine(pcFix)
+ switch {
+ case s.Flag('#'):
+ // done
+ case s.Flag('+'):
+ // Here we want to get the source file path relative to the
+ // compile time GOPATH. As of Go 1.3.x there is no direct way to
+ // know the compiled GOPATH at runtime, but we can infer the
+ // number of path segments in the GOPATH. We note that fn.Name()
+ // returns the function name qualified by the import path, which
+ // does not include the GOPATH. Thus we can trim segments from the
+ // beginning of the file path until the number of path separators
+ // remaining is one more than the number of path separators in the
+ // function name. For example, given:
+ //
+ // GOPATH /home/user
+ // file /home/user/src/pkg/sub/file.go
+ // fn.Name() pkg/sub.Type.Method
+ //
+ // We want to produce:
+ //
+ // pkg/sub/file.go
+ //
+ // From this we can easily see that fn.Name() has one less path
+ // separator than our desired output.
+ const sep = "/"
+ impCnt := strings.Count(fn.Name(), sep) + 1
+ pathCnt := strings.Count(file, sep)
+ for pathCnt > impCnt {
+ i := strings.Index(file, sep)
+ if i == -1 {
+ break
+ }
+ file = file[i+len(sep):]
+ pathCnt--
+ }
+ default:
+ const sep = "/"
+ if i := strings.LastIndex(file, sep); i != -1 {
+ file = file[i+len(sep):]
+ }
+ }
+ fmt.Fprint(s, file)
+ if c == 'v' {
+ fmt.Fprint(s, ":", line)
+ }
+
+ case 'd':
+ _, line := fn.FileLine(pcFix)
+ fmt.Fprint(s, line)
+
+ case 'n':
+ name := fn.Name()
+ if !s.Flag('+') {
+ const pathSep = "/"
+ if i := strings.LastIndex(name, pathSep); i != -1 {
+ name = name[i+len(pathSep):]
+ }
+ const pkgSep = "."
+ if i := strings.Index(name, pkgSep); i != -1 {
+ name = name[i+len(pkgSep):]
+ }
+ }
+ fmt.Fprint(s, name)
+ }
+}
+
+// Callers returns a Trace for the current goroutine with element 0
+// identifying the calling function.
+func Callers() Trace {
+ pcs := poolBuf()
+ pcs = pcs[:cap(pcs)]
+ n := runtime.Callers(2, pcs)
+ cs := make([]Call, n)
+ for i, pc := range pcs[:n] {
+ cs[i] = Call(pc)
+ }
+ putPoolBuf(pcs)
+ return cs
+}
+
+// name returns the import path qualified name of the function containing the
+// call.
+func (pc Call) name() string {
+ pcFix := uintptr(pc) - 1 // work around for go issue #7690
+ fn := runtime.FuncForPC(pcFix)
+ if fn == nil {
+ return "???"
+ }
+ return fn.Name()
+}
+
+func (pc Call) file() string {
+ pcFix := uintptr(pc) - 1 // work around for go issue #7690
+ fn := runtime.FuncForPC(pcFix)
+ if fn == nil {
+ return "???"
+ }
+ file, _ := fn.FileLine(pcFix)
+ return file
+}
+
+// Trace records a sequence of function invocations from a goroutine stack.
+type Trace []Call
+
+// Format implements fmt.Formatter by printing the Trace as square brackes ([,
+// ]) surrounding a space separated list of Calls each formatted with the
+// supplied verb and options.
+func (pcs Trace) Format(s fmt.State, c rune) {
+ s.Write([]byte("["))
+ for i, pc := range pcs {
+ if i > 0 {
+ s.Write([]byte(" "))
+ }
+ pc.Format(s, c)
+ }
+ s.Write([]byte("]"))
+}
+
+// TrimBelow returns a slice of the Trace with all entries below pc removed.
+func (pcs Trace) TrimBelow(pc Call) Trace {
+ for len(pcs) > 0 && pcs[0] != pc {
+ pcs = pcs[1:]
+ }
+ return pcs
+}
+
+// TrimAbove returns a slice of the Trace with all entries above pc removed.
+func (pcs Trace) TrimAbove(pc Call) Trace {
+ for len(pcs) > 0 && pcs[len(pcs)-1] != pc {
+ pcs = pcs[:len(pcs)-1]
+ }
+ return pcs
+}
+
+// TrimBelowName returns a slice of the Trace with all entries below the
+// lowest with function name name removed.
+func (pcs Trace) TrimBelowName(name string) Trace {
+ for len(pcs) > 0 && pcs[0].name() != name {
+ pcs = pcs[1:]
+ }
+ return pcs
+}
+
+// TrimAboveName returns a slice of the Trace with all entries above the
+// highest with function name name removed.
+func (pcs Trace) TrimAboveName(name string) Trace {
+ for len(pcs) > 0 && pcs[len(pcs)-1].name() != name {
+ pcs = pcs[:len(pcs)-1]
+ }
+ return pcs
+}
+
+var goroot string
+
+func init() {
+ goroot = filepath.ToSlash(runtime.GOROOT())
+ if runtime.GOOS == "windows" {
+ goroot = strings.ToLower(goroot)
+ }
+}
+
+func inGoroot(path string) bool {
+ if runtime.GOOS == "windows" {
+ path = strings.ToLower(path)
+ }
+ return strings.HasPrefix(path, goroot)
+}
+
+// TrimRuntime returns a slice of the Trace with the topmost entries from the
+// go runtime removed. It considers any calls originating from files under
+// GOROOT as part of the runtime.
+func (pcs Trace) TrimRuntime() Trace {
+ for len(pcs) > 0 && inGoroot(pcs[len(pcs)-1].file()) {
+ pcs = pcs[:len(pcs)-1]
+ }
+ return pcs
+}
diff --git a/Godeps/_workspace/src/github.com/inconshreveable/log15/stack/stack_pool.go b/Godeps/_workspace/src/github.com/inconshreveable/log15/stack/stack_pool.go
new file mode 100644
index 0000000000000000000000000000000000000000..34f2ca9707543de0a377ae920eefda21547e4929
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/inconshreveable/log15/stack/stack_pool.go
@@ -0,0 +1,19 @@
+// +build go1.3
+
+package stack
+
+import (
+ "sync"
+)
+
+var pcStackPool = sync.Pool{
+ New: func() interface{} { return make([]uintptr, 1000) },
+}
+
+func poolBuf() []uintptr {
+ return pcStackPool.Get().([]uintptr)
+}
+
+func putPoolBuf(p []uintptr) {
+ pcStackPool.Put(p)
+}
diff --git a/Godeps/_workspace/src/github.com/inconshreveable/log15/stack/stack_pool_chan.go b/Godeps/_workspace/src/github.com/inconshreveable/log15/stack/stack_pool_chan.go
new file mode 100644
index 0000000000000000000000000000000000000000..a9d6c154db3b3e9755236ead249c7d0ac2b16c3e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/inconshreveable/log15/stack/stack_pool_chan.go
@@ -0,0 +1,27 @@
+// +build !go1.3 appengine
+
+package stack
+
+const (
+ stackPoolSize = 64
+)
+
+var (
+ pcStackPool = make(chan []uintptr, stackPoolSize)
+)
+
+func poolBuf() []uintptr {
+ select {
+ case p := <-pcStackPool:
+ return p
+ default:
+ return make([]uintptr, 1000)
+ }
+}
+
+func putPoolBuf(p []uintptr) {
+ select {
+ case pcStackPool <- p:
+ default:
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/inconshreveable/log15/stack/stack_test.go b/Godeps/_workspace/src/github.com/inconshreveable/log15/stack/stack_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..64cd7d08075a7c43b884ce6076545c30a0564990
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/inconshreveable/log15/stack/stack_test.go
@@ -0,0 +1,231 @@
+package stack_test
+
+import (
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path"
+ "path/filepath"
+ "runtime"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/inconshreveable/log15/stack"
+)
+
+type testType struct{}
+
+func (tt testType) testMethod() (pc uintptr, file string, line int, ok bool) {
+ return runtime.Caller(0)
+}
+
+func TestCallFormat(t *testing.T) {
+ t.Parallel()
+
+ pc, file, line, ok := runtime.Caller(0)
+ if !ok {
+ t.Fatal("runtime.Caller(0) failed")
+ }
+
+ gopathSrc := filepath.Join(os.Getenv("GOPATH"), "src")
+ relFile, err := filepath.Rel(gopathSrc, file)
+ if err != nil {
+ t.Fatalf("failed to determine path relative to GOPATH: %v", err)
+ }
+ relFile = filepath.ToSlash(relFile)
+
+ pc2, file2, line2, ok2 := testType{}.testMethod()
+ if !ok2 {
+ t.Fatal("runtime.Caller(0) failed")
+ }
+ relFile2, err := filepath.Rel(gopathSrc, file)
+ if err != nil {
+ t.Fatalf("failed to determine path relative to GOPATH: %v", err)
+ }
+ relFile2 = filepath.ToSlash(relFile2)
+
+ data := []struct {
+ pc uintptr
+ desc string
+ fmt string
+ out string
+ }{
+ {0, "error", "%s", "%!s(NOFUNC)"},
+
+ {pc, "func", "%s", path.Base(file)},
+ {pc, "func", "%+s", relFile},
+ {pc, "func", "%#s", file},
+ {pc, "func", "%d", fmt.Sprint(line)},
+ {pc, "func", "%n", "TestCallFormat"},
+ {pc, "func", "%+n", runtime.FuncForPC(pc).Name()},
+ {pc, "func", "%v", fmt.Sprint(path.Base(file), ":", line)},
+ {pc, "func", "%+v", fmt.Sprint(relFile, ":", line)},
+ {pc, "func", "%#v", fmt.Sprint(file, ":", line)},
+ {pc, "func", "%v|%[1]n()", fmt.Sprint(path.Base(file), ":", line, "|", "TestCallFormat()")},
+
+ {pc2, "meth", "%s", path.Base(file2)},
+ {pc2, "meth", "%+s", relFile2},
+ {pc2, "meth", "%#s", file2},
+ {pc2, "meth", "%d", fmt.Sprint(line2)},
+ {pc2, "meth", "%n", "testType.testMethod"},
+ {pc2, "meth", "%+n", runtime.FuncForPC(pc2).Name()},
+ {pc2, "meth", "%v", fmt.Sprint(path.Base(file2), ":", line2)},
+ {pc2, "meth", "%+v", fmt.Sprint(relFile2, ":", line2)},
+ {pc2, "meth", "%#v", fmt.Sprint(file2, ":", line2)},
+ {pc2, "meth", "%v|%[1]n()", fmt.Sprint(path.Base(file2), ":", line2, "|", "testType.testMethod()")},
+ }
+
+ for _, d := range data {
+ got := fmt.Sprintf(d.fmt, stack.Call(d.pc))
+ if got != d.out {
+ t.Errorf("fmt.Sprintf(%q, Call(%s)) = %s, want %s", d.fmt, d.desc, got, d.out)
+ }
+ }
+}
+
+func BenchmarkCallVFmt(b *testing.B) {
+ pc, _, _, ok := runtime.Caller(0)
+ if !ok {
+ b.Fatal("runtime.Caller(0) failed")
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Fprint(ioutil.Discard, stack.Call(pc))
+ }
+}
+
+func BenchmarkCallPlusVFmt(b *testing.B) {
+ pc, _, _, ok := runtime.Caller(0)
+ if !ok {
+ b.Fatal("runtime.Caller(0) failed")
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Fprintf(ioutil.Discard, "%+v", stack.Call(pc))
+ }
+}
+
+func BenchmarkCallSharpVFmt(b *testing.B) {
+ pc, _, _, ok := runtime.Caller(0)
+ if !ok {
+ b.Fatal("runtime.Caller(0) failed")
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Fprintf(ioutil.Discard, "%#v", stack.Call(pc))
+ }
+}
+
+func BenchmarkCallSFmt(b *testing.B) {
+ pc, _, _, ok := runtime.Caller(0)
+ if !ok {
+ b.Fatal("runtime.Caller(0) failed")
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Fprintf(ioutil.Discard, "%s", stack.Call(pc))
+ }
+}
+
+func BenchmarkCallPlusSFmt(b *testing.B) {
+ pc, _, _, ok := runtime.Caller(0)
+ if !ok {
+ b.Fatal("runtime.Caller(0) failed")
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Fprintf(ioutil.Discard, "%+s", stack.Call(pc))
+ }
+}
+
+func BenchmarkCallSharpSFmt(b *testing.B) {
+ pc, _, _, ok := runtime.Caller(0)
+ if !ok {
+ b.Fatal("runtime.Caller(0) failed")
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Fprintf(ioutil.Discard, "%#s", stack.Call(pc))
+ }
+}
+
+func BenchmarkCallDFmt(b *testing.B) {
+ pc, _, _, ok := runtime.Caller(0)
+ if !ok {
+ b.Fatal("runtime.Caller(0) failed")
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Fprintf(ioutil.Discard, "%d", stack.Call(pc))
+ }
+}
+
+func BenchmarkCallNFmt(b *testing.B) {
+ pc, _, _, ok := runtime.Caller(0)
+ if !ok {
+ b.Fatal("runtime.Caller(0) failed")
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Fprintf(ioutil.Discard, "%n", stack.Call(pc))
+ }
+}
+
+func BenchmarkCallPlusNFmt(b *testing.B) {
+ pc, _, _, ok := runtime.Caller(0)
+ if !ok {
+ b.Fatal("runtime.Caller(0) failed")
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Fprintf(ioutil.Discard, "%+n", stack.Call(pc))
+ }
+}
+
+func BenchmarkCallers(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ stack.Callers()
+ }
+}
+
+func deepStack(depth int, b *testing.B) stack.Trace {
+ if depth > 0 {
+ return deepStack(depth-1, b)
+ }
+ b.StartTimer()
+ s := stack.Callers()
+ b.StopTimer()
+ return s
+}
+
+func BenchmarkCallers10(b *testing.B) {
+ b.StopTimer()
+
+ for i := 0; i < b.N; i++ {
+ deepStack(10, b)
+ }
+}
+
+func BenchmarkCallers50(b *testing.B) {
+ b.StopTimer()
+
+ for i := 0; i < b.N; i++ {
+ deepStack(50, b)
+ }
+}
+
+func BenchmarkCallers100(b *testing.B) {
+ b.StopTimer()
+
+ for i := 0; i < b.N; i++ {
+ deepStack(100, b)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/inconshreveable/log15/term/LICENSE b/Godeps/_workspace/src/github.com/inconshreveable/log15/term/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..f090cb42f370bda9e7f4f58d9b8b8ee2750c115f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/inconshreveable/log15/term/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Simon Eskildsen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/Godeps/_workspace/src/github.com/inconshreveable/log15/term/terminal_appengine.go b/Godeps/_workspace/src/github.com/inconshreveable/log15/term/terminal_appengine.go
new file mode 100644
index 0000000000000000000000000000000000000000..c1b5d2a3b1adf8f0866d2f7f7f62c90468db1583
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/inconshreveable/log15/term/terminal_appengine.go
@@ -0,0 +1,13 @@
+// Based on ssh/terminal:
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+package term
+
+// IsTty always returns false on AppEngine.
+func IsTty(fd uintptr) bool {
+ return false
+}
diff --git a/Godeps/_workspace/src/github.com/inconshreveable/log15/term/terminal_darwin.go b/Godeps/_workspace/src/github.com/inconshreveable/log15/term/terminal_darwin.go
new file mode 100644
index 0000000000000000000000000000000000000000..b05de4cb8c8f89c5f7a70b192b84a07c545fc2e5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/inconshreveable/log15/term/terminal_darwin.go
@@ -0,0 +1,12 @@
+// Based on ssh/terminal:
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package term
+
+import "syscall"
+
+const ioctlReadTermios = syscall.TIOCGETA
+
+type Termios syscall.Termios
diff --git a/Godeps/_workspace/src/github.com/inconshreveable/log15/term/terminal_freebsd.go b/Godeps/_workspace/src/github.com/inconshreveable/log15/term/terminal_freebsd.go
new file mode 100644
index 0000000000000000000000000000000000000000..cfaceab337a2aaf905c895618e0121ec8bb3236b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/inconshreveable/log15/term/terminal_freebsd.go
@@ -0,0 +1,18 @@
+package term
+
+import (
+ "syscall"
+)
+
+const ioctlReadTermios = syscall.TIOCGETA
+
+// Go 1.2 doesn't include Termios for FreeBSD. This should be added in 1.3 and this could be merged with terminal_darwin.
+type Termios struct {
+ Iflag uint32
+ Oflag uint32
+ Cflag uint32
+ Lflag uint32
+ Cc [20]uint8
+ Ispeed uint32
+ Ospeed uint32
+}
diff --git a/Godeps/_workspace/src/github.com/inconshreveable/log15/term/terminal_linux.go b/Godeps/_workspace/src/github.com/inconshreveable/log15/term/terminal_linux.go
new file mode 100644
index 0000000000000000000000000000000000000000..5290468d698ac2000f6101d665cfecec3c0faa42
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/inconshreveable/log15/term/terminal_linux.go
@@ -0,0 +1,14 @@
+// Based on ssh/terminal:
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !appengine
+
+package term
+
+import "syscall"
+
+const ioctlReadTermios = syscall.TCGETS
+
+type Termios syscall.Termios
diff --git a/Godeps/_workspace/src/github.com/inconshreveable/log15/term/terminal_notwindows.go b/Godeps/_workspace/src/github.com/inconshreveable/log15/term/terminal_notwindows.go
new file mode 100644
index 0000000000000000000000000000000000000000..c0b201a5308991fe68a003c3684805fcb34fa556
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/inconshreveable/log15/term/terminal_notwindows.go
@@ -0,0 +1,20 @@
+// Based on ssh/terminal:
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build linux,!appengine darwin freebsd
+
+package term
+
+import (
+ "syscall"
+ "unsafe"
+)
+
+// IsTty returns true if the given file descriptor is a terminal.
+func IsTty(fd uintptr) bool {
+ var termios Termios
+ _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
+ return err == 0
+}
diff --git a/Godeps/_workspace/src/github.com/inconshreveable/log15/term/terminal_windows.go b/Godeps/_workspace/src/github.com/inconshreveable/log15/term/terminal_windows.go
new file mode 100644
index 0000000000000000000000000000000000000000..df3c30c15892a7bf23de61064e84d6842c145957
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/inconshreveable/log15/term/terminal_windows.go
@@ -0,0 +1,26 @@
+// Based on ssh/terminal:
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package term
+
+import (
+ "syscall"
+ "unsafe"
+)
+
+var kernel32 = syscall.NewLazyDLL("kernel32.dll")
+
+var (
+ procGetConsoleMode = kernel32.NewProc("GetConsoleMode")
+)
+
+// IsTty returns true if the given file descriptor is a terminal.
+func IsTty(fd uintptr) bool {
+ var st uint32
+ r, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, fd, uintptr(unsafe.Pointer(&st)), 0)
+ return r != 0 && e == 0
+}
diff --git a/Godeps/_workspace/src/github.com/manucorporat/sse/.travis.yml b/Godeps/_workspace/src/github.com/manucorporat/sse/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..3d3383312806f24c5e21807b1dfc568e044025ce
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/manucorporat/sse/.travis.yml
@@ -0,0 +1,6 @@
+language: go
+sudo: false
+go:
+ - 1.3
+ - 1.4
+ - tip
diff --git a/Godeps/_workspace/src/github.com/manucorporat/sse/LICENSE b/Godeps/_workspace/src/github.com/manucorporat/sse/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..1ff7f370605592e4c09bd16f6775c075631bd9e6
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/manucorporat/sse/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Manuel MartÃnez-Almeida
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/Godeps/_workspace/src/github.com/manucorporat/sse/README.md b/Godeps/_workspace/src/github.com/manucorporat/sse/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4e1cf0ec222d1b4f501065b1438db33e03a380e4
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/manucorporat/sse/README.md
@@ -0,0 +1,54 @@
+#Server-Sent Events [](https://godoc.org/github.com/manucorporat/sse) [](https://travis-ci.org/manucorporat/sse)
+
+Server-sent events (SSE) is a technology where a browser receives automatic updates from a server via HTTP connection. The Server-Sent Events EventSource API is [standardized as part of HTML5[1] by the W3C](http://www.w3.org/TR/2009/WD-eventsource-20091029/).
+
+- [Real world demostration using Gin](http://sse.getgin.io/)
+- [Read this great SSE introduction by the HTML5Rocks guys](http://www.html5rocks.com/en/tutorials/eventsource/basics/)
+- [Browser support](http://caniuse.com/#feat=eventsource)
+
+##Sample code
+
+```go
+import "github.com/manucorporat/sse"
+
+func httpHandler(w http.ResponseWriter, req *http.Request) {
+ // data can be a primitive like a string, an integer or a float
+ sse.Encode(w, sse.Event{
+ Event: "message",
+ Data: "some data\nmore data",
+ })
+
+ // also a complex type, like a map, a struct or a slice
+ sse.Encode(w, sse.Event{
+ Id: "124",
+ Event: "message",
+ Data: map[string]interface{}{
+ "user": "manu",
+ "date": time.Now().Unix(),
+ "content": "hi!",
+ },
+ })
+}
+```
+```
+event: message
+data: some data\\nmore data
+
+id: 124
+event: message
+data: {"content":"hi!","date":1431540810,"user":"manu"}
+
+```
+
+##Content-Type
+
+```go
+fmt.Println(sse.ContentType)
+```
+```
+text/event-stream
+```
+
+##Decoding support
+
+There is a client-side implementation of SSE coming soon.
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/manucorporat/sse/sse-encoder.go b/Godeps/_workspace/src/github.com/manucorporat/sse/sse-encoder.go
new file mode 100644
index 0000000000000000000000000000000000000000..16bab76523f1a0f9ab6adb8d190e824150e358d4
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/manucorporat/sse/sse-encoder.go
@@ -0,0 +1,106 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package sse
+
+import (
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "reflect"
+ "strconv"
+ "strings"
+)
+
+// Server-Sent Events
+// W3C Working Draft 29 October 2009
+// http://www.w3.org/TR/2009/WD-eventsource-20091029/
+
+const ContentType = "text/event-stream"
+
+var contentType = []string{ContentType}
+var noCache = []string{"no-cache"}
+var replacer = strings.NewReplacer("\n", "\\n", "\r", "\\r")
+
+type Event struct {
+ Event string
+ Id string
+ Retry uint
+ Data interface{}
+}
+
+func Encode(writer io.Writer, event Event) error {
+ w := checkWriter(writer)
+ writeId(w, event.Id)
+ writeEvent(w, event.Event)
+ writeRetry(w, event.Retry)
+ return writeData(w, event.Data)
+}
+
+func writeId(w stringWriter, id string) {
+ if len(id) > 0 {
+ w.WriteString("id: ")
+ writeEscape(w, id)
+ w.WriteString("\n")
+ }
+}
+
+func writeEvent(w stringWriter, event string) {
+ if len(event) > 0 {
+ w.WriteString("event: ")
+ writeEscape(w, event)
+ w.WriteString("\n")
+ }
+}
+
+func writeRetry(w stringWriter, retry uint) {
+ if retry > 0 {
+ w.WriteString("retry: ")
+ w.WriteString(strconv.FormatUint(uint64(retry), 10))
+ w.WriteString("\n")
+ }
+}
+
+func writeData(w stringWriter, data interface{}) error {
+ w.WriteString("data: ")
+ switch kindOfData(data) {
+ case reflect.Struct, reflect.Slice, reflect.Map:
+ err := json.NewEncoder(w).Encode(data)
+ if err != nil {
+ return err
+ }
+ w.WriteString("\n")
+ default:
+ text := fmt.Sprint(data)
+ writeEscape(w, text)
+ w.WriteString("\n\n")
+ }
+ return nil
+}
+
+func (r Event) Render(w http.ResponseWriter) error {
+ header := w.Header()
+ header["Content-Type"] = contentType
+
+ if _, exist := header["Cache-Control"]; !exist {
+ header["Cache-Control"] = noCache
+ }
+ return Encode(w, r)
+}
+
+func kindOfData(data interface{}) reflect.Kind {
+ value := reflect.ValueOf(data)
+ valueType := value.Kind()
+ if valueType == reflect.Ptr {
+ valueType = value.Elem().Kind()
+ }
+ return valueType
+}
+
+func writeEscape(w stringWriter, str string) {
+ // any-char = %x0000-0009 / %x000B-000C / %x000E-10FFFF
+ // ; a Unicode character other than U+000A LINE FEED (LF) or U+000D CARRIAGE RETURN (CR)
+ replacer.WriteString(w, str)
+}
diff --git a/Godeps/_workspace/src/github.com/manucorporat/sse/sse_test.go b/Godeps/_workspace/src/github.com/manucorporat/sse/sse_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..f1e15440afd80e113863015035c75306fc81888c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/manucorporat/sse/sse_test.go
@@ -0,0 +1,219 @@
+// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package sse
+
+import (
+ "bytes"
+ "net/http/httptest"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+func TestEncodeOnlyData(t *testing.T) {
+ w := new(bytes.Buffer)
+ err := Encode(w, Event{
+ Data: "junk\n\njk\nid:fake",
+ })
+ assert.NoError(t, err)
+ assert.Equal(t, w.String(), "data: junk\\n\\njk\\nid:fake\n\n")
+}
+
+func TestEncodeWithEvent(t *testing.T) {
+ w := new(bytes.Buffer)
+ err := Encode(w, Event{
+ Event: "t\n:<>\r\test",
+ Data: "junk\n\njk\nid:fake",
+ })
+ assert.NoError(t, err)
+ assert.Equal(t, w.String(), "event: t\\n:<>\\r\test\ndata: junk\\n\\njk\\nid:fake\n\n")
+}
+
+func TestEncodeWithId(t *testing.T) {
+ w := new(bytes.Buffer)
+ err := Encode(w, Event{
+ Id: "t\n:<>\r\test",
+ Data: "junk\n\njk\nid:fa\rke",
+ })
+ assert.NoError(t, err)
+ assert.Equal(t, w.String(), "id: t\\n:<>\\r\test\ndata: junk\\n\\njk\\nid:fa\\rke\n\n")
+}
+
+func TestEncodeWithRetry(t *testing.T) {
+ w := new(bytes.Buffer)
+ err := Encode(w, Event{
+ Retry: 11,
+ Data: "junk\n\njk\nid:fake\n",
+ })
+ assert.NoError(t, err)
+ assert.Equal(t, w.String(), "retry: 11\ndata: junk\\n\\njk\\nid:fake\\n\n\n")
+}
+
+func TestEncodeWithEverything(t *testing.T) {
+ w := new(bytes.Buffer)
+ err := Encode(w, Event{
+ Event: "abc",
+ Id: "12345",
+ Retry: 10,
+ Data: "some data",
+ })
+ assert.NoError(t, err)
+ assert.Equal(t, w.String(), "id: 12345\nevent: abc\nretry: 10\ndata: some data\n\n")
+}
+
+func TestEncodeMap(t *testing.T) {
+ w := new(bytes.Buffer)
+ err := Encode(w, Event{
+ Event: "a map",
+ Data: map[string]interface{}{
+ "foo": "b\n\rar",
+ "bar": "id: 2",
+ },
+ })
+ assert.NoError(t, err)
+ assert.Equal(t, w.String(), "event: a map\ndata: {\"bar\":\"id: 2\",\"foo\":\"b\\n\\rar\"}\n\n")
+}
+
+func TestEncodeSlice(t *testing.T) {
+ w := new(bytes.Buffer)
+ err := Encode(w, Event{
+ Event: "a slice",
+ Data: []interface{}{1, "text", map[string]interface{}{"foo": "bar"}},
+ })
+ assert.NoError(t, err)
+ assert.Equal(t, w.String(), "event: a slice\ndata: [1,\"text\",{\"foo\":\"bar\"}]\n\n")
+}
+
+func TestEncodeStruct(t *testing.T) {
+ myStruct := struct {
+ A int
+ B string `json:"value"`
+ }{1, "number"}
+
+ w := new(bytes.Buffer)
+ err := Encode(w, Event{
+ Event: "a struct",
+ Data: myStruct,
+ })
+ assert.NoError(t, err)
+ assert.Equal(t, w.String(), "event: a struct\ndata: {\"A\":1,\"value\":\"number\"}\n\n")
+
+ w.Reset()
+ err = Encode(w, Event{
+ Event: "a struct",
+ Data: &myStruct,
+ })
+ assert.NoError(t, err)
+ assert.Equal(t, w.String(), "event: a struct\ndata: {\"A\":1,\"value\":\"number\"}\n\n")
+}
+
+func TestEncodeInteger(t *testing.T) {
+ w := new(bytes.Buffer)
+ err := Encode(w, Event{
+ Event: "an integer",
+ Data: 1,
+ })
+ assert.NoError(t, err)
+ assert.Equal(t, w.String(), "event: an integer\ndata: 1\n\n")
+}
+
+func TestEncodeFloat(t *testing.T) {
+ w := new(bytes.Buffer)
+ err := Encode(w, Event{
+ Event: "Float",
+ Data: 1.5,
+ })
+ assert.NoError(t, err)
+ assert.Equal(t, w.String(), "event: Float\ndata: 1.5\n\n")
+}
+
+func TestEncodeStream(t *testing.T) {
+ w := new(bytes.Buffer)
+
+ Encode(w, Event{
+ Event: "float",
+ Data: 1.5,
+ })
+
+ Encode(w, Event{
+ Id: "123",
+ Data: map[string]interface{}{"foo": "bar", "bar": "foo"},
+ })
+
+ Encode(w, Event{
+ Id: "124",
+ Event: "chat",
+ Data: "hi! dude",
+ })
+ assert.Equal(t, w.String(), "event: float\ndata: 1.5\n\nid: 123\ndata: {\"bar\":\"foo\",\"foo\":\"bar\"}\n\nid: 124\nevent: chat\ndata: hi! dude\n\n")
+}
+
+func TestRenderSSE(t *testing.T) {
+ w := httptest.NewRecorder()
+
+ err := (Event{
+ Event: "msg",
+ Data: "hi! how are you?",
+ }).Render(w)
+
+ assert.NoError(t, err)
+ assert.Equal(t, w.Body.String(), "event: msg\ndata: hi! how are you?\n\n")
+ assert.Equal(t, w.Header().Get("Content-Type"), "text/event-stream")
+ assert.Equal(t, w.Header().Get("Cache-Control"), "no-cache")
+}
+
+func BenchmarkResponseWriter(b *testing.B) {
+ w := httptest.NewRecorder()
+ b.ResetTimer()
+ b.ReportAllocs()
+ for i := 0; i < b.N; i++ {
+ (Event{
+ Event: "new_message",
+ Data: "hi! how are you? I am fine. this is a long stupid message!!!",
+ }).Render(w)
+ }
+}
+
+func BenchmarkFullSSE(b *testing.B) {
+ buf := new(bytes.Buffer)
+ b.ResetTimer()
+ b.ReportAllocs()
+ for i := 0; i < b.N; i++ {
+ Encode(buf, Event{
+ Event: "new_message",
+ Id: "13435",
+ Retry: 10,
+ Data: "hi! how are you? I am fine. this is a long stupid message!!!",
+ })
+ buf.Reset()
+ }
+}
+
+func BenchmarkNoRetrySSE(b *testing.B) {
+ buf := new(bytes.Buffer)
+ b.ResetTimer()
+ b.ReportAllocs()
+ for i := 0; i < b.N; i++ {
+ Encode(buf, Event{
+ Event: "new_message",
+ Id: "13435",
+ Data: "hi! how are you? I am fine. this is a long stupid message!!!",
+ })
+ buf.Reset()
+ }
+}
+
+func BenchmarkSimpleSSE(b *testing.B) {
+ buf := new(bytes.Buffer)
+ b.ResetTimer()
+ b.ReportAllocs()
+ for i := 0; i < b.N; i++ {
+ Encode(buf, Event{
+ Event: "new_message",
+ Data: "hi! how are you? I am fine. this is a long stupid message!!!",
+ })
+ buf.Reset()
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/manucorporat/sse/writer.go b/Godeps/_workspace/src/github.com/manucorporat/sse/writer.go
new file mode 100644
index 0000000000000000000000000000000000000000..6f9806c55a3ee0a73f4a409e6eb806b0473e603e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/manucorporat/sse/writer.go
@@ -0,0 +1,24 @@
+package sse
+
+import "io"
+
+type stringWriter interface {
+ io.Writer
+ WriteString(string) (int, error)
+}
+
+type stringWrapper struct {
+ io.Writer
+}
+
+func (w stringWrapper) WriteString(str string) (int, error) {
+ return w.Writer.Write([]byte(str))
+}
+
+func checkWriter(writer io.Writer) stringWriter {
+ if w, ok := writer.(stringWriter); ok {
+ return w
+ } else {
+ return stringWrapper{writer}
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/mattn/go-colorable/README.md b/Godeps/_workspace/src/github.com/mattn/go-colorable/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..c69da4a76116925188771c4691d76224c920112a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/mattn/go-colorable/README.md
@@ -0,0 +1,42 @@
+# go-colorable
+
+Colorable writer for windows.
+
+For example, most of logger packages doesn't show colors on windows. (I know we can do it with ansicon. But I don't want.)
+This package is possible to handle escape sequence for ansi color on windows.
+
+## Too Bad!
+
+
+
+
+## So Good!
+
+
+
+## Usage
+
+```go
+logrus.SetOutput(colorable.NewColorableStdout())
+
+logrus.Info("succeeded")
+logrus.Warn("not correct")
+logrus.Error("something error")
+logrus.Fatal("panic")
+```
+
+You can compile above code on non-windows OSs.
+
+## Installation
+
+```
+$ go get github.com/mattn/go-colorable
+```
+
+# License
+
+MIT
+
+# Author
+
+Yasuhiro Matsumoto (a.k.a mattn)
diff --git a/Godeps/_workspace/src/github.com/mattn/go-colorable/colorable_others.go b/Godeps/_workspace/src/github.com/mattn/go-colorable/colorable_others.go
new file mode 100644
index 0000000000000000000000000000000000000000..219f02f62a604f8a7af71ba726936712600bc773
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/mattn/go-colorable/colorable_others.go
@@ -0,0 +1,16 @@
+// +build !windows
+
+package colorable
+
+import (
+ "io"
+ "os"
+)
+
+func NewColorableStdout() io.Writer {
+ return os.Stdout
+}
+
+func NewColorableStderr() io.Writer {
+ return os.Stderr
+}
diff --git a/Godeps/_workspace/src/github.com/mattn/go-colorable/colorable_windows.go b/Godeps/_workspace/src/github.com/mattn/go-colorable/colorable_windows.go
new file mode 100644
index 0000000000000000000000000000000000000000..6a27878088c5b6b3fdc433e7a43d71608e9ff7fe
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/mattn/go-colorable/colorable_windows.go
@@ -0,0 +1,594 @@
+package colorable
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "os"
+ "strconv"
+ "strings"
+ "syscall"
+ "unsafe"
+
+ "github.com/mattn/go-isatty"
+)
+
+const (
+ foregroundBlue = 0x1
+ foregroundGreen = 0x2
+ foregroundRed = 0x4
+ foregroundIntensity = 0x8
+ foregroundMask = (foregroundRed | foregroundBlue | foregroundGreen | foregroundIntensity)
+ backgroundBlue = 0x10
+ backgroundGreen = 0x20
+ backgroundRed = 0x40
+ backgroundIntensity = 0x80
+ backgroundMask = (backgroundRed | backgroundBlue | backgroundGreen | backgroundIntensity)
+)
+
+type wchar uint16
+type short int16
+type dword uint32
+type word uint16
+
+type coord struct {
+ x short
+ y short
+}
+
+type smallRect struct {
+ left short
+ top short
+ right short
+ bottom short
+}
+
+type consoleScreenBufferInfo struct {
+ size coord
+ cursorPosition coord
+ attributes word
+ window smallRect
+ maximumWindowSize coord
+}
+
+var (
+ kernel32 = syscall.NewLazyDLL("kernel32.dll")
+ procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo")
+ procSetConsoleTextAttribute = kernel32.NewProc("SetConsoleTextAttribute")
+)
+
+type Writer struct {
+ out io.Writer
+ handle syscall.Handle
+ lastbuf bytes.Buffer
+ oldattr word
+}
+
+func NewColorableStdout() io.Writer {
+ var csbi consoleScreenBufferInfo
+ out := os.Stdout
+ if !isatty.IsTerminal(out.Fd()) {
+ return out
+ }
+ handle := syscall.Handle(out.Fd())
+ procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+ return &Writer{out: out, handle: handle, oldattr: csbi.attributes}
+}
+
+func NewColorableStderr() io.Writer {
+ var csbi consoleScreenBufferInfo
+ out := os.Stderr
+ if !isatty.IsTerminal(out.Fd()) {
+ return out
+ }
+ handle := syscall.Handle(out.Fd())
+ procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+ return &Writer{out: out, handle: handle, oldattr: csbi.attributes}
+}
+
+var color256 = map[int]int{
+ 0: 0x000000,
+ 1: 0x800000,
+ 2: 0x008000,
+ 3: 0x808000,
+ 4: 0x000080,
+ 5: 0x800080,
+ 6: 0x008080,
+ 7: 0xc0c0c0,
+ 8: 0x808080,
+ 9: 0xff0000,
+ 10: 0x00ff00,
+ 11: 0xffff00,
+ 12: 0x0000ff,
+ 13: 0xff00ff,
+ 14: 0x00ffff,
+ 15: 0xffffff,
+ 16: 0x000000,
+ 17: 0x00005f,
+ 18: 0x000087,
+ 19: 0x0000af,
+ 20: 0x0000d7,
+ 21: 0x0000ff,
+ 22: 0x005f00,
+ 23: 0x005f5f,
+ 24: 0x005f87,
+ 25: 0x005faf,
+ 26: 0x005fd7,
+ 27: 0x005fff,
+ 28: 0x008700,
+ 29: 0x00875f,
+ 30: 0x008787,
+ 31: 0x0087af,
+ 32: 0x0087d7,
+ 33: 0x0087ff,
+ 34: 0x00af00,
+ 35: 0x00af5f,
+ 36: 0x00af87,
+ 37: 0x00afaf,
+ 38: 0x00afd7,
+ 39: 0x00afff,
+ 40: 0x00d700,
+ 41: 0x00d75f,
+ 42: 0x00d787,
+ 43: 0x00d7af,
+ 44: 0x00d7d7,
+ 45: 0x00d7ff,
+ 46: 0x00ff00,
+ 47: 0x00ff5f,
+ 48: 0x00ff87,
+ 49: 0x00ffaf,
+ 50: 0x00ffd7,
+ 51: 0x00ffff,
+ 52: 0x5f0000,
+ 53: 0x5f005f,
+ 54: 0x5f0087,
+ 55: 0x5f00af,
+ 56: 0x5f00d7,
+ 57: 0x5f00ff,
+ 58: 0x5f5f00,
+ 59: 0x5f5f5f,
+ 60: 0x5f5f87,
+ 61: 0x5f5faf,
+ 62: 0x5f5fd7,
+ 63: 0x5f5fff,
+ 64: 0x5f8700,
+ 65: 0x5f875f,
+ 66: 0x5f8787,
+ 67: 0x5f87af,
+ 68: 0x5f87d7,
+ 69: 0x5f87ff,
+ 70: 0x5faf00,
+ 71: 0x5faf5f,
+ 72: 0x5faf87,
+ 73: 0x5fafaf,
+ 74: 0x5fafd7,
+ 75: 0x5fafff,
+ 76: 0x5fd700,
+ 77: 0x5fd75f,
+ 78: 0x5fd787,
+ 79: 0x5fd7af,
+ 80: 0x5fd7d7,
+ 81: 0x5fd7ff,
+ 82: 0x5fff00,
+ 83: 0x5fff5f,
+ 84: 0x5fff87,
+ 85: 0x5fffaf,
+ 86: 0x5fffd7,
+ 87: 0x5fffff,
+ 88: 0x870000,
+ 89: 0x87005f,
+ 90: 0x870087,
+ 91: 0x8700af,
+ 92: 0x8700d7,
+ 93: 0x8700ff,
+ 94: 0x875f00,
+ 95: 0x875f5f,
+ 96: 0x875f87,
+ 97: 0x875faf,
+ 98: 0x875fd7,
+ 99: 0x875fff,
+ 100: 0x878700,
+ 101: 0x87875f,
+ 102: 0x878787,
+ 103: 0x8787af,
+ 104: 0x8787d7,
+ 105: 0x8787ff,
+ 106: 0x87af00,
+ 107: 0x87af5f,
+ 108: 0x87af87,
+ 109: 0x87afaf,
+ 110: 0x87afd7,
+ 111: 0x87afff,
+ 112: 0x87d700,
+ 113: 0x87d75f,
+ 114: 0x87d787,
+ 115: 0x87d7af,
+ 116: 0x87d7d7,
+ 117: 0x87d7ff,
+ 118: 0x87ff00,
+ 119: 0x87ff5f,
+ 120: 0x87ff87,
+ 121: 0x87ffaf,
+ 122: 0x87ffd7,
+ 123: 0x87ffff,
+ 124: 0xaf0000,
+ 125: 0xaf005f,
+ 126: 0xaf0087,
+ 127: 0xaf00af,
+ 128: 0xaf00d7,
+ 129: 0xaf00ff,
+ 130: 0xaf5f00,
+ 131: 0xaf5f5f,
+ 132: 0xaf5f87,
+ 133: 0xaf5faf,
+ 134: 0xaf5fd7,
+ 135: 0xaf5fff,
+ 136: 0xaf8700,
+ 137: 0xaf875f,
+ 138: 0xaf8787,
+ 139: 0xaf87af,
+ 140: 0xaf87d7,
+ 141: 0xaf87ff,
+ 142: 0xafaf00,
+ 143: 0xafaf5f,
+ 144: 0xafaf87,
+ 145: 0xafafaf,
+ 146: 0xafafd7,
+ 147: 0xafafff,
+ 148: 0xafd700,
+ 149: 0xafd75f,
+ 150: 0xafd787,
+ 151: 0xafd7af,
+ 152: 0xafd7d7,
+ 153: 0xafd7ff,
+ 154: 0xafff00,
+ 155: 0xafff5f,
+ 156: 0xafff87,
+ 157: 0xafffaf,
+ 158: 0xafffd7,
+ 159: 0xafffff,
+ 160: 0xd70000,
+ 161: 0xd7005f,
+ 162: 0xd70087,
+ 163: 0xd700af,
+ 164: 0xd700d7,
+ 165: 0xd700ff,
+ 166: 0xd75f00,
+ 167: 0xd75f5f,
+ 168: 0xd75f87,
+ 169: 0xd75faf,
+ 170: 0xd75fd7,
+ 171: 0xd75fff,
+ 172: 0xd78700,
+ 173: 0xd7875f,
+ 174: 0xd78787,
+ 175: 0xd787af,
+ 176: 0xd787d7,
+ 177: 0xd787ff,
+ 178: 0xd7af00,
+ 179: 0xd7af5f,
+ 180: 0xd7af87,
+ 181: 0xd7afaf,
+ 182: 0xd7afd7,
+ 183: 0xd7afff,
+ 184: 0xd7d700,
+ 185: 0xd7d75f,
+ 186: 0xd7d787,
+ 187: 0xd7d7af,
+ 188: 0xd7d7d7,
+ 189: 0xd7d7ff,
+ 190: 0xd7ff00,
+ 191: 0xd7ff5f,
+ 192: 0xd7ff87,
+ 193: 0xd7ffaf,
+ 194: 0xd7ffd7,
+ 195: 0xd7ffff,
+ 196: 0xff0000,
+ 197: 0xff005f,
+ 198: 0xff0087,
+ 199: 0xff00af,
+ 200: 0xff00d7,
+ 201: 0xff00ff,
+ 202: 0xff5f00,
+ 203: 0xff5f5f,
+ 204: 0xff5f87,
+ 205: 0xff5faf,
+ 206: 0xff5fd7,
+ 207: 0xff5fff,
+ 208: 0xff8700,
+ 209: 0xff875f,
+ 210: 0xff8787,
+ 211: 0xff87af,
+ 212: 0xff87d7,
+ 213: 0xff87ff,
+ 214: 0xffaf00,
+ 215: 0xffaf5f,
+ 216: 0xffaf87,
+ 217: 0xffafaf,
+ 218: 0xffafd7,
+ 219: 0xffafff,
+ 220: 0xffd700,
+ 221: 0xffd75f,
+ 222: 0xffd787,
+ 223: 0xffd7af,
+ 224: 0xffd7d7,
+ 225: 0xffd7ff,
+ 226: 0xffff00,
+ 227: 0xffff5f,
+ 228: 0xffff87,
+ 229: 0xffffaf,
+ 230: 0xffffd7,
+ 231: 0xffffff,
+ 232: 0x080808,
+ 233: 0x121212,
+ 234: 0x1c1c1c,
+ 235: 0x262626,
+ 236: 0x303030,
+ 237: 0x3a3a3a,
+ 238: 0x444444,
+ 239: 0x4e4e4e,
+ 240: 0x585858,
+ 241: 0x626262,
+ 242: 0x6c6c6c,
+ 243: 0x767676,
+ 244: 0x808080,
+ 245: 0x8a8a8a,
+ 246: 0x949494,
+ 247: 0x9e9e9e,
+ 248: 0xa8a8a8,
+ 249: 0xb2b2b2,
+ 250: 0xbcbcbc,
+ 251: 0xc6c6c6,
+ 252: 0xd0d0d0,
+ 253: 0xdadada,
+ 254: 0xe4e4e4,
+ 255: 0xeeeeee,
+}
+
+func (w *Writer) Write(data []byte) (n int, err error) {
+ var csbi consoleScreenBufferInfo
+ procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+
+ er := bytes.NewBuffer(data)
+loop:
+ for {
+ r1, _, err := procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+ if r1 == 0 {
+ break loop
+ }
+
+ c1, _, err := er.ReadRune()
+ if err != nil {
+ break loop
+ }
+ if c1 != 0x1b {
+ fmt.Fprint(w.out, string(c1))
+ continue
+ }
+ c2, _, err := er.ReadRune()
+ if err != nil {
+ w.lastbuf.WriteRune(c1)
+ break loop
+ }
+ if c2 != 0x5b {
+ w.lastbuf.WriteRune(c1)
+ w.lastbuf.WriteRune(c2)
+ continue
+ }
+
+ var buf bytes.Buffer
+ var m rune
+ for {
+ c, _, err := er.ReadRune()
+ if err != nil {
+ w.lastbuf.WriteRune(c1)
+ w.lastbuf.WriteRune(c2)
+ w.lastbuf.Write(buf.Bytes())
+ break loop
+ }
+ if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '@' {
+ m = c
+ break
+ }
+ buf.Write([]byte(string(c)))
+ }
+
+ switch m {
+ case 'm':
+ attr := csbi.attributes
+ cs := buf.String()
+ if cs == "" {
+ procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(w.oldattr))
+ continue
+ }
+ token := strings.Split(cs, ";")
+ for i, ns := range token {
+ if n, err = strconv.Atoi(ns); err == nil {
+ switch {
+ case n == 0 || n == 100:
+ attr = w.oldattr
+ case 1 <= n && n <= 5:
+ attr |= foregroundIntensity
+ case n == 7:
+ attr = ((attr & foregroundMask) << 4) | ((attr & backgroundMask) >> 4)
+ case 22 == n || n == 25 || n == 25:
+ attr |= foregroundIntensity
+ case n == 27:
+ attr = ((attr & foregroundMask) << 4) | ((attr & backgroundMask) >> 4)
+ case 30 <= n && n <= 37:
+ attr = (attr & backgroundMask)
+ if (n-30)&1 != 0 {
+ attr |= foregroundRed
+ }
+ if (n-30)&2 != 0 {
+ attr |= foregroundGreen
+ }
+ if (n-30)&4 != 0 {
+ attr |= foregroundBlue
+ }
+ case n == 38: // set foreground color.
+ if i < len(token)-2 && token[i+1] == "5" {
+ if n256, err := strconv.Atoi(token[i+2]); err == nil {
+ if n256foreAttr == nil {
+ n256setup()
+ }
+ attr &= backgroundMask
+ attr |= n256foreAttr[n256]
+ i += 2
+ }
+ } else {
+ attr = attr & (w.oldattr & backgroundMask)
+ }
+ case n == 39: // reset foreground color.
+ attr &= backgroundMask
+ attr |= w.oldattr & foregroundMask
+ case 40 <= n && n <= 47:
+ attr = (attr & foregroundMask)
+ if (n-40)&1 != 0 {
+ attr |= backgroundRed
+ }
+ if (n-40)&2 != 0 {
+ attr |= backgroundGreen
+ }
+ if (n-40)&4 != 0 {
+ attr |= backgroundBlue
+ }
+ case n == 48: // set background color.
+ if i < len(token)-2 && token[i+1] == "5" {
+ if n256, err := strconv.Atoi(token[i+2]); err == nil {
+ if n256backAttr == nil {
+ n256setup()
+ }
+ attr &= foregroundMask
+ attr |= n256backAttr[n256]
+ i += 2
+ }
+ } else {
+ attr = attr & (w.oldattr & foregroundMask)
+ }
+ case n == 49: // reset foreground color.
+ attr &= foregroundMask
+ attr |= w.oldattr & backgroundMask
+ }
+ procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(attr))
+ }
+ }
+ }
+ }
+ return len(data) - w.lastbuf.Len(), nil
+}
+
+type consoleColor struct {
+ red bool
+ green bool
+ blue bool
+ intensity bool
+}
+
+func minmax3(a, b, c int) (min, max int) {
+ if a < b {
+ if b < c {
+ return a, c
+ } else if a < c {
+ return a, b
+ } else {
+ return c, b
+ }
+ } else {
+ if a < c {
+ return b, c
+ } else if b < c {
+ return b, a
+ } else {
+ return c, a
+ }
+ }
+}
+
+func toConsoleColor(rgb int) (c consoleColor) {
+ r, g, b := (rgb&0xFF0000)>>16, (rgb&0x00FF00)>>8, rgb&0x0000FF
+ min, max := minmax3(r, g, b)
+ a := (min + max) / 2
+ if r < 128 && g < 128 && b < 128 {
+ if r >= a {
+ c.red = true
+ }
+ if g >= a {
+ c.green = true
+ }
+ if b >= a {
+ c.blue = true
+ }
+ // non-intensed white is lighter than intensed black, so swap those.
+ if c.red && c.green && c.blue {
+ c.red, c.green, c.blue = false, false, false
+ c.intensity = true
+ }
+ } else {
+ if min < 128 {
+ min = 128
+ a = (min + max) / 2
+ }
+ if r >= a {
+ c.red = true
+ }
+ if g >= a {
+ c.green = true
+ }
+ if b >= a {
+ c.blue = true
+ }
+ c.intensity = true
+ // intensed black is darker than non-intensed white, so swap those.
+ if !c.red && !c.green && !c.blue {
+ c.red, c.green, c.blue = true, true, true
+ c.intensity = false
+ }
+ }
+ return c
+}
+
+func (c consoleColor) foregroundAttr() (attr word) {
+ if c.red {
+ attr |= foregroundRed
+ }
+ if c.green {
+ attr |= foregroundGreen
+ }
+ if c.blue {
+ attr |= foregroundBlue
+ }
+ if c.intensity {
+ attr |= foregroundIntensity
+ }
+ return
+}
+
+func (c consoleColor) backgroundAttr() (attr word) {
+ if c.red {
+ attr |= backgroundRed
+ }
+ if c.green {
+ attr |= backgroundGreen
+ }
+ if c.blue {
+ attr |= backgroundBlue
+ }
+ if c.intensity {
+ attr |= backgroundIntensity
+ }
+ return
+}
+
+var n256foreAttr []word
+var n256backAttr []word
+
+func n256setup() {
+ n256foreAttr = make([]word, 256)
+ n256backAttr = make([]word, 256)
+ for i, rgb := range color256 {
+ c := toConsoleColor(rgb)
+ n256foreAttr[i] = c.foregroundAttr()
+ n256backAttr[i] = c.backgroundAttr()
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/naoina/go-stringutil/.travis.yml b/Godeps/_workspace/src/github.com/naoina/go-stringutil/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..926eb992aca6aba4b03bc24ab88616d6578ebc71
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/go-stringutil/.travis.yml
@@ -0,0 +1,9 @@
+language: go
+go:
+ - 1.3
+ - 1.4
+ - tip
+install:
+ - go get -v github.com/naoina/go-stringutil
+script:
+ - go test -v ./... -bench . -benchmem
diff --git a/Godeps/_workspace/src/github.com/naoina/go-stringutil/LICENSE b/Godeps/_workspace/src/github.com/naoina/go-stringutil/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..0fff1c58b73aef84e064877b5239b50c6edc6915
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/go-stringutil/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2015 Naoya Inada <naoina@kuune.org>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/Godeps/_workspace/src/github.com/naoina/go-stringutil/README.md b/Godeps/_workspace/src/github.com/naoina/go-stringutil/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..87772e88d9c2827c9e5e7513ec4935f5f40327d2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/go-stringutil/README.md
@@ -0,0 +1,13 @@
+# stringutil [](https://travis-ci.org/naoina/go-stringutil)
+
+## Installation
+
+ go get -u github.com/naoina/go-stringutil
+
+## Documentation
+
+See https://godoc.org/github.com/naoina/go-stringutil
+
+## License
+
+MIT
diff --git a/Godeps/_workspace/src/github.com/naoina/go-stringutil/strings.go b/Godeps/_workspace/src/github.com/naoina/go-stringutil/strings.go
new file mode 100644
index 0000000000000000000000000000000000000000..c0fdd4cc197724bc7be65939e91982c76efa95d6
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/go-stringutil/strings.go
@@ -0,0 +1,120 @@
+package stringutil
+
+import (
+ "bytes"
+ "unicode"
+)
+
+// ToUpperCamelCase returns a copy of the string s with all Unicode letters mapped to their camel case.
+// It will convert to upper case previous letter of '_' and first letter, and remove letter of '_'.
+func ToUpperCamelCase(s string) string {
+ if s == "" {
+ return ""
+ }
+ upper := true
+ var result bytes.Buffer
+ for _, c := range s {
+ if c == '_' {
+ upper = true
+ continue
+ }
+ if upper {
+ result.WriteRune(unicode.ToUpper(c))
+ upper = false
+ continue
+ }
+ result.WriteRune(c)
+ }
+ return result.String()
+}
+
+// ToUpperCamelCaseASCII is similar to ToUpperCamelCase, but optimized for
+// only the ASCII characters.
+// ToUpperCamelCaseASCII is faster than ToUpperCamelCase, but doesn't work if
+// contains non-ASCII characters.
+func ToUpperCamelCaseASCII(s string) string {
+ if s == "" {
+ return ""
+ }
+ upper := true
+ result := make([]byte, 0, len(s))
+ for i := 0; i < len(s); i++ {
+ c := s[i]
+ if c == '_' {
+ upper = true
+ continue
+ }
+ if upper {
+ result = append(result, toUpperASCII(c))
+ upper = false
+ continue
+ }
+ result = append(result, c)
+ }
+ return string(result)
+}
+
+// ToSnakeCase returns a copy of the string s with all Unicode letters mapped to their snake case.
+// It will insert letter of '_' at position of previous letter of uppercase and all
+// letters convert to lower case.
+func ToSnakeCase(s string) string {
+ if s == "" {
+ return ""
+ }
+ var result bytes.Buffer
+ for _, c := range s {
+ if unicode.IsUpper(c) {
+ result.WriteByte('_')
+ }
+ result.WriteRune(unicode.ToLower(c))
+ }
+ s = result.String()
+ if s[0] == '_' {
+ return s[1:]
+ }
+ return s
+}
+
+// ToSnakeCaseASCII is similar to ToSnakeCase, but optimized for only the ASCII
+// characters.
+// ToSnakeCaseASCII is faster than ToSnakeCase, but doesn't work correctly if
+// contains non-ASCII characters.
+func ToSnakeCaseASCII(s string) string {
+ if s == "" {
+ return ""
+ }
+ result := make([]byte, 0, len(s))
+ for i := 0; i < len(s); i++ {
+ c := s[i]
+ if isUpperASCII(c) {
+ result = append(result, '_')
+ }
+ result = append(result, toLowerASCII(c))
+ }
+ if result[0] == '_' {
+ return string(result[1:])
+ }
+ return string(result)
+}
+
+func isUpperASCII(c byte) bool {
+ return 'A' <= c && c <= 'Z'
+}
+
+func isLowerASCII(c byte) bool {
+ return 'a' <= c && c <= 'z'
+}
+
+func toUpperASCII(c byte) byte {
+ if isLowerASCII(c) {
+ return c - ('a' - 'A')
+ }
+ return c
+}
+
+func toLowerASCII(c byte) byte {
+ if isUpperASCII(c) {
+ return c + 'a' - 'A'
+ }
+ return c
+}
diff --git a/Godeps/_workspace/src/github.com/naoina/go-stringutil/strings_bench_test.go b/Godeps/_workspace/src/github.com/naoina/go-stringutil/strings_bench_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..9e9dbc45133be54bae72d4c567d91b5624d9bc46
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/go-stringutil/strings_bench_test.go
@@ -0,0 +1,35 @@
+package stringutil_test
+
+import (
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/naoina/go-stringutil"
+)
+
+var benchcaseForCamelCase = "the_quick_brown_fox_jumps_over_the_lazy_dog"
+
+func BenchmarkToUpperCamelCase(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ stringutil.ToUpperCamelCase(benchcaseForCamelCase)
+ }
+}
+
+func BenchmarkToUpperCamelCaseASCII(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ stringutil.ToUpperCamelCaseASCII(benchcaseForCamelCase)
+ }
+}
+
+var benchcaseForSnakeCase = "TheQuickBrownFoxJumpsOverTheLazyDog"
+
+func BenchmarkToSnakeCase(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ stringutil.ToSnakeCase(benchcaseForSnakeCase)
+ }
+}
+
+func BenchmarkToSnakeCaseASCII(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ stringutil.ToSnakeCaseASCII(benchcaseForSnakeCase)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/naoina/go-stringutil/strings_test.go b/Godeps/_workspace/src/github.com/naoina/go-stringutil/strings_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..89384c2c0b3c822d4868f1092507b1cc72c57862
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/go-stringutil/strings_test.go
@@ -0,0 +1,88 @@
+package stringutil_test
+
+import (
+ "reflect"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/naoina/go-stringutil"
+)
+
+func TestToUpperCamelCase(t *testing.T) {
+ for _, v := range []struct {
+ input, expect string
+ }{
+ {"", ""},
+ {"thequickbrownfoxoverthelazydog", "Thequickbrownfoxoverthelazydog"},
+ {"thequickbrownfoxoverthelazydoG", "ThequickbrownfoxoverthelazydoG"},
+ {"thequickbrownfoxoverthelazydo_g", "ThequickbrownfoxoverthelazydoG"},
+ {"TheQuickBrownFoxJumpsOverTheLazyDog", "TheQuickBrownFoxJumpsOverTheLazyDog"},
+ {"the_quick_brown_fox_jumps_over_the_lazy_dog", "TheQuickBrownFoxJumpsOverTheLazyDog"},
+ {"the_Quick_Brown_Fox_Jumps_Over_The_Lazy_Dog", "TheQuickBrownFoxJumpsOverTheLazyDog"},
+ {"ｔｈｅ_ｑｕｉｃｋ_ｂｒï½ï½—ｎ_ｆï½ï½˜_ï½ï½–ï½…ï½’_ｔｈｅ_ｌï½ï½šï½™_ｄï½ï½‡", "ＴｈｅＱｕｉｃｋＢｒï½ï½—ｎＦï½ï½˜ï¼¯ï½–ｅｒＴｈｅＬï½ï½šï½™ï¼¤ï½ï½‡"},
+ } {
+ actual := stringutil.ToUpperCamelCase(v.input)
+ expect := v.expect
+ if !reflect.DeepEqual(actual, expect) {
+ t.Errorf(`stringutil.ToUpperCamelCase(%#v) => %#v; want %#v`, v.input, actual, expect)
+ }
+ }
+}
+
+func TestToUpperCamelCaseASCII(t *testing.T) {
+ for _, v := range []struct {
+ input, expect string
+ }{
+ {"", ""},
+ {"thequickbrownfoxoverthelazydog", "Thequickbrownfoxoverthelazydog"},
+ {"thequickbrownfoxoverthelazydoG", "ThequickbrownfoxoverthelazydoG"},
+ {"thequickbrownfoxoverthelazydo_g", "ThequickbrownfoxoverthelazydoG"},
+ {"TheQuickBrownFoxJumpsOverTheLazyDog", "TheQuickBrownFoxJumpsOverTheLazyDog"},
+ {"the_quick_brown_fox_jumps_over_the_lazy_dog", "TheQuickBrownFoxJumpsOverTheLazyDog"},
+ {"the_Quick_Brown_Fox_Jumps_Over_The_Lazy_Dog", "TheQuickBrownFoxJumpsOverTheLazyDog"},
+ } {
+ actual := stringutil.ToUpperCamelCaseASCII(v.input)
+ expect := v.expect
+ if !reflect.DeepEqual(actual, expect) {
+ t.Errorf(`stringutil.ToUpperCamelCaseASCII(%#v) => %#v; want %#v`, v.input, actual, expect)
+ }
+ }
+}
+
+func TestToSnakeCase(t *testing.T) {
+ for _, v := range []struct {
+ input, expect string
+ }{
+ {"", ""},
+ {"thequickbrownfoxjumpsoverthelazydog", "thequickbrownfoxjumpsoverthelazydog"},
+ {"Thequickbrownfoxjumpsoverthelazydog", "thequickbrownfoxjumpsoverthelazydog"},
+ {"ThequickbrownfoxjumpsoverthelazydoG", "thequickbrownfoxjumpsoverthelazydo_g"},
+ {"TheQuickBrownFoxJumpsOverTheLazyDog", "the_quick_brown_fox_jumps_over_the_lazy_dog"},
+ {"the_quick_brown_fox_jumps_over_the_lazy_dog", "the_quick_brown_fox_jumps_over_the_lazy_dog"},
+ {"ＴｈｅＱｕｉｃｋＢｒï½ï½—ｎＦï½ï½˜ï¼¯ï½–ｅｒＴｈｅＬï½ï½šï½™ï¼¤ï½ï½‡", "ｔｈｅ_ｑｕｉｃｋ_ｂｒï½ï½—ｎ_ｆï½ï½˜_ï½ï½–ï½…ï½’_ｔｈｅ_ｌï½ï½šï½™_ｄï½ï½‡"},
+ } {
+ actual := stringutil.ToSnakeCase(v.input)
+ expect := v.expect
+ if !reflect.DeepEqual(actual, expect) {
+ t.Errorf(`stringutil.ToSnakeCase(%#v) => %#v; want %#v`, v.input, actual, expect)
+ }
+ }
+}
+
+func TestToSnakeCaseASCII(t *testing.T) {
+ for _, v := range []struct {
+ input, expect string
+ }{
+ {"", ""},
+ {"thequickbrownfoxjumpsoverthelazydog", "thequickbrownfoxjumpsoverthelazydog"},
+ {"Thequickbrownfoxjumpsoverthelazydog", "thequickbrownfoxjumpsoverthelazydog"},
+ {"ThequickbrownfoxjumpsoverthelazydoG", "thequickbrownfoxjumpsoverthelazydo_g"},
+ {"TheQuickBrownFoxJumpsOverTheLazyDog", "the_quick_brown_fox_jumps_over_the_lazy_dog"},
+ {"the_quick_brown_fox_jumps_over_the_lazy_dog", "the_quick_brown_fox_jumps_over_the_lazy_dog"},
+ } {
+ actual := stringutil.ToSnakeCaseASCII(v.input)
+ expect := v.expect
+ if !reflect.DeepEqual(actual, expect) {
+ t.Errorf(`stringutil.ToSnakeCaseASCII(%#v) => %#v; want %#v`, v.input, actual, expect)
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/naoina/toml/.travis.yml b/Godeps/_workspace/src/github.com/naoina/toml/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..6bd7b6df3f7c082a60ab5d38e07f6e198ba5ae89
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/toml/.travis.yml
@@ -0,0 +1,11 @@
+language: go
+
+go:
+ - 1.3
+ - tip
+
+install:
+ - go get -v ./...
+
+script:
+ - go test ./...
diff --git a/Godeps/_workspace/src/github.com/naoina/toml/LICENSE b/Godeps/_workspace/src/github.com/naoina/toml/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..e65039ad84caf7d877a3348978af448cbffbbf4c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/toml/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2014 Naoya Inada <naoina@kuune.org>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/Godeps/_workspace/src/github.com/naoina/toml/Makefile b/Godeps/_workspace/src/github.com/naoina/toml/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..10dc5a553d75f28b364f955a2c2f5f47f9bb357e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/toml/Makefile
@@ -0,0 +1,16 @@
+GO = go
+PEG = peg
+
+.SUFFIXES: .peg .peg.go
+
+.PHONY: all test clean
+all: parse.peg.go
+
+.peg.peg.go:
+ $(PEG) -switch -inline $<
+
+test: all
+ $(GO) test ./...
+
+clean:
+ $(RM) *.peg.go
diff --git a/Godeps/_workspace/src/github.com/naoina/toml/README.md b/Godeps/_workspace/src/github.com/naoina/toml/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..7330ce4d01721ce5b404963a48c62cf1a83a6358
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/toml/README.md
@@ -0,0 +1,364 @@
+# TOML parser and encoder library for Golang [](https://travis-ci.org/naoina/toml)
+
+[TOML](https://github.com/toml-lang/toml) parser and encoder library for [Golang](http://golang.org/).
+
+This library is compatible with TOML version [v0.4.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md).
+
+## Installation
+
+ go get -u github.com/naoina/toml
+
+## Usage
+
+The following TOML save as `example.toml`.
+
+```toml
+# This is a TOML document. Boom.
+
+title = "TOML Example"
+
+[owner]
+name = "Lance Uppercut"
+dob = 1979-05-27T07:32:00-08:00 # First class dates? Why not?
+
+[database]
+server = "192.168.1.1"
+ports = [ 8001, 8001, 8002 ]
+connection_max = 5000
+enabled = true
+
+[servers]
+
+ # You can indent as you please. Tabs or spaces. TOML don't care.
+ [servers.alpha]
+ ip = "10.0.0.1"
+ dc = "eqdc10"
+
+ [servers.beta]
+ ip = "10.0.0.2"
+ dc = "eqdc10"
+
+[clients]
+data = [ ["gamma", "delta"], [1, 2] ]
+
+# Line breaks are OK when inside arrays
+hosts = [
+ "alpha",
+ "omega"
+]
+```
+
+Then above TOML will mapping to `tomlConfig` struct using `toml.Unmarshal`.
+
+```go
+package main
+
+import (
+ "io/ioutil"
+ "os"
+ "time"
+
+ "github.com/naoina/toml"
+)
+
+type tomlConfig struct {
+ Title string
+ Owner struct {
+ Name string
+ Dob time.Time
+ }
+ Database struct {
+ Server string
+ Ports []int
+ ConnectionMax uint
+ Enabled bool
+ }
+ Servers map[string]Server
+ Clients struct {
+ Data [][]interface{}
+ Hosts []string
+ }
+}
+
+type Server struct {
+ IP string
+ DC string
+}
+
+func main() {
+ f, err := os.Open("example.toml")
+ if err != nil {
+ panic(err)
+ }
+ defer f.Close()
+ buf, err := ioutil.ReadAll(f)
+ if err != nil {
+ panic(err)
+ }
+ var config tomlConfig
+ if err := toml.Unmarshal(buf, &config); err != nil {
+ panic(err)
+ }
+ // then to use the unmarshaled config...
+}
+```
+
+## Mappings
+
+A key and value of TOML will map to the corresponding field.
+The fields of struct for mapping must be exported.
+
+The rules of the mapping of key are following:
+
+#### Exact matching
+
+```toml
+timeout_seconds = 256
+```
+
+```go
+type Config struct {
+ Timeout_seconds int
+}
+```
+
+#### Camelcase matching
+
+```toml
+server_name = "srv1"
+```
+
+```go
+type Config struct {
+ ServerName string
+}
+```
+
+#### Uppercase matching
+
+```toml
+ip = "10.0.0.1"
+```
+
+```go
+type Config struct {
+ IP string
+}
+```
+
+See the following examples for the value mappings.
+
+### String
+
+```toml
+val = "string"
+```
+
+```go
+type Config struct {
+ Val string
+}
+```
+
+### Integer
+
+```toml
+val = 100
+```
+
+```go
+type Config struct {
+ Val int
+}
+```
+
+All types that can be used are following:
+
+* int8 (from `-128` to `127`)
+* int16 (from `-32768` to `32767`)
+* int32 (from `-2147483648` to `2147483647`)
+* int64 (from `-9223372036854775808` to `9223372036854775807`)
+* int (same as `int32` on 32bit environment, or `int64` on 64bit environment)
+* uint8 (from `0` to `255`)
+* uint16 (from `0` to `65535`)
+* uint32 (from `0` to `4294967295`)
+* uint64 (from `0` to `18446744073709551615`)
+* uint (same as `uint` on 32bit environment, or `uint64` on 64bit environment)
+
+### Float
+
+```toml
+val = 3.1415
+```
+
+```go
+type Config struct {
+ Val float32
+}
+```
+
+All types that can be used are following:
+
+* float32
+* float64
+
+### Boolean
+
+```toml
+val = true
+```
+
+```go
+type Config struct {
+ Val bool
+}
+```
+
+### Datetime
+
+```toml
+val = 2014-09-28T21:27:39Z
+```
+
+```go
+type Config struct {
+ Val time.Time
+}
+```
+
+### Array
+
+```toml
+val = ["a", "b", "c"]
+```
+
+```go
+type Config struct {
+ Val []string
+}
+```
+
+Also following examples all can be mapped:
+
+```toml
+val1 = [1, 2, 3]
+val2 = [["a", "b"], ["c", "d"]]
+val3 = [[1, 2, 3], ["a", "b", "c"]]
+val4 = [[1, 2, 3], [["a", "b"], [true, false]]]
+```
+
+```go
+type Config struct {
+ Val1 []int
+ Val2 [][]string
+ Val3 [][]interface{}
+ Val4 [][]interface{}
+}
+```
+
+### Table
+
+```toml
+[server]
+type = "app"
+
+ [server.development]
+ ip = "10.0.0.1"
+
+ [server.production]
+ ip = "10.0.0.2"
+```
+
+```go
+type Config struct {
+ Server map[string]Server
+}
+
+type Server struct {
+ IP string
+}
+```
+
+You can also use the following struct instead of map of struct.
+
+```go
+type Config struct {
+ Server struct {
+ Development Server
+ Production Server
+ }
+}
+
+type Server struct {
+ IP string
+}
+```
+
+### Array of Tables
+
+```toml
+[[fruit]]
+ name = "apple"
+
+ [fruit.physical]
+ color = "red"
+ shape = "round"
+
+ [[fruit.variety]]
+ name = "red delicious"
+
+ [[fruit.variety]]
+ name = "granny smith"
+
+[[fruit]]
+ name = "banana"
+
+ [[fruit.variety]]
+ name = "plantain"
+```
+
+```go
+type Config struct {
+ Fruit []struct {
+ Name string
+ Physical struct {
+ Color string
+ Shape string
+ }
+ Variety []struct {
+ Name string
+ }
+ }
+}
+```
+
+### Using `toml.UnmarshalTOML` interface
+
+```toml
+duration = "10s"
+```
+
+```go
+import time
+
+type Config struct {
+ Duration Duration
+}
+
+type Duration struct {
+ time.Duration
+}
+
+func (d *Duration) UnmarshalTOML(data []byte) error {
+ d.Duration, err := time.ParseDuration(string(data))
+ return err
+}
+```
+
+## API documentation
+
+See [Godoc](http://godoc.org/github.com/naoina/toml).
+
+## License
+
+MIT
diff --git a/Godeps/_workspace/src/github.com/naoina/toml/ast/ast.go b/Godeps/_workspace/src/github.com/naoina/toml/ast/ast.go
new file mode 100644
index 0000000000000000000000000000000000000000..68bb0ee15916eda34b803b4776b8e45f520a3e97
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/toml/ast/ast.go
@@ -0,0 +1,184 @@
+package ast
+
+import (
+ "strconv"
+ "time"
+)
+
+type Position struct {
+ Begin int
+ End int
+}
+
+type Value interface {
+ Pos() int
+ End() int
+ Source() string
+}
+
+type String struct {
+ Position Position
+ Value string
+ Data []rune
+}
+
+func (s *String) Pos() int {
+ return s.Position.Begin
+}
+
+func (s *String) End() int {
+ return s.Position.End
+}
+
+func (s *String) Source() string {
+ return string(s.Data)
+}
+
+type Integer struct {
+ Position Position
+ Value string
+ Data []rune
+}
+
+func (i *Integer) Pos() int {
+ return i.Position.Begin
+}
+
+func (i *Integer) End() int {
+ return i.Position.End
+}
+
+func (i *Integer) Source() string {
+ return string(i.Data)
+}
+
+func (i *Integer) Int() (int64, error) {
+ return strconv.ParseInt(i.Value, 10, 64)
+}
+
+type Float struct {
+ Position Position
+ Value string
+ Data []rune
+}
+
+func (f *Float) Pos() int {
+ return f.Position.Begin
+}
+
+func (f *Float) End() int {
+ return f.Position.End
+}
+
+func (f *Float) Source() string {
+ return string(f.Data)
+}
+
+func (f *Float) Float() (float64, error) {
+ return strconv.ParseFloat(f.Value, 64)
+}
+
+type Boolean struct {
+ Position Position
+ Value string
+ Data []rune
+}
+
+func (b *Boolean) Pos() int {
+ return b.Position.Begin
+}
+
+func (b *Boolean) End() int {
+ return b.Position.End
+}
+
+func (b *Boolean) Source() string {
+ return string(b.Data)
+}
+
+func (b *Boolean) Boolean() (bool, error) {
+ return strconv.ParseBool(b.Value)
+}
+
+type Datetime struct {
+ Position Position
+ Value string
+ Data []rune
+}
+
+func (d *Datetime) Pos() int {
+ return d.Position.Begin
+}
+
+func (d *Datetime) End() int {
+ return d.Position.End
+}
+
+func (d *Datetime) Source() string {
+ return string(d.Data)
+}
+
+func (d *Datetime) Time() (time.Time, error) {
+ return time.Parse(time.RFC3339Nano, d.Value)
+}
+
+type Array struct {
+ Position Position
+ Value []Value
+ Data []rune
+}
+
+func (a *Array) Pos() int {
+ return a.Position.Begin
+}
+
+func (a *Array) End() int {
+ return a.Position.End
+}
+
+func (a *Array) Source() string {
+ return string(a.Data)
+}
+
+type TableType uint8
+
+const (
+ TableTypeNormal TableType = iota
+ TableTypeArray
+)
+
+var tableTypes = [...]string{
+ "normal",
+ "array",
+}
+
+func (t TableType) String() string {
+ return tableTypes[t]
+}
+
+type Table struct {
+ Position Position
+ Line int
+ Name string
+ Fields map[string]interface{}
+ Type TableType
+ Data []rune
+}
+
+func (t *Table) Pos() int {
+ return t.Position.Begin
+}
+
+func (t *Table) End() int {
+ return t.Position.End
+}
+
+func (t *Table) Source() string {
+ return string(t.Data)
+}
+
+type KeyValue struct {
+ Key string
+ Value Value
+ Line int
+}
diff --git a/Godeps/_workspace/src/github.com/naoina/toml/decode.go b/Godeps/_workspace/src/github.com/naoina/toml/decode.go
new file mode 100644
index 0000000000000000000000000000000000000000..4bc86a4e47eedcc4d4e7db680c5f1a308f3bd1ec
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/toml/decode.go
@@ -0,0 +1,649 @@
+package toml
+
+import (
+ "fmt"
+ "reflect"
+ "strconv"
+ "strings"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/naoina/toml/ast"
+)
+
+const (
+ tableSeparator = '.'
+)
+
+var (
+ escapeReplacer = strings.NewReplacer(
+ "\b", "\\n",
+ "\f", "\\f",
+ "\n", "\\n",
+ "\r", "\\r",
+ "\t", "\\t",
+ )
+ underscoreReplacer = strings.NewReplacer(
+ "_", "",
+ )
+)
+
+// Unmarshal parses the TOML data and stores the result in the value pointed to by v.
+//
+// Unmarshal will mapped to v that according to following rules:
+//
+// TOML strings to string
+// TOML integers to any int type
+// TOML floats to float32 or float64
+// TOML booleans to bool
+// TOML datetimes to time.Time
+// TOML arrays to any type of slice or []interface{}
+// TOML tables to struct
+// TOML array of tables to slice of struct
+func Unmarshal(data []byte, v interface{}) error {
+ table, err := Parse(data)
+ if err != nil {
+ return err
+ }
+ if err := UnmarshalTable(table, v); err != nil {
+ return fmt.Errorf("toml: unmarshal: %v", err)
+ }
+ return nil
+}
+
+// Unmarshaler is the interface implemented by objects that can unmarshal a
+// TOML description of themselves.
+// The input can be assumed to be a valid encoding of a TOML value.
+// UnmarshalJSON must copy the TOML data if it wishes to retain the data after
+// returning.
+type Unmarshaler interface {
+ UnmarshalTOML([]byte) error
+}
+
+// UnmarshalTable applies the contents of an ast.Table to the value pointed at by v.
+//
+// UnmarshalTable will mapped to v that according to following rules:
+//
+// TOML strings to string
+// TOML integers to any int type
+// TOML floats to float32 or float64
+// TOML booleans to bool
+// TOML datetimes to time.Time
+// TOML arrays to any type of slice or []interface{}
+// TOML tables to struct
+// TOML array of tables to slice of struct
+func UnmarshalTable(t *ast.Table, v interface{}) (err error) {
+ if v == nil {
+ return fmt.Errorf("v must not be nil")
+ }
+ rv := reflect.ValueOf(v)
+ if kind := rv.Kind(); kind != reflect.Ptr && kind != reflect.Map {
+ return fmt.Errorf("v must be a pointer or map")
+ }
+ for rv.Kind() == reflect.Ptr {
+ rv = rv.Elem()
+ }
+ for key, val := range t.Fields {
+ switch av := val.(type) {
+ case *ast.KeyValue:
+ fv, fieldName, found := findField(rv, key)
+ if !found {
+ return fmt.Errorf("line %d: field corresponding to `%s' is not defined in `%T'", av.Line, key, v)
+ }
+ switch fv.Kind() {
+ case reflect.Map:
+ mv := reflect.New(fv.Type().Elem()).Elem()
+ if err := UnmarshalTable(t, mv.Addr().Interface()); err != nil {
+ return err
+ }
+ fv.SetMapIndex(reflect.ValueOf(fieldName), mv)
+ default:
+ if err := setValue(fv, av.Value); err != nil {
+ return fmt.Errorf("line %d: %v.%s: %v", av.Line, rv.Type(), fieldName, err)
+ }
+ if rv.Kind() == reflect.Map {
+ rv.SetMapIndex(reflect.ValueOf(fieldName), fv)
+ }
+ }
+ case *ast.Table:
+ fv, fieldName, found := findField(rv, key)
+ if !found {
+ return fmt.Errorf("line %d: field corresponding to `%s' is not defined in `%T'", av.Line, key, v)
+ }
+ if err, ok := setUnmarshaler(fv, string(av.Data)); ok {
+ if err != nil {
+ return err
+ }
+ continue
+ }
+ for fv.Kind() == reflect.Ptr {
+ fv.Set(reflect.New(fv.Type().Elem()))
+ fv = fv.Elem()
+ }
+ switch fv.Kind() {
+ case reflect.Struct:
+ vv := reflect.New(fv.Type()).Elem()
+ if err := UnmarshalTable(av, vv.Addr().Interface()); err != nil {
+ return err
+ }
+ fv.Set(vv)
+ if rv.Kind() == reflect.Map {
+ rv.SetMapIndex(reflect.ValueOf(fieldName), fv)
+ }
+ case reflect.Map:
+ mv := reflect.MakeMap(fv.Type())
+ if err := UnmarshalTable(av, mv.Interface()); err != nil {
+ return err
+ }
+ fv.Set(mv)
+ default:
+ return fmt.Errorf("line %d: `%v.%s' must be struct or map, but %v given", av.Line, rv.Type(), fieldName, fv.Kind())
+ }
+ case []*ast.Table:
+ fv, fieldName, found := findField(rv, key)
+ if !found {
+ return fmt.Errorf("line %d: field corresponding to `%s' is not defined in `%T'", av[0].Line, key, v)
+ }
+ data := make([]string, 0, len(av))
+ for _, tbl := range av {
+ data = append(data, string(tbl.Data))
+ }
+ if err, ok := setUnmarshaler(fv, strings.Join(data, "\n")); ok {
+ if err != nil {
+ return err
+ }
+ continue
+ }
+ t := fv.Type().Elem()
+ pc := 0
+ for ; t.Kind() == reflect.Ptr; pc++ {
+ t = t.Elem()
+ }
+ if fv.Kind() != reflect.Slice {
+ return fmt.Errorf("line %d: `%v.%s' must be slice type, but %v given", av[0].Line, rv.Type(), fieldName, fv.Kind())
+ }
+ for _, tbl := range av {
+ var vv reflect.Value
+ switch t.Kind() {
+ case reflect.Map:
+ vv = reflect.MakeMap(t)
+ if err := UnmarshalTable(tbl, vv.Interface()); err != nil {
+ return err
+ }
+ default:
+ vv = reflect.New(t).Elem()
+ if err := UnmarshalTable(tbl, vv.Addr().Interface()); err != nil {
+ return err
+ }
+ }
+ for i := 0; i < pc; i++ {
+ vv = vv.Addr()
+ pv := reflect.New(vv.Type()).Elem()
+ pv.Set(vv)
+ vv = pv
+ }
+ fv.Set(reflect.Append(fv, vv))
+ }
+ if rv.Kind() == reflect.Map {
+ rv.SetMapIndex(reflect.ValueOf(fieldName), fv)
+ }
+ default:
+ return fmt.Errorf("BUG: unknown type `%T'", t)
+ }
+ }
+ return nil
+}
+
+func setUnmarshaler(lhs reflect.Value, data string) (error, bool) {
+ for lhs.Kind() == reflect.Ptr {
+ lhs.Set(reflect.New(lhs.Type().Elem()))
+ lhs = lhs.Elem()
+ }
+ if lhs.CanAddr() {
+ if u, ok := lhs.Addr().Interface().(Unmarshaler); ok {
+ return u.UnmarshalTOML([]byte(data)), true
+ }
+ }
+ return nil, false
+}
+
+func setValue(lhs reflect.Value, val ast.Value) error {
+ for lhs.Kind() == reflect.Ptr {
+ lhs.Set(reflect.New(lhs.Type().Elem()))
+ lhs = lhs.Elem()
+ }
+ if err, ok := setUnmarshaler(lhs, val.Source()); ok {
+ return err
+ }
+ switch v := val.(type) {
+ case *ast.Integer:
+ if err := setInt(lhs, v); err != nil {
+ return err
+ }
+ case *ast.Float:
+ if err := setFloat(lhs, v); err != nil {
+ return err
+ }
+ case *ast.String:
+ if err := setString(lhs, v); err != nil {
+ return err
+ }
+ case *ast.Boolean:
+ if err := setBoolean(lhs, v); err != nil {
+ return err
+ }
+ case *ast.Datetime:
+ if err := setDatetime(lhs, v); err != nil {
+ return err
+ }
+ case *ast.Array:
+ if err := setArray(lhs, v); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func setInt(fv reflect.Value, v *ast.Integer) error {
+ i, err := v.Int()
+ if err != nil {
+ return err
+ }
+ switch fv.Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ if fv.OverflowInt(i) {
+ return &errorOutOfRange{fv.Kind(), i}
+ }
+ fv.SetInt(i)
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+ fv.SetUint(uint64(i))
+ case reflect.Interface:
+ fv.Set(reflect.ValueOf(i))
+ default:
+ return fmt.Errorf("`%v' is not any types of int", fv.Type())
+ }
+ return nil
+}
+
+func setFloat(fv reflect.Value, v *ast.Float) error {
+ f, err := v.Float()
+ if err != nil {
+ return err
+ }
+ switch fv.Kind() {
+ case reflect.Float32, reflect.Float64:
+ if fv.OverflowFloat(f) {
+ return &errorOutOfRange{fv.Kind(), f}
+ }
+ fv.SetFloat(f)
+ case reflect.Interface:
+ fv.Set(reflect.ValueOf(f))
+ default:
+ return fmt.Errorf("`%v' is not float32 or float64", fv.Type())
+ }
+ return nil
+}
+
+func setString(fv reflect.Value, v *ast.String) error {
+ return set(fv, v.Value)
+}
+
+func setBoolean(fv reflect.Value, v *ast.Boolean) error {
+ b, err := v.Boolean()
+ if err != nil {
+ return err
+ }
+ return set(fv, b)
+}
+
+func setDatetime(fv reflect.Value, v *ast.Datetime) error {
+ tm, err := v.Time()
+ if err != nil {
+ return err
+ }
+ return set(fv, tm)
+}
+
+func setArray(fv reflect.Value, v *ast.Array) error {
+ if len(v.Value) == 0 {
+ return nil
+ }
+ typ := reflect.TypeOf(v.Value[0])
+ for _, vv := range v.Value[1:] {
+ if typ != reflect.TypeOf(vv) {
+ return fmt.Errorf("array cannot contain multiple types")
+ }
+ }
+ sliceType := fv.Type()
+ if fv.Kind() == reflect.Interface {
+ sliceType = reflect.SliceOf(sliceType)
+ }
+ slice := reflect.MakeSlice(sliceType, 0, len(v.Value))
+ t := sliceType.Elem()
+ for _, vv := range v.Value {
+ tmp := reflect.New(t).Elem()
+ if err := setValue(tmp, vv); err != nil {
+ return err
+ }
+ slice = reflect.Append(slice, tmp)
+ }
+ fv.Set(slice)
+ return nil
+}
+
+func set(fv reflect.Value, v interface{}) error {
+ rhs := reflect.ValueOf(v)
+ if !rhs.Type().AssignableTo(fv.Type()) {
+ return fmt.Errorf("`%v' type is not assignable to `%v' type", rhs.Type(), fv.Type())
+ }
+ fv.Set(rhs)
+ return nil
+}
+
+type stack struct {
+ key string
+ table *ast.Table
+}
+
+type toml struct {
+ table *ast.Table
+ line int
+ currentTable *ast.Table
+ s string
+ key string
+ val ast.Value
+ arr *array
+ tableMap map[string]*ast.Table
+ stack []*stack
+ skip bool
+}
+
+func (p *toml) init() {
+ p.line = 1
+ p.table = &ast.Table{
+ Line: p.line,
+ Type: ast.TableTypeNormal,
+ }
+ p.tableMap = map[string]*ast.Table{
+ "": p.table,
+ }
+ p.currentTable = p.table
+}
+
+func (p *toml) Error(err error) {
+ panic(convertError{fmt.Errorf("toml: line %d: %v", p.line, err)})
+}
+
+func (p *tomlParser) SetTime(begin, end int) {
+ p.val = &ast.Datetime{
+ Position: ast.Position{Begin: begin, End: end},
+ Data: p.buffer[begin:end],
+ Value: string(p.buffer[begin:end]),
+ }
+}
+
+func (p *tomlParser) SetFloat64(begin, end int) {
+ p.val = &ast.Float{
+ Position: ast.Position{Begin: begin, End: end},
+ Data: p.buffer[begin:end],
+ Value: underscoreReplacer.Replace(string(p.buffer[begin:end])),
+ }
+}
+
+func (p *tomlParser) SetInt64(begin, end int) {
+ p.val = &ast.Integer{
+ Position: ast.Position{Begin: begin, End: end},
+ Data: p.buffer[begin:end],
+ Value: underscoreReplacer.Replace(string(p.buffer[begin:end])),
+ }
+}
+
+func (p *tomlParser) SetString(begin, end int) {
+ p.val = &ast.String{
+ Position: ast.Position{Begin: begin, End: end},
+ Data: p.buffer[begin:end],
+ Value: p.s,
+ }
+ p.s = ""
+}
+
+func (p *tomlParser) SetBool(begin, end int) {
+ p.val = &ast.Boolean{
+ Position: ast.Position{Begin: begin, End: end},
+ Data: p.buffer[begin:end],
+ Value: string(p.buffer[begin:end]),
+ }
+}
+
+func (p *tomlParser) StartArray() {
+ if p.arr == nil {
+ p.arr = &array{line: p.line, current: &ast.Array{}}
+ return
+ }
+ p.arr.child = &array{parent: p.arr, line: p.line, current: &ast.Array{}}
+ p.arr = p.arr.child
+}
+
+func (p *tomlParser) AddArrayVal() {
+ if p.arr.current == nil {
+ p.arr.current = &ast.Array{}
+ }
+ p.arr.current.Value = append(p.arr.current.Value, p.val)
+}
+
+func (p *tomlParser) SetArray(begin, end int) {
+ p.arr.current.Position = ast.Position{Begin: begin, End: end}
+ p.arr.current.Data = p.buffer[begin:end]
+ p.val = p.arr.current
+ p.arr = p.arr.parent
+}
+
+func (p *toml) SetTable(buf []rune, begin, end int) {
+ p.setTable(p.table, buf, begin, end)
+}
+
+func (p *toml) setTable(t *ast.Table, buf []rune, begin, end int) {
+ name := string(buf[begin:end])
+ names := splitTableKey(name)
+ if t, exists := p.tableMap[name]; exists {
+ if lt := p.tableMap[names[len(names)-1]]; t.Type == ast.TableTypeArray || lt != nil && lt.Type == ast.TableTypeNormal {
+ p.Error(fmt.Errorf("table `%s' is in conflict with %v table in line %d", name, t.Type, t.Line))
+ }
+ }
+ t, err := p.lookupTable(t, names)
+ if err != nil {
+ p.Error(err)
+ }
+ p.currentTable = t
+ p.tableMap[name] = p.currentTable
+}
+
+func (p *tomlParser) SetTableString(begin, end int) {
+ p.currentTable.Data = p.buffer[begin:end]
+
+ p.currentTable.Position.Begin = begin
+ p.currentTable.Position.End = end
+}
+
+func (p *toml) SetArrayTable(buf []rune, begin, end int) {
+ p.setArrayTable(p.table, buf, begin, end)
+}
+
+func (p *toml) setArrayTable(t *ast.Table, buf []rune, begin, end int) {
+ name := string(buf[begin:end])
+ if t, exists := p.tableMap[name]; exists && t.Type == ast.TableTypeNormal {
+ p.Error(fmt.Errorf("table `%s' is in conflict with %v table in line %d", name, t.Type, t.Line))
+ }
+ names := splitTableKey(name)
+ t, err := p.lookupTable(t, names[:len(names)-1])
+ if err != nil {
+ p.Error(err)
+ }
+ last := names[len(names)-1]
+ tbl := &ast.Table{
+ Position: ast.Position{begin, end},
+ Line: p.line,
+ Name: last,
+ Type: ast.TableTypeArray,
+ }
+ switch v := t.Fields[last].(type) {
+ case nil:
+ if t.Fields == nil {
+ t.Fields = make(map[string]interface{})
+ }
+ t.Fields[last] = []*ast.Table{tbl}
+ case []*ast.Table:
+ t.Fields[last] = append(v, tbl)
+ case *ast.KeyValue:
+ p.Error(fmt.Errorf("key `%s' is in conflict with line %d", last, v.Line))
+ default:
+ p.Error(fmt.Errorf("BUG: key `%s' is in conflict but it's unknown type `%T'", last, v))
+ }
+ p.currentTable = tbl
+ p.tableMap[name] = p.currentTable
+}
+
+func (p *toml) StartInlineTable() {
+ p.skip = false
+ p.stack = append(p.stack, &stack{p.key, p.currentTable})
+ buf := []rune(p.key)
+ if p.arr == nil {
+ p.setTable(p.currentTable, buf, 0, len(buf))
+ } else {
+ p.setArrayTable(p.currentTable, buf, 0, len(buf))
+ }
+}
+
+func (p *toml) EndInlineTable() {
+ st := p.stack[len(p.stack)-1]
+ p.key, p.currentTable = st.key, st.table
+ p.stack[len(p.stack)-1] = nil
+ p.stack = p.stack[:len(p.stack)-1]
+ p.skip = true
+}
+
+func (p *toml) AddLineCount(i int) {
+ p.line += i
+}
+
+func (p *toml) SetKey(buf []rune, begin, end int) {
+ p.key = string(buf[begin:end])
+}
+
+func (p *toml) AddKeyValue() {
+ if p.skip {
+ p.skip = false
+ return
+ }
+ if val, exists := p.currentTable.Fields[p.key]; exists {
+ switch v := val.(type) {
+ case *ast.Table:
+ p.Error(fmt.Errorf("key `%s' is in conflict with %v table in line %d", p.key, v.Type, v.Line))
+ case *ast.KeyValue:
+ p.Error(fmt.Errorf("key `%s' is in conflict with line %d", p.key, v.Line))
+ default:
+ p.Error(fmt.Errorf("BUG: key `%s' is in conflict but it's unknown type `%T'", p.key, v))
+ }
+ }
+ if p.currentTable.Fields == nil {
+ p.currentTable.Fields = make(map[string]interface{})
+ }
+ p.currentTable.Fields[p.key] = &ast.KeyValue{
+ Key: p.key,
+ Value: p.val,
+ Line: p.line,
+ }
+}
+
+func (p *toml) SetBasicString(buf []rune, begin, end int) {
+ p.s = p.unquote(string(buf[begin:end]))
+}
+
+func (p *toml) SetMultilineString() {
+ p.s = p.unquote(`"` + escapeReplacer.Replace(strings.TrimLeft(p.s, "\r\n")) + `"`)
+}
+
+func (p *toml) AddMultilineBasicBody(buf []rune, begin, end int) {
+ p.s += string(buf[begin:end])
+}
+
+func (p *toml) SetLiteralString(buf []rune, begin, end int) {
+ p.s = string(buf[begin:end])
+}
+
+func (p *toml) SetMultilineLiteralString(buf []rune, begin, end int) {
+ p.s = strings.TrimLeft(string(buf[begin:end]), "\r\n")
+}
+
+func (p *toml) unquote(s string) string {
+ s, err := strconv.Unquote(s)
+ if err != nil {
+ p.Error(err)
+ }
+ return s
+}
+
+func (p *toml) lookupTable(t *ast.Table, keys []string) (*ast.Table, error) {
+ for _, s := range keys {
+ val, exists := t.Fields[s]
+ if !exists {
+ tbl := &ast.Table{
+ Line: p.line,
+ Name: s,
+ Type: ast.TableTypeNormal,
+ }
+ if t.Fields == nil {
+ t.Fields = make(map[string]interface{})
+ }
+ t.Fields[s] = tbl
+ t = tbl
+ continue
+ }
+ switch v := val.(type) {
+ case *ast.Table:
+ t = v
+ case []*ast.Table:
+ t = v[len(v)-1]
+ case *ast.KeyValue:
+ return nil, fmt.Errorf("key `%s' is in conflict with line %d", s, v.Line)
+ default:
+ return nil, fmt.Errorf("BUG: key `%s' is in conflict but it's unknown type `%T'", s, v)
+ }
+ }
+ return t, nil
+}
+
+func splitTableKey(tk string) []string {
+ key := make([]byte, 0, 1)
+ keys := make([]string, 0, 1)
+ inQuote := false
+ for i := 0; i < len(tk); i++ {
+ k := tk[i]
+ switch {
+ case k == tableSeparator && !inQuote:
+ keys = append(keys, string(key))
+ key = key[:0] // reuse buffer.
+ case k == '"':
+ inQuote = !inQuote
+ case (k == ' ' || k == '\t') && !inQuote:
+ // skip.
+ default:
+ key = append(key, k)
+ }
+ }
+ keys = append(keys, string(key))
+ return keys
+}
+
+type convertError struct {
+ err error
+}
+
+func (e convertError) Error() string {
+ return e.err.Error()
+}
+
+type array struct {
+ parent *array
+ child *array
+ current *ast.Array
+ line int
+}
diff --git a/Godeps/_workspace/src/github.com/naoina/toml/decode_bench_test.go b/Godeps/_workspace/src/github.com/naoina/toml/decode_bench_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..94ffdfb365ba1f69ecb48a0a9a098956abe5a2b0
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/toml/decode_bench_test.go
@@ -0,0 +1,49 @@
+package toml_test
+
+import (
+ "testing"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/naoina/toml"
+)
+
+func BenchmarkUnmarshal(b *testing.B) {
+ var v struct {
+ Title string
+ Owner struct {
+ Name string
+ Organization string
+ Bio string
+ Dob time.Time
+ }
+ Database struct {
+ Server string
+ Ports []int
+ ConnectionMax int
+ Enabled bool
+ }
+ Servers struct {
+ Alpha struct {
+ IP string
+ DC string
+ }
+ Beta struct {
+ IP string
+ DC string
+ }
+ }
+ Clients struct {
+ Data []interface{}
+ Hosts []string
+ }
+ }
+ data, err := loadTestData()
+ if err != nil {
+ b.Fatal(err)
+ }
+ for i := 0; i < b.N; i++ {
+ if err := toml.Unmarshal(data, &v); err != nil {
+ b.Fatal(err)
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/naoina/toml/decode_test.go b/Godeps/_workspace/src/github.com/naoina/toml/decode_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..17dd2e79b56155af3609167becb7975ffafe5b66
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/toml/decode_test.go
@@ -0,0 +1,1083 @@
+package toml_test
+
+import (
+ "fmt"
+ "io/ioutil"
+ "path/filepath"
+ "reflect"
+ "testing"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/naoina/toml"
+)
+
+const (
+ dataDir = "testdata"
+)
+
+func loadTestData() ([]byte, error) {
+ f := filepath.Join(dataDir, "test.toml")
+ data, err := ioutil.ReadFile(f)
+ if err != nil {
+ return nil, err
+ }
+ return data, nil
+}
+
+func mustTime(tm time.Time, err error) time.Time {
+ if err != nil {
+ panic(err)
+ }
+ return tm
+}
+
+type Name struct {
+ First string
+ Last string
+}
+type Point struct {
+ X int
+ Y int
+}
+type Inline struct {
+ Name Name
+ Point Point
+}
+type Subtable struct {
+ Key string
+}
+type Table struct {
+ Key string
+ Subtable Subtable
+ Inline Inline
+}
+type W struct {
+}
+type Z struct {
+ W W
+}
+type Y struct {
+ Z Z
+}
+type X struct {
+ Y Y
+}
+type Basic struct {
+ Basic string
+}
+type Continued struct {
+ Key1 string
+ Key2 string
+ Key3 string
+}
+type Multiline struct {
+ Key1 string
+ Key2 string
+ Key3 string
+ Continued Continued
+}
+type LiteralMultiline struct {
+ Regex2 string
+ Lines string
+}
+type Literal struct {
+ Winpath string
+ Winpath2 string
+ Quoted string
+ Regex string
+ Multiline LiteralMultiline
+}
+type String struct {
+ Basic Basic
+ Multiline Multiline
+ Literal Literal
+}
+type IntegerUnderscores struct {
+ Key1 int
+ Key2 int
+ Key3 int
+}
+type Integer struct {
+ Key1 int
+ Key2 int
+ Key3 int
+ Key4 int
+ Underscores IntegerUnderscores
+}
+type Fractional struct {
+ Key1 float64
+ Key2 float64
+ Key3 float64
+}
+type Exponent struct {
+ Key1 float64
+ Key2 float64
+ Key3 float64
+}
+type Both struct {
+ Key float64
+}
+type FloatUnderscores struct {
+ Key1 float64
+ Key2 float64
+}
+type Float struct {
+ Fractional Fractional
+ Exponent Exponent
+ Both Both
+ Underscores FloatUnderscores
+}
+type Boolean struct {
+ True bool
+ False bool
+}
+type Datetime struct {
+ Key1 time.Time
+ Key2 time.Time
+ Key3 time.Time
+}
+type Array struct {
+ Key1 []int
+ Key2 []string
+ Key3 [][]int
+ Key4 [][]interface{}
+ Key5 []int
+ Key6 []int
+}
+type Product struct {
+ Name string
+ Sku int64
+ Color string
+}
+type Physical struct {
+ Color string
+ Shape string
+}
+type Variety struct {
+ Name string
+}
+type Fruit struct {
+ Name string
+ Physical Physical
+ Variety []Variety
+}
+type testStruct struct {
+ Table Table
+ X X
+ String String
+ Integer Integer
+ Float Float
+ Boolean Boolean
+ Datetime Datetime
+ Array Array
+ Products []Product
+ Fruit []Fruit
+}
+
+func TestUnmarshal(t *testing.T) {
+ data, err := loadTestData()
+ if err != nil {
+ t.Fatal(err)
+ }
+ var v testStruct
+ var actual interface{} = toml.Unmarshal(data, &v)
+ var expect interface{} = nil
+ if !reflect.DeepEqual(actual, expect) {
+ t.Errorf(`toml.Unmarshal(data, &testStruct{}) => %#v; want %#v`, actual, expect)
+ }
+
+ actual = v
+ expect = testStruct{
+ Table: Table{
+ Key: "value",
+ Subtable: Subtable{
+ Key: "another value",
+ },
+ Inline: Inline{
+ Name: Name{
+ First: "Tom",
+ Last: "Preston-Werner",
+ },
+ Point: Point{
+ X: 1,
+ Y: 2,
+ },
+ },
+ },
+ X: X{},
+ String: String{
+ Basic: Basic{
+ Basic: "I'm a string. \"You can quote me\". Name\tJos\u00E9\nLocation\tSF.",
+ },
+ Multiline: Multiline{
+ Key1: "One\nTwo",
+ Key2: "One\nTwo",
+ Key3: "One\nTwo",
+ Continued: Continued{
+ Key1: "The quick brown fox jumps over the lazy dog.",
+ Key2: "The quick brown fox jumps over the lazy dog.",
+ Key3: "The quick brown fox jumps over the lazy dog.",
+ },
+ },
+ Literal: Literal{
+ Winpath: `C:\Users\nodejs\templates`,
+ Winpath2: `\\ServerX\admin$\system32\`,
+ Quoted: `Tom "Dubs" Preston-Werner`,
+ Regex: `<\i\c*\s*>`,
+ Multiline: LiteralMultiline{
+ Regex2: `I [dw]on't need \d{2} apples`,
+ Lines: "The first newline is\ntrimmed in raw strings.\n All other whitespace\n is preserved.\n",
+ },
+ },
+ },
+ Integer: Integer{
+ Key1: 99,
+ Key2: 42,
+ Key3: 0,
+ Key4: -17,
+ Underscores: IntegerUnderscores{
+ Key1: 1000,
+ Key2: 5349221,
+ Key3: 12345,
+ },
+ },
+ Float: Float{
+ Fractional: Fractional{
+ Key1: 1.0,
+ Key2: 3.1415,
+ Key3: -0.01,
+ },
+ Exponent: Exponent{
+ Key1: 5e22,
+ Key2: 1e6,
+ Key3: -2e-2,
+ },
+ Both: Both{
+ Key: 6.626e-34,
+ },
+ Underscores: FloatUnderscores{
+ Key1: 9224617.445991228313,
+ Key2: 1e100,
+ },
+ },
+ Boolean: Boolean{
+ True: true,
+ False: false,
+ },
+ Datetime: Datetime{
+ Key1: mustTime(time.Parse(time.RFC3339Nano, "1979-05-27T07:32:00Z")),
+ Key2: mustTime(time.Parse(time.RFC3339Nano, "1979-05-27T00:32:00-07:00")),
+ Key3: mustTime(time.Parse(time.RFC3339Nano, "1979-05-27T00:32:00.999999-07:00")),
+ },
+ Array: Array{
+ Key1: []int{1, 2, 3},
+ Key2: []string{"red", "yellow", "green"},
+ Key3: [][]int{{1, 2}, {3, 4, 5}},
+ Key4: [][]interface{}{{int64(1), int64(2)}, {"a", "b", "c"}},
+ Key5: []int{1, 2, 3},
+ Key6: []int{1, 2},
+ },
+ Products: []Product{
+ {Name: "Hammer", Sku: 738594937},
+ {},
+ {Name: "Nail", Sku: 284758393, Color: "gray"},
+ },
+ Fruit: []Fruit{
+ {
+ Name: "apple",
+ Physical: Physical{
+ Color: "red",
+ Shape: "round",
+ },
+ Variety: []Variety{
+ {Name: "red delicious"},
+ {Name: "granny smith"},
+ },
+ },
+ {
+ Name: "banana",
+ Variety: []Variety{
+ {Name: "plantain"},
+ },
+ },
+ },
+ }
+ if !reflect.DeepEqual(actual, expect) {
+ t.Errorf(`toml.Unmarshal(data, v); v => %#v; want %#v`, actual, expect)
+ }
+}
+
+type testcase struct {
+ data string
+ err error
+ actual interface{}
+ expect interface{}
+}
+
+func testUnmarshal(t *testing.T, testcases []testcase) {
+ for _, v := range testcases {
+ var actual error = toml.Unmarshal([]byte(v.data), v.actual)
+ var expect error = v.err
+ if !reflect.DeepEqual(actual, expect) {
+ t.Errorf(`toml.Unmarshal([]byte(%#v), %#v) => %#v; want %#v`, v.data, nil, actual, expect)
+ }
+ if !reflect.DeepEqual(v.actual, v.expect) {
+ t.Errorf(`toml.Unmarshal([]byte(%#v), v); v => %#v; want %#v`, v.data, v.actual, v.expect)
+ }
+ }
+}
+
+func TestUnmarshal_WithString(t *testing.T) {
+ type testStruct struct {
+ Str string
+ Key1 string
+ Key2 string
+ Key3 string
+ Winpath string
+ Winpath2 string
+ Quoted string
+ Regex string
+ Regex2 string
+ Lines string
+ }
+ testUnmarshal(t, []testcase{
+ {`str = "I'm a string. \"You can quote me\". Name\tJos\u00E9\nLocation\tSF."`, nil, &testStruct{}, &testStruct{
+ Str: "I'm a string. \"You can quote me\". Name\tJos\u00E9\nLocation\tSF.",
+ }},
+ {`key1 = "One\nTwo"
+key2 = """One\nTwo"""
+key3 = """
+One
+Two"""
+`, nil, &testStruct{}, &testStruct{
+ Key1: "One\nTwo",
+ Key2: "One\nTwo",
+ Key3: "One\nTwo",
+ }},
+ {`# The following strings are byte-for-byte equivalent:
+key1 = "The quick brown fox jumps over the lazy dog."
+
+key2 = """
+The quick brown \
+
+
+ fox jumps over \
+ the lazy dog."""
+
+key3 = """\
+ The quick brown \
+ fox jumps over \
+ the lazy dog.\
+ """`, nil, &testStruct{}, &testStruct{
+ Key1: "The quick brown fox jumps over the lazy dog.",
+ Key2: "The quick brown fox jumps over the lazy dog.",
+ Key3: "The quick brown fox jumps over the lazy dog.",
+ }},
+ {`# What you see is what you get.
+winpath = 'C:\Users\nodejs\templates'
+winpath2 = '\\ServerX\admin$\system32\'
+quoted = 'Tom "Dubs" Preston-Werner'
+regex = '<\i\c*\s*>'`, nil, &testStruct{}, &testStruct{
+ Winpath: `C:\Users\nodejs\templates`,
+ Winpath2: `\\ServerX\admin$\system32\`,
+ Quoted: `Tom "Dubs" Preston-Werner`,
+ Regex: `<\i\c*\s*>`,
+ }},
+ {`regex2 = '''I [dw]on't need \d{2} apples'''
+lines = '''
+The first newline is
+trimmed in raw strings.
+ All other whitespace
+ is preserved.
+'''`, nil, &testStruct{}, &testStruct{
+ Regex2: `I [dw]on't need \d{2} apples`,
+ Lines: "The first newline is\ntrimmed in raw strings.\n All other whitespace\n is preserved.\n",
+ }},
+ })
+}
+
+func TestUnmarshal_WithInteger(t *testing.T) {
+ type testStruct struct {
+ Intval int64
+ }
+ testUnmarshal(t, []testcase{
+ {`intval = 0`, nil, &testStruct{}, &testStruct{0}},
+ {`intval = +0`, nil, &testStruct{}, &testStruct{0}},
+ {`intval = -0`, nil, &testStruct{}, &testStruct{-0}},
+ {`intval = 1`, nil, &testStruct{}, &testStruct{1}},
+ {`intval = +1`, nil, &testStruct{}, &testStruct{1}},
+ {`intval = -1`, nil, &testStruct{}, &testStruct{-1}},
+ {`intval = 10`, nil, &testStruct{}, &testStruct{10}},
+ {`intval = 777`, nil, &testStruct{}, &testStruct{777}},
+ {`intval = 2147483647`, nil, &testStruct{}, &testStruct{2147483647}},
+ {`intval = 2147483648`, nil, &testStruct{}, &testStruct{2147483648}},
+ {`intval = +2147483648`, nil, &testStruct{}, &testStruct{2147483648}},
+ {`intval = -2147483648`, nil, &testStruct{}, &testStruct{-2147483648}},
+ {`intval = -2147483649`, nil, &testStruct{}, &testStruct{-2147483649}},
+ {`intval = 9223372036854775807`, nil, &testStruct{}, &testStruct{9223372036854775807}},
+ {`intval = +9223372036854775807`, nil, &testStruct{}, &testStruct{9223372036854775807}},
+ {`intval = 9223372036854775808`, fmt.Errorf(`toml: unmarshal: line 1: toml_test.testStruct.Intval: strconv.ParseInt: parsing "9223372036854775808": value out of range`), &testStruct{}, &testStruct{}},
+ {`intval = +9223372036854775808`, fmt.Errorf(`toml: unmarshal: line 1: toml_test.testStruct.Intval: strconv.ParseInt: parsing "+9223372036854775808": value out of range`), &testStruct{}, &testStruct{}},
+ {`intval = -9223372036854775808`, nil, &testStruct{}, &testStruct{-9223372036854775808}},
+ {`intval = -9223372036854775809`, fmt.Errorf(`toml: unmarshal: line 1: toml_test.testStruct.Intval: strconv.ParseInt: parsing "-9223372036854775809": value out of range`), &testStruct{}, &testStruct{}},
+ {`intval = 1_000`, nil, &testStruct{}, &testStruct{1000}},
+ {`intval = 5_349_221`, nil, &testStruct{}, &testStruct{5349221}},
+ {`intval = 1_2_3_4_5`, nil, &testStruct{}, &testStruct{12345}},
+ {`intval = _1_000`, fmt.Errorf("toml: line 1: parse error"), &testStruct{}, &testStruct{}},
+ {`intval = 1_000_`, fmt.Errorf("toml: line 1: parse error"), &testStruct{}, &testStruct{}},
+ })
+}
+
+func TestUnmarshal_WithFloat(t *testing.T) {
+ type testStruct struct {
+ Floatval float64
+ }
+ testUnmarshal(t, []testcase{
+ {`floatval = 0.0`, nil, &testStruct{}, &testStruct{0.0}},
+ {`floatval = +0.0`, nil, &testStruct{}, &testStruct{0.0}},
+ {`floatval = -0.0`, nil, &testStruct{}, &testStruct{-0.0}},
+ {`floatval = 0.1`, nil, &testStruct{}, &testStruct{0.1}},
+ {`floatval = +0.1`, nil, &testStruct{}, &testStruct{0.1}},
+ {`floatval = -0.1`, nil, &testStruct{}, &testStruct{-0.1}},
+ {`floatval = 0.2`, nil, &testStruct{}, &testStruct{0.2}},
+ {`floatval = +0.2`, nil, &testStruct{}, &testStruct{0.2}},
+ {`floatval = -0.2`, nil, &testStruct{}, &testStruct{-0.2}},
+ {`floatval = 1.0`, nil, &testStruct{}, &testStruct{1.0}},
+ {`floatval = +1.0`, nil, &testStruct{}, &testStruct{1.0}},
+ {`floatval = -1.0`, nil, &testStruct{}, &testStruct{-1.0}},
+ {`floatval = 1.1`, nil, &testStruct{}, &testStruct{1.1}},
+ {`floatval = +1.1`, nil, &testStruct{}, &testStruct{1.1}},
+ {`floatval = -1.1`, nil, &testStruct{}, &testStruct{-1.1}},
+ {`floatval = 3.1415`, nil, &testStruct{}, &testStruct{3.1415}},
+ {`floatval = +3.1415`, nil, &testStruct{}, &testStruct{3.1415}},
+ {`floatval = -3.1415`, nil, &testStruct{}, &testStruct{-3.1415}},
+ {`floatval = 10.2e5`, nil, &testStruct{}, &testStruct{10.2e5}},
+ {`floatval = +10.2e5`, nil, &testStruct{}, &testStruct{10.2e5}},
+ {`floatval = -10.2e5`, nil, &testStruct{}, &testStruct{-10.2e5}},
+ {`floatval = 10.2E5`, nil, &testStruct{}, &testStruct{10.2e5}},
+ {`floatval = +10.2E5`, nil, &testStruct{}, &testStruct{10.2e5}},
+ {`floatval = -10.2E5`, nil, &testStruct{}, &testStruct{-10.2e5}},
+ {`floatval = 5e+22`, nil, &testStruct{}, &testStruct{5e+22}},
+ {`floatval = 1e6`, nil, &testStruct{}, &testStruct{1e6}},
+ {`floatval = -2E-2`, nil, &testStruct{}, &testStruct{-2E-2}},
+ {`floatval = 6.626e-34`, nil, &testStruct{}, &testStruct{6.626e-34}},
+ {`floatval = 9_224_617.445_991_228_313`, nil, &testStruct{}, &testStruct{9224617.445991228313}},
+ {`floatval = 1e1_00`, nil, &testStruct{}, &testStruct{1e100}},
+ {`floatval = 1e02`, nil, &testStruct{}, &testStruct{1e2}},
+ {`floatval = _1e1_00`, fmt.Errorf("toml: line 1: parse error"), &testStruct{}, &testStruct{}},
+ {`floatval = 1e1_00_`, fmt.Errorf("toml: line 1: parse error"), &testStruct{}, &testStruct{}},
+ })
+}
+
+func TestUnmarshal_WithBoolean(t *testing.T) {
+ type testStruct struct {
+ Boolval bool
+ }
+ testUnmarshal(t, []testcase{
+ {`boolval = true`, nil, &testStruct{}, &testStruct{true}},
+ {`boolval = false`, nil, &testStruct{}, &testStruct{false}},
+ })
+}
+
+func TestUnmarshal_WithDatetime(t *testing.T) {
+ type testStruct struct {
+ Datetimeval time.Time
+ }
+ testUnmarshal(t, []testcase{
+ {`datetimeval = 1979-05-27T07:32:00Z`, nil, &testStruct{}, &testStruct{
+ mustTime(time.Parse(time.RFC3339Nano, "1979-05-27T07:32:00Z")),
+ }},
+ {`datetimeval = 2014-09-13T12:37:39Z`, nil, &testStruct{}, &testStruct{
+ mustTime(time.Parse(time.RFC3339Nano, "2014-09-13T12:37:39Z")),
+ }},
+ {`datetimeval = 1979-05-27T00:32:00-07:00`, nil, &testStruct{}, &testStruct{
+ mustTime(time.Parse(time.RFC3339Nano, "1979-05-27T00:32:00-07:00")),
+ }},
+ {`datetimeval = 1979-05-27T00:32:00.999999-07:00`, nil, &testStruct{}, &testStruct{
+ mustTime(time.Parse(time.RFC3339Nano, "1979-05-27T00:32:00.999999-07:00")),
+ }},
+ })
+}
+
+func TestUnmarshal_WithArray(t *testing.T) {
+ testUnmarshal(t, []testcase{
+ {`arrayval = []`, nil, &struct{ Arrayval []interface{} }{}, &struct{ Arrayval []interface{} }{}},
+ {`arrayval = [ 1 ]`, nil, &struct{ Arrayval []int }{},
+ &struct {
+ Arrayval []int
+ }{
+ []int{1},
+ }},
+ {`arrayval = [ 1, 2, 3 ]`, nil, &struct{ Arrayval []int }{},
+ &struct {
+ Arrayval []int
+ }{
+ []int{1, 2, 3},
+ }},
+ {`arrayval = [ 1, 2, 3, ]`, nil, &struct{ Arrayval []int }{},
+ &struct {
+ Arrayval []int
+ }{
+ []int{1, 2, 3},
+ }},
+ {`arrayval = ["red", "yellow", "green"]`, nil, &struct{ Arrayval []string }{},
+ &struct{ Arrayval []string }{
+ []string{"red", "yellow", "green"},
+ }},
+ {`arrayval = [ "all", 'strings', """are the same""", '''type''']`, nil, &struct{ Arrayval []string }{},
+ &struct{ Arrayval []string }{
+ []string{"all", "strings", "are the same", "type"},
+ }},
+ {`arrayval = [[1,2],[3,4,5]]`, nil, &struct{ Arrayval [][]int }{},
+ &struct{ Arrayval [][]int }{
+ [][]int{
+ []int{1, 2},
+ []int{3, 4, 5},
+ },
+ }},
+ {`arrayval = [ [ 1, 2 ], ["a", "b", "c"] ] # this is ok`, nil, &struct{ Arrayval [][]interface{} }{},
+ &struct{ Arrayval [][]interface{} }{
+ [][]interface{}{
+ []interface{}{int64(1), int64(2)},
+ []interface{}{"a", "b", "c"},
+ },
+ }},
+ {`arrayval = [ [ 1, 2 ], [ [3, 4], [5, 6] ] ] # this is ok`, nil, &struct{ Arrayval [][]interface{} }{},
+ &struct{ Arrayval [][]interface{} }{
+ [][]interface{}{
+ []interface{}{int64(1), int64(2)},
+ []interface{}{
+ []interface{}{int64(3), int64(4)},
+ []interface{}{int64(5), int64(6)},
+ },
+ },
+ }},
+ {`arrayval = [ [ 1, 2 ], [ [3, 4], [5, 6], [7, 8] ] ] # this is ok`, nil, &struct{ Arrayval [][]interface{} }{},
+ &struct{ Arrayval [][]interface{} }{
+ [][]interface{}{
+ []interface{}{int64(1), int64(2)},
+ []interface{}{
+ []interface{}{int64(3), int64(4)},
+ []interface{}{int64(5), int64(6)},
+ []interface{}{int64(7), int64(8)},
+ },
+ },
+ }},
+ {`arrayval = [ [[ 1, 2 ]], [3, 4], [5, 6] ] # this is ok`, nil, &struct{ Arrayval [][]interface{} }{},
+ &struct{ Arrayval [][]interface{} }{
+ [][]interface{}{
+ []interface{}{
+ []interface{}{int64(1), int64(2)},
+ },
+ []interface{}{int64(3), int64(4)},
+ []interface{}{int64(5), int64(6)},
+ },
+ }},
+ {`arrayval = [ 1, 2.0 ] # note: this is NOT ok`, fmt.Errorf("toml: unmarshal: line 1: struct { Arrayval []interface {} }.Arrayval: array cannot contain multiple types"), &struct{ Arrayval []interface{} }{}, &struct{ Arrayval []interface{} }{}},
+ {`key = [
+ 1, 2, 3
+]`, nil, &struct{ Key []int }{},
+ &struct{ Key []int }{
+ []int{1, 2, 3},
+ }},
+ {`key = [
+ 1,
+ 2, # this is ok
+]`, nil, &struct{ Key []int }{},
+ &struct{ Key []int }{
+ []int{1, 2},
+ }},
+ })
+}
+
+func TestUnmarshal_WithTable(t *testing.T) {
+ type W struct{}
+ type Z struct {
+ W W
+ }
+ type Y struct {
+ Z Z
+ }
+ type X struct {
+ Y Y
+ }
+ type testStruct struct {
+ Table struct {
+ Key string
+ }
+ Dog struct {
+ Tater struct{}
+ }
+ X X
+ A struct {
+ D int
+ B struct {
+ C int
+ }
+ }
+ }
+ type testQuotedKeyStruct struct {
+ Dog struct {
+ TaterMan struct {
+ Type string
+ } `toml:"tater.man"`
+ }
+ }
+ type testQuotedKeyWithWhitespaceStruct struct {
+ Dog struct {
+ TaterMan struct {
+ Type string
+ } `toml:"tater . man"`
+ }
+ }
+ type testStructWithMap struct {
+ Servers map[string]struct {
+ IP string
+ DC string
+ }
+ }
+ testUnmarshal(t, []testcase{
+ {`[table]`, nil, &testStruct{}, &testStruct{}},
+ {`[table]
+key = "value"`, nil, &testStruct{},
+ &testStruct{
+ Table: struct {
+ Key string
+ }{
+ Key: "value",
+ },
+ }},
+ {`[dog.tater]`, nil, &testStruct{},
+ &testStruct{
+ Dog: struct {
+ Tater struct{}
+ }{
+ Tater: struct{}{},
+ },
+ }},
+ {`[dog."tater.man"]
+type = "pug"`, nil, &testQuotedKeyStruct{},
+ &testQuotedKeyStruct{
+ Dog: struct {
+ TaterMan struct {
+ Type string
+ } `toml:"tater.man"`
+ }{
+ TaterMan: struct {
+ Type string
+ }{
+ Type: "pug",
+ },
+ },
+ }},
+ {`[dog."tater . man"]
+type = "pug"`, nil, &testQuotedKeyWithWhitespaceStruct{},
+ &testQuotedKeyWithWhitespaceStruct{
+ Dog: struct {
+ TaterMan struct {
+ Type string
+ } `toml:"tater . man"`
+ }{
+ TaterMan: struct {
+ Type string
+ }{
+ Type: "pug",
+ },
+ },
+ }},
+ {`[x.y.z.w] # for this to work`, nil, &testStruct{},
+ &testStruct{
+ X: X{},
+ }},
+ {`[ x . y . z . w ]`, nil, &testStruct{},
+ &testStruct{
+ X: X{},
+ }},
+ {`[ x . "y" . z . "w" ]`, nil, &testStruct{},
+ &testStruct{
+ X: X{},
+ }},
+ {`table = {}`, nil, &testStruct{}, &testStruct{}},
+ {`table = { key = "value" }`, nil, &testStruct{}, &testStruct{
+ Table: struct {
+ Key string
+ }{
+ Key: "value",
+ },
+ }},
+ {`x = { y = { "z" = { w = {} } } }`, nil, &testStruct{}, &testStruct{X: X{}}},
+ {`[a.b]
+c = 1
+
+[a]
+d = 2`, nil, &testStruct{},
+ &testStruct{
+ A: struct {
+ D int
+ B struct {
+ C int
+ }
+ }{
+ D: 2,
+ B: struct {
+ C int
+ }{
+ C: 1,
+ },
+ },
+ }},
+ {`# DO NOT DO THIS
+
+[a]
+b = 1
+
+[a]
+c = 2`, fmt.Errorf("toml: line 6: table `a' is in conflict with normal table in line 3"), &testStruct{}, &testStruct{}},
+ {`# DO NOT DO THIS EITHER
+
+[a]
+b = 1
+
+[a.b]
+c = 2`, fmt.Errorf("toml: line 6: key `b' is in conflict with line 4"), &testStruct{}, &testStruct{}},
+ {`# DO NOT DO THIS EITHER
+
+[a.b]
+c = 2
+
+[a]
+b = 1`, fmt.Errorf("toml: line 7: key `b' is in conflict with normal table in line 3"), &testStruct{}, &testStruct{}},
+ {`[]`, fmt.Errorf("toml: line 1: parse error"), &testStruct{}, &testStruct{}},
+ {`[a.]`, fmt.Errorf("toml: line 1: parse error"), &testStruct{}, &testStruct{}},
+ {`[a..b]`, fmt.Errorf("toml: line 1: parse error"), &testStruct{}, &testStruct{}},
+ {`[.b]`, fmt.Errorf("toml: line 1: parse error"), &testStruct{}, &testStruct{}},
+ {`[.]`, fmt.Errorf("toml: line 1: parse error"), &testStruct{}, &testStruct{}},
+ {` = "no key name" # not allowed`, fmt.Errorf("toml: line 1: parse error"), &testStruct{}, &testStruct{}},
+ {`[servers]
+[servers.alpha]
+ip = "10.0.0.1"
+dc = "eqdc10"
+[servers.beta]
+ip = "10.0.0.2"
+dc = "eqdc10"
+`, nil, &testStructWithMap{},
+ &testStructWithMap{
+ Servers: map[string]struct {
+ IP string
+ DC string
+ }{
+ "alpha": {
+ IP: "10.0.0.1",
+ DC: "eqdc10",
+ },
+ "beta": {
+ IP: "10.0.0.2",
+ DC: "eqdc10",
+ },
+ },
+ }},
+ })
+}
+
+func TestUnmarshal_WithArrayTable(t *testing.T) {
+ type Product struct {
+ Name string
+ SKU int64
+ Color string
+ }
+ type Physical struct {
+ Color string
+ Shape string
+ }
+ type Variety struct {
+ Name string
+ }
+ type Fruit struct {
+ Name string
+ Physical Physical
+ Variety []Variety
+ }
+ type testStruct struct {
+ Products []Product
+ Fruit []Fruit
+ }
+ type testStructWithMap struct {
+ Fruit []map[string][]struct {
+ Name string
+ }
+ }
+ testUnmarshal(t, []testcase{
+ {`[[products]]
+ name = "Hammer"
+ sku = 738594937
+
+ [[products]]
+
+ [[products]]
+ name = "Nail"
+ sku = 284758393
+ color = "gray"`, nil, &testStruct{},
+ &testStruct{
+ Products: []Product{
+ {Name: "Hammer", SKU: 738594937},
+ {},
+ {Name: "Nail", SKU: 284758393, Color: "gray"},
+ },
+ }},
+ {`products = [{name = "Hammer", sku = 738594937}, {},
+{name = "Nail", sku = 284758393, color = "gray"}]`, nil, &testStruct{}, &testStruct{
+ Products: []Product{
+ {Name: "Hammer", SKU: 738594937},
+ {},
+ {Name: "Nail", SKU: 284758393, Color: "gray"},
+ },
+ }},
+ {`[[fruit]]
+ name = "apple"
+
+ [fruit.physical]
+ color = "red"
+ shape = "round"
+
+ [[fruit.variety]]
+ name = "red delicious"
+
+ [[fruit.variety]]
+ name = "granny smith"
+
+ [[fruit]]
+ name = "banana"
+
+ [fruit.physical]
+ color = "yellow"
+ shape = "lune"
+
+ [[fruit.variety]]
+ name = "plantain"`, nil, &testStruct{},
+ &testStruct{
+ Fruit: []Fruit{
+ {
+ Name: "apple",
+ Physical: Physical{
+ Color: "red",
+ Shape: "round",
+ },
+ Variety: []Variety{
+ {Name: "red delicious"},
+ {Name: "granny smith"},
+ },
+ },
+ {
+ Name: "banana",
+ Physical: Physical{
+ Color: "yellow",
+ Shape: "lune",
+ },
+ Variety: []Variety{
+ {Name: "plantain"},
+ },
+ },
+ },
+ }},
+ {`[[fruit]]
+
+ [[fruit.variety]]
+ name = "red delicious"
+
+ [[fruit.variety]]
+ name = "granny smith"
+
+ [[fruit]]
+
+ [[fruit.variety]]
+ name = "plantain"
+
+ [[fruit.area]]
+ name = "phillippines"`, nil, &testStructWithMap{},
+ &testStructWithMap{
+ Fruit: []map[string][]struct {
+ Name string
+ }{
+ {
+ "variety": {
+ {Name: "red delicious"},
+ {Name: "granny smith"},
+ },
+ },
+ {
+ "variety": {
+ {Name: "plantain"},
+ },
+ "area": {
+ {Name: "phillippines"},
+ },
+ },
+ },
+ }},
+ {`# INVALID TOML DOC
+ [[fruit]]
+ name = "apple"
+
+ [[fruit.variety]]
+ name = "red delicious"
+
+ # This table conflicts with the previous table
+ [fruit.variety]
+ name = "granny smith"`, fmt.Errorf("toml: line 9: table `fruit.variety' is in conflict with array table in line 5"), &testStruct{}, &testStruct{}},
+ {`# INVALID TOML DOC
+ [[fruit]]
+ name = "apple"
+
+ [fruit.variety]
+ name = "granny smith"
+
+ # This table conflicts with the previous table
+ [[fruit.variety]]
+ name = "red delicious"`, fmt.Errorf("toml: line 9: table `fruit.variety' is in conflict with normal table in line 5"), &testStruct{}, &testStruct{}},
+ })
+}
+
+type UnmarshalString string
+
+func (u *UnmarshalString) UnmarshalTOML(data []byte) error {
+ *u = UnmarshalString("UnmarshalString: " + string(data))
+ return nil
+}
+
+func TestUnmarshal_WithUnmarshaler(t *testing.T) {
+ type testStruct struct {
+ Title UnmarshalString
+ MaxConn UnmarshalString
+ Ports UnmarshalString
+ Servers UnmarshalString
+ Table UnmarshalString
+ Arraytable UnmarshalString
+ }
+ data := `title = "testtitle"
+max_conn = 777
+ports = [8080, 8081, 8082]
+servers = [1, 2, 3]
+[table]
+name = "alice"
+[[arraytable]]
+name = "alice"
+[[arraytable]]
+name = "bob"
+`
+ var v testStruct
+ if err := toml.Unmarshal([]byte(data), &v); err != nil {
+ t.Fatal(err)
+ }
+ actual := v
+ expect := testStruct{
+ Title: `UnmarshalString: "testtitle"`,
+ MaxConn: `UnmarshalString: 777`,
+ Ports: `UnmarshalString: [8080, 8081, 8082]`,
+ Servers: `UnmarshalString: [1, 2, 3]`,
+ Table: "UnmarshalString: [table]\nname = \"alice\"",
+ Arraytable: "UnmarshalString: [[arraytable]]\nname = \"alice\"\n[[arraytable]]\nname = \"bob\"",
+ }
+ if !reflect.DeepEqual(actual, expect) {
+ t.Errorf(`toml.Unmarshal(data, &v); v => %#v; want %#v`, actual, expect)
+ }
+}
+
+func TestUnmarshal_WithMultibyteString(t *testing.T) {
+ type testStruct struct {
+ Name string
+ Numbers []string
+ }
+ v := testStruct{}
+ data := `name = "七一〇七"
+numbers = ["壱", "å¼", "å‚"]
+`
+ if err := toml.Unmarshal([]byte(data), &v); err != nil {
+ t.Fatal(err)
+ }
+ actual := v
+ expect := testStruct{
+ Name: "七一〇七",
+ Numbers: []string{"壱", "å¼", "å‚"},
+ }
+ if !reflect.DeepEqual(actual, expect) {
+ t.Errorf(`toml.Unmarshal([]byte(data), &v); v => %#v; want %#v`, actual, expect)
+ }
+}
+
+func TestUnmarshal_WithPointers(t *testing.T) {
+ type Inline struct {
+ Key1 string
+ Key2 *string
+ Key3 **string
+ }
+ type Table struct {
+ Key1 *string
+ Key2 **string
+ Key3 ***string
+ }
+ type testStruct struct {
+ Inline *Inline
+ Tables []*Table
+ }
+ type testStruct2 struct {
+ Inline **Inline
+ Tables []**Table
+ }
+ type testStruct3 struct {
+ Inline ***Inline
+ Tables []***Table
+ }
+ data := `
+inline = { key1 = "test", key2 = "a", key3 = "b" }
+[[tables]]
+key1 = "a"
+key2 = "a"
+key3 = "a"
+[[tables]]
+key1 = "b"
+key2 = "b"
+key3 = "b"
+`
+ s1 := "a"
+ s2 := &s1
+ s3 := &s2
+ s4 := &s3
+ s5 := "b"
+ s6 := &s5
+ s7 := &s6
+ s8 := &s7
+ i1 := &Inline{"test", s2, s7}
+ i2 := &i1
+ i3 := &i2
+ t1 := &Table{s2, s3, s4}
+ t2 := &Table{s6, s7, s8}
+ t3 := &t1
+ t4 := &t2
+ sc := &testStruct{
+ Inline: i1, Tables: []*Table{t1, t2},
+ }
+ ac := &testStruct{}
+ testUnmarshal(t, []testcase{
+ {data, nil, ac, sc},
+ {data, nil, &testStruct2{}, &testStruct2{
+ Inline: i2,
+ Tables: []**Table{&t1, &t2},
+ }},
+ {data, nil, &testStruct3{}, &testStruct3{
+ Inline: i3,
+ Tables: []***Table{&t3, &t4},
+ }},
+ })
+}
+
+func TestUnmarshalMap(t *testing.T) {
+ testUnmarshal(t, []testcase{
+ {`
+name = "evan"
+foo = 1
+`, nil, map[string]interface{}{}, map[string]interface{}{
+ "name": "evan",
+ "foo": int64(1),
+ }},
+ })
+}
diff --git a/Godeps/_workspace/src/github.com/naoina/toml/encode.go b/Godeps/_workspace/src/github.com/naoina/toml/encode.go
new file mode 100644
index 0000000000000000000000000000000000000000..7465a7a2b996ea2a35f4f16e278dd91c785e5ff9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/toml/encode.go
@@ -0,0 +1,211 @@
+package toml
+
+import (
+ "fmt"
+ "reflect"
+ "strconv"
+ "time"
+
+ "go/ast"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/naoina/go-stringutil"
+)
+
+const (
+ tagOmitempty = "omitempty"
+ tagSkip = "-"
+)
+
+// Marshal returns the TOML encoding of v.
+//
+// Struct values encode as TOML. Each exported struct field becomes a field of
+// the TOML structure unless
+// - the field's tag is "-", or
+// - the field is empty and its tag specifies the "omitempty" option.
+// The "toml" key in the struct field's tag value is the key name, followed by
+// an optional comma and options. Examples:
+//
+// // Field is ignored by this package.
+// Field int `toml:"-"`
+//
+// // Field appears in TOML as key "myName".
+// Field int `toml:"myName"`
+//
+// // Field appears in TOML as key "myName" and the field is omitted from the
+// // result of encoding if its value is empty.
+// Field int `toml:"myName,omitempty"`
+//
+// // Field appears in TOML as key "field", but the field is skipped if
+// // empty.
+// // Note the leading comma.
+// Field int `toml:",omitempty"`
+func Marshal(v interface{}) ([]byte, error) {
+ return marshal(nil, "", reflect.ValueOf(v), false, false)
+}
+
+// Marshaler is the interface implemented by objects that can marshal themshelves into valid TOML.
+type Marshaler interface {
+ MarshalTOML() ([]byte, error)
+}
+
+func marshal(buf []byte, prefix string, rv reflect.Value, inArray, arrayTable bool) ([]byte, error) {
+ rt := rv.Type()
+ for i := 0; i < rv.NumField(); i++ {
+ ft := rt.Field(i)
+ if !ast.IsExported(ft.Name) {
+ continue
+ }
+ colName, rest := extractTag(rt.Field(i).Tag.Get(fieldTagName))
+ if colName == tagSkip {
+ continue
+ }
+ if colName == "" {
+ colName = stringutil.ToSnakeCase(ft.Name)
+ }
+ fv := rv.Field(i)
+ switch rest {
+ case tagOmitempty:
+ if fv.Interface() == reflect.Zero(ft.Type).Interface() {
+ continue
+ }
+ }
+ var err error
+ if buf, err = encodeValue(buf, prefix, colName, fv, inArray, arrayTable); err != nil {
+ return nil, err
+ }
+ }
+ return buf, nil
+}
+
+func encodeValue(buf []byte, prefix, name string, fv reflect.Value, inArray, arrayTable bool) ([]byte, error) {
+ switch t := fv.Interface().(type) {
+ case Marshaler:
+ b, err := t.MarshalTOML()
+ if err != nil {
+ return nil, err
+ }
+ return appendNewline(append(appendKey(buf, name, inArray, arrayTable), b...), inArray, arrayTable), nil
+ case time.Time:
+ return appendNewline(encodeTime(appendKey(buf, name, inArray, arrayTable), t), inArray, arrayTable), nil
+ }
+ switch fv.Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return appendNewline(encodeInt(appendKey(buf, name, inArray, arrayTable), fv.Int()), inArray, arrayTable), nil
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+ return appendNewline(encodeUint(appendKey(buf, name, inArray, arrayTable), fv.Uint()), inArray, arrayTable), nil
+ case reflect.Float32, reflect.Float64:
+ return appendNewline(encodeFloat(appendKey(buf, name, inArray, arrayTable), fv.Float()), inArray, arrayTable), nil
+ case reflect.Bool:
+ return appendNewline(encodeBool(appendKey(buf, name, inArray, arrayTable), fv.Bool()), inArray, arrayTable), nil
+ case reflect.String:
+ return appendNewline(encodeString(appendKey(buf, name, inArray, arrayTable), fv.String()), inArray, arrayTable), nil
+ case reflect.Slice, reflect.Array:
+ ft := fv.Type().Elem()
+ for ft.Kind() == reflect.Ptr {
+ ft = ft.Elem()
+ }
+ if ft.Kind() == reflect.Struct {
+ name := tableName(prefix, name)
+ var err error
+ for i := 0; i < fv.Len(); i++ {
+ if buf, err = marshal(append(append(append(buf, '[', '['), name...), ']', ']', '\n'), name, fv.Index(i), false, true); err != nil {
+ return nil, err
+ }
+ }
+ return buf, nil
+ }
+ buf = append(appendKey(buf, name, inArray, arrayTable), '[')
+ var err error
+ for i := 0; i < fv.Len(); i++ {
+ if i != 0 {
+ buf = append(buf, ',')
+ }
+ if buf, err = encodeValue(buf, prefix, name, fv.Index(i), true, false); err != nil {
+ return nil, err
+ }
+ }
+ return appendNewline(append(buf, ']'), inArray, arrayTable), nil
+ case reflect.Struct:
+ name := tableName(prefix, name)
+ return marshal(append(append(append(buf, '['), name...), ']', '\n'), name, fv, inArray, arrayTable)
+ case reflect.Interface:
+ var err error
+ if buf, err = encodeInterface(appendKey(buf, name, inArray, arrayTable), fv.Interface()); err != nil {
+ return nil, err
+ }
+ return appendNewline(buf, inArray, arrayTable), nil
+ }
+ return nil, fmt.Errorf("toml: marshal: unsupported type %v", fv.Kind())
+}
+
+func appendKey(buf []byte, key string, inArray, arrayTable bool) []byte {
+ if !inArray {
+ return append(append(buf, key...), '=')
+ }
+ return buf
+}
+
+func appendNewline(buf []byte, inArray, arrayTable bool) []byte {
+ if !inArray {
+ return append(buf, '\n')
+ }
+ return buf
+}
+
+func encodeInterface(buf []byte, v interface{}) ([]byte, error) {
+ switch v := v.(type) {
+ case int:
+ return encodeInt(buf, int64(v)), nil
+ case int8:
+ return encodeInt(buf, int64(v)), nil
+ case int16:
+ return encodeInt(buf, int64(v)), nil
+ case int32:
+ return encodeInt(buf, int64(v)), nil
+ case int64:
+ return encodeInt(buf, v), nil
+ case uint:
+ return encodeUint(buf, uint64(v)), nil
+ case uint8:
+ return encodeUint(buf, uint64(v)), nil
+ case uint16:
+ return encodeUint(buf, uint64(v)), nil
+ case uint32:
+ return encodeUint(buf, uint64(v)), nil
+ case uint64:
+ return encodeUint(buf, v), nil
+ case float32:
+ return encodeFloat(buf, float64(v)), nil
+ case float64:
+ return encodeFloat(buf, v), nil
+ case bool:
+ return encodeBool(buf, v), nil
+ case string:
+ return encodeString(buf, v), nil
+ }
+ return nil, fmt.Errorf("toml: marshal: unable to detect a type of value `%v'", v)
+}
+
+func encodeInt(buf []byte, i int64) []byte {
+ return strconv.AppendInt(buf, i, 10)
+}
+
+func encodeUint(buf []byte, u uint64) []byte {
+ return strconv.AppendUint(buf, u, 10)
+}
+
+func encodeFloat(buf []byte, f float64) []byte {
+ return strconv.AppendFloat(buf, f, 'e', -1, 64)
+}
+
+func encodeBool(buf []byte, b bool) []byte {
+ return strconv.AppendBool(buf, b)
+}
+
+func encodeString(buf []byte, s string) []byte {
+ return strconv.AppendQuote(buf, s)
+}
+
+func encodeTime(buf []byte, t time.Time) []byte {
+ return append(buf, t.Format(time.RFC3339Nano)...)
+}
diff --git a/Godeps/_workspace/src/github.com/naoina/toml/encode_test.go b/Godeps/_workspace/src/github.com/naoina/toml/encode_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..3445c879e5756aab000beca1931bdcf125daac35
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/toml/encode_test.go
@@ -0,0 +1,298 @@
+package toml_test
+
+import (
+ "reflect"
+ "testing"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/naoina/toml"
+)
+
+func TestMarshal(t *testing.T) {
+ for _, v := range []struct {
+ v interface{}
+ expect string
+ }{
+ {struct{ Name string }{"alice"}, "name=\"alice\"\n"},
+ {struct{ Age int }{7}, "age=7\n"},
+ {struct {
+ Name string
+ Age int
+ }{"alice", 7}, "name=\"alice\"\nage=7\n"},
+ {struct {
+ Name string `toml:"-"`
+ Age int
+ }{"alice", 7}, "age=7\n"},
+ {struct {
+ Name string `toml:"my_name"`
+ }{"bob"}, "my_name=\"bob\"\n"},
+ {struct {
+ Name string `toml:"my_name,omitempty"`
+ }{"bob"}, "my_name=\"bob\"\n"},
+ {struct {
+ Name string `toml:",omitempty"`
+ }{"bob"}, "name=\"bob\"\n"},
+ {struct {
+ Name string `toml:",omitempty"`
+ }{""}, ""},
+ } {
+ b, err := toml.Marshal(v.v)
+ var actual interface{} = err
+ var expect interface{} = nil
+ if !reflect.DeepEqual(actual, expect) {
+ t.Errorf(`Marshal(%#v) => %#v; want %#v`, v.v, actual, expect)
+ }
+
+ actual = string(b)
+ expect = v.expect
+ if !reflect.DeepEqual(actual, expect) {
+ t.Errorf(`Marshal(%#v); v => %#v; want %#v`, v, actual, expect)
+ }
+ }
+}
+
+func TestMarshalWhole(t *testing.T) {
+ for _, v := range []struct {
+ v interface{}
+ expect string
+ }{
+ {
+ testStruct{
+ Table: Table{
+ Key: "value",
+ Subtable: Subtable{
+ Key: "another value",
+ },
+ Inline: Inline{
+ Name: Name{
+ First: "Tom",
+ Last: "Preston-Werner",
+ },
+ Point: Point{
+ X: 1,
+ Y: 2,
+ },
+ },
+ },
+ X: X{},
+ String: String{
+ Basic: Basic{
+ Basic: "I'm a string. \"You can quote me\". Name\tJos\u00E9\nLocation\tSF.",
+ },
+ Multiline: Multiline{
+ Key1: "One\nTwo",
+ Continued: Continued{
+ Key1: "The quick brown fox jumps over the lazy dog.",
+ },
+ },
+ Literal: Literal{
+ Winpath: `C:\Users\nodejs\templates`,
+ Winpath2: `\\ServerX\admin$\system32\`,
+ Quoted: `Tom "Dubs" Preston-Werner`,
+ Regex: `<\i\c*\s*>`,
+ Multiline: LiteralMultiline{
+ Regex2: `I [dw]on't need \d{2} apples`,
+ Lines: "The first newline is\ntrimmed in raw strings.\n All other whitespace\n is preserved.\n",
+ },
+ },
+ },
+ Integer: Integer{
+ Key1: 99,
+ Key2: 42,
+ Key3: 0,
+ Key4: -17,
+ Underscores: IntegerUnderscores{
+ Key1: 1000,
+ Key2: 5349221,
+ Key3: 12345,
+ },
+ },
+ Float: Float{
+ Fractional: Fractional{
+ Key1: 1.0,
+ Key2: 3.1415,
+ Key3: -0.01,
+ },
+ Exponent: Exponent{
+ Key1: 5e22,
+ Key2: 1e6,
+ Key3: -2e-2,
+ },
+ Both: Both{
+ Key: 6.626e-34,
+ },
+ Underscores: FloatUnderscores{
+ Key1: 9224617.445991228313,
+ Key2: 1e100,
+ },
+ },
+ Boolean: Boolean{
+ True: true,
+ False: false,
+ },
+ Datetime: Datetime{
+ Key1: mustTime(time.Parse(time.RFC3339Nano, "1979-05-27T07:32:00Z")),
+ Key2: mustTime(time.Parse(time.RFC3339Nano, "1979-05-27T00:32:00-07:00")),
+ Key3: mustTime(time.Parse(time.RFC3339Nano, "1979-05-27T00:32:00.999999-07:00")),
+ },
+ Array: Array{
+ Key1: []int{1, 2, 3},
+ Key2: []string{"red", "yellow", "green"},
+ Key3: [][]int{{1, 2}, {3, 4, 5}},
+ Key4: [][]interface{}{{int64(1), int64(2)}, {"a", "b", "c"}},
+ Key5: []int{1, 2, 3},
+ Key6: []int{1, 2},
+ },
+ Products: []Product{
+ {Name: "Hammer", Sku: 738594937},
+ {},
+ {Name: "Nail", Sku: 284758393, Color: "gray"},
+ },
+ Fruit: []Fruit{
+ {
+ Name: "apple",
+ Physical: Physical{
+ Color: "red",
+ Shape: "round",
+ },
+ Variety: []Variety{
+ {Name: "red delicious"},
+ {Name: "granny smith"},
+ },
+ },
+ {
+ Name: "banana",
+ Variety: []Variety{
+ {Name: "plantain"},
+ },
+ },
+ },
+ },
+ `[table]
+key="value"
+[table.subtable]
+key="another value"
+[table.inline]
+[table.inline.name]
+first="Tom"
+last="Preston-Werner"
+[table.inline.point]
+x=1
+y=2
+[x]
+[x.y]
+[x.y.z]
+[x.y.z.w]
+[string]
+[string.basic]
+basic="I'm a string. \"You can quote me\". Name\tJosé\nLocation\tSF."
+[string.multiline]
+key1="One\nTwo"
+key2=""
+key3=""
+[string.multiline.continued]
+key1="The quick brown fox jumps over the lazy dog."
+key2=""
+key3=""
+[string.literal]
+winpath="C:\\Users\\nodejs\\templates"
+winpath2="\\\\ServerX\\admin$\\system32\\"
+quoted="Tom \"Dubs\" Preston-Werner"
+regex="<\\i\\c*\\s*>"
+[string.literal.multiline]
+regex2="I [dw]on't need \\d{2} apples"
+lines="The first newline is\ntrimmed in raw strings.\n All other whitespace\n is preserved.\n"
+[integer]
+key1=99
+key2=42
+key3=0
+key4=-17
+[integer.underscores]
+key1=1000
+key2=5349221
+key3=12345
+[float]
+[float.fractional]
+key1=1e+00
+key2=3.1415e+00
+key3=-1e-02
+[float.exponent]
+key1=5e+22
+key2=1e+06
+key3=-2e-02
+[float.both]
+key=6.626e-34
+[float.underscores]
+key1=9.224617445991227e+06
+key2=1e+100
+[boolean]
+true=true
+false=false
+[datetime]
+key1=1979-05-27T07:32:00Z
+key2=1979-05-27T00:32:00-07:00
+key3=1979-05-27T00:32:00.999999-07:00
+[array]
+key1=[1,2,3]
+key2=["red","yellow","green"]
+key3=[[1,2],[3,4,5]]
+key4=[[1,2],["a","b","c"]]
+key5=[1,2,3]
+key6=[1,2]
+[[products]]
+name="Hammer"
+sku=738594937
+color=""
+[[products]]
+name=""
+sku=0
+color=""
+[[products]]
+name="Nail"
+sku=284758393
+color="gray"
+[[fruit]]
+name="apple"
+[fruit.physical]
+color="red"
+shape="round"
+[[fruit.variety]]
+name="red delicious"
+[[fruit.variety]]
+name="granny smith"
+[[fruit]]
+name="banana"
+[fruit.physical]
+color=""
+shape=""
+[[fruit.variety]]
+name="plantain"
+`,
+ },
+ } {
+ b, err := toml.Marshal(v.v)
+ var actual interface{} = err
+ var expect interface{} = nil
+ if !reflect.DeepEqual(actual, expect) {
+ t.Errorf(`Marshal(%#v) => %#v; want %#v`, v.v, actual, expect)
+ }
+ actual = string(b)
+ expect = v.expect
+ if !reflect.DeepEqual(actual, expect) {
+ t.Errorf(`Marshal(%#v); v => %#v; want %#v`, v.v, actual, expect)
+ }
+
+ // test for reversible.
+ dest := testStruct{}
+ actual = toml.Unmarshal(b, &dest)
+ expect = nil
+ if !reflect.DeepEqual(actual, expect) {
+ t.Errorf(`Unmarshal after Marshal => %#v; want %#v`, actual, expect)
+ }
+ actual = dest
+ expect = v.v
+ if !reflect.DeepEqual(actual, expect) {
+ t.Errorf(`Unmarshal after Marshal => %#v; want %#v`, v, actual, expect)
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/naoina/toml/error.go b/Godeps/_workspace/src/github.com/naoina/toml/error.go
new file mode 100644
index 0000000000000000000000000000000000000000..0261b3c2bb5d8dd5e4b4f9acf981a31f9e585012
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/toml/error.go
@@ -0,0 +1,31 @@
+package toml
+
+import (
+ "fmt"
+ "reflect"
+)
+
+func (e *parseError) Line() int {
+ tokens := e.p.tokenTree.Error()
+ positions := make([]int, len(tokens)*2)
+ p := 0
+ for _, token := range tokens {
+ positions[p], p = int(token.begin), p+1
+ positions[p], p = int(token.end), p+1
+ }
+ for _, t := range translatePositions(e.p.Buffer, positions) {
+ if e.p.line < t.line {
+ e.p.line = t.line
+ }
+ }
+ return e.p.line
+}
+
+type errorOutOfRange struct {
+ kind reflect.Kind
+ v interface{}
+}
+
+func (err *errorOutOfRange) Error() string {
+ return fmt.Sprintf("value %d is out of range for `%v` type", err.v, err.kind)
+}
diff --git a/Godeps/_workspace/src/github.com/naoina/toml/parse.go b/Godeps/_workspace/src/github.com/naoina/toml/parse.go
new file mode 100644
index 0000000000000000000000000000000000000000..f7a3c83cdb47604ca716a0da17fd2e33b4b0ff0d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/toml/parse.go
@@ -0,0 +1,54 @@
+package toml
+
+import (
+ "fmt"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/naoina/toml/ast"
+)
+
+// Parse returns an AST representation of TOML.
+// The toplevel is represented by a table.
+func Parse(data []byte) (*ast.Table, error) {
+ d := &parseState{p: &tomlParser{Buffer: string(data)}}
+ d.init()
+
+ if err := d.parse(); err != nil {
+ return nil, err
+ }
+
+ return d.p.toml.table, nil
+}
+
+type parseState struct {
+ p *tomlParser
+}
+
+func (d *parseState) init() {
+ d.p.Init()
+ d.p.toml.init()
+}
+
+func (d *parseState) parse() error {
+ if err := d.p.Parse(); err != nil {
+ if err, ok := err.(*parseError); ok {
+ return fmt.Errorf("toml: line %d: parse error", err.Line())
+ }
+ return err
+ }
+ return d.execute()
+}
+
+func (d *parseState) execute() (err error) {
+ defer func() {
+ e := recover()
+ if e != nil {
+ cerr, ok := e.(convertError)
+ if !ok {
+ panic(e)
+ }
+ err = cerr.err
+ }
+ }()
+ d.p.Execute()
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/naoina/toml/parse.peg b/Godeps/_workspace/src/github.com/naoina/toml/parse.peg
new file mode 100644
index 0000000000000000000000000000000000000000..0380a201d82042915dee7701fbf677eb433adfaf
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/toml/parse.peg
@@ -0,0 +1,138 @@
+package toml
+
+type tomlParser Peg {
+ toml
+}
+
+TOML <- Expression (newline Expression)* newline? !. { _ = buffer }
+
+Expression <- (
+ <ws table ws comment? (wsnl keyval ws comment?)*> { p.SetTableString(begin, end) }
+ / ws keyval ws comment?
+ / ws comment?
+ / ws
+)
+
+newline <- <[\r\n]+> { p.AddLineCount(end - begin) }
+
+ws <- [ \t]*
+wsnl <- (
+ [ \t]
+ / <[\r\n]> { p.AddLineCount(end - begin) }
+)*
+
+comment <- '#' <[\t -\0x10FFFF]*>
+
+keyval <- key ws '=' ws val { p.AddKeyValue() }
+
+key <- bareKey / quotedKey
+
+bareKey <- <[0-9A-Za-z\-_]+> { p.SetKey(p.buffer, begin, end) }
+
+quotedKey <- '"' <basicChar+> '"' { p.SetKey(p.buffer, begin, end) }
+
+val <- (
+ <datetime> { p.SetTime(begin, end) }
+ / <float> { p.SetFloat64(begin, end) }
+ / <integer> { p.SetInt64(begin, end) }
+ / <string> { p.SetString(begin, end) }
+ / <boolean> { p.SetBool(begin, end) }
+ / <array> { p.SetArray(begin, end) }
+ / inlineTable
+)
+
+table <- stdTable / arrayTable
+
+stdTable <- '[' ws <tableKey> ws ']' { p.SetTable(p.buffer, begin, end) }
+
+arrayTable <- '[[' ws <tableKey> ws ']]' { p.SetArrayTable(p.buffer, begin, end) }
+
+inlineTable <- (
+ '{' { p.StartInlineTable() }
+ ws inlineTableKeyValues ws
+ '}' { p.EndInlineTable() }
+)
+
+inlineTableKeyValues <- (keyval inlineTableValSep?)*
+
+tableKey <- key (tableKeySep key)*
+
+tableKeySep <- ws '.' ws
+
+inlineTableValSep <- ws ',' ws
+
+integer <- [\-+]? int
+int <- [1-9] (digit / '_' digit)+ / digit
+
+float <- integer (frac exp? / frac? exp)
+frac <- '.' digit (digit / '_' digit)*
+exp <- [eE] [\-+]? digit (digit / '_' digit)*
+
+string <- (
+ mlLiteralString
+ / literalString
+ / mlBasicString
+ / basicString
+)
+
+basicString <- <'"' basicChar* '"'> { p.SetBasicString(p.buffer, begin, end) }
+
+basicChar <- basicUnescaped / escaped
+escaped <- escape ([btnfr"/\\] / 'u' hexQuad / 'U' hexQuad hexQuad)
+
+basicUnescaped <- [ -!#-\[\]-\0x10FFFF]
+
+escape <- '\\'
+
+mlBasicString <- '"""' mlBasicBody '"""' { p.SetMultilineString() }
+
+mlBasicBody <- (
+ <basicChar / newline> { p.AddMultilineBasicBody(p.buffer, begin, end) }
+ / escape newline wsnl
+)*
+
+literalString <- "'" <literalChar*> "'" { p.SetLiteralString(p.buffer, begin, end) }
+
+literalChar <- [\t -&(-\0x10FFFF]
+
+mlLiteralString <- "'''" <mlLiteralBody> "'''" { p.SetMultilineLiteralString(p.buffer, begin, end) }
+
+mlLiteralBody <- (!"'''" (mlLiteralChar / newline))*
+
+mlLiteralChar <- [\t -\0x10FFFF]
+
+hexdigit <- [0-9A-Fa-f]
+hexQuad <- hexdigit hexdigit hexdigit hexdigit
+
+boolean <- 'true' / 'false'
+
+dateFullYear <- digitQuad
+dateMonth <- digitDual
+dateMDay <- digitDual
+timeHour <- digitDual
+timeMinute <- digitDual
+timeSecond <- digitDual
+timeSecfrac <- '.' digit+
+timeNumoffset <- [\-+] timeHour ':' timeMinute
+timeOffset <- 'Z' / timeNumoffset
+partialTime <- timeHour ':' timeMinute ':' timeSecond timeSecfrac?
+fullDate <- dateFullYear '-' dateMonth '-' dateMDay
+fullTime <- partialTime timeOffset
+datetime <- fullDate 'T' fullTime
+
+digit <- [0-9]
+digitDual <- digit digit
+digitQuad <- digitDual digitDual
+
+array <- (
+ '[' { p.StartArray() }
+ wsnl arrayValues wsnl
+ ']'
+)
+
+arrayValues <- (
+ val { p.AddArrayVal() }
+ arraySep? (comment? newline)?
+)*
+
+arraySep <- ws ',' wsnl
diff --git a/Godeps/_workspace/src/github.com/naoina/toml/parse.peg.go b/Godeps/_workspace/src/github.com/naoina/toml/parse.peg.go
new file mode 100644
index 0000000000000000000000000000000000000000..ce967e968e7f97bd170fd363313a80c0117970bf
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/toml/parse.peg.go
@@ -0,0 +1,3065 @@
+package toml
+
+import (
+ "fmt"
+ "math"
+ "sort"
+ "strconv"
+)
+
+const end_symbol rune = 4
+
+/* The rule types inferred from the grammar are below. */
+type pegRule uint8
+
+const (
+ ruleUnknown pegRule = iota
+ ruleTOML
+ ruleExpression
+ rulenewline
+ rulews
+ rulewsnl
+ rulecomment
+ rulekeyval
+ rulekey
+ rulebareKey
+ rulequotedKey
+ ruleval
+ ruletable
+ rulestdTable
+ rulearrayTable
+ ruleinlineTable
+ ruleinlineTableKeyValues
+ ruletableKey
+ ruletableKeySep
+ ruleinlineTableValSep
+ ruleinteger
+ ruleint
+ rulefloat
+ rulefrac
+ ruleexp
+ rulestring
+ rulebasicString
+ rulebasicChar
+ ruleescaped
+ rulebasicUnescaped
+ ruleescape
+ rulemlBasicString
+ rulemlBasicBody
+ ruleliteralString
+ ruleliteralChar
+ rulemlLiteralString
+ rulemlLiteralBody
+ rulemlLiteralChar
+ rulehexdigit
+ rulehexQuad
+ ruleboolean
+ ruledateFullYear
+ ruledateMonth
+ ruledateMDay
+ ruletimeHour
+ ruletimeMinute
+ ruletimeSecond
+ ruletimeSecfrac
+ ruletimeNumoffset
+ ruletimeOffset
+ rulepartialTime
+ rulefullDate
+ rulefullTime
+ ruledatetime
+ ruledigit
+ ruledigitDual
+ ruledigitQuad
+ rulearray
+ rulearrayValues
+ rulearraySep
+ ruleAction0
+ rulePegText
+ ruleAction1
+ ruleAction2
+ ruleAction3
+ ruleAction4
+ ruleAction5
+ ruleAction6
+ ruleAction7
+ ruleAction8
+ ruleAction9
+ ruleAction10
+ ruleAction11
+ ruleAction12
+ ruleAction13
+ ruleAction14
+ ruleAction15
+ ruleAction16
+ ruleAction17
+ ruleAction18
+ ruleAction19
+ ruleAction20
+ ruleAction21
+ ruleAction22
+ ruleAction23
+
+ rulePre_
+ rule_In_
+ rule_Suf
+)
+
+var rul3s = [...]string{
+ "Unknown",
+ "TOML",
+ "Expression",
+ "newline",
+ "ws",
+ "wsnl",
+ "comment",
+ "keyval",
+ "key",
+ "bareKey",
+ "quotedKey",
+ "val",
+ "table",
+ "stdTable",
+ "arrayTable",
+ "inlineTable",
+ "inlineTableKeyValues",
+ "tableKey",
+ "tableKeySep",
+ "inlineTableValSep",
+ "integer",
+ "int",
+ "float",
+ "frac",
+ "exp",
+ "string",
+ "basicString",
+ "basicChar",
+ "escaped",
+ "basicUnescaped",
+ "escape",
+ "mlBasicString",
+ "mlBasicBody",
+ "literalString",
+ "literalChar",
+ "mlLiteralString",
+ "mlLiteralBody",
+ "mlLiteralChar",
+ "hexdigit",
+ "hexQuad",
+ "boolean",
+ "dateFullYear",
+ "dateMonth",
+ "dateMDay",
+ "timeHour",
+ "timeMinute",
+ "timeSecond",
+ "timeSecfrac",
+ "timeNumoffset",
+ "timeOffset",
+ "partialTime",
+ "fullDate",
+ "fullTime",
+ "datetime",
+ "digit",
+ "digitDual",
+ "digitQuad",
+ "array",
+ "arrayValues",
+ "arraySep",
+ "Action0",
+ "PegText",
+ "Action1",
+ "Action2",
+ "Action3",
+ "Action4",
+ "Action5",
+ "Action6",
+ "Action7",
+ "Action8",
+ "Action9",
+ "Action10",
+ "Action11",
+ "Action12",
+ "Action13",
+ "Action14",
+ "Action15",
+ "Action16",
+ "Action17",
+ "Action18",
+ "Action19",
+ "Action20",
+ "Action21",
+ "Action22",
+ "Action23",
+
+ "Pre_",
+ "_In_",
+ "_Suf",
+}
+
+type tokenTree interface {
+ Print()
+ PrintSyntax()
+ PrintSyntaxTree(buffer string)
+ Add(rule pegRule, begin, end, next, depth int)
+ Expand(index int) tokenTree
+ Tokens() <-chan token32
+ AST() *node32
+ Error() []token32
+ trim(length int)
+}
+
+type node32 struct {
+ token32
+ up, next *node32
+}
+
+func (node *node32) print(depth int, buffer string) {
+ for node != nil {
+ for c := 0; c < depth; c++ {
+ fmt.Printf(" ")
+ }
+ fmt.Printf("\x1B[34m%v\x1B[m %v\n", rul3s[node.pegRule], strconv.Quote(string(([]rune(buffer)[node.begin:node.end]))))
+ if node.up != nil {
+ node.up.print(depth+1, buffer)
+ }
+ node = node.next
+ }
+}
+
+func (ast *node32) Print(buffer string) {
+ ast.print(0, buffer)
+}
+
+type element struct {
+ node *node32
+ down *element
+}
+
+/* ${@} bit structure for abstract syntax tree */
+type token16 struct {
+ pegRule
+ begin, end, next int16
+}
+
+func (t *token16) isZero() bool {
+ return t.pegRule == ruleUnknown && t.begin == 0 && t.end == 0 && t.next == 0
+}
+
+func (t *token16) isParentOf(u token16) bool {
+ return t.begin <= u.begin && t.end >= u.end && t.next > u.next
+}
+
+func (t *token16) getToken32() token32 {
+ return token32{pegRule: t.pegRule, begin: int32(t.begin), end: int32(t.end), next: int32(t.next)}
+}
+
+func (t *token16) String() string {
+ return fmt.Sprintf("\x1B[34m%v\x1B[m %v %v %v", rul3s[t.pegRule], t.begin, t.end, t.next)
+}
+
+type tokens16 struct {
+ tree []token16
+ ordered [][]token16
+}
+
+func (t *tokens16) trim(length int) {
+ t.tree = t.tree[0:length]
+}
+
+func (t *tokens16) Print() {
+ for _, token := range t.tree {
+ fmt.Println(token.String())
+ }
+}
+
+func (t *tokens16) Order() [][]token16 {
+ if t.ordered != nil {
+ return t.ordered
+ }
+
+ depths := make([]int16, 1, math.MaxInt16)
+ for i, token := range t.tree {
+ if token.pegRule == ruleUnknown {
+ t.tree = t.tree[:i]
+ break
+ }
+ depth := int(token.next)
+ if length := len(depths); depth >= length {
+ depths = depths[:depth+1]
+ }
+ depths[depth]++
+ }
+ depths = append(depths, 0)
+
+ ordered, pool := make([][]token16, len(depths)), make([]token16, len(t.tree)+len(depths))
+ for i, depth := range depths {
+ depth++
+ ordered[i], pool, depths[i] = pool[:depth], pool[depth:], 0
+ }
+
+ for i, token := range t.tree {
+ depth := token.next
+ token.next = int16(i)
+ ordered[depth][depths[depth]] = token
+ depths[depth]++
+ }
+ t.ordered = ordered
+ return ordered
+}
+
+type state16 struct {
+ token16
+ depths []int16
+ leaf bool
+}
+
+func (t *tokens16) AST() *node32 {
+ tokens := t.Tokens()
+ stack := &element{node: &node32{token32: <-tokens}}
+ for token := range tokens {
+ if token.begin == token.end {
+ continue
+ }
+ node := &node32{token32: token}
+ for stack != nil && stack.node.begin >= token.begin && stack.node.end <= token.end {
+ stack.node.next = node.up
+ node.up = stack.node
+ stack = stack.down
+ }
+ stack = &element{node: node, down: stack}
+ }
+ return stack.node
+}
+
+func (t *tokens16) PreOrder() (<-chan state16, [][]token16) {
+ s, ordered := make(chan state16, 6), t.Order()
+ go func() {
+ var states [8]state16
+ for i, _ := range states {
+ states[i].depths = make([]int16, len(ordered))
+ }
+ depths, state, depth := make([]int16, len(ordered)), 0, 1
+ write := func(t token16, leaf bool) {
+ S := states[state]
+ state, S.pegRule, S.begin, S.end, S.next, S.leaf = (state+1)%8, t.pegRule, t.begin, t.end, int16(depth), leaf
+ copy(S.depths, depths)
+ s <- S
+ }
+
+ states[state].token16 = ordered[0][0]
+ depths[0]++
+ state++
+ a, b := ordered[depth-1][depths[depth-1]-1], ordered[depth][depths[depth]]
+ depthFirstSearch:
+ for {
+ for {
+ if i := depths[depth]; i > 0 {
+ if c, j := ordered[depth][i-1], depths[depth-1]; a.isParentOf(c) &&
+ (j < 2 || !ordered[depth-1][j-2].isParentOf(c)) {
+ if c.end != b.begin {
+ write(token16{pegRule: rule_In_, begin: c.end, end: b.begin}, true)
+ }
+ break
+ }
+ }
+
+ if a.begin < b.begin {
+ write(token16{pegRule: rulePre_, begin: a.begin, end: b.begin}, true)
+ }
+ break
+ }
+
+ next := depth + 1
+ if c := ordered[next][depths[next]]; c.pegRule != ruleUnknown && b.isParentOf(c) {
+ write(b, false)
+ depths[depth]++
+ depth, a, b = next, b, c
+ continue
+ }
+
+ write(b, true)
+ depths[depth]++
+ c, parent := ordered[depth][depths[depth]], true
+ for {
+ if c.pegRule != ruleUnknown && a.isParentOf(c) {
+ b = c
+ continue depthFirstSearch
+ } else if parent && b.end != a.end {
+ write(token16{pegRule: rule_Suf, begin: b.end, end: a.end}, true)
+ }
+
+ depth--
+ if depth > 0 {
+ a, b, c = ordered[depth-1][depths[depth-1]-1], a, ordered[depth][depths[depth]]
+ parent = a.isParentOf(b)
+ continue
+ }
+
+ break depthFirstSearch
+ }
+ }
+
+ close(s)
+ }()
+ return s, ordered
+}
+
+func (t *tokens16) PrintSyntax() {
+ tokens, ordered := t.PreOrder()
+ max := -1
+ for token := range tokens {
+ if !token.leaf {
+ fmt.Printf("%v", token.begin)
+ for i, leaf, depths := 0, int(token.next), token.depths; i < leaf; i++ {
+ fmt.Printf(" \x1B[36m%v\x1B[m", rul3s[ordered[i][depths[i]-1].pegRule])
+ }
+ fmt.Printf(" \x1B[36m%v\x1B[m\n", rul3s[token.pegRule])
+ } else if token.begin == token.end {
+ fmt.Printf("%v", token.begin)
+ for i, leaf, depths := 0, int(token.next), token.depths; i < leaf; i++ {
+ fmt.Printf(" \x1B[31m%v\x1B[m", rul3s[ordered[i][depths[i]-1].pegRule])
+ }
+ fmt.Printf(" \x1B[31m%v\x1B[m\n", rul3s[token.pegRule])
+ } else {
+ for c, end := token.begin, token.end; c < end; c++ {
+ if i := int(c); max+1 < i {
+ for j := max; j < i; j++ {
+ fmt.Printf("skip %v %v\n", j, token.String())
+ }
+ max = i
+ } else if i := int(c); i <= max {
+ for j := i; j <= max; j++ {
+ fmt.Printf("dupe %v %v\n", j, token.String())
+ }
+ } else {
+ max = int(c)
+ }
+ fmt.Printf("%v", c)
+ for i, leaf, depths := 0, int(token.next), token.depths; i < leaf; i++ {
+ fmt.Printf(" \x1B[34m%v\x1B[m", rul3s[ordered[i][depths[i]-1].pegRule])
+ }
+ fmt.Printf(" \x1B[34m%v\x1B[m\n", rul3s[token.pegRule])
+ }
+ fmt.Printf("\n")
+ }
+ }
+}
+
+func (t *tokens16) PrintSyntaxTree(buffer string) {
+ tokens, _ := t.PreOrder()
+ for token := range tokens {
+ for c := 0; c < int(token.next); c++ {
+ fmt.Printf(" ")
+ }
+ fmt.Printf("\x1B[34m%v\x1B[m %v\n", rul3s[token.pegRule], strconv.Quote(string(([]rune(buffer)[token.begin:token.end]))))
+ }
+}
+
+func (t *tokens16) Add(rule pegRule, begin, end, depth, index int) {
+ t.tree[index] = token16{pegRule: rule, begin: int16(begin), end: int16(end), next: int16(depth)}
+}
+
+func (t *tokens16) Tokens() <-chan token32 {
+ s := make(chan token32, 16)
+ go func() {
+ for _, v := range t.tree {
+ s <- v.getToken32()
+ }
+ close(s)
+ }()
+ return s
+}
+
+func (t *tokens16) Error() []token32 {
+ ordered := t.Order()
+ length := len(ordered)
+ tokens, length := make([]token32, length), length-1
+ for i, _ := range tokens {
+ o := ordered[length-i]
+ if len(o) > 1 {
+ tokens[i] = o[len(o)-2].getToken32()
+ }
+ }
+ return tokens
+}
+
+/* ${@} bit structure for abstract syntax tree */
+type token32 struct {
+ pegRule
+ begin, end, next int32
+}
+
+func (t *token32) isZero() bool {
+ return t.pegRule == ruleUnknown && t.begin == 0 && t.end == 0 && t.next == 0
+}
+
+func (t *token32) isParentOf(u token32) bool {
+ return t.begin <= u.begin && t.end >= u.end && t.next > u.next
+}
+
+func (t *token32) getToken32() token32 {
+ return token32{pegRule: t.pegRule, begin: int32(t.begin), end: int32(t.end), next: int32(t.next)}
+}
+
+func (t *token32) String() string {
+ return fmt.Sprintf("\x1B[34m%v\x1B[m %v %v %v", rul3s[t.pegRule], t.begin, t.end, t.next)
+}
+
+type tokens32 struct {
+ tree []token32
+ ordered [][]token32
+}
+
+func (t *tokens32) trim(length int) {
+ t.tree = t.tree[0:length]
+}
+
+func (t *tokens32) Print() {
+ for _, token := range t.tree {
+ fmt.Println(token.String())
+ }
+}
+
+func (t *tokens32) Order() [][]token32 {
+ if t.ordered != nil {
+ return t.ordered
+ }
+
+ depths := make([]int32, 1, math.MaxInt16)
+ for i, token := range t.tree {
+ if token.pegRule == ruleUnknown {
+ t.tree = t.tree[:i]
+ break
+ }
+ depth := int(token.next)
+ if length := len(depths); depth >= length {
+ depths = depths[:depth+1]
+ }
+ depths[depth]++
+ }
+ depths = append(depths, 0)
+
+ ordered, pool := make([][]token32, len(depths)), make([]token32, len(t.tree)+len(depths))
+ for i, depth := range depths {
+ depth++
+ ordered[i], pool, depths[i] = pool[:depth], pool[depth:], 0
+ }
+
+ for i, token := range t.tree {
+ depth := token.next
+ token.next = int32(i)
+ ordered[depth][depths[depth]] = token
+ depths[depth]++
+ }
+ t.ordered = ordered
+ return ordered
+}
+
+type state32 struct {
+ token32
+ depths []int32
+ leaf bool
+}
+
+func (t *tokens32) AST() *node32 {
+ tokens := t.Tokens()
+ stack := &element{node: &node32{token32: <-tokens}}
+ for token := range tokens {
+ if token.begin == token.end {
+ continue
+ }
+ node := &node32{token32: token}
+ for stack != nil && stack.node.begin >= token.begin && stack.node.end <= token.end {
+ stack.node.next = node.up
+ node.up = stack.node
+ stack = stack.down
+ }
+ stack = &element{node: node, down: stack}
+ }
+ return stack.node
+}
+
+func (t *tokens32) PreOrder() (<-chan state32, [][]token32) {
+ s, ordered := make(chan state32, 6), t.Order()
+ go func() {
+ var states [8]state32
+ for i, _ := range states {
+ states[i].depths = make([]int32, len(ordered))
+ }
+ depths, state, depth := make([]int32, len(ordered)), 0, 1
+ write := func(t token32, leaf bool) {
+ S := states[state]
+ state, S.pegRule, S.begin, S.end, S.next, S.leaf = (state+1)%8, t.pegRule, t.begin, t.end, int32(depth), leaf
+ copy(S.depths, depths)
+ s <- S
+ }
+
+ states[state].token32 = ordered[0][0]
+ depths[0]++
+ state++
+ a, b := ordered[depth-1][depths[depth-1]-1], ordered[depth][depths[depth]]
+ depthFirstSearch:
+ for {
+ for {
+ if i := depths[depth]; i > 0 {
+ if c, j := ordered[depth][i-1], depths[depth-1]; a.isParentOf(c) &&
+ (j < 2 || !ordered[depth-1][j-2].isParentOf(c)) {
+ if c.end != b.begin {
+ write(token32{pegRule: rule_In_, begin: c.end, end: b.begin}, true)
+ }
+ break
+ }
+ }
+
+ if a.begin < b.begin {
+ write(token32{pegRule: rulePre_, begin: a.begin, end: b.begin}, true)
+ }
+ break
+ }
+
+ next := depth + 1
+ if c := ordered[next][depths[next]]; c.pegRule != ruleUnknown && b.isParentOf(c) {
+ write(b, false)
+ depths[depth]++
+ depth, a, b = next, b, c
+ continue
+ }
+
+ write(b, true)
+ depths[depth]++
+ c, parent := ordered[depth][depths[depth]], true
+ for {
+ if c.pegRule != ruleUnknown && a.isParentOf(c) {
+ b = c
+ continue depthFirstSearch
+ } else if parent && b.end != a.end {
+ write(token32{pegRule: rule_Suf, begin: b.end, end: a.end}, true)
+ }
+
+ depth--
+ if depth > 0 {
+ a, b, c = ordered[depth-1][depths[depth-1]-1], a, ordered[depth][depths[depth]]
+ parent = a.isParentOf(b)
+ continue
+ }
+
+ break depthFirstSearch
+ }
+ }
+
+ close(s)
+ }()
+ return s, ordered
+}
+
+func (t *tokens32) PrintSyntax() {
+ tokens, ordered := t.PreOrder()
+ max := -1
+ for token := range tokens {
+ if !token.leaf {
+ fmt.Printf("%v", token.begin)
+ for i, leaf, depths := 0, int(token.next), token.depths; i < leaf; i++ {
+ fmt.Printf(" \x1B[36m%v\x1B[m", rul3s[ordered[i][depths[i]-1].pegRule])
+ }
+ fmt.Printf(" \x1B[36m%v\x1B[m\n", rul3s[token.pegRule])
+ } else if token.begin == token.end {
+ fmt.Printf("%v", token.begin)
+ for i, leaf, depths := 0, int(token.next), token.depths; i < leaf; i++ {
+ fmt.Printf(" \x1B[31m%v\x1B[m", rul3s[ordered[i][depths[i]-1].pegRule])
+ }
+ fmt.Printf(" \x1B[31m%v\x1B[m\n", rul3s[token.pegRule])
+ } else {
+ for c, end := token.begin, token.end; c < end; c++ {
+ if i := int(c); max+1 < i {
+ for j := max; j < i; j++ {
+ fmt.Printf("skip %v %v\n", j, token.String())
+ }
+ max = i
+ } else if i := int(c); i <= max {
+ for j := i; j <= max; j++ {
+ fmt.Printf("dupe %v %v\n", j, token.String())
+ }
+ } else {
+ max = int(c)
+ }
+ fmt.Printf("%v", c)
+ for i, leaf, depths := 0, int(token.next), token.depths; i < leaf; i++ {
+ fmt.Printf(" \x1B[34m%v\x1B[m", rul3s[ordered[i][depths[i]-1].pegRule])
+ }
+ fmt.Printf(" \x1B[34m%v\x1B[m\n", rul3s[token.pegRule])
+ }
+ fmt.Printf("\n")
+ }
+ }
+}
+
+func (t *tokens32) PrintSyntaxTree(buffer string) {
+ tokens, _ := t.PreOrder()
+ for token := range tokens {
+ for c := 0; c < int(token.next); c++ {
+ fmt.Printf(" ")
+ }
+ fmt.Printf("\x1B[34m%v\x1B[m %v\n", rul3s[token.pegRule], strconv.Quote(string(([]rune(buffer)[token.begin:token.end]))))
+ }
+}
+
+func (t *tokens32) Add(rule pegRule, begin, end, depth, index int) {
+ t.tree[index] = token32{pegRule: rule, begin: int32(begin), end: int32(end), next: int32(depth)}
+}
+
+func (t *tokens32) Tokens() <-chan token32 {
+ s := make(chan token32, 16)
+ go func() {
+ for _, v := range t.tree {
+ s <- v.getToken32()
+ }
+ close(s)
+ }()
+ return s
+}
+
+func (t *tokens32) Error() []token32 {
+ ordered := t.Order()
+ length := len(ordered)
+ tokens, length := make([]token32, length), length-1
+ for i, _ := range tokens {
+ o := ordered[length-i]
+ if len(o) > 1 {
+ tokens[i] = o[len(o)-2].getToken32()
+ }
+ }
+ return tokens
+}
+
+func (t *tokens16) Expand(index int) tokenTree {
+ tree := t.tree
+ if index >= len(tree) {
+ expanded := make([]token32, 2*len(tree))
+ for i, v := range tree {
+ expanded[i] = v.getToken32()
+ }
+ return &tokens32{tree: expanded}
+ }
+ return nil
+}
+
+func (t *tokens32) Expand(index int) tokenTree {
+ tree := t.tree
+ if index >= len(tree) {
+ expanded := make([]token32, 2*len(tree))
+ copy(expanded, tree)
+ t.tree = expanded
+ }
+ return nil
+}
+
+type tomlParser struct {
+ toml
+
+ Buffer string
+ buffer []rune
+ rules [85]func() bool
+ Parse func(rule ...int) error
+ Reset func()
+ tokenTree
+}
+
+type textPosition struct {
+ line, symbol int
+}
+
+type textPositionMap map[int]textPosition
+
+func translatePositions(buffer string, positions []int) textPositionMap {
+ length, translations, j, line, symbol := len(positions), make(textPositionMap, len(positions)), 0, 1, 0
+ sort.Ints(positions)
+
+search:
+ for i, c := range buffer[0:] {
+ if c == '\n' {
+ line, symbol = line+1, 0
+ } else {
+ symbol++
+ }
+ if i == positions[j] {
+ translations[positions[j]] = textPosition{line, symbol}
+ for j++; j < length; j++ {
+ if i != positions[j] {
+ continue search
+ }
+ }
+ break search
+ }
+ }
+
+ return translations
+}
+
+type parseError struct {
+ p *tomlParser
+}
+
+func (e *parseError) Error() string {
+ tokens, error := e.p.tokenTree.Error(), "\n"
+ positions, p := make([]int, 2*len(tokens)), 0
+ for _, token := range tokens {
+ positions[p], p = int(token.begin), p+1
+ positions[p], p = int(token.end), p+1
+ }
+ translations := translatePositions(e.p.Buffer, positions)
+ for _, token := range tokens {
+ begin, end := int(token.begin), int(token.end)
+ error += fmt.Sprintf("parse error near \x1B[34m%v\x1B[m (line %v symbol %v - line %v symbol %v):\n%v\n",
+ rul3s[token.pegRule],
+ translations[begin].line, translations[begin].symbol,
+ translations[end].line, translations[end].symbol,
+ /*strconv.Quote(*/ e.p.Buffer[begin:end] /*)*/)
+ }
+
+ return error
+}
+
+func (p *tomlParser) PrintSyntaxTree() {
+ p.tokenTree.PrintSyntaxTree(p.Buffer)
+}
+
+func (p *tomlParser) Highlighter() {
+ p.tokenTree.PrintSyntax()
+}
+
+func (p *tomlParser) Execute() {
+ buffer, begin, end := p.Buffer, 0, 0
+ for token := range p.tokenTree.Tokens() {
+ switch token.pegRule {
+
+ case rulePegText:
+ begin, end = int(token.begin), int(token.end)
+
+ case ruleAction0:
+ _ = buffer
+ case ruleAction1:
+ p.SetTableString(begin, end)
+ case ruleAction2:
+ p.AddLineCount(end - begin)
+ case ruleAction3:
+ p.AddLineCount(end - begin)
+ case ruleAction4:
+ p.AddKeyValue()
+ case ruleAction5:
+ p.SetKey(p.buffer, begin, end)
+ case ruleAction6:
+ p.SetKey(p.buffer, begin, end)
+ case ruleAction7:
+ p.SetTime(begin, end)
+ case ruleAction8:
+ p.SetFloat64(begin, end)
+ case ruleAction9:
+ p.SetInt64(begin, end)
+ case ruleAction10:
+ p.SetString(begin, end)
+ case ruleAction11:
+ p.SetBool(begin, end)
+ case ruleAction12:
+ p.SetArray(begin, end)
+ case ruleAction13:
+ p.SetTable(p.buffer, begin, end)
+ case ruleAction14:
+ p.SetArrayTable(p.buffer, begin, end)
+ case ruleAction15:
+ p.StartInlineTable()
+ case ruleAction16:
+ p.EndInlineTable()
+ case ruleAction17:
+ p.SetBasicString(p.buffer, begin, end)
+ case ruleAction18:
+ p.SetMultilineString()
+ case ruleAction19:
+ p.AddMultilineBasicBody(p.buffer, begin, end)
+ case ruleAction20:
+ p.SetLiteralString(p.buffer, begin, end)
+ case ruleAction21:
+ p.SetMultilineLiteralString(p.buffer, begin, end)
+ case ruleAction22:
+ p.StartArray()
+ case ruleAction23:
+ p.AddArrayVal()
+
+ }
+ }
+ _, _, _ = buffer, begin, end
+}
+
+func (p *tomlParser) Init() {
+ p.buffer = []rune(p.Buffer)
+ if len(p.buffer) == 0 || p.buffer[len(p.buffer)-1] != end_symbol {
+ p.buffer = append(p.buffer, end_symbol)
+ }
+
+ var tree tokenTree = &tokens16{tree: make([]token16, math.MaxInt16)}
+ position, depth, tokenIndex, buffer, _rules := 0, 0, 0, p.buffer, p.rules
+
+ p.Parse = func(rule ...int) error {
+ r := 1
+ if len(rule) > 0 {
+ r = rule[0]
+ }
+ matches := p.rules[r]()
+ p.tokenTree = tree
+ if matches {
+ p.tokenTree.trim(tokenIndex)
+ return nil
+ }
+ return &parseError{p}
+ }
+
+ p.Reset = func() {
+ position, tokenIndex, depth = 0, 0, 0
+ }
+
+ add := func(rule pegRule, begin int) {
+ if t := tree.Expand(tokenIndex); t != nil {
+ tree = t
+ }
+ tree.Add(rule, begin, position, depth, tokenIndex)
+ tokenIndex++
+ }
+
+ matchDot := func() bool {
+ if buffer[position] != end_symbol {
+ position++
+ return true
+ }
+ return false
+ }
+
+ /*matchChar := func(c byte) bool {
+ if buffer[position] == c {
+ position++
+ return true
+ }
+ return false
+ }*/
+
+ /*matchRange := func(lower byte, upper byte) bool {
+ if c := buffer[position]; c >= lower && c <= upper {
+ position++
+ return true
+ }
+ return false
+ }*/
+
+ _rules = [...]func() bool{
+ nil,
+ /* 0 TOML <- <(Expression (newline Expression)* newline? !. Action0)> */
+ func() bool {
+ position0, tokenIndex0, depth0 := position, tokenIndex, depth
+ {
+ position1 := position
+ depth++
+ if !_rules[ruleExpression]() {
+ goto l0
+ }
+ l2:
+ {
+ position3, tokenIndex3, depth3 := position, tokenIndex, depth
+ if !_rules[rulenewline]() {
+ goto l3
+ }
+ if !_rules[ruleExpression]() {
+ goto l3
+ }
+ goto l2
+ l3:
+ position, tokenIndex, depth = position3, tokenIndex3, depth3
+ }
+ {
+ position4, tokenIndex4, depth4 := position, tokenIndex, depth
+ if !_rules[rulenewline]() {
+ goto l4
+ }
+ goto l5
+ l4:
+ position, tokenIndex, depth = position4, tokenIndex4, depth4
+ }
+ l5:
+ {
+ position6, tokenIndex6, depth6 := position, tokenIndex, depth
+ if !matchDot() {
+ goto l6
+ }
+ goto l0
+ l6:
+ position, tokenIndex, depth = position6, tokenIndex6, depth6
+ }
+ {
+ add(ruleAction0, position)
+ }
+ depth--
+ add(ruleTOML, position1)
+ }
+ return true
+ l0:
+ position, tokenIndex, depth = position0, tokenIndex0, depth0
+ return false
+ },
+ /* 1 Expression <- <((<(ws table ws comment? (wsnl keyval ws comment?)*)> Action1) / (ws keyval ws comment?) / (ws comment?) / ws)> */
+ func() bool {
+ position8, tokenIndex8, depth8 := position, tokenIndex, depth
+ {
+ position9 := position
+ depth++
+ {
+ position10, tokenIndex10, depth10 := position, tokenIndex, depth
+ {
+ position12 := position
+ depth++
+ if !_rules[rulews]() {
+ goto l11
+ }
+ {
+ position13 := position
+ depth++
+ {
+ position14, tokenIndex14, depth14 := position, tokenIndex, depth
+ {
+ position16 := position
+ depth++
+ if buffer[position] != rune('[') {
+ goto l15
+ }
+ position++
+ if !_rules[rulews]() {
+ goto l15
+ }
+ {
+ position17 := position
+ depth++
+ if !_rules[ruletableKey]() {
+ goto l15
+ }
+ depth--
+ add(rulePegText, position17)
+ }
+ if !_rules[rulews]() {
+ goto l15
+ }
+ if buffer[position] != rune(']') {
+ goto l15
+ }
+ position++
+ {
+ add(ruleAction13, position)
+ }
+ depth--
+ add(rulestdTable, position16)
+ }
+ goto l14
+ l15:
+ position, tokenIndex, depth = position14, tokenIndex14, depth14
+ {
+ position19 := position
+ depth++
+ if buffer[position] != rune('[') {
+ goto l11
+ }
+ position++
+ if buffer[position] != rune('[') {
+ goto l11
+ }
+ position++
+ if !_rules[rulews]() {
+ goto l11
+ }
+ {
+ position20 := position
+ depth++
+ if !_rules[ruletableKey]() {
+ goto l11
+ }
+ depth--
+ add(rulePegText, position20)
+ }
+ if !_rules[rulews]() {
+ goto l11
+ }
+ if buffer[position] != rune(']') {
+ goto l11
+ }
+ position++
+ if buffer[position] != rune(']') {
+ goto l11
+ }
+ position++
+ {
+ add(ruleAction14, position)
+ }
+ depth--
+ add(rulearrayTable, position19)
+ }
+ }
+ l14:
+ depth--
+ add(ruletable, position13)
+ }
+ if !_rules[rulews]() {
+ goto l11
+ }
+ {
+ position22, tokenIndex22, depth22 := position, tokenIndex, depth
+ if !_rules[rulecomment]() {
+ goto l22
+ }
+ goto l23
+ l22:
+ position, tokenIndex, depth = position22, tokenIndex22, depth22
+ }
+ l23:
+ l24:
+ {
+ position25, tokenIndex25, depth25 := position, tokenIndex, depth
+ if !_rules[rulewsnl]() {
+ goto l25
+ }
+ if !_rules[rulekeyval]() {
+ goto l25
+ }
+ if !_rules[rulews]() {
+ goto l25
+ }
+ {
+ position26, tokenIndex26, depth26 := position, tokenIndex, depth
+ if !_rules[rulecomment]() {
+ goto l26
+ }
+ goto l27
+ l26:
+ position, tokenIndex, depth = position26, tokenIndex26, depth26
+ }
+ l27:
+ goto l24
+ l25:
+ position, tokenIndex, depth = position25, tokenIndex25, depth25
+ }
+ depth--
+ add(rulePegText, position12)
+ }
+ {
+ add(ruleAction1, position)
+ }
+ goto l10
+ l11:
+ position, tokenIndex, depth = position10, tokenIndex10, depth10
+ if !_rules[rulews]() {
+ goto l29
+ }
+ if !_rules[rulekeyval]() {
+ goto l29
+ }
+ if !_rules[rulews]() {
+ goto l29
+ }
+ {
+ position30, tokenIndex30, depth30 := position, tokenIndex, depth
+ if !_rules[rulecomment]() {
+ goto l30
+ }
+ goto l31
+ l30:
+ position, tokenIndex, depth = position30, tokenIndex30, depth30
+ }
+ l31:
+ goto l10
+ l29:
+ position, tokenIndex, depth = position10, tokenIndex10, depth10
+ if !_rules[rulews]() {
+ goto l32
+ }
+ {
+ position33, tokenIndex33, depth33 := position, tokenIndex, depth
+ if !_rules[rulecomment]() {
+ goto l33
+ }
+ goto l34
+ l33:
+ position, tokenIndex, depth = position33, tokenIndex33, depth33
+ }
+ l34:
+ goto l10
+ l32:
+ position, tokenIndex, depth = position10, tokenIndex10, depth10
+ if !_rules[rulews]() {
+ goto l8
+ }
+ }
+ l10:
+ depth--
+ add(ruleExpression, position9)
+ }
+ return true
+ l8:
+ position, tokenIndex, depth = position8, tokenIndex8, depth8
+ return false
+ },
+ /* 2 newline <- <(<('\r' / '\n')+> Action2)> */
+ func() bool {
+ position35, tokenIndex35, depth35 := position, tokenIndex, depth
+ {
+ position36 := position
+ depth++
+ {
+ position37 := position
+ depth++
+ {
+ position40, tokenIndex40, depth40 := position, tokenIndex, depth
+ if buffer[position] != rune('\r') {
+ goto l41
+ }
+ position++
+ goto l40
+ l41:
+ position, tokenIndex, depth = position40, tokenIndex40, depth40
+ if buffer[position] != rune('\n') {
+ goto l35
+ }
+ position++
+ }
+ l40:
+ l38:
+ {
+ position39, tokenIndex39, depth39 := position, tokenIndex, depth
+ {
+ position42, tokenIndex42, depth42 := position, tokenIndex, depth
+ if buffer[position] != rune('\r') {
+ goto l43
+ }
+ position++
+ goto l42
+ l43:
+ position, tokenIndex, depth = position42, tokenIndex42, depth42
+ if buffer[position] != rune('\n') {
+ goto l39
+ }
+ position++
+ }
+ l42:
+ goto l38
+ l39:
+ position, tokenIndex, depth = position39, tokenIndex39, depth39
+ }
+ depth--
+ add(rulePegText, position37)
+ }
+ {
+ add(ruleAction2, position)
+ }
+ depth--
+ add(rulenewline, position36)
+ }
+ return true
+ l35:
+ position, tokenIndex, depth = position35, tokenIndex35, depth35
+ return false
+ },
+ /* 3 ws <- <(' ' / '\t')*> */
+ func() bool {
+ {
+ position46 := position
+ depth++
+ l47:
+ {
+ position48, tokenIndex48, depth48 := position, tokenIndex, depth
+ {
+ position49, tokenIndex49, depth49 := position, tokenIndex, depth
+ if buffer[position] != rune(' ') {
+ goto l50
+ }
+ position++
+ goto l49
+ l50:
+ position, tokenIndex, depth = position49, tokenIndex49, depth49
+ if buffer[position] != rune('\t') {
+ goto l48
+ }
+ position++
+ }
+ l49:
+ goto l47
+ l48:
+ position, tokenIndex, depth = position48, tokenIndex48, depth48
+ }
+ depth--
+ add(rulews, position46)
+ }
+ return true
+ },
+ /* 4 wsnl <- <((&('\t') '\t') | (&(' ') ' ') | (&('\n' | '\r') (<('\r' / '\n')> Action3)))*> */
+ func() bool {
+ {
+ position52 := position
+ depth++
+ l53:
+ {
+ position54, tokenIndex54, depth54 := position, tokenIndex, depth
+ {
+ switch buffer[position] {
+ case '\t':
+ if buffer[position] != rune('\t') {
+ goto l54
+ }
+ position++
+ break
+ case ' ':
+ if buffer[position] != rune(' ') {
+ goto l54
+ }
+ position++
+ break
+ default:
+ {
+ position56 := position
+ depth++
+ {
+ position57, tokenIndex57, depth57 := position, tokenIndex, depth
+ if buffer[position] != rune('\r') {
+ goto l58
+ }
+ position++
+ goto l57
+ l58:
+ position, tokenIndex, depth = position57, tokenIndex57, depth57
+ if buffer[position] != rune('\n') {
+ goto l54
+ }
+ position++
+ }
+ l57:
+ depth--
+ add(rulePegText, position56)
+ }
+ {
+ add(ruleAction3, position)
+ }
+ break
+ }
+ }
+
+ goto l53
+ l54:
+ position, tokenIndex, depth = position54, tokenIndex54, depth54
+ }
+ depth--
+ add(rulewsnl, position52)
+ }
+ return true
+ },
+ /* 5 comment <- <('#' <('\t' / [ -ô¿¿])*>)> */
+ func() bool {
+ position60, tokenIndex60, depth60 := position, tokenIndex, depth
+ {
+ position61 := position
+ depth++
+ if buffer[position] != rune('#') {
+ goto l60
+ }
+ position++
+ {
+ position62 := position
+ depth++
+ l63:
+ {
+ position64, tokenIndex64, depth64 := position, tokenIndex, depth
+ {
+ position65, tokenIndex65, depth65 := position, tokenIndex, depth
+ if buffer[position] != rune('\t') {
+ goto l66
+ }
+ position++
+ goto l65
+ l66:
+ position, tokenIndex, depth = position65, tokenIndex65, depth65
+ if c := buffer[position]; c < rune(' ') || c > rune('\U0010ffff') {
+ goto l64
+ }
+ position++
+ }
+ l65:
+ goto l63
+ l64:
+ position, tokenIndex, depth = position64, tokenIndex64, depth64
+ }
+ depth--
+ add(rulePegText, position62)
+ }
+ depth--
+ add(rulecomment, position61)
+ }
+ return true
+ l60:
+ position, tokenIndex, depth = position60, tokenIndex60, depth60
+ return false
+ },
+ /* 6 keyval <- <(key ws '=' ws val Action4)> */
+ func() bool {
+ position67, tokenIndex67, depth67 := position, tokenIndex, depth
+ {
+ position68 := position
+ depth++
+ if !_rules[rulekey]() {
+ goto l67
+ }
+ if !_rules[rulews]() {
+ goto l67
+ }
+ if buffer[position] != rune('=') {
+ goto l67
+ }
+ position++
+ if !_rules[rulews]() {
+ goto l67
+ }
+ if !_rules[ruleval]() {
+ goto l67
+ }
+ {
+ add(ruleAction4, position)
+ }
+ depth--
+ add(rulekeyval, position68)
+ }
+ return true
+ l67:
+ position, tokenIndex, depth = position67, tokenIndex67, depth67
+ return false
+ },
+ /* 7 key <- <(bareKey / quotedKey)> */
+ func() bool {
+ position70, tokenIndex70, depth70 := position, tokenIndex, depth
+ {
+ position71 := position
+ depth++
+ {
+ position72, tokenIndex72, depth72 := position, tokenIndex, depth
+ {
+ position74 := position
+ depth++
+ {
+ position75 := position
+ depth++
+ {
+ switch buffer[position] {
+ case '_':
+ if buffer[position] != rune('_') {
+ goto l73
+ }
+ position++
+ break
+ case '-':
+ if buffer[position] != rune('-') {
+ goto l73
+ }
+ position++
+ break
+ case 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z':
+ if c := buffer[position]; c < rune('a') || c > rune('z') {
+ goto l73
+ }
+ position++
+ break
+ case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+ if c := buffer[position]; c < rune('0') || c > rune('9') {
+ goto l73
+ }
+ position++
+ break
+ default:
+ if c := buffer[position]; c < rune('A') || c > rune('Z') {
+ goto l73
+ }
+ position++
+ break
+ }
+ }
+
+ l76:
+ {
+ position77, tokenIndex77, depth77 := position, tokenIndex, depth
+ {
+ switch buffer[position] {
+ case '_':
+ if buffer[position] != rune('_') {
+ goto l77
+ }
+ position++
+ break
+ case '-':
+ if buffer[position] != rune('-') {
+ goto l77
+ }
+ position++
+ break
+ case 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z':
+ if c := buffer[position]; c < rune('a') || c > rune('z') {
+ goto l77
+ }
+ position++
+ break
+ case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+ if c := buffer[position]; c < rune('0') || c > rune('9') {
+ goto l77
+ }
+ position++
+ break
+ default:
+ if c := buffer[position]; c < rune('A') || c > rune('Z') {
+ goto l77
+ }
+ position++
+ break
+ }
+ }
+
+ goto l76
+ l77:
+ position, tokenIndex, depth = position77, tokenIndex77, depth77
+ }
+ depth--
+ add(rulePegText, position75)
+ }
+ {
+ add(ruleAction5, position)
+ }
+ depth--
+ add(rulebareKey, position74)
+ }
+ goto l72
+ l73:
+ position, tokenIndex, depth = position72, tokenIndex72, depth72
+ {
+ position81 := position
+ depth++
+ if buffer[position] != rune('"') {
+ goto l70
+ }
+ position++
+ {
+ position82 := position
+ depth++
+ if !_rules[rulebasicChar]() {
+ goto l70
+ }
+ l83:
+ {
+ position84, tokenIndex84, depth84 := position, tokenIndex, depth
+ if !_rules[rulebasicChar]() {
+ goto l84
+ }
+ goto l83
+ l84:
+ position, tokenIndex, depth = position84, tokenIndex84, depth84
+ }
+ depth--
+ add(rulePegText, position82)
+ }
+ if buffer[position] != rune('"') {
+ goto l70
+ }
+ position++
+ {
+ add(ruleAction6, position)
+ }
+ depth--
+ add(rulequotedKey, position81)
+ }
+ }
+ l72:
+ depth--
+ add(rulekey, position71)
+ }
+ return true
+ l70:
+ position, tokenIndex, depth = position70, tokenIndex70, depth70
+ return false
+ },
+ /* 8 bareKey <- <(<((&('_') '_') | (&('-') '-') | (&('a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z') [a-z]) | (&('0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') [0-9]) | (&('A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z') [A-Z]))+> Action5)> */
+ nil,
+ /* 9 quotedKey <- <('"' <basicChar+> '"' Action6)> */
+ nil,
+ /* 10 val <- <((<datetime> Action7) / (<float> Action8) / ((&('{') inlineTable) | (&('[') (<array> Action12)) | (&('f' | 't') (<boolean> Action11)) | (&('"' | '\'') (<string> Action10)) | (&('+' | '-' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') (<integer> Action9))))> */
+ func() bool {
+ position88, tokenIndex88, depth88 := position, tokenIndex, depth
+ {
+ position89 := position
+ depth++
+ {
+ position90, tokenIndex90, depth90 := position, tokenIndex, depth
+ {
+ position92 := position
+ depth++
+ {
+ position93 := position
+ depth++
+ {
+ position94 := position
+ depth++
+ {
+ position95 := position
+ depth++
+ {
+ position96 := position
+ depth++
+ if !_rules[ruledigitDual]() {
+ goto l91
+ }
+ if !_rules[ruledigitDual]() {
+ goto l91
+ }
+ depth--
+ add(ruledigitQuad, position96)
+ }
+ depth--
+ add(ruledateFullYear, position95)
+ }
+ if buffer[position] != rune('-') {
+ goto l91
+ }
+ position++
+ {
+ position97 := position
+ depth++
+ if !_rules[ruledigitDual]() {
+ goto l91
+ }
+ depth--
+ add(ruledateMonth, position97)
+ }
+ if buffer[position] != rune('-') {
+ goto l91
+ }
+ position++
+ {
+ position98 := position
+ depth++
+ if !_rules[ruledigitDual]() {
+ goto l91
+ }
+ depth--
+ add(ruledateMDay, position98)
+ }
+ depth--
+ add(rulefullDate, position94)
+ }
+ if buffer[position] != rune('T') {
+ goto l91
+ }
+ position++
+ {
+ position99 := position
+ depth++
+ {
+ position100 := position
+ depth++
+ if !_rules[ruletimeHour]() {
+ goto l91
+ }
+ if buffer[position] != rune(':') {
+ goto l91
+ }
+ position++
+ if !_rules[ruletimeMinute]() {
+ goto l91
+ }
+ if buffer[position] != rune(':') {
+ goto l91
+ }
+ position++
+ {
+ position101 := position
+ depth++
+ if !_rules[ruledigitDual]() {
+ goto l91
+ }
+ depth--
+ add(ruletimeSecond, position101)
+ }
+ {
+ position102, tokenIndex102, depth102 := position, tokenIndex, depth
+ {
+ position104 := position
+ depth++
+ if buffer[position] != rune('.') {
+ goto l102
+ }
+ position++
+ if !_rules[ruledigit]() {
+ goto l102
+ }
+ l105:
+ {
+ position106, tokenIndex106, depth106 := position, tokenIndex, depth
+ if !_rules[ruledigit]() {
+ goto l106
+ }
+ goto l105
+ l106:
+ position, tokenIndex, depth = position106, tokenIndex106, depth106
+ }
+ depth--
+ add(ruletimeSecfrac, position104)
+ }
+ goto l103
+ l102:
+ position, tokenIndex, depth = position102, tokenIndex102, depth102
+ }
+ l103:
+ depth--
+ add(rulepartialTime, position100)
+ }
+ {
+ position107 := position
+ depth++
+ {
+ position108, tokenIndex108, depth108 := position, tokenIndex, depth
+ if buffer[position] != rune('Z') {
+ goto l109
+ }
+ position++
+ goto l108
+ l109:
+ position, tokenIndex, depth = position108, tokenIndex108, depth108
+ {
+ position110 := position
+ depth++
+ {
+ position111, tokenIndex111, depth111 := position, tokenIndex, depth
+ if buffer[position] != rune('-') {
+ goto l112
+ }
+ position++
+ goto l111
+ l112:
+ position, tokenIndex, depth = position111, tokenIndex111, depth111
+ if buffer[position] != rune('+') {
+ goto l91
+ }
+ position++
+ }
+ l111:
+ if !_rules[ruletimeHour]() {
+ goto l91
+ }
+ if buffer[position] != rune(':') {
+ goto l91
+ }
+ position++
+ if !_rules[ruletimeMinute]() {
+ goto l91
+ }
+ depth--
+ add(ruletimeNumoffset, position110)
+ }
+ }
+ l108:
+ depth--
+ add(ruletimeOffset, position107)
+ }
+ depth--
+ add(rulefullTime, position99)
+ }
+ depth--
+ add(ruledatetime, position93)
+ }
+ depth--
+ add(rulePegText, position92)
+ }
+ {
+ add(ruleAction7, position)
+ }
+ goto l90
+ l91:
+ position, tokenIndex, depth = position90, tokenIndex90, depth90
+ {
+ position115 := position
+ depth++
+ {
+ position116 := position
+ depth++
+ if !_rules[ruleinteger]() {
+ goto l114
+ }
+ {
+ position117, tokenIndex117, depth117 := position, tokenIndex, depth
+ if !_rules[rulefrac]() {
+ goto l118
+ }
+ {
+ position119, tokenIndex119, depth119 := position, tokenIndex, depth
+ if !_rules[ruleexp]() {
+ goto l119
+ }
+ goto l120
+ l119:
+ position, tokenIndex, depth = position119, tokenIndex119, depth119
+ }
+ l120:
+ goto l117
+ l118:
+ position, tokenIndex, depth = position117, tokenIndex117, depth117
+ {
+ position121, tokenIndex121, depth121 := position, tokenIndex, depth
+ if !_rules[rulefrac]() {
+ goto l121
+ }
+ goto l122
+ l121:
+ position, tokenIndex, depth = position121, tokenIndex121, depth121
+ }
+ l122:
+ if !_rules[ruleexp]() {
+ goto l114
+ }
+ }
+ l117:
+ depth--
+ add(rulefloat, position116)
+ }
+ depth--
+ add(rulePegText, position115)
+ }
+ {
+ add(ruleAction8, position)
+ }
+ goto l90
+ l114:
+ position, tokenIndex, depth = position90, tokenIndex90, depth90
+ {
+ switch buffer[position] {
+ case '{':
+ {
+ position125 := position
+ depth++
+ if buffer[position] != rune('{') {
+ goto l88
+ }
+ position++
+ {
+ add(ruleAction15, position)
+ }
+ if !_rules[rulews]() {
+ goto l88
+ }
+ {
+ position127 := position
+ depth++
+ l128:
+ {
+ position129, tokenIndex129, depth129 := position, tokenIndex, depth
+ if !_rules[rulekeyval]() {
+ goto l129
+ }
+ {
+ position130, tokenIndex130, depth130 := position, tokenIndex, depth
+ {
+ position132 := position
+ depth++
+ if !_rules[rulews]() {
+ goto l130
+ }
+ if buffer[position] != rune(',') {
+ goto l130
+ }
+ position++
+ if !_rules[rulews]() {
+ goto l130
+ }
+ depth--
+ add(ruleinlineTableValSep, position132)
+ }
+ goto l131
+ l130:
+ position, tokenIndex, depth = position130, tokenIndex130, depth130
+ }
+ l131:
+ goto l128
+ l129:
+ position, tokenIndex, depth = position129, tokenIndex129, depth129
+ }
+ depth--
+ add(ruleinlineTableKeyValues, position127)
+ }
+ if !_rules[rulews]() {
+ goto l88
+ }
+ if buffer[position] != rune('}') {
+ goto l88
+ }
+ position++
+ {
+ add(ruleAction16, position)
+ }
+ depth--
+ add(ruleinlineTable, position125)
+ }
+ break
+ case '[':
+ {
+ position134 := position
+ depth++
+ {
+ position135 := position
+ depth++
+ if buffer[position] != rune('[') {
+ goto l88
+ }
+ position++
+ {
+ add(ruleAction22, position)
+ }
+ if !_rules[rulewsnl]() {
+ goto l88
+ }
+ {
+ position137 := position
+ depth++
+ l138:
+ {
+ position139, tokenIndex139, depth139 := position, tokenIndex, depth
+ if !_rules[ruleval]() {
+ goto l139
+ }
+ {
+ add(ruleAction23, position)
+ }
+ {
+ position141, tokenIndex141, depth141 := position, tokenIndex, depth
+ {
+ position143 := position
+ depth++
+ if !_rules[rulews]() {
+ goto l141
+ }
+ if buffer[position] != rune(',') {
+ goto l141
+ }
+ position++
+ if !_rules[rulewsnl]() {
+ goto l141
+ }
+ depth--
+ add(rulearraySep, position143)
+ }
+ goto l142
+ l141:
+ position, tokenIndex, depth = position141, tokenIndex141, depth141
+ }
+ l142:
+ {
+ position144, tokenIndex144, depth144 := position, tokenIndex, depth
+ {
+ position146, tokenIndex146, depth146 := position, tokenIndex, depth
+ if !_rules[rulecomment]() {
+ goto l146
+ }
+ goto l147
+ l146:
+ position, tokenIndex, depth = position146, tokenIndex146, depth146
+ }
+ l147:
+ if !_rules[rulenewline]() {
+ goto l144
+ }
+ goto l145
+ l144:
+ position, tokenIndex, depth = position144, tokenIndex144, depth144
+ }
+ l145:
+ goto l138
+ l139:
+ position, tokenIndex, depth = position139, tokenIndex139, depth139
+ }
+ depth--
+ add(rulearrayValues, position137)
+ }
+ if !_rules[rulewsnl]() {
+ goto l88
+ }
+ if buffer[position] != rune(']') {
+ goto l88
+ }
+ position++
+ depth--
+ add(rulearray, position135)
+ }
+ depth--
+ add(rulePegText, position134)
+ }
+ {
+ add(ruleAction12, position)
+ }
+ break
+ case 'f', 't':
+ {
+ position149 := position
+ depth++
+ {
+ position150 := position
+ depth++
+ {
+ position151, tokenIndex151, depth151 := position, tokenIndex, depth
+ if buffer[position] != rune('t') {
+ goto l152
+ }
+ position++
+ if buffer[position] != rune('r') {
+ goto l152
+ }
+ position++
+ if buffer[position] != rune('u') {
+ goto l152
+ }
+ position++
+ if buffer[position] != rune('e') {
+ goto l152
+ }
+ position++
+ goto l151
+ l152:
+ position, tokenIndex, depth = position151, tokenIndex151, depth151
+ if buffer[position] != rune('f') {
+ goto l88
+ }
+ position++
+ if buffer[position] != rune('a') {
+ goto l88
+ }
+ position++
+ if buffer[position] != rune('l') {
+ goto l88
+ }
+ position++
+ if buffer[position] != rune('s') {
+ goto l88
+ }
+ position++
+ if buffer[position] != rune('e') {
+ goto l88
+ }
+ position++
+ }
+ l151:
+ depth--
+ add(ruleboolean, position150)
+ }
+ depth--
+ add(rulePegText, position149)
+ }
+ {
+ add(ruleAction11, position)
+ }
+ break
+ case '"', '\'':
+ {
+ position154 := position
+ depth++
+ {
+ position155 := position
+ depth++
+ {
+ position156, tokenIndex156, depth156 := position, tokenIndex, depth
+ {
+ position158 := position
+ depth++
+ if buffer[position] != rune('\'') {
+ goto l157
+ }
+ position++
+ if buffer[position] != rune('\'') {
+ goto l157
+ }
+ position++
+ if buffer[position] != rune('\'') {
+ goto l157
+ }
+ position++
+ {
+ position159 := position
+ depth++
+ {
+ position160 := position
+ depth++
+ l161:
+ {
+ position162, tokenIndex162, depth162 := position, tokenIndex, depth
+ {
+ position163, tokenIndex163, depth163 := position, tokenIndex, depth
+ if buffer[position] != rune('\'') {
+ goto l163
+ }
+ position++
+ if buffer[position] != rune('\'') {
+ goto l163
+ }
+ position++
+ if buffer[position] != rune('\'') {
+ goto l163
+ }
+ position++
+ goto l162
+ l163:
+ position, tokenIndex, depth = position163, tokenIndex163, depth163
+ }
+ {
+ position164, tokenIndex164, depth164 := position, tokenIndex, depth
+ {
+ position166 := position
+ depth++
+ {
+ position167, tokenIndex167, depth167 := position, tokenIndex, depth
+ if buffer[position] != rune('\t') {
+ goto l168
+ }
+ position++
+ goto l167
+ l168:
+ position, tokenIndex, depth = position167, tokenIndex167, depth167
+ if c := buffer[position]; c < rune(' ') || c > rune('\U0010ffff') {
+ goto l165
+ }
+ position++
+ }
+ l167:
+ depth--
+ add(rulemlLiteralChar, position166)
+ }
+ goto l164
+ l165:
+ position, tokenIndex, depth = position164, tokenIndex164, depth164
+ if !_rules[rulenewline]() {
+ goto l162
+ }
+ }
+ l164:
+ goto l161
+ l162:
+ position, tokenIndex, depth = position162, tokenIndex162, depth162
+ }
+ depth--
+ add(rulemlLiteralBody, position160)
+ }
+ depth--
+ add(rulePegText, position159)
+ }
+ if buffer[position] != rune('\'') {
+ goto l157
+ }
+ position++
+ if buffer[position] != rune('\'') {
+ goto l157
+ }
+ position++
+ if buffer[position] != rune('\'') {
+ goto l157
+ }
+ position++
+ {
+ add(ruleAction21, position)
+ }
+ depth--
+ add(rulemlLiteralString, position158)
+ }
+ goto l156
+ l157:
+ position, tokenIndex, depth = position156, tokenIndex156, depth156
+ {
+ position171 := position
+ depth++
+ if buffer[position] != rune('\'') {
+ goto l170
+ }
+ position++
+ {
+ position172 := position
+ depth++
+ l173:
+ {
+ position174, tokenIndex174, depth174 := position, tokenIndex, depth
+ {
+ position175 := position
+ depth++
+ {
+ switch buffer[position] {
+ case '\t':
+ if buffer[position] != rune('\t') {
+ goto l174
+ }
+ position++
+ break
+ case ' ', '!', '"', '#', '$', '%', '&':
+ if c := buffer[position]; c < rune(' ') || c > rune('&') {
+ goto l174
+ }
+ position++
+ break
+ default:
+ if c := buffer[position]; c < rune('(') || c > rune('\U0010ffff') {
+ goto l174
+ }
+ position++
+ break
+ }
+ }
+
+ depth--
+ add(ruleliteralChar, position175)
+ }
+ goto l173
+ l174:
+ position, tokenIndex, depth = position174, tokenIndex174, depth174
+ }
+ depth--
+ add(rulePegText, position172)
+ }
+ if buffer[position] != rune('\'') {
+ goto l170
+ }
+ position++
+ {
+ add(ruleAction20, position)
+ }
+ depth--
+ add(ruleliteralString, position171)
+ }
+ goto l156
+ l170:
+ position, tokenIndex, depth = position156, tokenIndex156, depth156
+ {
+ position179 := position
+ depth++
+ if buffer[position] != rune('"') {
+ goto l178
+ }
+ position++
+ if buffer[position] != rune('"') {
+ goto l178
+ }
+ position++
+ if buffer[position] != rune('"') {
+ goto l178
+ }
+ position++
+ {
+ position180 := position
+ depth++
+ l181:
+ {
+ position182, tokenIndex182, depth182 := position, tokenIndex, depth
+ {
+ position183, tokenIndex183, depth183 := position, tokenIndex, depth
+ {
+ position185 := position
+ depth++
+ {
+ position186, tokenIndex186, depth186 := position, tokenIndex, depth
+ if !_rules[rulebasicChar]() {
+ goto l187
+ }
+ goto l186
+ l187:
+ position, tokenIndex, depth = position186, tokenIndex186, depth186
+ if !_rules[rulenewline]() {
+ goto l184
+ }
+ }
+ l186:
+ depth--
+ add(rulePegText, position185)
+ }
+ {
+ add(ruleAction19, position)
+ }
+ goto l183
+ l184:
+ position, tokenIndex, depth = position183, tokenIndex183, depth183
+ if !_rules[ruleescape]() {
+ goto l182
+ }
+ if !_rules[rulenewline]() {
+ goto l182
+ }
+ if !_rules[rulewsnl]() {
+ goto l182
+ }
+ }
+ l183:
+ goto l181
+ l182:
+ position, tokenIndex, depth = position182, tokenIndex182, depth182
+ }
+ depth--
+ add(rulemlBasicBody, position180)
+ }
+ if buffer[position] != rune('"') {
+ goto l178
+ }
+ position++
+ if buffer[position] != rune('"') {
+ goto l178
+ }
+ position++
+ if buffer[position] != rune('"') {
+ goto l178
+ }
+ position++
+ {
+ add(ruleAction18, position)
+ }
+ depth--
+ add(rulemlBasicString, position179)
+ }
+ goto l156
+ l178:
+ position, tokenIndex, depth = position156, tokenIndex156, depth156
+ {
+ position190 := position
+ depth++
+ {
+ position191 := position
+ depth++
+ if buffer[position] != rune('"') {
+ goto l88
+ }
+ position++
+ l192:
+ {
+ position193, tokenIndex193, depth193 := position, tokenIndex, depth
+ if !_rules[rulebasicChar]() {
+ goto l193
+ }
+ goto l192
+ l193:
+ position, tokenIndex, depth = position193, tokenIndex193, depth193
+ }
+ if buffer[position] != rune('"') {
+ goto l88
+ }
+ position++
+ depth--
+ add(rulePegText, position191)
+ }
+ {
+ add(ruleAction17, position)
+ }
+ depth--
+ add(rulebasicString, position190)
+ }
+ }
+ l156:
+ depth--
+ add(rulestring, position155)
+ }
+ depth--
+ add(rulePegText, position154)
+ }
+ {
+ add(ruleAction10, position)
+ }
+ break
+ default:
+ {
+ position196 := position
+ depth++
+ if !_rules[ruleinteger]() {
+ goto l88
+ }
+ depth--
+ add(rulePegText, position196)
+ }
+ {
+ add(ruleAction9, position)
+ }
+ break
+ }
+ }
+
+ }
+ l90:
+ depth--
+ add(ruleval, position89)
+ }
+ return true
+ l88:
+ position, tokenIndex, depth = position88, tokenIndex88, depth88
+ return false
+ },
+ /* 11 table <- <(stdTable / arrayTable)> */
+ nil,
+ /* 12 stdTable <- <('[' ws <tableKey> ws ']' Action13)> */
+ nil,
+ /* 13 arrayTable <- <('[' '[' ws <tableKey> ws (']' ']') Action14)> */
+ nil,
+ /* 14 inlineTable <- <('{' Action15 ws inlineTableKeyValues ws '}' Action16)> */
+ nil,
+ /* 15 inlineTableKeyValues <- <(keyval inlineTableValSep?)*> */
+ nil,
+ /* 16 tableKey <- <(key (tableKeySep key)*)> */
+ func() bool {
+ position203, tokenIndex203, depth203 := position, tokenIndex, depth
+ {
+ position204 := position
+ depth++
+ if !_rules[rulekey]() {
+ goto l203
+ }
+ l205:
+ {
+ position206, tokenIndex206, depth206 := position, tokenIndex, depth
+ {
+ position207 := position
+ depth++
+ if !_rules[rulews]() {
+ goto l206
+ }
+ if buffer[position] != rune('.') {
+ goto l206
+ }
+ position++
+ if !_rules[rulews]() {
+ goto l206
+ }
+ depth--
+ add(ruletableKeySep, position207)
+ }
+ if !_rules[rulekey]() {
+ goto l206
+ }
+ goto l205
+ l206:
+ position, tokenIndex, depth = position206, tokenIndex206, depth206
+ }
+ depth--
+ add(ruletableKey, position204)
+ }
+ return true
+ l203:
+ position, tokenIndex, depth = position203, tokenIndex203, depth203
+ return false
+ },
+ /* 17 tableKeySep <- <(ws '.' ws)> */
+ nil,
+ /* 18 inlineTableValSep <- <(ws ',' ws)> */
+ nil,
+ /* 19 integer <- <(('-' / '+')? int)> */
+ func() bool {
+ position210, tokenIndex210, depth210 := position, tokenIndex, depth
+ {
+ position211 := position
+ depth++
+ {
+ position212, tokenIndex212, depth212 := position, tokenIndex, depth
+ {
+ position214, tokenIndex214, depth214 := position, tokenIndex, depth
+ if buffer[position] != rune('-') {
+ goto l215
+ }
+ position++
+ goto l214
+ l215:
+ position, tokenIndex, depth = position214, tokenIndex214, depth214
+ if buffer[position] != rune('+') {
+ goto l212
+ }
+ position++
+ }
+ l214:
+ goto l213
+ l212:
+ position, tokenIndex, depth = position212, tokenIndex212, depth212
+ }
+ l213:
+ {
+ position216 := position
+ depth++
+ {
+ position217, tokenIndex217, depth217 := position, tokenIndex, depth
+ if c := buffer[position]; c < rune('1') || c > rune('9') {
+ goto l218
+ }
+ position++
+ {
+ position221, tokenIndex221, depth221 := position, tokenIndex, depth
+ if !_rules[ruledigit]() {
+ goto l222
+ }
+ goto l221
+ l222:
+ position, tokenIndex, depth = position221, tokenIndex221, depth221
+ if buffer[position] != rune('_') {
+ goto l218
+ }
+ position++
+ if !_rules[ruledigit]() {
+ goto l218
+ }
+ }
+ l221:
+ l219:
+ {
+ position220, tokenIndex220, depth220 := position, tokenIndex, depth
+ {
+ position223, tokenIndex223, depth223 := position, tokenIndex, depth
+ if !_rules[ruledigit]() {
+ goto l224
+ }
+ goto l223
+ l224:
+ position, tokenIndex, depth = position223, tokenIndex223, depth223
+ if buffer[position] != rune('_') {
+ goto l220
+ }
+ position++
+ if !_rules[ruledigit]() {
+ goto l220
+ }
+ }
+ l223:
+ goto l219
+ l220:
+ position, tokenIndex, depth = position220, tokenIndex220, depth220
+ }
+ goto l217
+ l218:
+ position, tokenIndex, depth = position217, tokenIndex217, depth217
+ if !_rules[ruledigit]() {
+ goto l210
+ }
+ }
+ l217:
+ depth--
+ add(ruleint, position216)
+ }
+ depth--
+ add(ruleinteger, position211)
+ }
+ return true
+ l210:
+ position, tokenIndex, depth = position210, tokenIndex210, depth210
+ return false
+ },
+ /* 20 int <- <(([1-9] (digit / ('_' digit))+) / digit)> */
+ nil,
+ /* 21 float <- <(integer ((frac exp?) / (frac? exp)))> */
+ nil,
+ /* 22 frac <- <('.' digit (digit / ('_' digit))*)> */
+ func() bool {
+ position227, tokenIndex227, depth227 := position, tokenIndex, depth
+ {
+ position228 := position
+ depth++
+ if buffer[position] != rune('.') {
+ goto l227
+ }
+ position++
+ if !_rules[ruledigit]() {
+ goto l227
+ }
+ l229:
+ {
+ position230, tokenIndex230, depth230 := position, tokenIndex, depth
+ {
+ position231, tokenIndex231, depth231 := position, tokenIndex, depth
+ if !_rules[ruledigit]() {
+ goto l232
+ }
+ goto l231
+ l232:
+ position, tokenIndex, depth = position231, tokenIndex231, depth231
+ if buffer[position] != rune('_') {
+ goto l230
+ }
+ position++
+ if !_rules[ruledigit]() {
+ goto l230
+ }
+ }
+ l231:
+ goto l229
+ l230:
+ position, tokenIndex, depth = position230, tokenIndex230, depth230
+ }
+ depth--
+ add(rulefrac, position228)
+ }
+ return true
+ l227:
+ position, tokenIndex, depth = position227, tokenIndex227, depth227
+ return false
+ },
+ /* 23 exp <- <(('e' / 'E') ('-' / '+')? digit (digit / ('_' digit))*)> */
+ func() bool {
+ position233, tokenIndex233, depth233 := position, tokenIndex, depth
+ {
+ position234 := position
+ depth++
+ {
+ position235, tokenIndex235, depth235 := position, tokenIndex, depth
+ if buffer[position] != rune('e') {
+ goto l236
+ }
+ position++
+ goto l235
+ l236:
+ position, tokenIndex, depth = position235, tokenIndex235, depth235
+ if buffer[position] != rune('E') {
+ goto l233
+ }
+ position++
+ }
+ l235:
+ {
+ position237, tokenIndex237, depth237 := position, tokenIndex, depth
+ {
+ position239, tokenIndex239, depth239 := position, tokenIndex, depth
+ if buffer[position] != rune('-') {
+ goto l240
+ }
+ position++
+ goto l239
+ l240:
+ position, tokenIndex, depth = position239, tokenIndex239, depth239
+ if buffer[position] != rune('+') {
+ goto l237
+ }
+ position++
+ }
+ l239:
+ goto l238
+ l237:
+ position, tokenIndex, depth = position237, tokenIndex237, depth237
+ }
+ l238:
+ if !_rules[ruledigit]() {
+ goto l233
+ }
+ l241:
+ {
+ position242, tokenIndex242, depth242 := position, tokenIndex, depth
+ {
+ position243, tokenIndex243, depth243 := position, tokenIndex, depth
+ if !_rules[ruledigit]() {
+ goto l244
+ }
+ goto l243
+ l244:
+ position, tokenIndex, depth = position243, tokenIndex243, depth243
+ if buffer[position] != rune('_') {
+ goto l242
+ }
+ position++
+ if !_rules[ruledigit]() {
+ goto l242
+ }
+ }
+ l243:
+ goto l241
+ l242:
+ position, tokenIndex, depth = position242, tokenIndex242, depth242
+ }
+ depth--
+ add(ruleexp, position234)
+ }
+ return true
+ l233:
+ position, tokenIndex, depth = position233, tokenIndex233, depth233
+ return false
+ },
+ /* 24 string <- <(mlLiteralString / literalString / mlBasicString / basicString)> */
+ nil,
+ /* 25 basicString <- <(<('"' basicChar* '"')> Action17)> */
+ nil,
+ /* 26 basicChar <- <(basicUnescaped / escaped)> */
+ func() bool {
+ position247, tokenIndex247, depth247 := position, tokenIndex, depth
+ {
+ position248 := position
+ depth++
+ {
+ position249, tokenIndex249, depth249 := position, tokenIndex, depth
+ {
+ position251 := position
+ depth++
+ {
+ switch buffer[position] {
+ case ' ', '!':
+ if c := buffer[position]; c < rune(' ') || c > rune('!') {
+ goto l250
+ }
+ position++
+ break
+ case '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[':
+ if c := buffer[position]; c < rune('#') || c > rune('[') {
+ goto l250
+ }
+ position++
+ break
+ default:
+ if c := buffer[position]; c < rune(']') || c > rune('\U0010ffff') {
+ goto l250
+ }
+ position++
+ break
+ }
+ }
+
+ depth--
+ add(rulebasicUnescaped, position251)
+ }
+ goto l249
+ l250:
+ position, tokenIndex, depth = position249, tokenIndex249, depth249
+ {
+ position253 := position
+ depth++
+ if !_rules[ruleescape]() {
+ goto l247
+ }
+ {
+ switch buffer[position] {
+ case 'U':
+ if buffer[position] != rune('U') {
+ goto l247
+ }
+ position++
+ if !_rules[rulehexQuad]() {
+ goto l247
+ }
+ if !_rules[rulehexQuad]() {
+ goto l247
+ }
+ break
+ case 'u':
+ if buffer[position] != rune('u') {
+ goto l247
+ }
+ position++
+ if !_rules[rulehexQuad]() {
+ goto l247
+ }
+ break
+ case '\\':
+ if buffer[position] != rune('\\') {
+ goto l247
+ }
+ position++
+ break
+ case '/':
+ if buffer[position] != rune('/') {
+ goto l247
+ }
+ position++
+ break
+ case '"':
+ if buffer[position] != rune('"') {
+ goto l247
+ }
+ position++
+ break
+ case 'r':
+ if buffer[position] != rune('r') {
+ goto l247
+ }
+ position++
+ break
+ case 'f':
+ if buffer[position] != rune('f') {
+ goto l247
+ }
+ position++
+ break
+ case 'n':
+ if buffer[position] != rune('n') {
+ goto l247
+ }
+ position++
+ break
+ case 't':
+ if buffer[position] != rune('t') {
+ goto l247
+ }
+ position++
+ break
+ default:
+ if buffer[position] != rune('b') {
+ goto l247
+ }
+ position++
+ break
+ }
+ }
+
+ depth--
+ add(ruleescaped, position253)
+ }
+ }
+ l249:
+ depth--
+ add(rulebasicChar, position248)
+ }
+ return true
+ l247:
+ position, tokenIndex, depth = position247, tokenIndex247, depth247
+ return false
+ },
+ /* 27 escaped <- <(escape ((&('U') ('U' hexQuad hexQuad)) | (&('u') ('u' hexQuad)) | (&('\\') '\\') | (&('/') '/') | (&('"') '"') | (&('r') 'r') | (&('f') 'f') | (&('n') 'n') | (&('t') 't') | (&('b') 'b')))> */
+ nil,
+ /* 28 basicUnescaped <- <((&(' ' | '!') [ -!]) | (&('#' | '$' | '%' | '&' | '\'' | '(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | ':' | ';' | '<' | '=' | '>' | '?' | '@' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | '[') [#-[]) | (&(']' | '^' | '_' | '`' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | '{' | '|' | '}' | '~' | '\u007f' | '\u0080' | '\u0081' | '\u0082' | '\u0083' | '\u0084' | '\u0085' | '\u0086' | '\u0087' | '\u0088' | '\u0089' | '\u008a' | '\u008b' | '\u008c' | '\u008d' | '\u008e' | '\u008f' | '\u0090' | '\u0091' | '\u0092' | '\u0093' | '\u0094' | '\u0095' | '\u0096' | '\u0097' | '\u0098' | '\u0099' | '\u009a' | '\u009b' | '\u009c' | '\u009d' | '\u009e' | '\u009f' | '\u00a0' | '¡' | '¢' | '£' | '¤' | 'Â¥' | '¦' | '§' | '¨' | '©' | 'ª' | '«' | '¬' | '\u00ad' | '®' | '¯' | '°' | '±' | '²' | '³' | '´' | 'µ' | '¶' | '·' | '¸' | '¹' | 'º' | '»' | '¼' | '½' | '¾' | '¿' | 'À' | 'Ã' | 'Â' | 'Ã' | 'Ä' | 'Ã…' | 'Æ' | 'Ç' | 'È' | 'É' | 'Ê' | 'Ë' | 'ÃŒ' | 'Ã' | 'ÃŽ' | 'Ã' | 'Ã' | 'Ñ' | 'Ã’' | 'Ó' | 'Ô' | 'Õ' | 'Ö' | '×' | 'Ø' | 'Ù' | 'Ú' | 'Û' | 'Ãœ' | 'Ã' | 'Þ' | 'ß' | 'à ' | 'á' | 'â' | 'ã' | 'ä' | 'Ã¥' | 'æ' | 'ç' | 'è' | 'é' | 'ê' | 'ë' | 'ì' | 'Ã' | 'î' | 'ï' | 'ð' | 'ñ' | 'ò' | 'ó' | 'ô') []-ô¿¿]))> */
+ nil,
+ /* 29 escape <- <'\\'> */
+ func() bool {
+ position257, tokenIndex257, depth257 := position, tokenIndex, depth
+ {
+ position258 := position
+ depth++
+ if buffer[position] != rune('\\') {
+ goto l257
+ }
+ position++
+ depth--
+ add(ruleescape, position258)
+ }
+ return true
+ l257:
+ position, tokenIndex, depth = position257, tokenIndex257, depth257
+ return false
+ },
+ /* 30 mlBasicString <- <('"' '"' '"' mlBasicBody ('"' '"' '"') Action18)> */
+ nil,
+ /* 31 mlBasicBody <- <((<(basicChar / newline)> Action19) / (escape newline wsnl))*> */
+ nil,
+ /* 32 literalString <- <('\'' <literalChar*> '\'' Action20)> */
+ nil,
+ /* 33 literalChar <- <((&('\t') '\t') | (&(' ' | '!' | '"' | '#' | '$' | '%' | '&') [ -&]) | (&('(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | ':' | ';' | '<' | '=' | '>' | '?' | '@' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | '[' | '\\' | ']' | '^' | '_' | '`' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | '{' | '|' | '}' | '~' | '\u007f' | '\u0080' | '\u0081' | '\u0082' | '\u0083' | '\u0084' | '\u0085' | '\u0086' | '\u0087' | '\u0088' | '\u0089' | '\u008a' | '\u008b' | '\u008c' | '\u008d' | '\u008e' | '\u008f' | '\u0090' | '\u0091' | '\u0092' | '\u0093' | '\u0094' | '\u0095' | '\u0096' | '\u0097' | '\u0098' | '\u0099' | '\u009a' | '\u009b' | '\u009c' | '\u009d' | '\u009e' | '\u009f' | '\u00a0' | '¡' | '¢' | '£' | '¤' | 'Â¥' | '¦' | '§' | '¨' | '©' | 'ª' | '«' | '¬' | '\u00ad' | '®' | '¯' | '°' | '±' | '²' | '³' | '´' | 'µ' | '¶' | '·' | '¸' | '¹' | 'º' | '»' | '¼' | '½' | '¾' | '¿' | 'À' | 'Ã' | 'Â' | 'Ã' | 'Ä' | 'Ã…' | 'Æ' | 'Ç' | 'È' | 'É' | 'Ê' | 'Ë' | 'ÃŒ' | 'Ã' | 'ÃŽ' | 'Ã' | 'Ã' | 'Ñ' | 'Ã’' | 'Ó' | 'Ô' | 'Õ' | 'Ö' | '×' | 'Ø' | 'Ù' | 'Ú' | 'Û' | 'Ãœ' | 'Ã' | 'Þ' | 'ß' | 'à ' | 'á' | 'â' | 'ã' | 'ä' | 'Ã¥' | 'æ' | 'ç' | 'è' | 'é' | 'ê' | 'ë' | 'ì' | 'Ã' | 'î' | 'ï' | 'ð' | 'ñ' | 'ò' | 'ó' | 'ô') [(-ô¿¿]))> */
+ nil,
+ /* 34 mlLiteralString <- <('\'' '\'' '\'' <mlLiteralBody> ('\'' '\'' '\'') Action21)> */
+ nil,
+ /* 35 mlLiteralBody <- <(!('\'' '\'' '\'') (mlLiteralChar / newline))*> */
+ nil,
+ /* 36 mlLiteralChar <- <('\t' / [ -ô¿¿])> */
+ nil,
+ /* 37 hexdigit <- <((&('a' | 'b' | 'c' | 'd' | 'e' | 'f') [a-f]) | (&('A' | 'B' | 'C' | 'D' | 'E' | 'F') [A-F]) | (&('0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') [0-9]))> */
+ func() bool {
+ position266, tokenIndex266, depth266 := position, tokenIndex, depth
+ {
+ position267 := position
+ depth++
+ {
+ switch buffer[position] {
+ case 'a', 'b', 'c', 'd', 'e', 'f':
+ if c := buffer[position]; c < rune('a') || c > rune('f') {
+ goto l266
+ }
+ position++
+ break
+ case 'A', 'B', 'C', 'D', 'E', 'F':
+ if c := buffer[position]; c < rune('A') || c > rune('F') {
+ goto l266
+ }
+ position++
+ break
+ default:
+ if c := buffer[position]; c < rune('0') || c > rune('9') {
+ goto l266
+ }
+ position++
+ break
+ }
+ }
+
+ depth--
+ add(rulehexdigit, position267)
+ }
+ return true
+ l266:
+ position, tokenIndex, depth = position266, tokenIndex266, depth266
+ return false
+ },
+ /* 38 hexQuad <- <(hexdigit hexdigit hexdigit hexdigit)> */
+ func() bool {
+ position269, tokenIndex269, depth269 := position, tokenIndex, depth
+ {
+ position270 := position
+ depth++
+ if !_rules[rulehexdigit]() {
+ goto l269
+ }
+ if !_rules[rulehexdigit]() {
+ goto l269
+ }
+ if !_rules[rulehexdigit]() {
+ goto l269
+ }
+ if !_rules[rulehexdigit]() {
+ goto l269
+ }
+ depth--
+ add(rulehexQuad, position270)
+ }
+ return true
+ l269:
+ position, tokenIndex, depth = position269, tokenIndex269, depth269
+ return false
+ },
+ /* 39 boolean <- <(('t' 'r' 'u' 'e') / ('f' 'a' 'l' 's' 'e'))> */
+ nil,
+ /* 40 dateFullYear <- <digitQuad> */
+ nil,
+ /* 41 dateMonth <- <digitDual> */
+ nil,
+ /* 42 dateMDay <- <digitDual> */
+ nil,
+ /* 43 timeHour <- <digitDual> */
+ func() bool {
+ position275, tokenIndex275, depth275 := position, tokenIndex, depth
+ {
+ position276 := position
+ depth++
+ if !_rules[ruledigitDual]() {
+ goto l275
+ }
+ depth--
+ add(ruletimeHour, position276)
+ }
+ return true
+ l275:
+ position, tokenIndex, depth = position275, tokenIndex275, depth275
+ return false
+ },
+ /* 44 timeMinute <- <digitDual> */
+ func() bool {
+ position277, tokenIndex277, depth277 := position, tokenIndex, depth
+ {
+ position278 := position
+ depth++
+ if !_rules[ruledigitDual]() {
+ goto l277
+ }
+ depth--
+ add(ruletimeMinute, position278)
+ }
+ return true
+ l277:
+ position, tokenIndex, depth = position277, tokenIndex277, depth277
+ return false
+ },
+ /* 45 timeSecond <- <digitDual> */
+ nil,
+ /* 46 timeSecfrac <- <('.' digit+)> */
+ nil,
+ /* 47 timeNumoffset <- <(('-' / '+') timeHour ':' timeMinute)> */
+ nil,
+ /* 48 timeOffset <- <('Z' / timeNumoffset)> */
+ nil,
+ /* 49 partialTime <- <(timeHour ':' timeMinute ':' timeSecond timeSecfrac?)> */
+ nil,
+ /* 50 fullDate <- <(dateFullYear '-' dateMonth '-' dateMDay)> */
+ nil,
+ /* 51 fullTime <- <(partialTime timeOffset)> */
+ nil,
+ /* 52 datetime <- <(fullDate 'T' fullTime)> */
+ nil,
+ /* 53 digit <- <[0-9]> */
+ func() bool {
+ position287, tokenIndex287, depth287 := position, tokenIndex, depth
+ {
+ position288 := position
+ depth++
+ if c := buffer[position]; c < rune('0') || c > rune('9') {
+ goto l287
+ }
+ position++
+ depth--
+ add(ruledigit, position288)
+ }
+ return true
+ l287:
+ position, tokenIndex, depth = position287, tokenIndex287, depth287
+ return false
+ },
+ /* 54 digitDual <- <(digit digit)> */
+ func() bool {
+ position289, tokenIndex289, depth289 := position, tokenIndex, depth
+ {
+ position290 := position
+ depth++
+ if !_rules[ruledigit]() {
+ goto l289
+ }
+ if !_rules[ruledigit]() {
+ goto l289
+ }
+ depth--
+ add(ruledigitDual, position290)
+ }
+ return true
+ l289:
+ position, tokenIndex, depth = position289, tokenIndex289, depth289
+ return false
+ },
+ /* 55 digitQuad <- <(digitDual digitDual)> */
+ nil,
+ /* 56 array <- <('[' Action22 wsnl arrayValues wsnl ']')> */
+ nil,
+ /* 57 arrayValues <- <(val Action23 arraySep? (comment? newline)?)*> */
+ nil,
+ /* 58 arraySep <- <(ws ',' wsnl)> */
+ nil,
+ /* 60 Action0 <- <{ _ = buffer }> */
+ nil,
+ nil,
+ /* 62 Action1 <- <{ p.SetTableString(begin, end) }> */
+ nil,
+ /* 63 Action2 <- <{ p.AddLineCount(end - begin) }> */
+ nil,
+ /* 64 Action3 <- <{ p.AddLineCount(end - begin) }> */
+ nil,
+ /* 65 Action4 <- <{ p.AddKeyValue() }> */
+ nil,
+ /* 66 Action5 <- <{ p.SetKey(p.buffer, begin, end) }> */
+ nil,
+ /* 67 Action6 <- <{ p.SetKey(p.buffer, begin, end) }> */
+ nil,
+ /* 68 Action7 <- <{ p.SetTime(begin, end) }> */
+ nil,
+ /* 69 Action8 <- <{ p.SetFloat64(begin, end) }> */
+ nil,
+ /* 70 Action9 <- <{ p.SetInt64(begin, end) }> */
+ nil,
+ /* 71 Action10 <- <{ p.SetString(begin, end) }> */
+ nil,
+ /* 72 Action11 <- <{ p.SetBool(begin, end) }> */
+ nil,
+ /* 73 Action12 <- <{ p.SetArray(begin, end) }> */
+ nil,
+ /* 74 Action13 <- <{ p.SetTable(p.buffer, begin, end) }> */
+ nil,
+ /* 75 Action14 <- <{ p.SetArrayTable(p.buffer, begin, end) }> */
+ nil,
+ /* 76 Action15 <- <{ p.StartInlineTable() }> */
+ nil,
+ /* 77 Action16 <- <{ p.EndInlineTable() }> */
+ nil,
+ /* 78 Action17 <- <{ p.SetBasicString(p.buffer, begin, end) }> */
+ nil,
+ /* 79 Action18 <- <{ p.SetMultilineString() }> */
+ nil,
+ /* 80 Action19 <- <{ p.AddMultilineBasicBody(p.buffer, begin, end) }> */
+ nil,
+ /* 81 Action20 <- <{ p.SetLiteralString(p.buffer, begin, end) }> */
+ nil,
+ /* 82 Action21 <- <{ p.SetMultilineLiteralString(p.buffer, begin, end) }> */
+ nil,
+ /* 83 Action22 <- <{ p.StartArray() }> */
+ nil,
+ /* 84 Action23 <- <{ p.AddArrayVal() }> */
+ nil,
+ }
+ p.rules = _rules
+}
diff --git a/Godeps/_workspace/src/github.com/naoina/toml/testdata/test.toml b/Godeps/_workspace/src/github.com/naoina/toml/testdata/test.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ec119752d21ded69ee322bd18d8e3445aa709ef2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/toml/testdata/test.toml
@@ -0,0 +1,244 @@
+################################################################################
+## Comment
+
+# Speak your mind with the hash symbol. They go from the symbol to the end of
+# the line.
+
+
+################################################################################
+## Table
+
+# Tables (also known as hash tables or dictionaries) are collections of
+# key/value pairs. They appear in square brackets on a line by themselves.
+
+[table]
+
+key = "value" # Yeah, you can do this.
+
+# Nested tables are denoted by table names with dots in them. Name your tables
+# whatever crap you please, just don't use #, ., [ or ].
+
+[table.subtable]
+
+key = "another value"
+
+# You don't need to specify all the super-tables if you don't want to. TOML
+# knows how to do it for you.
+
+# [x] you
+# [x.y] don't
+# [x.y.z] need these
+[x.y.z.w] # for this to work
+
+
+################################################################################
+## Inline Table
+
+# Inline tables provide a more compact syntax for expressing tables. They are
+# especially useful for grouped data that can otherwise quickly become verbose.
+# Inline tables are enclosed in curly braces `{` and `}`. No newlines are
+# allowed between the curly braces unless they are valid within a value.
+
+[table.inline]
+
+name = { first = "Tom", last = "Preston-Werner" }
+point = { x = 1, y = 2 }
+
+
+################################################################################
+## String
+
+# There are four ways to express strings: basic, multi-line basic, literal, and
+# multi-line literal. All strings must contain only valid UTF-8 characters.
+
+[string.basic]
+
+basic = "I'm a string. \"You can quote me\". Name\tJos\u00E9\nLocation\tSF."
+
+[string.multiline]
+
+# The following strings are byte-for-byte equivalent:
+key1 = "One\nTwo"
+key2 = """One\nTwo"""
+key3 = """
+One
+Two"""
+
+[string.multiline.continued]
+
+# The following strings are byte-for-byte equivalent:
+key1 = "The quick brown fox jumps over the lazy dog."
+
+key2 = """
+The quick brown \
+
+
+ fox jumps over \
+ the lazy dog."""
+
+key3 = """\
+ The quick brown \
+ fox jumps over \
+ the lazy dog.\
+ """
+
+[string.literal]
+
+# What you see is what you get.
+winpath = 'C:\Users\nodejs\templates'
+winpath2 = '\\ServerX\admin$\system32\'
+quoted = 'Tom "Dubs" Preston-Werner'
+regex = '<\i\c*\s*>'
+
+
+[string.literal.multiline]
+
+regex2 = '''I [dw]on't need \d{2} apples'''
+lines = '''
+The first newline is
+trimmed in raw strings.
+ All other whitespace
+ is preserved.
+'''
+
+
+################################################################################
+## Integer
+
+# Integers are whole numbers. Positive numbers may be prefixed with a plus sign.
+# Negative numbers are prefixed with a minus sign.
+
+[integer]
+
+key1 = +99
+key2 = 42
+key3 = 0
+key4 = -17
+
+[integer.underscores]
+
+# For large numbers, you may use underscores to enhance readability. Each
+# underscore must be surrounded by at least one digit.
+key1 = 1_000
+key2 = 5_349_221
+key3 = 1_2_3_4_5 # valid but inadvisable
+
+
+################################################################################
+## Float
+
+# A float consists of an integer part (which may be prefixed with a plus or
+# minus sign) followed by a fractional part and/or an exponent part.
+
+[float.fractional]
+
+key1 = +1.0
+key2 = 3.1415
+key3 = -0.01
+
+[float.exponent]
+
+key1 = 5e+22
+key2 = 1e6
+key3 = -2E-2
+
+[float.both]
+
+key = 6.626e-34
+
+[float.underscores]
+
+key1 = 9_224_617.445_991_228_313
+key2 = 1e1_00
+
+
+################################################################################
+## Boolean
+
+# Booleans are just the tokens you're used to. Always lowercase.
+
+[boolean]
+
+True = true
+False = false
+
+
+################################################################################
+## Datetime
+
+# Datetimes are RFC 3339 dates.
+
+[datetime]
+
+key1 = 1979-05-27T07:32:00Z
+key2 = 1979-05-27T00:32:00-07:00
+key3 = 1979-05-27T00:32:00.999999-07:00
+
+
+################################################################################
+## Array
+
+# Arrays are square brackets with other primitives inside. Whitespace is
+# ignored. Elements are separated by commas. Data types may not be mixed.
+
+[array]
+
+key1 = [ 1, 2, 3 ]
+key2 = [ "red", "yellow", "green" ]
+key3 = [ [ 1, 2 ], [3, 4, 5] ]
+key4 = [ [ 1, 2 ], ["a", "b", "c"] ] # this is ok
+
+# Arrays can also be multiline. So in addition to ignoring whitespace, arrays
+# also ignore newlines between the brackets. Terminating commas are ok before
+# the closing bracket.
+
+key5 = [
+ 1, 2, 3
+]
+key6 = [
+ 1,
+ 2, # this is ok
+]
+
+
+################################################################################
+## Array of Tables
+
+# These can be expressed by using a table name in double brackets. Each table
+# with the same double bracketed name will be an element in the array. The
+# tables are inserted in the order encountered.
+
+[[products]]
+
+name = "Hammer"
+sku = 738594937
+
+[[products]]
+
+[[products]]
+
+name = "Nail"
+sku = 284758393
+color = "gray"
+
+
+# You can create nested arrays of tables as well.
+
+[[fruit]]
+ name = "apple"
+
+ [fruit.physical]
+ color = "red"
+ shape = "round"
+
+ [[fruit.variety]]
+ name = "red delicious"
+
+ [[fruit.variety]]
+ name = "granny smith"
+
+[[fruit]]
+ name = "banana"
+
+ [[fruit.variety]]
+ name = "plantain"
diff --git a/Godeps/_workspace/src/github.com/naoina/toml/util.go b/Godeps/_workspace/src/github.com/naoina/toml/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..dc6a548d75d6c8f665cf1355245e142173e61c1a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/naoina/toml/util.go
@@ -0,0 +1,79 @@
+package toml
+
+import (
+ "go/ast"
+ "reflect"
+ "strings"
+ "unicode"
+)
+
+// toCamelCase returns a copy of the string s with all Unicode letters mapped to their camel case.
+// It will convert to upper case previous letter of '_' and first letter, and remove letter of '_'.
+func toCamelCase(s string) string {
+ if s == "" {
+ return ""
+ }
+ result := make([]rune, 0, len(s))
+ upper := false
+ for _, r := range s {
+ if r == '_' {
+ upper = true
+ continue
+ }
+ if upper {
+ result = append(result, unicode.ToUpper(r))
+ upper = false
+ continue
+ }
+ result = append(result, r)
+ }
+ result[0] = unicode.ToUpper(result[0])
+ return string(result)
+}
+
+const (
+ fieldTagName = "toml"
+)
+
+func findField(rv reflect.Value, name string) (field reflect.Value, fieldName string, found bool) {
+ switch rv.Kind() {
+ case reflect.Struct:
+ rt := rv.Type()
+ for i := 0; i < rt.NumField(); i++ {
+ ft := rt.Field(i)
+ if !ast.IsExported(ft.Name) {
+ continue
+ }
+ if col, _ := extractTag(ft.Tag.Get(fieldTagName)); col == name {
+ return rv.Field(i), ft.Name, true
+ }
+ }
+ for _, name := range []string{
+ strings.Title(name),
+ toCamelCase(name),
+ strings.ToUpper(name),
+ } {
+ if field := rv.FieldByName(name); field.IsValid() {
+ return field, name, true
+ }
+ }
+ case reflect.Map:
+ return reflect.New(rv.Type().Elem()).Elem(), name, true
+ }
+ return field, "", false
+}
+
+func extractTag(tag string) (col, rest string) {
+ tags := strings.SplitN(tag, ",", 2)
+ if len(tags) == 2 {
+ return strings.TrimSpace(tags[0]), strings.TrimSpace(tags[1])
+ }
+ return strings.TrimSpace(tags[0]), ""
+}
+
+func tableName(prefix, name string) string {
+ if prefix != "" {
+ return prefix + string(tableSeparator) + name
+ }
+ return name
+}
diff --git a/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/LICENSE b/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..da139850ff96a70c6b717ee1d62010a55d916105
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/LICENSE
@@ -0,0 +1,9 @@
+Copyright (c) 2012, Sam Freiberg
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+* 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.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER 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.
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/README.md b/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..63907ffbf45121cbe2e5d20b832ab5ec55351891
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/README.md
@@ -0,0 +1,65 @@
+## Overview
+This is the start of a library for [Twilio](http://www.twilio.com/). Gotwilio supports making voice calls and sending text messages.
+
+## License
+Gotwilio is licensed under a BSD license.
+
+## Installation
+To install gotwilio, simply run `go get github.com/sfreiberg/gotwilio`.
+
+## SMS Example
+
+ package main
+
+ import (
+ "github.com/sfreiberg/gotwilio"
+ )
+
+ func main() {
+ accountSid := "ABC123..........ABC123"
+ authToken := "ABC123..........ABC123"
+ twilio := gotwilio.NewTwilioClient(accountSid, authToken)
+
+ from := "+15555555555"
+ to := "+15555555555"
+ message := "Welcome to gotwilio!"
+ twilio.SendSMS(from, to, message, "", "")
+ }
+
+## MMS Example
+
+ package main
+
+ import (
+ "github.com/sfreiberg/gotwilio"
+ )
+
+ func main() {
+ accountSid := "ABC123..........ABC123"
+ authToken := "ABC123..........ABC123"
+ twilio := gotwilio.NewTwilioClient(accountSid, authToken)
+
+ from := "+15555555555"
+ to := "+15555555555"
+ message := "Welcome to gotwilio!"
+ twilio.SendMMS(from, to, message, "http://host/myimage.gif", "", "")
+ }
+
+## Voice Example
+
+ package main
+
+ import (
+ "github.com/sfreiberg/gotwilio"
+ )
+
+ func main() {
+ accountSid := "ABC123..........ABC123"
+ authToken := "ABC123..........ABC123"
+ twilio := gotwilio.NewTwilioClient(accountSid, authToken)
+
+ from := "+15555555555"
+ to := "+15555555555"
+ callbackParams := gotwilio.NewCallbackParameters("http://example.com")
+ twilio.CallWithUrlCallbacks(from, to, callbackParams)
+ }
diff --git a/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/gotwilio.go b/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/gotwilio.go
new file mode 100644
index 0000000000000000000000000000000000000000..2a966b19e7b611f5e42e9cf43987c5b906f448f4
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/gotwilio.go
@@ -0,0 +1,57 @@
+// Package gotwilio is a library for interacting with http://www.twilio.com/ API.
+package gotwilio
+
+import (
+ "net/http"
+ "net/url"
+ "strings"
+)
+
+// Twilio stores basic information important for connecting to the
+// twilio.com REST api such as AccountSid and AuthToken.
+type Twilio struct {
+ AccountSid string
+ AuthToken string
+ BaseUrl string
+ HTTPClient *http.Client
+}
+
+// Exception is a representation of a twilio exception.
+type Exception struct {
+ Status int `json:"status"` // HTTP specific error code
+ Message string `json:"message"` // HTTP error message
+ Code int `json:"code"` // Twilio specific error code
+ MoreInfo string `json:"more_info"` // Additional info from Twilio
+}
+
+// Create a new Twilio struct.
+func NewTwilioClient(accountSid, authToken string) *Twilio {
+ return NewTwilioClientCustomHTTP(accountSid, authToken, nil)
+}
+
+// Create a new Twilio client, optionally using a custom http.Client
+func NewTwilioClientCustomHTTP(accountSid, authToken string, HTTPClient *http.Client) *Twilio {
+ twilioUrl := "https://api.twilio.com/2010-04-01" // Should this be moved into a constant?
+
+ if HTTPClient == nil {
+ HTTPClient = http.DefaultClient
+ }
+
+ return &Twilio{accountSid, authToken, twilioUrl, HTTPClient}
+}
+
+func (twilio *Twilio) post(formValues url.Values, twilioUrl string) (*http.Response, error) {
+ req, err := http.NewRequest("POST", twilioUrl, strings.NewReader(formValues.Encode()))
+ if err != nil {
+ return nil, err
+ }
+ req.SetBasicAuth(twilio.AccountSid, twilio.AuthToken)
+ req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+
+ client := twilio.HTTPClient
+ if client == nil {
+ client = http.DefaultClient
+ }
+
+ return client.Do(req)
+}
diff --git a/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/gotwilio_test.go b/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/gotwilio_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..8903683b671a9487eb007b286f78e8d139d447cf
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/gotwilio_test.go
@@ -0,0 +1,54 @@
+package gotwilio
+
+import (
+ "testing"
+)
+
+var params map[string]string
+
+func init() {
+ params = make(map[string]string)
+ params["SID"] = "AC0f30491286ab4abb4a108abefbd05d8a"
+ params["TOKEN"] = "1dcf52d7a1f3853ed78f0ee20d056dd0"
+ params["FROM"] = "+15005550006"
+ params["TO"] = "+19135551234"
+}
+
+func TestSMS(t *testing.T) {
+ msg := "Welcome to gotwilio"
+ twilio := NewTwilioClient(params["SID"], params["TOKEN"])
+ _, exc, err := twilio.SendSMS(params["FROM"], params["TO"], msg, "", "")
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if exc != nil {
+ t.Fatal(exc)
+ }
+}
+
+func TestMMS(t *testing.T) {
+ msg := "Welcome to gotwilio"
+ twilio := NewTwilioClient(params["SID"], params["TOKEN"])
+ _, exc, err := twilio.SendMMS(params["FROM"], params["TO"], msg, "http://www.google.com/images/logo.png", "", "")
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if exc != nil {
+ t.Fatal(exc)
+ }
+}
+
+func TestVoice(t *testing.T) {
+ callback := NewCallbackParameters("http://example.com")
+ twilio := NewTwilioClient(params["SID"], params["TOKEN"])
+ _, exc, err := twilio.CallWithUrlCallbacks(params["FROM"], params["TO"], callback)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if exc != nil {
+ t.Fatal(exc)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/sms.go b/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/sms.go
new file mode 100644
index 0000000000000000000000000000000000000000..d87e36bd99aca0c6974bfcca1e43e7623adee127
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/sms.go
@@ -0,0 +1,112 @@
+package gotwilio
+
+import (
+ "encoding/json"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "time"
+)
+
+// SmsResponse is returned after a text/sms message is posted to Twilio
+type SmsResponse struct {
+ Sid string `json:"sid"`
+ DateCreated string `json:"date_created"`
+ DateUpdate string `json:"date_updated"`
+ DateSent string `json:"date_sent"`
+ AccountSid string `json:"account_sid"`
+ To string `json:"to"`
+ From string `json:"from"`
+ MediaUrl string `json:"media_url"`
+ Body string `json:"body"`
+ Status string `json:"status"`
+ Direction string `json:"direction"`
+ ApiVersion string `json:"api_version"`
+ Price *float32 `json:"price,omitempty"`
+ Url string `json:"uri"`
+}
+
+// Returns SmsResponse.DateCreated as a time.Time object
+// instead of a string.
+func (sms *SmsResponse) DateCreatedAsTime() (time.Time, error) {
+ return time.Parse(time.RFC1123Z, sms.DateCreated)
+}
+
+// Returns SmsResponse.DateUpdate as a time.Time object
+// instead of a string.
+func (sms *SmsResponse) DateUpdateAsTime() (time.Time, error) {
+ return time.Parse(time.RFC1123Z, sms.DateUpdate)
+}
+
+// Returns SmsResponse.DateSent as a time.Time object
+// instead of a string.
+func (sms *SmsResponse) DateSentAsTime() (time.Time, error) {
+ return time.Parse(time.RFC1123Z, sms.DateSent)
+}
+
+// SendTextMessage uses Twilio to send a text message.
+// See http://www.twilio.com/docs/api/rest/sending-sms for more information.
+func (twilio *Twilio) SendSMS(from, to, body, statusCallback, applicationSid string) (smsResponse *SmsResponse, exception *Exception, err error) {
+ formValues := initFormValues(from, to, body, "", statusCallback, applicationSid)
+ smsResponse, exception, err = twilio.sendMessage(formValues)
+ return
+}
+
+// SendMultimediaMessage uses Twilio to send a multimedia message.
+func (twilio *Twilio) SendMMS(from, to, body, mediaUrl, statusCallback, applicationSid string) (smsResponse *SmsResponse, exception *Exception, err error) {
+ formValues := initFormValues(from, to, body, mediaUrl, statusCallback, applicationSid)
+ smsResponse, exception, err = twilio.sendMessage(formValues)
+ return
+}
+
+// Core method to send message
+func (twilio *Twilio) sendMessage(formValues url.Values) (smsResponse *SmsResponse, exception *Exception, err error) {
+ twilioUrl := twilio.BaseUrl + "/Accounts/" + twilio.AccountSid + "/Messages.json"
+
+ res, err := twilio.post(formValues, twilioUrl)
+ if err != nil {
+ return smsResponse, exception, err
+ }
+ defer res.Body.Close()
+
+ responseBody, err := ioutil.ReadAll(res.Body)
+ if err != nil {
+ return smsResponse, exception, err
+ }
+
+ if res.StatusCode != http.StatusCreated {
+ exception = new(Exception)
+ err = json.Unmarshal(responseBody, exception)
+
+ // We aren't checking the error because we don't actually care.
+ // It's going to be passed to the client either way.
+ return smsResponse, exception, err
+ }
+
+ smsResponse = new(SmsResponse)
+ err = json.Unmarshal(responseBody, smsResponse)
+ return smsResponse, exception, err
+}
+
+// Form values initialization
+func initFormValues(from, to, body, mediaUrl, statusCallback, applicationSid string) url.Values {
+ formValues := url.Values{}
+
+ formValues.Set("From", from)
+ formValues.Set("To", to)
+ formValues.Set("Body", body)
+
+ if mediaUrl != "" {
+ formValues.Set("MediaUrl", mediaUrl)
+ }
+
+ if statusCallback != "" {
+ formValues.Set("StatusCallback", statusCallback)
+ }
+
+ if applicationSid != "" {
+ formValues.Set("ApplicationSid", applicationSid)
+ }
+
+ return formValues
+}
diff --git a/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/util.go b/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..81aa1930ce7e2d53e9e144825bbae08de62b0b0a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/util.go
@@ -0,0 +1,84 @@
+package gotwilio
+
+import (
+ "bytes"
+ "crypto/hmac"
+ "crypto/sha1"
+ "encoding/base64"
+ "errors"
+ "net/http"
+ "net/url"
+ "sort"
+)
+
+// GenerateSignature computes the Twilio signature for verifying the
+// authenticity of a request. It is based on the specification at:
+// https://www.twilio.com/docs/security#validating-requests
+func (twilio *Twilio) GenerateSignature(url string, form url.Values) ([]byte, error) {
+ var buf bytes.Buffer
+
+ buf.WriteString(url)
+
+ keys := make(sort.StringSlice, 0, len(form))
+ for k := range form {
+ keys = append(keys, k)
+ }
+
+ keys.Sort()
+
+ for _, k := range keys {
+ buf.WriteString(k)
+ for _, v := range form[k] {
+ buf.WriteString(v)
+ }
+ }
+
+ mac := hmac.New(sha1.New, []byte(twilio.AuthToken))
+ mac.Write(buf.Bytes())
+
+ var expected bytes.Buffer
+ coder := base64.NewEncoder(base64.StdEncoding, &expected)
+ _, err := coder.Write(mac.Sum(nil))
+ if err != nil {
+ return nil, err
+ }
+
+ err = coder.Close()
+ if err != nil {
+ return nil, err
+ }
+
+ return expected.Bytes(), nil
+}
+
+// CheckRequestSignature checks that the X-Twilio-Signature header on a request
+// matches the expected signature defined by the GenerateSignature function.
+//
+// The baseUrl parameter will be prepended to the request URL. It is useful for
+// specifying the protocol and host parts of the server URL hosting your endpoint.
+//
+// Passing a non-POST request or a request without the X-Twilio-Signature
+// header is an error.
+func (twilio *Twilio) CheckRequestSignature(r *http.Request, baseURL string) (bool, error) {
+ if r.Method != "POST" {
+ return false, errors.New("Checking signatures on non-POST requests is not implemented")
+ }
+
+ if err := r.ParseForm(); err != nil {
+ return false, err
+ }
+
+ url := baseURL + r.URL.String()
+
+ expected, err := twilio.GenerateSignature(url, r.PostForm)
+ if err != nil {
+ return false, err
+ }
+
+ actual := r.Header.Get("X-Twilio-Signature")
+ if actual == "" {
+ return false, errors.New("Request does not have a twilio signature header")
+ }
+
+ return hmac.Equal(expected, []byte(actual)), nil
+}
diff --git a/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/util_test.go b/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/util_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..4d53899a4bc33fa7006a5fa0d4540c6affa525ea
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/util_test.go
@@ -0,0 +1,70 @@
+package gotwilio
+
+import (
+ "bytes"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "testing"
+)
+
+const (
+ // Magic strings from https://github.com/twilio/twilio-python
+ testServerURL = "http://www.postbin.org"
+ testAuthToken = "1c892n40nd03kdnc0112slzkl3091j20"
+ testValidSignature = "fF+xx6dTinOaCdZ0aIeNkHr/ZAA="
+)
+
+func TestCheckSignature(t *testing.T) {
+ twilio := Twilio{
+ AuthToken: testAuthToken,
+ }
+
+ // Magic strings from https://github.com/twilio/twilio-python
+ u, err := url.Parse("/1ed898x")
+ if err != nil {
+ t.Fatal(err)
+ }
+ h := http.Header{
+ "Content-Type": []string{"application/x-www-form-urlencoded"},
+ "X-Twilio-Signature": []string{testValidSignature},
+ }
+ b := bytes.NewBufferString(`FromZip=89449&From=%2B15306666666&` +
+ `FromCity=SOUTH+LAKE+TAHOE&ApiVersion=2010-04-01&To=%2B15306384866&` +
+ `CallStatus=ringing&CalledState=CA&FromState=CA&Direction=inbound&` +
+ `ToCity=OAKLAND&ToZip=94612&CallerCity=SOUTH+LAKE+TAHOE&FromCountry=US&` +
+ `CallerName=CA+Wireless+Call&CalledCity=OAKLAND&CalledCountry=US&` +
+ `Caller=%2B15306666666&CallerZip=89449&AccountSid=AC9a9f9392lad99kla0sklakjs90j092j3&` +
+ `Called=%2B15306384866&CallerCountry=US&CalledZip=94612&CallSid=CAd800bb12c0426a7ea4230e492fef2a4f&` +
+ `CallerState=CA&ToCountry=US&ToState=CA`)
+
+ r := http.Request{
+ Method: "POST",
+ URL: u,
+ Header: h,
+ Body: ioutil.NopCloser(b),
+ }
+
+ valid, err := twilio.CheckRequestSignature(&r, testServerURL)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !valid {
+ t.Fatal("Expected signature to be valid")
+ }
+
+ h["X-Twilio-Signature"] = []string{"foo"}
+ valid, err = twilio.CheckRequestSignature(&r, testServerURL)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if valid {
+ t.Fatal("Expected signature to be invalid")
+ }
+
+ delete(h, "X-Twilio-Signature")
+ valid, err = twilio.CheckRequestSignature(&r, testServerURL)
+ if err == nil {
+ t.Fatal("Expected an error verifying a request without a signature header")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/voice.go b/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/voice.go
new file mode 100644
index 0000000000000000000000000000000000000000..091db41b3fc0f5930c25650befc38ee3d3d949a3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/sfreiberg/gotwilio/voice.go
@@ -0,0 +1,161 @@
+package gotwilio
+
+import (
+ "encoding/json"
+ "net/http"
+ "net/url"
+ "strconv"
+ "time"
+)
+
+// These are the paramters to use when you want Twilio to use callback urls.
+// See http://www.twilio.com/docs/api/rest/making-calls for more info.
+type CallbackParameters struct {
+ Url string // Required
+ Method string // Optional
+ FallbackUrl string // Optional
+ FallbackMethod string // Optional
+ StatusCallback string // Optional
+ StatusCallbackMethod string // Optional
+ SendDigits string // Optional
+ IfMachine string // False, Continue or Hangup; http://www.twilio.com/docs/errors/21207
+ Timeout int // Optional
+ Record bool // Optional
+}
+
+// VoiceResponse contains the details about successful voice calls.
+type VoiceResponse struct {
+ Sid string `json:"sid"`
+ DateCreated string `json:"date_created"`
+ DateUpdated string `json:"date_updated"`
+ ParentCallSid string `json:"parent_call_sid"`
+ AccountSid string `json:"account_sid"`
+ To string `json:"to"`
+ ToFormatted string `json:"to_formatted"`
+ From string `json:"from"`
+ FromFormatted string `json:"from_formatted"`
+ PhoneNumberSid string `json:"phone_number_sid"`
+ Status string `json:"status"`
+ StartTime string `json:"start_time"`
+ EndTime string `json:"end_time"`
+ Duration int `json:"duration"`
+ Price *float32 `json:"price,omitempty"`
+ Direction string `json:"direction"`
+ AnsweredBy string `json:"answered_by"`
+ ApiVersion string `json:"api_version"`
+ Annotation string `json:"annotation"`
+ ForwardedFrom string `json:"forwarded_from"`
+ GroupSid string `json:"group_sid"`
+ CallerName string `json:"caller_name"`
+ Uri string `json:"uri"`
+ // TODO: handle SubresourceUris
+}
+
+// Returns VoiceResponse.DateCreated as a time.Time object
+// instead of a string.
+func (vr *VoiceResponse) DateCreatedAsTime() (time.Time, error) {
+ return time.Parse(time.RFC1123Z, vr.DateCreated)
+}
+
+// Returns VoiceResponse.DateUpdated as a time.Time object
+// instead of a string.
+func (vr *VoiceResponse) DateUpdatedAsTime() (time.Time, error) {
+ return time.Parse(time.RFC1123Z, vr.DateUpdated)
+}
+
+// Returns VoiceResponse.StartTime as a time.Time object
+// instead of a string.
+func (vr *VoiceResponse) StartTimeAsTime() (time.Time, error) {
+ return time.Parse(time.RFC1123Z, vr.StartTime)
+}
+
+// Returns VoiceResponse.EndTime as a time.Time object
+// instead of a string.
+func (vr *VoiceResponse) EndTimeAsTime() (time.Time, error) {
+ return time.Parse(time.RFC1123Z, vr.EndTime)
+}
+
+// Returns a CallbackParameters type with the specified url and
+// CallbackParameters.Timeout set to 60.
+func NewCallbackParameters(url string) *CallbackParameters {
+ return &CallbackParameters{Url: url, Timeout: 60}
+}
+
+// Place a voice call with a list of callbacks specified.
+func (twilio *Twilio) CallWithUrlCallbacks(from, to string, callbackParameters *CallbackParameters) (*VoiceResponse, *Exception, error) {
+ formValues := url.Values{}
+ formValues.Set("From", from)
+ formValues.Set("To", to)
+ formValues.Set("Url", callbackParameters.Url)
+
+ // Optional values
+ if callbackParameters.Method != "" {
+ formValues.Set("Method", callbackParameters.Method)
+ }
+ if callbackParameters.FallbackUrl != "" {
+ formValues.Set("FallbackUrl", callbackParameters.FallbackUrl)
+ }
+ if callbackParameters.FallbackMethod != "" {
+ formValues.Set("FallbackMethod", callbackParameters.FallbackMethod)
+ }
+ if callbackParameters.StatusCallback != "" {
+ formValues.Set("StatusCallback", callbackParameters.StatusCallback)
+ }
+ if callbackParameters.StatusCallbackMethod != "" {
+ formValues.Set("StatusCallbackMethod", callbackParameters.StatusCallbackMethod)
+ }
+ if callbackParameters.SendDigits != "" {
+ formValues.Set("SendDigits", callbackParameters.SendDigits)
+ }
+ if callbackParameters.IfMachine != "" {
+ formValues.Set("IfMachine", callbackParameters.IfMachine)
+ }
+ if callbackParameters.Timeout != 0 {
+ formValues.Set("Timeout", strconv.Itoa(callbackParameters.Timeout))
+ }
+ if callbackParameters.Record {
+ formValues.Set("Record", "true")
+ } else {
+ formValues.Set("Record", "false")
+ }
+
+ return twilio.voicePost(formValues)
+}
+
+// Place a voice call with an ApplicationSid specified.
+func (twilio *Twilio) CallWithApplicationCallbacks(from, to, applicationSid string) (*VoiceResponse, *Exception, error) {
+ formValues := url.Values{}
+ formValues.Set("From", from)
+ formValues.Set("To", to)
+ formValues.Set("ApplicationSid", applicationSid)
+
+ return twilio.voicePost(formValues)
+}
+
+// This is a private method that has the common bits for making a voice call.
+func (twilio *Twilio) voicePost(formValues url.Values) (*VoiceResponse, *Exception, error) {
+ var voiceResponse *VoiceResponse
+ var exception *Exception
+ twilioUrl := twilio.BaseUrl + "/Accounts/" + twilio.AccountSid + "/Calls.json"
+
+ res, err := twilio.post(formValues, twilioUrl)
+ if err != nil {
+ return voiceResponse, exception, err
+ }
+ defer res.Body.Close()
+
+ decoder := json.NewDecoder(res.Body)
+
+ if res.StatusCode != http.StatusCreated {
+ exception = new(Exception)
+ err = decoder.Decode(exception)
+
+ // We aren't checking the error because we don't actually care.
+ // It's going to be passed to the client either way.
+ return voiceResponse, exception, err
+ }
+
+ voiceResponse = new(VoiceResponse)
+ err = decoder.Decode(voiceResponse)
+ return voiceResponse, exception, err
+}
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/assert/assertions.go b/Godeps/_workspace/src/github.com/stretchr/testify/assert/assertions.go
new file mode 100644
index 0000000000000000000000000000000000000000..5de1ab11795ca3c4e0085f45e08c5c964b503119
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/assert/assertions.go
@@ -0,0 +1,782 @@
+package assert
+
+import (
+ "bufio"
+ "bytes"
+ "fmt"
+ "reflect"
+ "regexp"
+ "runtime"
+ "strings"
+ "time"
+)
+
+// TestingT is an interface wrapper around *testing.T
+type TestingT interface {
+ Errorf(format string, args ...interface{})
+}
+
+// Comparison a custom function that returns true on success and false on failure
+type Comparison func() (success bool)
+
+/*
+ Helper functions
+*/
+
+// ObjectsAreEqual determines if two objects are considered equal.
+//
+// This function does no assertion of any kind.
+func ObjectsAreEqual(expected, actual interface{}) bool {
+
+ if expected == nil || actual == nil {
+ return expected == actual
+ }
+
+ if reflect.DeepEqual(expected, actual) {
+ return true
+ }
+
+ expectedValue := reflect.ValueOf(expected)
+ actualValue := reflect.ValueOf(actual)
+ if expectedValue == actualValue {
+ return true
+ }
+
+ // Attempt comparison after type conversion
+ if actualValue.Type().ConvertibleTo(expectedValue.Type()) && expectedValue == actualValue.Convert(expectedValue.Type()) {
+ return true
+ }
+
+ // Last ditch effort
+ if fmt.Sprintf("%#v", expected) == fmt.Sprintf("%#v", actual) {
+ return true
+ }
+
+ return false
+
+}
+
+/* CallerInfo is necessary because the assert functions use the testing object
+internally, causing it to print the file:line of the assert method, rather than where
+the problem actually occured in calling code.*/
+
+// CallerInfo returns a string containing the file and line number of the assert call
+// that failed.
+func CallerInfo() string {
+
+ file := ""
+ line := 0
+ ok := false
+
+ for i := 0; ; i++ {
+ _, file, line, ok = runtime.Caller(i)
+ if !ok {
+ return ""
+ }
+ parts := strings.Split(file, "/")
+ dir := parts[len(parts)-2]
+ file = parts[len(parts)-1]
+ if (dir != "assert" && dir != "mock" && dir != "require") || file == "mock_test.go" {
+ break
+ }
+ }
+
+ return fmt.Sprintf("%s:%d", file, line)
+}
+
+// getWhitespaceString returns a string that is long enough to overwrite the default
+// output from the go testing framework.
+func getWhitespaceString() string {
+
+ _, file, line, ok := runtime.Caller(1)
+ if !ok {
+ return ""
+ }
+ parts := strings.Split(file, "/")
+ file = parts[len(parts)-1]
+
+ return strings.Repeat(" ", len(fmt.Sprintf("%s:%d: ", file, line)))
+
+}
+
+func messageFromMsgAndArgs(msgAndArgs ...interface{}) string {
+ if len(msgAndArgs) == 0 || msgAndArgs == nil {
+ return ""
+ }
+ if len(msgAndArgs) == 1 {
+ return msgAndArgs[0].(string)
+ }
+ if len(msgAndArgs) > 1 {
+ return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...)
+ }
+ return ""
+}
+
+// Indents all lines of the message by appending a number of tabs to each line, in an output format compatible with Go's
+// test printing (see inner comment for specifics)
+func indentMessageLines(message string, tabs int) string {
+ outBuf := new(bytes.Buffer)
+
+ for i, scanner := 0, bufio.NewScanner(strings.NewReader(message)); scanner.Scan(); i++ {
+ if i != 0 {
+ outBuf.WriteRune('\n')
+ }
+ for ii := 0; ii < tabs; ii++ {
+ outBuf.WriteRune('\t')
+ // Bizarrely, all lines except the first need one fewer tabs prepended, so deliberately advance the counter
+ // by 1 prematurely.
+ if ii == 0 && i > 0 {
+ ii++
+ }
+ }
+ outBuf.WriteString(scanner.Text())
+ }
+
+ return outBuf.String()
+}
+
+// Fail reports a failure through
+func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool {
+
+ message := messageFromMsgAndArgs(msgAndArgs...)
+
+ if len(message) > 0 {
+ t.Errorf("\r%s\r\tLocation:\t%s\n"+
+ "\r\tError:%s\n"+
+ "\r\tMessages:\t%s\n\r",
+ getWhitespaceString(),
+ CallerInfo(),
+ indentMessageLines(failureMessage, 2),
+ message)
+ } else {
+ t.Errorf("\r%s\r\tLocation:\t%s\n"+
+ "\r\tError:%s\n\r",
+ getWhitespaceString(),
+ CallerInfo(),
+ indentMessageLines(failureMessage, 2))
+ }
+
+ return false
+}
+
+// Implements asserts that an object is implemented by the specified interface.
+//
+// assert.Implements(t, (*MyInterface)(nil), new(MyObject), "MyObject")
+func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+
+ interfaceType := reflect.TypeOf(interfaceObject).Elem()
+
+ if !reflect.TypeOf(object).Implements(interfaceType) {
+ return Fail(t, fmt.Sprintf("Object must implement %v", interfaceType), msgAndArgs...)
+ }
+
+ return true
+
+}
+
+// IsType asserts that the specified objects are of the same type.
+func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+
+ if !ObjectsAreEqual(reflect.TypeOf(object), reflect.TypeOf(expectedType)) {
+ return Fail(t, fmt.Sprintf("Object expected to be of type %v, but was %v", reflect.TypeOf(expectedType), reflect.TypeOf(object)), msgAndArgs...)
+ }
+
+ return true
+}
+
+// Equal asserts that two objects are equal.
+//
+// assert.Equal(t, 123, 123, "123 and 123 should be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+
+ if !ObjectsAreEqual(expected, actual) {
+ return Fail(t, fmt.Sprintf("Not equal: %#v (expected)\n"+
+ " != %#v (actual)", expected, actual), msgAndArgs...)
+ }
+
+ return true
+
+}
+
+// Exactly asserts that two objects are equal is value and type.
+//
+// assert.Exactly(t, int32(123), int64(123), "123 and 123 should NOT be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+
+ aType := reflect.TypeOf(expected)
+ bType := reflect.TypeOf(actual)
+
+ if aType != bType {
+ return Fail(t, "Types expected to match exactly", "%v != %v", aType, bType)
+ }
+
+ return Equal(t, expected, actual, msgAndArgs...)
+
+}
+
+// NotNil asserts that the specified object is not nil.
+//
+// assert.NotNil(t, err, "err should be something")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+
+ success := true
+
+ if object == nil {
+ success = false
+ } else {
+ value := reflect.ValueOf(object)
+ kind := value.Kind()
+ if kind >= reflect.Chan && kind <= reflect.Slice && value.IsNil() {
+ success = false
+ }
+ }
+
+ if !success {
+ Fail(t, "Expected not to be nil.", msgAndArgs...)
+ }
+
+ return success
+}
+
+// isNil checks if a specified object is nil or not, without Failing.
+func isNil(object interface{}) bool {
+ if object == nil {
+ return true
+ }
+
+ value := reflect.ValueOf(object)
+ kind := value.Kind()
+ if kind >= reflect.Chan && kind <= reflect.Slice && value.IsNil() {
+ return true
+ }
+
+ return false
+}
+
+// Nil asserts that the specified object is nil.
+//
+// assert.Nil(t, err, "err should be nothing")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+ if isNil(object) {
+ return true
+ }
+ return Fail(t, fmt.Sprintf("Expected nil, but got: %#v", object), msgAndArgs...)
+}
+
+var zeros = []interface{}{
+ int(0),
+ int8(0),
+ int16(0),
+ int32(0),
+ int64(0),
+ uint(0),
+ uint8(0),
+ uint16(0),
+ uint32(0),
+ uint64(0),
+ float32(0),
+ float64(0),
+}
+
+// isEmpty gets whether the specified object is considered empty or not.
+func isEmpty(object interface{}) bool {
+
+ if object == nil {
+ return true
+ } else if object == "" {
+ return true
+ } else if object == false {
+ return true
+ }
+
+ for _, v := range zeros {
+ if object == v {
+ return true
+ }
+ }
+
+ objValue := reflect.ValueOf(object)
+
+ switch objValue.Kind() {
+ case reflect.Map:
+ fallthrough
+ case reflect.Slice, reflect.Chan:
+ {
+ return (objValue.Len() == 0)
+ }
+ case reflect.Ptr:
+ {
+ switch object.(type) {
+ case *time.Time:
+ return object.(*time.Time).IsZero()
+ default:
+ return false
+ }
+ }
+ }
+ return false
+}
+
+// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+// assert.Empty(t, obj)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+
+ pass := isEmpty(object)
+ if !pass {
+ Fail(t, fmt.Sprintf("Should be empty, but was %v", object), msgAndArgs...)
+ }
+
+ return pass
+
+}
+
+// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+// if assert.NotEmpty(t, obj) {
+// assert.Equal(t, "two", obj[1])
+// }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+
+ pass := !isEmpty(object)
+ if !pass {
+ Fail(t, fmt.Sprintf("Should NOT be empty, but was %v", object), msgAndArgs...)
+ }
+
+ return pass
+
+}
+
+// getLen try to get length of object.
+// return (false, 0) if impossible.
+func getLen(x interface{}) (ok bool, length int) {
+ v := reflect.ValueOf(x)
+ defer func() {
+ if e := recover(); e != nil {
+ ok = false
+ }
+ }()
+ return true, v.Len()
+}
+
+// Len asserts that the specified object has specific length.
+// Len also fails if the object has a type that len() not accept.
+//
+// assert.Len(t, mySlice, 3, "The size of slice is not 3")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) bool {
+ ok, l := getLen(object)
+ if !ok {
+ return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", object), msgAndArgs...)
+ }
+
+ if l != length {
+ return Fail(t, fmt.Sprintf("\"%s\" should have %d item(s), but has %d", object, length, l), msgAndArgs...)
+ }
+ return true
+}
+
+// True asserts that the specified value is true.
+//
+// assert.True(t, myBool, "myBool should be true")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func True(t TestingT, value bool, msgAndArgs ...interface{}) bool {
+
+ if value != true {
+ return Fail(t, "Should be true", msgAndArgs...)
+ }
+
+ return true
+
+}
+
+// False asserts that the specified value is true.
+//
+// assert.False(t, myBool, "myBool should be false")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func False(t TestingT, value bool, msgAndArgs ...interface{}) bool {
+
+ if value != false {
+ return Fail(t, "Should be false", msgAndArgs...)
+ }
+
+ return true
+
+}
+
+// NotEqual asserts that the specified values are NOT equal.
+//
+// assert.NotEqual(t, obj1, obj2, "two objects shouldn't be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+
+ if ObjectsAreEqual(expected, actual) {
+ return Fail(t, "Should not be equal", msgAndArgs...)
+ }
+
+ return true
+
+}
+
+// containsElement try loop over the list check if the list includes the element.
+// return (false, false) if impossible.
+// return (true, false) if element was not found.
+// return (true, true) if element was found.
+func includeElement(list interface{}, element interface{}) (ok, found bool) {
+
+ listValue := reflect.ValueOf(list)
+ elementValue := reflect.ValueOf(element)
+ defer func() {
+ if e := recover(); e != nil {
+ ok = false
+ found = false
+ }
+ }()
+
+ if reflect.TypeOf(list).Kind() == reflect.String {
+ return true, strings.Contains(listValue.String(), elementValue.String())
+ }
+
+ for i := 0; i < listValue.Len(); i++ {
+ if listValue.Index(i).Interface() == element {
+ return true, true
+ }
+ }
+ return true, false
+
+}
+
+// Contains asserts that the specified string or list(array, slice...) contains the
+// specified substring or element.
+//
+// assert.Contains(t, "Hello World", "World", "But 'Hello World' does contain 'World'")
+// assert.Contains(t, ["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool {
+
+ ok, found := includeElement(s, contains)
+ if !ok {
+ return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...)
+ }
+ if !found {
+ return Fail(t, fmt.Sprintf("\"%s\" does not contain \"%s\"", s, contains), msgAndArgs...)
+ }
+
+ return true
+
+}
+
+// NotContains asserts that the specified string or list(array, slice...) does NOT contain the
+// specified substring or element.
+//
+// assert.NotContains(t, "Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
+// assert.NotContains(t, ["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool {
+
+ ok, found := includeElement(s, contains)
+ if !ok {
+ return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...)
+ }
+ if found {
+ return Fail(t, fmt.Sprintf("\"%s\" should not contain \"%s\"", s, contains), msgAndArgs...)
+ }
+
+ return true
+
+}
+
+// Condition uses a Comparison to assert a complex condition.
+func Condition(t TestingT, comp Comparison, msgAndArgs ...interface{}) bool {
+ result := comp()
+ if !result {
+ Fail(t, "Condition failed!", msgAndArgs...)
+ }
+ return result
+}
+
+// PanicTestFunc defines a func that should be passed to the assert.Panics and assert.NotPanics
+// methods, and represents a simple func that takes no arguments, and returns nothing.
+type PanicTestFunc func()
+
+// didPanic returns true if the function passed to it panics. Otherwise, it returns false.
+func didPanic(f PanicTestFunc) (bool, interface{}) {
+
+ didPanic := false
+ var message interface{}
+ func() {
+
+ defer func() {
+ if message = recover(); message != nil {
+ didPanic = true
+ }
+ }()
+
+ // call the target function
+ f()
+
+ }()
+
+ return didPanic, message
+
+}
+
+// Panics asserts that the code inside the specified PanicTestFunc panics.
+//
+// assert.Panics(t, func(){
+// GoCrazy()
+// }, "Calling GoCrazy() should panic")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool {
+
+ if funcDidPanic, panicValue := didPanic(f); !funcDidPanic {
+ return Fail(t, fmt.Sprintf("func %#v should panic\n\r\tPanic value:\t%v", f, panicValue), msgAndArgs...)
+ }
+
+ return true
+}
+
+// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+// assert.NotPanics(t, func(){
+// RemainCalm()
+// }, "Calling RemainCalm() should NOT panic")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool {
+
+ if funcDidPanic, panicValue := didPanic(f); funcDidPanic {
+ return Fail(t, fmt.Sprintf("func %#v should not panic\n\r\tPanic value:\t%v", f, panicValue), msgAndArgs...)
+ }
+
+ return true
+}
+
+// WithinDuration asserts that the two times are within duration delta of each other.
+//
+// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
+
+ dt := expected.Sub(actual)
+ if dt < -delta || dt > delta {
+ return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...)
+ }
+
+ return true
+}
+
+func toFloat(x interface{}) (float64, bool) {
+ var xf float64
+ xok := true
+
+ switch xn := x.(type) {
+ case uint8:
+ xf = float64(xn)
+ case uint16:
+ xf = float64(xn)
+ case uint32:
+ xf = float64(xn)
+ case uint64:
+ xf = float64(xn)
+ case int:
+ xf = float64(xn)
+ case int8:
+ xf = float64(xn)
+ case int16:
+ xf = float64(xn)
+ case int32:
+ xf = float64(xn)
+ case int64:
+ xf = float64(xn)
+ case float32:
+ xf = float64(xn)
+ case float64:
+ xf = float64(xn)
+ default:
+ xok = false
+ }
+
+ return xf, xok
+}
+
+// InDelta asserts that the two numerals are within delta of each other.
+//
+// assert.InDelta(t, math.Pi, (22 / 7.0), 0.01)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func InDelta(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
+
+ af, aok := toFloat(expected)
+ bf, bok := toFloat(actual)
+
+ if !aok || !bok {
+ return Fail(t, fmt.Sprintf("Parameters must be numerical"), msgAndArgs...)
+ }
+
+ dt := af - bf
+ if dt < -delta || dt > delta {
+ return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...)
+ }
+
+ return true
+}
+
+// min(|expected|, |actual|) * epsilon
+func calcEpsilonDelta(expected, actual interface{}, epsilon float64) float64 {
+ af, aok := toFloat(expected)
+ bf, bok := toFloat(actual)
+
+ if !aok || !bok {
+ // invalid input
+ return 0
+ }
+
+ if af < 0 {
+ af = -af
+ }
+ if bf < 0 {
+ bf = -bf
+ }
+ var delta float64
+ if af < bf {
+ delta = af * epsilon
+ } else {
+ delta = bf * epsilon
+ }
+ return delta
+}
+
+// InEpsilon asserts that expected and actual have a relative error less than epsilon
+//
+// Returns whether the assertion was successful (true) or not (false).
+func InEpsilon(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
+ delta := calcEpsilonDelta(expected, actual, epsilon)
+
+ return InDelta(t, expected, actual, delta, msgAndArgs...)
+}
+
+/*
+ Errors
+*/
+
+// NoError asserts that a function returned no error (i.e. `nil`).
+//
+// actualObj, err := SomeFunction()
+// if assert.NoError(t, err) {
+// assert.Equal(t, actualObj, expectedObj)
+// }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool {
+ if isNil(err) {
+ return true
+ }
+
+ return Fail(t, fmt.Sprintf("No error is expected but got %v", err), msgAndArgs...)
+}
+
+// Error asserts that a function returned an error (i.e. not `nil`).
+//
+// actualObj, err := SomeFunction()
+// if assert.Error(t, err, "An error was expected") {
+// assert.Equal(t, err, expectedError)
+// }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Error(t TestingT, err error, msgAndArgs ...interface{}) bool {
+
+ message := messageFromMsgAndArgs(msgAndArgs...)
+ return NotNil(t, err, "An error is expected but got nil. %s", message)
+
+}
+
+// EqualError asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+// actualObj, err := SomeFunction()
+// if assert.Error(t, err, "An error was expected") {
+// assert.Equal(t, err, expectedError)
+// }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) bool {
+
+ message := messageFromMsgAndArgs(msgAndArgs...)
+ if !NotNil(t, theError, "An error is expected but got nil. %s", message) {
+ return false
+ }
+ s := "An error with value \"%s\" is expected but got \"%s\". %s"
+ return Equal(t, theError.Error(), errString,
+ s, errString, theError.Error(), message)
+}
+
+// matchRegexp return true if a specified regexp matches a string.
+func matchRegexp(rx interface{}, str interface{}) bool {
+
+ var r *regexp.Regexp
+ if rr, ok := rx.(*regexp.Regexp); ok {
+ r = rr
+ } else {
+ r = regexp.MustCompile(fmt.Sprint(rx))
+ }
+
+ return (r.FindStringIndex(fmt.Sprint(str)) != nil)
+
+}
+
+// Regexp asserts that a specified regexp matches a string.
+//
+// assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
+// assert.Regexp(t, "start...$", "it's not starting")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Regexp(t TestingT, rx interface{}, str interface{}) bool {
+
+ match := matchRegexp(rx, str)
+
+ if !match {
+ Fail(t, "Expect \"%s\" to match \"%s\"")
+ }
+
+ return match
+}
+
+// NotRegexp asserts that a specified regexp does not match a string.
+//
+// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
+// assert.NotRegexp(t, "^start", "it's not starting")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotRegexp(t TestingT, rx interface{}, str interface{}) bool {
+ match := matchRegexp(rx, str)
+
+ if match {
+ Fail(t, "Expect \"%s\" to NOT match \"%s\"")
+ }
+
+ return !match
+
+}
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/assert/assertions_test.go b/Godeps/_workspace/src/github.com/stretchr/testify/assert/assertions_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..e5f12377c7bd7a0d04a537695ab3cf9ffa34ae67
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/assert/assertions_test.go
@@ -0,0 +1,723 @@
+package assert
+
+import (
+ "errors"
+ "regexp"
+ "testing"
+ "time"
+)
+
+// AssertionTesterInterface defines an interface to be used for testing assertion methods
+type AssertionTesterInterface interface {
+ TestMethod()
+}
+
+// AssertionTesterConformingObject is an object that conforms to the AssertionTesterInterface interface
+type AssertionTesterConformingObject struct {
+}
+
+func (a *AssertionTesterConformingObject) TestMethod() {
+}
+
+// AssertionTesterNonConformingObject is an object that does not conform to the AssertionTesterInterface interface
+type AssertionTesterNonConformingObject struct {
+}
+
+func TestObjectsAreEqual(t *testing.T) {
+
+ if !ObjectsAreEqual("Hello World", "Hello World") {
+ t.Error("objectsAreEqual should return true")
+ }
+ if !ObjectsAreEqual(123, 123) {
+ t.Error("objectsAreEqual should return true")
+ }
+ if !ObjectsAreEqual(123.5, 123.5) {
+ t.Error("objectsAreEqual should return true")
+ }
+ if !ObjectsAreEqual([]byte("Hello World"), []byte("Hello World")) {
+ t.Error("objectsAreEqual should return true")
+ }
+ if !ObjectsAreEqual(nil, nil) {
+ t.Error("objectsAreEqual should return true")
+ }
+
+}
+
+func TestImplements(t *testing.T) {
+
+ mockT := new(testing.T)
+
+ if !Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject)) {
+ t.Error("Implements method should return true: AssertionTesterConformingObject implements AssertionTesterInterface")
+ }
+ if Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject)) {
+ t.Error("Implements method should return false: AssertionTesterNonConformingObject does not implements AssertionTesterInterface")
+ }
+
+}
+
+func TestIsType(t *testing.T) {
+
+ mockT := new(testing.T)
+
+ if !IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) {
+ t.Error("IsType should return true: AssertionTesterConformingObject is the same type as AssertionTesterConformingObject")
+ }
+ if IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject)) {
+ t.Error("IsType should return false: AssertionTesterConformingObject is not the same type as AssertionTesterNonConformingObject")
+ }
+
+}
+
+func TestEqual(t *testing.T) {
+
+ mockT := new(testing.T)
+
+ if !Equal(mockT, "Hello World", "Hello World") {
+ t.Error("Equal should return true")
+ }
+ if !Equal(mockT, 123, 123) {
+ t.Error("Equal should return true")
+ }
+ if !Equal(mockT, 123.5, 123.5) {
+ t.Error("Equal should return true")
+ }
+ if !Equal(mockT, []byte("Hello World"), []byte("Hello World")) {
+ t.Error("Equal should return true")
+ }
+ if !Equal(mockT, nil, nil) {
+ t.Error("Equal should return true")
+ }
+ if !Equal(mockT, int32(123), int64(123)) {
+ t.Error("Equal should return true")
+ }
+ if !Equal(mockT, int64(123), uint64(123)) {
+ t.Error("Equal should return true")
+ }
+
+}
+
+func TestNotNil(t *testing.T) {
+
+ mockT := new(testing.T)
+
+ if !NotNil(mockT, new(AssertionTesterConformingObject)) {
+ t.Error("NotNil should return true: object is not nil")
+ }
+ if NotNil(mockT, nil) {
+ t.Error("NotNil should return false: object is nil")
+ }
+
+}
+
+func TestNil(t *testing.T) {
+
+ mockT := new(testing.T)
+
+ if !Nil(mockT, nil) {
+ t.Error("Nil should return true: object is nil")
+ }
+ if Nil(mockT, new(AssertionTesterConformingObject)) {
+ t.Error("Nil should return false: object is not nil")
+ }
+
+}
+
+func TestTrue(t *testing.T) {
+
+ mockT := new(testing.T)
+
+ if !True(mockT, true) {
+ t.Error("True should return true")
+ }
+ if True(mockT, false) {
+ t.Error("True should return false")
+ }
+
+}
+
+func TestFalse(t *testing.T) {
+
+ mockT := new(testing.T)
+
+ if !False(mockT, false) {
+ t.Error("False should return true")
+ }
+ if False(mockT, true) {
+ t.Error("False should return false")
+ }
+
+}
+
+func TestExactly(t *testing.T) {
+
+ mockT := new(testing.T)
+
+ a := float32(1)
+ b := float64(1)
+ c := float32(1)
+ d := float32(2)
+
+ if Exactly(mockT, a, b) {
+ t.Error("Exactly should return false")
+ }
+ if Exactly(mockT, a, d) {
+ t.Error("Exactly should return false")
+ }
+ if !Exactly(mockT, a, c) {
+ t.Error("Exactly should return true")
+ }
+
+ if Exactly(mockT, nil, a) {
+ t.Error("Exactly should return false")
+ }
+ if Exactly(mockT, a, nil) {
+ t.Error("Exactly should return false")
+ }
+
+}
+
+func TestNotEqual(t *testing.T) {
+
+ mockT := new(testing.T)
+
+ if !NotEqual(mockT, "Hello World", "Hello World!") {
+ t.Error("NotEqual should return true")
+ }
+ if !NotEqual(mockT, 123, 1234) {
+ t.Error("NotEqual should return true")
+ }
+ if !NotEqual(mockT, 123.5, 123.55) {
+ t.Error("NotEqual should return true")
+ }
+ if !NotEqual(mockT, []byte("Hello World"), []byte("Hello World!")) {
+ t.Error("NotEqual should return true")
+ }
+ if !NotEqual(mockT, nil, new(AssertionTesterConformingObject)) {
+ t.Error("NotEqual should return true")
+ }
+
+ if NotEqual(mockT, "Hello World", "Hello World") {
+ t.Error("NotEqual should return false")
+ }
+ if NotEqual(mockT, 123, 123) {
+ t.Error("NotEqual should return false")
+ }
+ if NotEqual(mockT, 123.5, 123.5) {
+ t.Error("NotEqual should return false")
+ }
+ if NotEqual(mockT, []byte("Hello World"), []byte("Hello World")) {
+ t.Error("NotEqual should return false")
+ }
+ if NotEqual(mockT, new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) {
+ t.Error("NotEqual should return false")
+ }
+}
+
+func TestContains(t *testing.T) {
+
+ mockT := new(testing.T)
+ list := []string{"Foo", "Bar"}
+
+ if !Contains(mockT, "Hello World", "Hello") {
+ t.Error("Contains should return true: \"Hello World\" contains \"Hello\"")
+ }
+ if Contains(mockT, "Hello World", "Salut") {
+ t.Error("Contains should return false: \"Hello World\" does not contain \"Salut\"")
+ }
+
+ if !Contains(mockT, list, "Bar") {
+ t.Error("Contains should return true: \"[\"Foo\", \"Bar\"]\" contains \"Bar\"")
+ }
+ if Contains(mockT, list, "Salut") {
+ t.Error("Contains should return false: \"[\"Foo\", \"Bar\"]\" does not contain \"Salut\"")
+ }
+
+}
+
+func TestNotContains(t *testing.T) {
+
+ mockT := new(testing.T)
+ list := []string{"Foo", "Bar"}
+
+ if !NotContains(mockT, "Hello World", "Hello!") {
+ t.Error("NotContains should return true: \"Hello World\" does not contain \"Hello!\"")
+ }
+ if NotContains(mockT, "Hello World", "Hello") {
+ t.Error("NotContains should return false: \"Hello World\" contains \"Hello\"")
+ }
+
+ if !NotContains(mockT, list, "Foo!") {
+ t.Error("NotContains should return true: \"[\"Foo\", \"Bar\"]\" does not contain \"Foo!\"")
+ }
+ if NotContains(mockT, list, "Foo") {
+ t.Error("NotContains should return false: \"[\"Foo\", \"Bar\"]\" contains \"Foo\"")
+ }
+
+}
+
+func Test_includeElement(t *testing.T) {
+
+ list1 := []string{"Foo", "Bar"}
+ list2 := []int{1, 2}
+
+ ok, found := includeElement("Hello World", "World")
+ True(t, ok)
+ True(t, found)
+
+ ok, found = includeElement(list1, "Foo")
+ True(t, ok)
+ True(t, found)
+
+ ok, found = includeElement(list1, "Bar")
+ True(t, ok)
+ True(t, found)
+
+ ok, found = includeElement(list2, 1)
+ True(t, ok)
+ True(t, found)
+
+ ok, found = includeElement(list2, 2)
+ True(t, ok)
+ True(t, found)
+
+ ok, found = includeElement(list1, "Foo!")
+ True(t, ok)
+ False(t, found)
+
+ ok, found = includeElement(list2, 3)
+ True(t, ok)
+ False(t, found)
+
+ ok, found = includeElement(list2, "1")
+ True(t, ok)
+ False(t, found)
+
+ ok, found = includeElement(1433, "1")
+ False(t, ok)
+ False(t, found)
+
+}
+
+func TestCondition(t *testing.T) {
+ mockT := new(testing.T)
+
+ if !Condition(mockT, func() bool { return true }, "Truth") {
+ t.Error("Condition should return true")
+ }
+
+ if Condition(mockT, func() bool { return false }, "Lie") {
+ t.Error("Condition should return false")
+ }
+
+}
+
+func TestDidPanic(t *testing.T) {
+
+ if funcDidPanic, _ := didPanic(func() {
+ panic("Panic!")
+ }); !funcDidPanic {
+ t.Error("didPanic should return true")
+ }
+
+ if funcDidPanic, _ := didPanic(func() {
+ }); funcDidPanic {
+ t.Error("didPanic should return false")
+ }
+
+}
+
+func TestPanics(t *testing.T) {
+
+ mockT := new(testing.T)
+
+ if !Panics(mockT, func() {
+ panic("Panic!")
+ }) {
+ t.Error("Panics should return true")
+ }
+
+ if Panics(mockT, func() {
+ }) {
+ t.Error("Panics should return false")
+ }
+
+}
+
+func TestNotPanics(t *testing.T) {
+
+ mockT := new(testing.T)
+
+ if !NotPanics(mockT, func() {
+ }) {
+ t.Error("NotPanics should return true")
+ }
+
+ if NotPanics(mockT, func() {
+ panic("Panic!")
+ }) {
+ t.Error("NotPanics should return false")
+ }
+
+}
+
+func TestEqual_Funcs(t *testing.T) {
+
+ type f func() int
+ f1 := func() int { return 1 }
+ f2 := func() int { return 2 }
+
+ f1Copy := f1
+
+ Equal(t, f1Copy, f1, "Funcs are the same and should be considered equal")
+ NotEqual(t, f1, f2, "f1 and f2 are different")
+
+}
+
+func TestNoError(t *testing.T) {
+
+ mockT := new(testing.T)
+
+ // start with a nil error
+ var err error
+
+ True(t, NoError(mockT, err), "NoError should return True for nil arg")
+
+ // now set an error
+ err = errors.New("some error")
+
+ False(t, NoError(mockT, err), "NoError with error should return False")
+
+}
+
+func TestError(t *testing.T) {
+
+ mockT := new(testing.T)
+
+ // start with a nil error
+ var err error
+
+ False(t, Error(mockT, err), "Error should return False for nil arg")
+
+ // now set an error
+ err = errors.New("some error")
+
+ True(t, Error(mockT, err), "Error with error should return True")
+
+}
+
+func TestEqualError(t *testing.T) {
+ mockT := new(testing.T)
+
+ // start with a nil error
+ var err error
+ False(t, EqualError(mockT, err, ""),
+ "EqualError should return false for nil arg")
+
+ // now set an error
+ err = errors.New("some error")
+ False(t, EqualError(mockT, err, "Not some error"),
+ "EqualError should return false for different error string")
+ True(t, EqualError(mockT, err, "some error"),
+ "EqualError should return true")
+}
+
+func Test_isEmpty(t *testing.T) {
+
+ chWithValue := make(chan struct{}, 1)
+ chWithValue <- struct{}{}
+
+ True(t, isEmpty(""))
+ True(t, isEmpty(nil))
+ True(t, isEmpty([]string{}))
+ True(t, isEmpty(0))
+ True(t, isEmpty(int32(0)))
+ True(t, isEmpty(int64(0)))
+ True(t, isEmpty(false))
+ True(t, isEmpty(map[string]string{}))
+ True(t, isEmpty(new(time.Time)))
+ True(t, isEmpty(make(chan struct{})))
+ False(t, isEmpty("something"))
+ False(t, isEmpty(errors.New("something")))
+ False(t, isEmpty([]string{"something"}))
+ False(t, isEmpty(1))
+ False(t, isEmpty(true))
+ False(t, isEmpty(map[string]string{"Hello": "World"}))
+ False(t, isEmpty(chWithValue))
+
+}
+
+func TestEmpty(t *testing.T) {
+
+ mockT := new(testing.T)
+ chWithValue := make(chan struct{}, 1)
+ chWithValue <- struct{}{}
+
+ True(t, Empty(mockT, ""), "Empty string is empty")
+ True(t, Empty(mockT, nil), "Nil is empty")
+ True(t, Empty(mockT, []string{}), "Empty string array is empty")
+ True(t, Empty(mockT, 0), "Zero int value is empty")
+ True(t, Empty(mockT, false), "False value is empty")
+ True(t, Empty(mockT, make(chan struct{})), "Channel without values is empty")
+
+ False(t, Empty(mockT, "something"), "Non Empty string is not empty")
+ False(t, Empty(mockT, errors.New("something")), "Non nil object is not empty")
+ False(t, Empty(mockT, []string{"something"}), "Non empty string array is not empty")
+ False(t, Empty(mockT, 1), "Non-zero int value is not empty")
+ False(t, Empty(mockT, true), "True value is not empty")
+ False(t, Empty(mockT, chWithValue), "Channel with values is not empty")
+}
+
+func TestNotEmpty(t *testing.T) {
+
+ mockT := new(testing.T)
+ chWithValue := make(chan struct{}, 1)
+ chWithValue <- struct{}{}
+
+ False(t, NotEmpty(mockT, ""), "Empty string is empty")
+ False(t, NotEmpty(mockT, nil), "Nil is empty")
+ False(t, NotEmpty(mockT, []string{}), "Empty string array is empty")
+ False(t, NotEmpty(mockT, 0), "Zero int value is empty")
+ False(t, NotEmpty(mockT, false), "False value is empty")
+ False(t, NotEmpty(mockT, make(chan struct{})), "Channel without values is empty")
+
+ True(t, NotEmpty(mockT, "something"), "Non Empty string is not empty")
+ True(t, NotEmpty(mockT, errors.New("something")), "Non nil object is not empty")
+ True(t, NotEmpty(mockT, []string{"something"}), "Non empty string array is not empty")
+ True(t, NotEmpty(mockT, 1), "Non-zero int value is not empty")
+ True(t, NotEmpty(mockT, true), "True value is not empty")
+ True(t, NotEmpty(mockT, chWithValue), "Channel with values is not empty")
+}
+
+func Test_getLen(t *testing.T) {
+ falseCases := []interface{}{
+ nil,
+ 0,
+ true,
+ false,
+ 'A',
+ struct{}{},
+ }
+ for _, v := range falseCases {
+ ok, l := getLen(v)
+ False(t, ok, "Expected getLen fail to get length of %#v", v)
+ Equal(t, 0, l, "getLen should return 0 for %#v", v)
+ }
+
+ ch := make(chan int, 5)
+ ch <- 1
+ ch <- 2
+ ch <- 3
+ trueCases := []struct {
+ v interface{}
+ l int
+ }{
+ {[]int{1, 2, 3}, 3},
+ {[...]int{1, 2, 3}, 3},
+ {"ABC", 3},
+ {map[int]int{1: 2, 2: 4, 3: 6}, 3},
+ {ch, 3},
+
+ {[]int{}, 0},
+ {map[int]int{}, 0},
+ {make(chan int), 0},
+
+ {[]int(nil), 0},
+ {map[int]int(nil), 0},
+ {(chan int)(nil), 0},
+ }
+
+ for _, c := range trueCases {
+ ok, l := getLen(c.v)
+ True(t, ok, "Expected getLen success to get length of %#v", c.v)
+ Equal(t, c.l, l)
+ }
+}
+
+func TestLen(t *testing.T) {
+ mockT := new(testing.T)
+
+ False(t, Len(mockT, nil, 0), "nil does not have length")
+ False(t, Len(mockT, 0, 0), "int does not have length")
+ False(t, Len(mockT, true, 0), "true does not have length")
+ False(t, Len(mockT, false, 0), "false does not have length")
+ False(t, Len(mockT, 'A', 0), "Rune does not have length")
+ False(t, Len(mockT, struct{}{}, 0), "Struct does not have length")
+
+ ch := make(chan int, 5)
+ ch <- 1
+ ch <- 2
+ ch <- 3
+
+ cases := []struct {
+ v interface{}
+ l int
+ }{
+ {[]int{1, 2, 3}, 3},
+ {[...]int{1, 2, 3}, 3},
+ {"ABC", 3},
+ {map[int]int{1: 2, 2: 4, 3: 6}, 3},
+ {ch, 3},
+
+ {[]int{}, 0},
+ {map[int]int{}, 0},
+ {make(chan int), 0},
+
+ {[]int(nil), 0},
+ {map[int]int(nil), 0},
+ {(chan int)(nil), 0},
+ }
+
+ for _, c := range cases {
+ True(t, Len(mockT, c.v, c.l), "%#v have %d items", c.v, c.l)
+ }
+
+ cases = []struct {
+ v interface{}
+ l int
+ }{
+ {[]int{1, 2, 3}, 4},
+ {[...]int{1, 2, 3}, 2},
+ {"ABC", 2},
+ {map[int]int{1: 2, 2: 4, 3: 6}, 4},
+ {ch, 2},
+
+ {[]int{}, 1},
+ {map[int]int{}, 1},
+ {make(chan int), 1},
+
+ {[]int(nil), 1},
+ {map[int]int(nil), 1},
+ {(chan int)(nil), 1},
+ }
+
+ for _, c := range cases {
+ False(t, Len(mockT, c.v, c.l), "%#v have %d items", c.v, c.l)
+ }
+}
+
+func TestWithinDuration(t *testing.T) {
+
+ mockT := new(testing.T)
+ a := time.Now()
+ b := a.Add(10 * time.Second)
+
+ True(t, WithinDuration(mockT, a, b, 10*time.Second), "A 10s difference is within a 10s time difference")
+ True(t, WithinDuration(mockT, b, a, 10*time.Second), "A 10s difference is within a 10s time difference")
+
+ False(t, WithinDuration(mockT, a, b, 9*time.Second), "A 10s difference is not within a 9s time difference")
+ False(t, WithinDuration(mockT, b, a, 9*time.Second), "A 10s difference is not within a 9s time difference")
+
+ False(t, WithinDuration(mockT, a, b, -9*time.Second), "A 10s difference is not within a 9s time difference")
+ False(t, WithinDuration(mockT, b, a, -9*time.Second), "A 10s difference is not within a 9s time difference")
+
+ False(t, WithinDuration(mockT, a, b, -11*time.Second), "A 10s difference is not within a 9s time difference")
+ False(t, WithinDuration(mockT, b, a, -11*time.Second), "A 10s difference is not within a 9s time difference")
+}
+
+func TestInDelta(t *testing.T) {
+ mockT := new(testing.T)
+
+ True(t, InDelta(mockT, 1.001, 1, 0.01), "|1.001 - 1| <= 0.01")
+ True(t, InDelta(mockT, 1, 1.001, 0.01), "|1 - 1.001| <= 0.01")
+ True(t, InDelta(mockT, 1, 2, 1), "|1 - 2| <= 1")
+ False(t, InDelta(mockT, 1, 2, 0.5), "Expected |1 - 2| <= 0.5 to fail")
+ False(t, InDelta(mockT, 2, 1, 0.5), "Expected |2 - 1| <= 0.5 to fail")
+ False(t, InDelta(mockT, "", nil, 1), "Expected non numerals to fail")
+
+ cases := []struct {
+ a, b interface{}
+ delta float64
+ }{
+ {uint8(2), uint8(1), 1},
+ {uint16(2), uint16(1), 1},
+ {uint32(2), uint32(1), 1},
+ {uint64(2), uint64(1), 1},
+
+ {int(2), int(1), 1},
+ {int8(2), int8(1), 1},
+ {int16(2), int16(1), 1},
+ {int32(2), int32(1), 1},
+ {int64(2), int64(1), 1},
+
+ {float32(2), float32(1), 1},
+ {float64(2), float64(1), 1},
+ }
+
+ for _, tc := range cases {
+ True(t, InDelta(mockT, tc.a, tc.b, tc.delta), "Expected |%V - %V| <= %v", tc.a, tc.b, tc.delta)
+ }
+}
+
+func TestInEpsilon(t *testing.T) {
+ mockT := new(testing.T)
+
+ cases := []struct {
+ a, b interface{}
+ epsilon float64
+ }{
+ {uint8(2), uint16(2), .001},
+ {2.1, 2.2, 0.1},
+ {2.2, 2.1, 0.1},
+ {-2.1, -2.2, 0.1},
+ {-2.2, -2.1, 0.1},
+ {uint64(100), uint8(101), 0.01},
+ {0.1, -0.1, 2},
+ }
+
+ for _, tc := range cases {
+ True(t, InEpsilon(mockT, tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon))
+ }
+
+ cases = []struct {
+ a, b interface{}
+ epsilon float64
+ }{
+ {uint8(2), int16(-2), .001},
+ {uint64(100), uint8(102), 0.01},
+ {2.1, 2.2, 0.001},
+ {2.2, 2.1, 0.001},
+ {2.1, -2.2, 1},
+ {2.1, "bla-bla", 0},
+ {0.1, -0.1, 1.99},
+ }
+
+ for _, tc := range cases {
+ False(t, InEpsilon(mockT, tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon))
+ }
+
+}
+
+func TestRegexp(t *testing.T) {
+ mockT := new(testing.T)
+
+ cases := []struct {
+ rx, str string
+ }{
+ {"^start", "start of the line"},
+ {"end$", "in the end"},
+ {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12.34"},
+ }
+
+ for _, tc := range cases {
+ True(t, Regexp(mockT, tc.rx, tc.str))
+ True(t, Regexp(mockT, regexp.MustCompile(tc.rx), tc.str))
+ False(t, NotRegexp(mockT, tc.rx, tc.str))
+ False(t, NotRegexp(mockT, regexp.MustCompile(tc.rx), tc.str))
+ }
+
+ cases = []struct {
+ rx, str string
+ }{
+ {"^asdfastart", "Not the start of the line"},
+ {"end$", "in the end."},
+ {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12a.34"},
+ }
+
+ for _, tc := range cases {
+ False(t, Regexp(mockT, tc.rx, tc.str), "Expected \"%s\" to not match \"%s\"", tc.rx, tc.str)
+ False(t, Regexp(mockT, regexp.MustCompile(tc.rx), tc.str))
+ True(t, NotRegexp(mockT, tc.rx, tc.str))
+ True(t, NotRegexp(mockT, regexp.MustCompile(tc.rx), tc.str))
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/assert/doc.go b/Godeps/_workspace/src/github.com/stretchr/testify/assert/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..1c6de283d0bc65ff1ff8b2cde12193c16fab3686
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/assert/doc.go
@@ -0,0 +1,150 @@
+// A set of comprehensive testing tools for use with the normal Go testing system.
+//
+// Example Usage
+//
+// The following is a complete example using assert in a standard test function:
+// import (
+// "testing"
+// "github.com/stretchr/testify/assert"
+// )
+//
+// func TestSomething(t *testing.T) {
+//
+// var a string = "Hello"
+// var b string = "Hello"
+//
+// assert.Equal(t, a, b, "The two words should be the same.")
+//
+// }
+//
+// if you assert many times, use the below:
+//
+// import (
+// "testing"
+// "github.com/stretchr/testify/assert"
+// )
+//
+// func TestSomething(t *testing.T) {
+// assert := assert.New(t)
+//
+// var a string = "Hello"
+// var b string = "Hello"
+//
+// assert.Equal(a, b, "The two words should be the same.")
+// }
+//
+// Assertions
+//
+// Assertions allow you to easily write test code, and are global funcs in the `assert` package.
+// All assertion functions take, as the first argument, the `*testing.T` object provided by the
+// testing framework. This allows the assertion funcs to write the failings and other details to
+// the correct place.
+//
+// Every assertion function also takes an optional string message as the final argument,
+// allowing custom error messages to be appended to the message the assertion method outputs.
+//
+// Here is an overview of the assert functions:
+//
+// assert.Equal(t, expected, actual [, message [, format-args])
+//
+// assert.NotEqual(t, notExpected, actual [, message [, format-args]])
+//
+// assert.True(t, actualBool [, message [, format-args]])
+//
+// assert.False(t, actualBool [, message [, format-args]])
+//
+// assert.Nil(t, actualObject [, message [, format-args]])
+//
+// assert.NotNil(t, actualObject [, message [, format-args]])
+//
+// assert.Empty(t, actualObject [, message [, format-args]])
+//
+// assert.NotEmpty(t, actualObject [, message [, format-args]])
+//
+// assert.Len(t, actualObject, expectedLength, [, message [, format-args]])
+//
+// assert.Error(t, errorObject [, message [, format-args]])
+//
+// assert.NoError(t, errorObject [, message [, format-args]])
+//
+// assert.EqualError(t, theError, errString [, message [, format-args]])
+//
+// assert.Implements(t, (*MyInterface)(nil), new(MyObject) [,message [, format-args]])
+//
+// assert.IsType(t, expectedObject, actualObject [, message [, format-args]])
+//
+// assert.Contains(t, stringOrSlice, substringOrElement [, message [, format-args]])
+//
+// assert.NotContains(t, stringOrSlice, substringOrElement [, message [, format-args]])
+//
+// assert.Panics(t, func(){
+//
+// // call code that should panic
+//
+// } [, message [, format-args]])
+//
+// assert.NotPanics(t, func(){
+//
+// // call code that should not panic
+//
+// } [, message [, format-args]])
+//
+// assert.WithinDuration(t, timeA, timeB, deltaTime, [, message [, format-args]])
+//
+// assert.InDelta(t, numA, numB, delta, [, message [, format-args]])
+//
+// assert.InEpsilon(t, numA, numB, epsilon, [, message [, format-args]])
+//
+// assert package contains Assertions object. it has assertion methods.
+//
+// Here is an overview of the assert functions:
+// assert.Equal(expected, actual [, message [, format-args])
+//
+// assert.NotEqual(notExpected, actual [, message [, format-args]])
+//
+// assert.True(actualBool [, message [, format-args]])
+//
+// assert.False(actualBool [, message [, format-args]])
+//
+// assert.Nil(actualObject [, message [, format-args]])
+//
+// assert.NotNil(actualObject [, message [, format-args]])
+//
+// assert.Empty(actualObject [, message [, format-args]])
+//
+// assert.NotEmpty(actualObject [, message [, format-args]])
+//
+// assert.Len(actualObject, expectedLength, [, message [, format-args]])
+//
+// assert.Error(errorObject [, message [, format-args]])
+//
+// assert.NoError(errorObject [, message [, format-args]])
+//
+// assert.EqualError(theError, errString [, message [, format-args]])
+//
+// assert.Implements((*MyInterface)(nil), new(MyObject) [,message [, format-args]])
+//
+// assert.IsType(expectedObject, actualObject [, message [, format-args]])
+//
+// assert.Contains(stringOrSlice, substringOrElement [, message [, format-args]])
+//
+// assert.NotContains(stringOrSlice, substringOrElement [, message [, format-args]])
+//
+// assert.Panics(func(){
+//
+// // call code that should panic
+//
+// } [, message [, format-args]])
+//
+// assert.NotPanics(func(){
+//
+// // call code that should not panic
+//
+// } [, message [, format-args]])
+//
+// assert.WithinDuration(timeA, timeB, deltaTime, [, message [, format-args]])
+//
+// assert.InDelta(numA, numB, delta, [, message [, format-args]])
+//
+// assert.InEpsilon(numA, numB, epsilon, [, message [, format-args]])
+package assert
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/assert/errors.go b/Godeps/_workspace/src/github.com/stretchr/testify/assert/errors.go
new file mode 100644
index 0000000000000000000000000000000000000000..ac9dc9d1d6156b64c31ac0b130e7a2b1ca86f06d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/assert/errors.go
@@ -0,0 +1,10 @@
+package assert
+
+import (
+ "errors"
+)
+
+// AnError is an error instance useful for testing. If the code does not care
+// about error specifics, and only needs to return the error for example, this
+// error should be used to make the test code more readable.
+var AnError = errors.New("assert.AnError general error for testing")
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/assert/forward_assertions.go b/Godeps/_workspace/src/github.com/stretchr/testify/assert/forward_assertions.go
new file mode 100644
index 0000000000000000000000000000000000000000..e2866f8be052beaca3f0e11882325e6537030aa0
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/assert/forward_assertions.go
@@ -0,0 +1,252 @@
+package assert
+
+import "time"
+
+type Assertions struct {
+ t TestingT
+}
+
+func New(t TestingT) *Assertions {
+ return &Assertions{
+ t: t,
+ }
+}
+
+// Fail reports a failure through
+func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) bool {
+ return Fail(a.t, failureMessage, msgAndArgs...)
+}
+
+// Implements asserts that an object is implemented by the specified interface.
+//
+// assert.Implements((*MyInterface)(nil), new(MyObject), "MyObject")
+func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+ return Implements(a.t, interfaceObject, object, msgAndArgs...)
+}
+
+// IsType asserts that the specified objects are of the same type.
+func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+ return IsType(a.t, expectedType, object, msgAndArgs...)
+}
+
+// Equal asserts that two objects are equal.
+//
+// assert.Equal(123, 123, "123 and 123 should be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Equal(expected, actual interface{}, msgAndArgs ...interface{}) bool {
+ return Equal(a.t, expected, actual, msgAndArgs...)
+}
+
+// Exactly asserts that two objects are equal is value and type.
+//
+// assert.Exactly(int32(123), int64(123), "123 and 123 should NOT be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Exactly(expected, actual interface{}, msgAndArgs ...interface{}) bool {
+ return Exactly(a.t, expected, actual, msgAndArgs...)
+}
+
+// NotNil asserts that the specified object is not nil.
+//
+// assert.NotNil(err, "err should be something")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool {
+ return NotNil(a.t, object, msgAndArgs...)
+}
+
+// Nil asserts that the specified object is nil.
+//
+// assert.Nil(err, "err should be nothing")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool {
+ return Nil(a.t, object, msgAndArgs...)
+}
+
+// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or a
+// slice with len == 0.
+//
+// assert.Empty(obj)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool {
+ return Empty(a.t, object, msgAndArgs...)
+}
+
+// Empty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or a
+// slice with len == 0.
+//
+// if assert.NotEmpty(obj) {
+// assert.Equal("two", obj[1])
+// }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool {
+ return NotEmpty(a.t, object, msgAndArgs...)
+}
+
+// Len asserts that the specified object has specific length.
+// Len also fails if the object has a type that len() not accept.
+//
+// assert.Len(mySlice, 3, "The size of slice is not 3")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool {
+ return Len(a.t, object, length, msgAndArgs...)
+}
+
+// True asserts that the specified value is true.
+//
+// assert.True(myBool, "myBool should be true")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool {
+ return True(a.t, value, msgAndArgs...)
+}
+
+// False asserts that the specified value is true.
+//
+// assert.False(myBool, "myBool should be false")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool {
+ return False(a.t, value, msgAndArgs...)
+}
+
+// NotEqual asserts that the specified values are NOT equal.
+//
+// assert.NotEqual(obj1, obj2, "two objects shouldn't be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotEqual(expected, actual interface{}, msgAndArgs ...interface{}) bool {
+ return NotEqual(a.t, expected, actual, msgAndArgs...)
+}
+
+// Contains asserts that the specified string contains the specified substring.
+//
+// assert.Contains("Hello World", "World", "But 'Hello World' does contain 'World'")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Contains(s, contains interface{}, msgAndArgs ...interface{}) bool {
+ return Contains(a.t, s, contains, msgAndArgs...)
+}
+
+// NotContains asserts that the specified string does NOT contain the specified substring.
+//
+// assert.NotContains("Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotContains(s, contains interface{}, msgAndArgs ...interface{}) bool {
+ return NotContains(a.t, s, contains, msgAndArgs...)
+}
+
+// Uses a Comparison to assert a complex condition.
+func (a *Assertions) Condition(comp Comparison, msgAndArgs ...interface{}) bool {
+ return Condition(a.t, comp, msgAndArgs...)
+}
+
+// Panics asserts that the code inside the specified PanicTestFunc panics.
+//
+// assert.Panics(func(){
+// GoCrazy()
+// }, "Calling GoCrazy() should panic")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
+ return Panics(a.t, f, msgAndArgs...)
+}
+
+// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+// assert.NotPanics(func(){
+// RemainCalm()
+// }, "Calling RemainCalm() should NOT panic")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
+ return NotPanics(a.t, f, msgAndArgs...)
+}
+
+// WithinDuration asserts that the two times are within duration delta of each other.
+//
+// assert.WithinDuration(time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) WithinDuration(expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
+ return WithinDuration(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// InDelta asserts that the two numerals are within delta of each other.
+//
+// assert.InDelta(t, math.Pi, (22 / 7.0), 0.01)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) InDelta(expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
+ return InDelta(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// InEpsilon asserts that expected and actual have a relative error less than epsilon
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) InEpsilon(expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
+ return InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...)
+}
+
+// NoError asserts that a function returned no error (i.e. `nil`).
+//
+// actualObj, err := SomeFunction()
+// if assert.NoError(err) {
+// assert.Equal(actualObj, expectedObj)
+// }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NoError(theError error, msgAndArgs ...interface{}) bool {
+ return NoError(a.t, theError, msgAndArgs...)
+}
+
+// Error asserts that a function returned an error (i.e. not `nil`).
+//
+// actualObj, err := SomeFunction()
+// if assert.Error(err, "An error was expected") {
+// assert.Equal(err, expectedError)
+// }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Error(theError error, msgAndArgs ...interface{}) bool {
+ return Error(a.t, theError, msgAndArgs...)
+}
+
+// EqualError asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+// actualObj, err := SomeFunction()
+// if assert.Error(err, "An error was expected") {
+// assert.Equal(err, expectedError)
+// }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) bool {
+ return EqualError(a.t, theError, errString, msgAndArgs...)
+}
+
+// Regexp asserts that a specified regexp matches a string.
+//
+// assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
+// assert.Regexp(t, "start...$", "it's not starting")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Regexp(rx interface{}, str interface{}) bool {
+ return Regexp(a.t, rx, str)
+}
+
+// NotRegexp asserts that a specified regexp does not match a string.
+//
+// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
+// assert.NotRegexp(t, "^start", "it's not starting")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotRegexp(rx interface{}, str interface{}) bool {
+ return NotRegexp(a.t, rx, str)
+}
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/assert/forward_assertions_test.go b/Godeps/_workspace/src/github.com/stretchr/testify/assert/forward_assertions_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..20cca6e21e557ace2540dafa1734c492765d0b3e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/assert/forward_assertions_test.go
@@ -0,0 +1,518 @@
+package assert
+
+import (
+ "errors"
+ "regexp"
+ "testing"
+ "time"
+)
+
+func TestImplementsWrapper(t *testing.T) {
+ assert := New(new(testing.T))
+
+ if !assert.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject)) {
+ t.Error("Implements method should return true: AssertionTesterConformingObject implements AssertionTesterInterface")
+ }
+ if assert.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject)) {
+ t.Error("Implements method should return false: AssertionTesterNonConformingObject does not implements AssertionTesterInterface")
+ }
+}
+
+func TestIsTypeWrapper(t *testing.T) {
+ assert := New(new(testing.T))
+
+ if !assert.IsType(new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) {
+ t.Error("IsType should return true: AssertionTesterConformingObject is the same type as AssertionTesterConformingObject")
+ }
+ if assert.IsType(new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject)) {
+ t.Error("IsType should return false: AssertionTesterConformingObject is not the same type as AssertionTesterNonConformingObject")
+ }
+
+}
+
+func TestEqualWrapper(t *testing.T) {
+ assert := New(new(testing.T))
+
+ if !assert.Equal("Hello World", "Hello World") {
+ t.Error("Equal should return true")
+ }
+ if !assert.Equal(123, 123) {
+ t.Error("Equal should return true")
+ }
+ if !assert.Equal(123.5, 123.5) {
+ t.Error("Equal should return true")
+ }
+ if !assert.Equal([]byte("Hello World"), []byte("Hello World")) {
+ t.Error("Equal should return true")
+ }
+ if !assert.Equal(nil, nil) {
+ t.Error("Equal should return true")
+ }
+}
+
+func TestNotNilWrapper(t *testing.T) {
+ assert := New(new(testing.T))
+
+ if !assert.NotNil(new(AssertionTesterConformingObject)) {
+ t.Error("NotNil should return true: object is not nil")
+ }
+ if assert.NotNil(nil) {
+ t.Error("NotNil should return false: object is nil")
+ }
+
+}
+
+func TestNilWrapper(t *testing.T) {
+ assert := New(new(testing.T))
+
+ if !assert.Nil(nil) {
+ t.Error("Nil should return true: object is nil")
+ }
+ if assert.Nil(new(AssertionTesterConformingObject)) {
+ t.Error("Nil should return false: object is not nil")
+ }
+
+}
+
+func TestTrueWrapper(t *testing.T) {
+ assert := New(new(testing.T))
+
+ if !assert.True(true) {
+ t.Error("True should return true")
+ }
+ if assert.True(false) {
+ t.Error("True should return false")
+ }
+
+}
+
+func TestFalseWrapper(t *testing.T) {
+ assert := New(new(testing.T))
+
+ if !assert.False(false) {
+ t.Error("False should return true")
+ }
+ if assert.False(true) {
+ t.Error("False should return false")
+ }
+
+}
+
+func TestExactlyWrapper(t *testing.T) {
+ assert := New(new(testing.T))
+
+ a := float32(1)
+ b := float64(1)
+ c := float32(1)
+ d := float32(2)
+
+ if assert.Exactly(a, b) {
+ t.Error("Exactly should return false")
+ }
+ if assert.Exactly(a, d) {
+ t.Error("Exactly should return false")
+ }
+ if !assert.Exactly(a, c) {
+ t.Error("Exactly should return true")
+ }
+
+ if assert.Exactly(nil, a) {
+ t.Error("Exactly should return false")
+ }
+ if assert.Exactly(a, nil) {
+ t.Error("Exactly should return false")
+ }
+
+}
+
+func TestNotEqualWrapper(t *testing.T) {
+
+ assert := New(new(testing.T))
+
+ if !assert.NotEqual("Hello World", "Hello World!") {
+ t.Error("NotEqual should return true")
+ }
+ if !assert.NotEqual(123, 1234) {
+ t.Error("NotEqual should return true")
+ }
+ if !assert.NotEqual(123.5, 123.55) {
+ t.Error("NotEqual should return true")
+ }
+ if !assert.NotEqual([]byte("Hello World"), []byte("Hello World!")) {
+ t.Error("NotEqual should return true")
+ }
+ if !assert.NotEqual(nil, new(AssertionTesterConformingObject)) {
+ t.Error("NotEqual should return true")
+ }
+}
+
+func TestContainsWrapper(t *testing.T) {
+
+ assert := New(new(testing.T))
+ list := []string{"Foo", "Bar"}
+
+ if !assert.Contains("Hello World", "Hello") {
+ t.Error("Contains should return true: \"Hello World\" contains \"Hello\"")
+ }
+ if assert.Contains("Hello World", "Salut") {
+ t.Error("Contains should return false: \"Hello World\" does not contain \"Salut\"")
+ }
+
+ if !assert.Contains(list, "Foo") {
+ t.Error("Contains should return true: \"[\"Foo\", \"Bar\"]\" contains \"Foo\"")
+ }
+ if assert.Contains(list, "Salut") {
+ t.Error("Contains should return false: \"[\"Foo\", \"Bar\"]\" does not contain \"Salut\"")
+ }
+
+}
+
+func TestNotContainsWrapper(t *testing.T) {
+
+ assert := New(new(testing.T))
+ list := []string{"Foo", "Bar"}
+
+ if !assert.NotContains("Hello World", "Hello!") {
+ t.Error("NotContains should return true: \"Hello World\" does not contain \"Hello!\"")
+ }
+ if assert.NotContains("Hello World", "Hello") {
+ t.Error("NotContains should return false: \"Hello World\" contains \"Hello\"")
+ }
+
+ if !assert.NotContains(list, "Foo!") {
+ t.Error("NotContains should return true: \"[\"Foo\", \"Bar\"]\" does not contain \"Foo!\"")
+ }
+ if assert.NotContains(list, "Foo") {
+ t.Error("NotContains should return false: \"[\"Foo\", \"Bar\"]\" contains \"Foo\"")
+ }
+
+}
+
+func TestConditionWrapper(t *testing.T) {
+
+ assert := New(new(testing.T))
+
+ if !assert.Condition(func() bool { return true }, "Truth") {
+ t.Error("Condition should return true")
+ }
+
+ if assert.Condition(func() bool { return false }, "Lie") {
+ t.Error("Condition should return false")
+ }
+
+}
+
+func TestDidPanicWrapper(t *testing.T) {
+
+ if funcDidPanic, _ := didPanic(func() {
+ panic("Panic!")
+ }); !funcDidPanic {
+ t.Error("didPanic should return true")
+ }
+
+ if funcDidPanic, _ := didPanic(func() {
+ }); funcDidPanic {
+ t.Error("didPanic should return false")
+ }
+
+}
+
+func TestPanicsWrapper(t *testing.T) {
+
+ assert := New(new(testing.T))
+
+ if !assert.Panics(func() {
+ panic("Panic!")
+ }) {
+ t.Error("Panics should return true")
+ }
+
+ if assert.Panics(func() {
+ }) {
+ t.Error("Panics should return false")
+ }
+
+}
+
+func TestNotPanicsWrapper(t *testing.T) {
+
+ assert := New(new(testing.T))
+
+ if !assert.NotPanics(func() {
+ }) {
+ t.Error("NotPanics should return true")
+ }
+
+ if assert.NotPanics(func() {
+ panic("Panic!")
+ }) {
+ t.Error("NotPanics should return false")
+ }
+
+}
+
+func TestEqualWrapper_Funcs(t *testing.T) {
+
+ assert := New(t)
+
+ type f func() int
+ var f1 f = func() int { return 1 }
+ var f2 f = func() int { return 2 }
+
+ var f1_copy f = f1
+
+ assert.Equal(f1_copy, f1, "Funcs are the same and should be considered equal")
+ assert.NotEqual(f1, f2, "f1 and f2 are different")
+
+}
+
+func TestNoErrorWrapper(t *testing.T) {
+ assert := New(t)
+ mockAssert := New(new(testing.T))
+
+ // start with a nil error
+ var err error = nil
+
+ assert.True(mockAssert.NoError(err), "NoError should return True for nil arg")
+
+ // now set an error
+ err = errors.New("Some error")
+
+ assert.False(mockAssert.NoError(err), "NoError with error should return False")
+
+}
+
+func TestErrorWrapper(t *testing.T) {
+ assert := New(t)
+ mockAssert := New(new(testing.T))
+
+ // start with a nil error
+ var err error = nil
+
+ assert.False(mockAssert.Error(err), "Error should return False for nil arg")
+
+ // now set an error
+ err = errors.New("Some error")
+
+ assert.True(mockAssert.Error(err), "Error with error should return True")
+
+}
+
+func TestEqualErrorWrapper(t *testing.T) {
+ assert := New(t)
+ mockAssert := New(new(testing.T))
+
+ // start with a nil error
+ var err error
+ assert.False(mockAssert.EqualError(err, ""),
+ "EqualError should return false for nil arg")
+
+ // now set an error
+ err = errors.New("some error")
+ assert.False(mockAssert.EqualError(err, "Not some error"),
+ "EqualError should return false for different error string")
+ assert.True(mockAssert.EqualError(err, "some error"),
+ "EqualError should return true")
+}
+
+func TestEmptyWrapper(t *testing.T) {
+ assert := New(t)
+ mockAssert := New(new(testing.T))
+
+ assert.True(mockAssert.Empty(""), "Empty string is empty")
+ assert.True(mockAssert.Empty(nil), "Nil is empty")
+ assert.True(mockAssert.Empty([]string{}), "Empty string array is empty")
+ assert.True(mockAssert.Empty(0), "Zero int value is empty")
+ assert.True(mockAssert.Empty(false), "False value is empty")
+
+ assert.False(mockAssert.Empty("something"), "Non Empty string is not empty")
+ assert.False(mockAssert.Empty(errors.New("something")), "Non nil object is not empty")
+ assert.False(mockAssert.Empty([]string{"something"}), "Non empty string array is not empty")
+ assert.False(mockAssert.Empty(1), "Non-zero int value is not empty")
+ assert.False(mockAssert.Empty(true), "True value is not empty")
+
+}
+
+func TestNotEmptyWrapper(t *testing.T) {
+ assert := New(t)
+ mockAssert := New(new(testing.T))
+
+ assert.False(mockAssert.NotEmpty(""), "Empty string is empty")
+ assert.False(mockAssert.NotEmpty(nil), "Nil is empty")
+ assert.False(mockAssert.NotEmpty([]string{}), "Empty string array is empty")
+ assert.False(mockAssert.NotEmpty(0), "Zero int value is empty")
+ assert.False(mockAssert.NotEmpty(false), "False value is empty")
+
+ assert.True(mockAssert.NotEmpty("something"), "Non Empty string is not empty")
+ assert.True(mockAssert.NotEmpty(errors.New("something")), "Non nil object is not empty")
+ assert.True(mockAssert.NotEmpty([]string{"something"}), "Non empty string array is not empty")
+ assert.True(mockAssert.NotEmpty(1), "Non-zero int value is not empty")
+ assert.True(mockAssert.NotEmpty(true), "True value is not empty")
+
+}
+
+func TestLenWrapper(t *testing.T) {
+ assert := New(t)
+ mockAssert := New(new(testing.T))
+
+ assert.False(mockAssert.Len(nil, 0), "nil does not have length")
+ assert.False(mockAssert.Len(0, 0), "int does not have length")
+ assert.False(mockAssert.Len(true, 0), "true does not have length")
+ assert.False(mockAssert.Len(false, 0), "false does not have length")
+ assert.False(mockAssert.Len('A', 0), "Rune does not have length")
+ assert.False(mockAssert.Len(struct{}{}, 0), "Struct does not have length")
+
+ ch := make(chan int, 5)
+ ch <- 1
+ ch <- 2
+ ch <- 3
+
+ cases := []struct {
+ v interface{}
+ l int
+ }{
+ {[]int{1, 2, 3}, 3},
+ {[...]int{1, 2, 3}, 3},
+ {"ABC", 3},
+ {map[int]int{1: 2, 2: 4, 3: 6}, 3},
+ {ch, 3},
+
+ {[]int{}, 0},
+ {map[int]int{}, 0},
+ {make(chan int), 0},
+
+ {[]int(nil), 0},
+ {map[int]int(nil), 0},
+ {(chan int)(nil), 0},
+ }
+
+ for _, c := range cases {
+ assert.True(mockAssert.Len(c.v, c.l), "%#v have %d items", c.v, c.l)
+ }
+}
+
+func TestWithinDurationWrapper(t *testing.T) {
+ assert := New(t)
+ mockAssert := New(new(testing.T))
+ a := time.Now()
+ b := a.Add(10 * time.Second)
+
+ assert.True(mockAssert.WithinDuration(a, b, 10*time.Second), "A 10s difference is within a 10s time difference")
+ assert.True(mockAssert.WithinDuration(b, a, 10*time.Second), "A 10s difference is within a 10s time difference")
+
+ assert.False(mockAssert.WithinDuration(a, b, 9*time.Second), "A 10s difference is not within a 9s time difference")
+ assert.False(mockAssert.WithinDuration(b, a, 9*time.Second), "A 10s difference is not within a 9s time difference")
+
+ assert.False(mockAssert.WithinDuration(a, b, -9*time.Second), "A 10s difference is not within a 9s time difference")
+ assert.False(mockAssert.WithinDuration(b, a, -9*time.Second), "A 10s difference is not within a 9s time difference")
+
+ assert.False(mockAssert.WithinDuration(a, b, -11*time.Second), "A 10s difference is not within a 9s time difference")
+ assert.False(mockAssert.WithinDuration(b, a, -11*time.Second), "A 10s difference is not within a 9s time difference")
+}
+
+func TestInDeltaWrapper(t *testing.T) {
+ assert := New(new(testing.T))
+
+ True(t, assert.InDelta(1.001, 1, 0.01), "|1.001 - 1| <= 0.01")
+ True(t, assert.InDelta(1, 1.001, 0.01), "|1 - 1.001| <= 0.01")
+ True(t, assert.InDelta(1, 2, 1), "|1 - 2| <= 1")
+ False(t, assert.InDelta(1, 2, 0.5), "Expected |1 - 2| <= 0.5 to fail")
+ False(t, assert.InDelta(2, 1, 0.5), "Expected |2 - 1| <= 0.5 to fail")
+ False(t, assert.InDelta("", nil, 1), "Expected non numerals to fail")
+
+ cases := []struct {
+ a, b interface{}
+ delta float64
+ }{
+ {uint8(2), uint8(1), 1},
+ {uint16(2), uint16(1), 1},
+ {uint32(2), uint32(1), 1},
+ {uint64(2), uint64(1), 1},
+
+ {int(2), int(1), 1},
+ {int8(2), int8(1), 1},
+ {int16(2), int16(1), 1},
+ {int32(2), int32(1), 1},
+ {int64(2), int64(1), 1},
+
+ {float32(2), float32(1), 1},
+ {float64(2), float64(1), 1},
+ }
+
+ for _, tc := range cases {
+ True(t, assert.InDelta(tc.a, tc.b, tc.delta), "Expected |%V - %V| <= %v", tc.a, tc.b, tc.delta)
+ }
+}
+
+func TestInEpsilonWrapper(t *testing.T) {
+ assert := New(new(testing.T))
+
+ cases := []struct {
+ a, b interface{}
+ epsilon float64
+ }{
+ {uint8(2), uint16(2), .001},
+ {2.1, 2.2, 0.1},
+ {2.2, 2.1, 0.1},
+ {-2.1, -2.2, 0.1},
+ {-2.2, -2.1, 0.1},
+ {uint64(100), uint8(101), 0.01},
+ {0.1, -0.1, 2},
+ }
+
+ for _, tc := range cases {
+ True(t, assert.InEpsilon(tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon))
+ }
+
+ cases = []struct {
+ a, b interface{}
+ epsilon float64
+ }{
+ {uint8(2), int16(-2), .001},
+ {uint64(100), uint8(102), 0.01},
+ {2.1, 2.2, 0.001},
+ {2.2, 2.1, 0.001},
+ {2.1, -2.2, 1},
+ {2.1, "bla-bla", 0},
+ {0.1, -0.1, 1.99},
+ }
+
+ for _, tc := range cases {
+ False(t, assert.InEpsilon(tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon))
+ }
+}
+
+func TestRegexpWrapper(t *testing.T) {
+
+ assert := New(new(testing.T))
+
+ cases := []struct {
+ rx, str string
+ }{
+ {"^start", "start of the line"},
+ {"end$", "in the end"},
+ {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12.34"},
+ }
+
+ for _, tc := range cases {
+ True(t, assert.Regexp(tc.rx, tc.str))
+ True(t, assert.Regexp(regexp.MustCompile(tc.rx), tc.str))
+ False(t, assert.NotRegexp(tc.rx, tc.str))
+ False(t, assert.NotRegexp(regexp.MustCompile(tc.rx), tc.str))
+ }
+
+ cases = []struct {
+ rx, str string
+ }{
+ {"^asdfastart", "Not the start of the line"},
+ {"end$", "in the end."},
+ {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12a.34"},
+ }
+
+ for _, tc := range cases {
+ False(t, assert.Regexp(tc.rx, tc.str), "Expected \"%s\" to not match \"%s\"", tc.rx, tc.str)
+ False(t, assert.Regexp(regexp.MustCompile(tc.rx), tc.str))
+ True(t, assert.NotRegexp(tc.rx, tc.str))
+ True(t, assert.NotRegexp(regexp.MustCompile(tc.rx), tc.str))
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/assert/http_assertions.go b/Godeps/_workspace/src/github.com/stretchr/testify/assert/http_assertions.go
new file mode 100644
index 0000000000000000000000000000000000000000..0bcb6db9b8b86a48cea692d9b52b6c6dbd61affa
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/assert/http_assertions.go
@@ -0,0 +1,157 @@
+package assert
+
+import (
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "net/url"
+ "strings"
+)
+
+// httpCode is a helper that returns HTTP code of the response. It returns -1
+// if building a new request fails.
+func httpCode(handler http.HandlerFunc, mode, url string, values url.Values) int {
+ w := httptest.NewRecorder()
+ req, err := http.NewRequest(mode, url+"?"+values.Encode(), nil)
+ if err != nil {
+ return -1
+ }
+ handler(w, req)
+ return w.Code
+}
+
+// HTTPSuccess asserts that a specified handler returns a success status code.
+//
+// assert.HTTPSuccess(t, myHandler, "POST", http://www.google.com", nil)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPSuccess(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values) bool {
+ code := httpCode(handler, mode, url, values)
+ if code == -1 {
+ return false
+ }
+ return code >= http.StatusOK && code <= http.StatusPartialContent
+}
+
+// HTTPRedirect asserts that a specified handler returns a redirect status code.
+//
+// assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPRedirect(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values) bool {
+ code := httpCode(handler, mode, url, values)
+ if code == -1 {
+ return false
+ }
+ return code >= http.StatusMultipleChoices && code <= http.StatusTemporaryRedirect
+}
+
+// HTTPError asserts that a specified handler returns an error status code.
+//
+// assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPError(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values) bool {
+ code := httpCode(handler, mode, url, values)
+ if code == -1 {
+ return false
+ }
+ return code >= http.StatusBadRequest
+}
+
+// HttpBody is a helper that returns HTTP body of the response. It returns
+// empty string if building a new request fails.
+func HttpBody(handler http.HandlerFunc, mode, url string, values url.Values) string {
+ w := httptest.NewRecorder()
+ req, err := http.NewRequest(mode, url+"?"+values.Encode(), nil)
+ if err != nil {
+ return ""
+ }
+ handler(w, req)
+ return w.Body.String()
+}
+
+// HTTPBodyContains asserts that a specified handler returns a
+// body that contains a string.
+//
+// assert.HTTPBodyContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyContains(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values, str interface{}) bool {
+ body := HttpBody(handler, mode, url, values)
+
+ contains := strings.Contains(body, fmt.Sprint(str))
+ if !contains {
+ Fail(t, fmt.Sprintf("Expected response body for \"%s\" to contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body))
+ }
+
+ return contains
+}
+
+// HTTPBodyNotContains asserts that a specified handler returns a
+// body that does not contain a string.
+//
+// assert.HTTPBodyNotContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values, str interface{}) bool {
+ body := HttpBody(handler, mode, url, values)
+
+ contains := strings.Contains(body, fmt.Sprint(str))
+ if contains {
+ Fail(t, "Expected response body for %s to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body)
+ }
+
+ return !contains
+}
+
+//
+// Assertions Wrappers
+//
+
+// HTTPSuccess asserts that a specified handler returns a success status code.
+//
+// assert.HTTPSuccess(myHandler, "POST", http://www.google.com", nil)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, mode, url string, values url.Values) bool {
+ return HTTPSuccess(a.t, handler, mode, url, values)
+}
+
+// HTTPRedirect asserts that a specified handler returns a redirect status code.
+//
+// assert.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, mode, url string, values url.Values) bool {
+ return HTTPRedirect(a.t, handler, mode, url, values)
+}
+
+// HTTPError asserts that a specified handler returns an error status code.
+//
+// assert.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPError(handler http.HandlerFunc, mode, url string, values url.Values) bool {
+ return HTTPError(a.t, handler, mode, url, values)
+}
+
+// HTTPBodyContains asserts that a specified handler returns a
+// body that contains a string.
+//
+// assert.HTTPBodyContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, mode, url string, values url.Values, str interface{}) bool {
+ return HTTPBodyContains(a.t, handler, mode, url, values, str)
+}
+
+// HTTPBodyNotContains asserts that a specified handler returns a
+// body that does not contain a string.
+//
+// assert.HTTPBodyNotContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, mode, url string, values url.Values, str interface{}) bool {
+ return HTTPBodyNotContains(a.t, handler, mode, url, values, str)
+}
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/assert/http_assertions_test.go b/Godeps/_workspace/src/github.com/stretchr/testify/assert/http_assertions_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..684c2d5d1c56c1a85c429c72e05397c51bdcae1e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/assert/http_assertions_test.go
@@ -0,0 +1,86 @@
+package assert
+
+import (
+ "fmt"
+ "net/http"
+ "net/url"
+ "testing"
+)
+
+func httpOK(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusOK)
+}
+
+func httpRedirect(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusTemporaryRedirect)
+}
+
+func httpError(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusInternalServerError)
+}
+
+func TestHTTPStatuses(t *testing.T) {
+ assert := New(t)
+ mockT := new(testing.T)
+
+ assert.Equal(HTTPSuccess(mockT, httpOK, "GET", "/", nil), true)
+ assert.Equal(HTTPSuccess(mockT, httpRedirect, "GET", "/", nil), false)
+ assert.Equal(HTTPSuccess(mockT, httpError, "GET", "/", nil), false)
+
+ assert.Equal(HTTPRedirect(mockT, httpOK, "GET", "/", nil), false)
+ assert.Equal(HTTPRedirect(mockT, httpRedirect, "GET", "/", nil), true)
+ assert.Equal(HTTPRedirect(mockT, httpError, "GET", "/", nil), false)
+
+ assert.Equal(HTTPError(mockT, httpOK, "GET", "/", nil), false)
+ assert.Equal(HTTPError(mockT, httpRedirect, "GET", "/", nil), false)
+ assert.Equal(HTTPError(mockT, httpError, "GET", "/", nil), true)
+}
+
+func TestHTTPStatusesWrapper(t *testing.T) {
+ assert := New(t)
+ mockAssert := New(new(testing.T))
+
+ assert.Equal(mockAssert.HTTPSuccess(httpOK, "GET", "/", nil), true)
+ assert.Equal(mockAssert.HTTPSuccess(httpRedirect, "GET", "/", nil), false)
+ assert.Equal(mockAssert.HTTPSuccess(httpError, "GET", "/", nil), false)
+
+ assert.Equal(mockAssert.HTTPRedirect(httpOK, "GET", "/", nil), false)
+ assert.Equal(mockAssert.HTTPRedirect(httpRedirect, "GET", "/", nil), true)
+ assert.Equal(mockAssert.HTTPRedirect(httpError, "GET", "/", nil), false)
+
+ assert.Equal(mockAssert.HTTPError(httpOK, "GET", "/", nil), false)
+ assert.Equal(mockAssert.HTTPError(httpRedirect, "GET", "/", nil), false)
+ assert.Equal(mockAssert.HTTPError(httpError, "GET", "/", nil), true)
+}
+
+func httpHelloName(w http.ResponseWriter, r *http.Request) {
+ name := r.FormValue("name")
+ w.Write([]byte(fmt.Sprintf("Hello, %s!", name)))
+}
+
+func TestHttpBody(t *testing.T) {
+ assert := New(t)
+ mockT := new(testing.T)
+
+ assert.True(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
+ assert.True(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World"))
+ assert.False(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))
+
+ assert.False(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
+ assert.False(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World"))
+ assert.True(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))
+}
+
+func TestHttpBodyWrappers(t *testing.T) {
+ assert := New(t)
+ mockAssert := New(new(testing.T))
+
+ assert.True(mockAssert.HTTPBodyContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
+ assert.True(mockAssert.HTTPBodyContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World"))
+ assert.False(mockAssert.HTTPBodyContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))
+
+ assert.False(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
+ assert.False(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World"))
+ assert.True(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))
+
+}
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/suite/doc.go b/Godeps/_workspace/src/github.com/stretchr/testify/suite/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..3731eaa30427e7ed1ba52c69c995f6619e5b1f7c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/suite/doc.go
@@ -0,0 +1,65 @@
+// The suite package contains logic for creating testing suite structs
+// and running the methods on those structs as tests. The most useful
+// piece of this package is that you can create setup/teardown methods
+// on your testing suites, which will run before/after the whole suite
+// or individual tests (depending on which interface(s) you
+// implement).
+//
+// A testing suite is usually built by first extending the built-in
+// suite functionality from suite.Suite in testify. Alternatively,
+// you could reproduce that logic on your own if you wanted (you
+// just need to implement the TestingSuite interface from
+// suite/interfaces.go).
+//
+// After that, you can implement any of the interfaces in
+// suite/interfaces.go to add setup/teardown functionality to your
+// suite, and add any methods that start with "Test" to add tests.
+// Methods that do not match any suite interfaces and do not begin
+// with "Test" will not be run by testify, and can safely be used as
+// helper methods.
+//
+// Once you've built your testing suite, you need to run the suite
+// (using suite.Run from testify) inside any function that matches the
+// identity that "go test" is already looking for (i.e.
+// func(*testing.T)).
+//
+// Regular expression to select test suites specified command-line
+// argument "-run". Regular expression to select the methods
+// of test suites specified command-line argument "-m".
+// Suite object has assertion methods.
+//
+// A crude example:
+// // Basic imports
+// import (
+// "testing"
+// "github.com/stretchr/testify/assert"
+// "github.com/stretchr/testify/suite"
+// )
+//
+// // Define the suite, and absorb the built-in basic suite
+// // functionality from testify - including a T() method which
+// // returns the current testing context
+// type ExampleTestSuite struct {
+// suite.Suite
+// VariableThatShouldStartAtFive int
+// }
+//
+// // Make sure that VariableThatShouldStartAtFive is set to five
+// // before each test
+// func (suite *ExampleTestSuite) SetupTest() {
+// suite.VariableThatShouldStartAtFive = 5
+// }
+//
+// // All methods that begin with "Test" are run as tests within a
+// // suite.
+// func (suite *ExampleTestSuite) TestExample() {
+// assert.Equal(suite.T(), suite.VariableThatShouldStartAtFive, 5)
+// suite.Equal(suite.VariableThatShouldStartAtFive, 5)
+// }
+//
+// // In order for 'go test' to run this suite, we need to create
+// // a normal test function and pass our suite to suite.Run
+// func TestExampleTestSuite(t *testing.T) {
+// suite.Run(t, new(ExampleTestSuite))
+// }
+package suite
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/suite/interfaces.go b/Godeps/_workspace/src/github.com/stretchr/testify/suite/interfaces.go
new file mode 100644
index 0000000000000000000000000000000000000000..20969472c7ddcdef351f5a70c32503b19019130b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/suite/interfaces.go
@@ -0,0 +1,34 @@
+package suite
+
+import "testing"
+
+// TestingSuite can store and return the current *testing.T context
+// generated by 'go test'.
+type TestingSuite interface {
+ T() *testing.T
+ SetT(*testing.T)
+}
+
+// SetupAllSuite has a SetupSuite method, which will run before the
+// tests in the suite are run.
+type SetupAllSuite interface {
+ SetupSuite()
+}
+
+// SetupTestSuite has a SetupTest method, which will run before each
+// test in the suite.
+type SetupTestSuite interface {
+ SetupTest()
+}
+
+// TearDownAllSuite has a TearDownSuite method, which will run after
+// all the tests in the suite have been run.
+type TearDownAllSuite interface {
+ TearDownSuite()
+}
+
+// TearDownTestSuite has a TearDownTest method, which will run after
+// each test in the suite.
+type TearDownTestSuite interface {
+ TearDownTest()
+}
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/suite/suite.go b/Godeps/_workspace/src/github.com/stretchr/testify/suite/suite.go
new file mode 100644
index 0000000000000000000000000000000000000000..8f7fe7e629cdc1a2f57cac1ad0a61f3687249ddc
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/suite/suite.go
@@ -0,0 +1,89 @@
+package suite
+
+import (
+ "flag"
+ "fmt"
+ "os"
+ "reflect"
+ "regexp"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+var matchMethod = flag.String("m", "", "regular expression to select tests of the suite to run")
+
+// Suite is a basic testing suite with methods for storing and
+// retrieving the current *testing.T context.
+type Suite struct {
+ *assert.Assertions
+ t *testing.T
+}
+
+// T retrieves the current *testing.T context.
+func (suite *Suite) T() *testing.T {
+ return suite.t
+}
+
+// SetT sets the current *testing.T context.
+func (suite *Suite) SetT(t *testing.T) {
+ suite.t = t
+ suite.Assertions = assert.New(t)
+}
+
+// Run takes a testing suite and runs all of the tests attached
+// to it.
+func Run(t *testing.T, suite TestingSuite) {
+ suite.SetT(t)
+
+ if setupAllSuite, ok := suite.(SetupAllSuite); ok {
+ setupAllSuite.SetupSuite()
+ }
+
+ methodFinder := reflect.TypeOf(suite)
+ tests := []testing.InternalTest{}
+ for index := 0; index < methodFinder.NumMethod(); index++ {
+ method := methodFinder.Method(index)
+ ok, err := methodFilter(method.Name)
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "testify: invalid regexp for -m: %s\n", err)
+ os.Exit(1)
+ }
+ if ok {
+ test := testing.InternalTest{
+ Name: method.Name,
+ F: func(t *testing.T) {
+ parentT := suite.T()
+ suite.SetT(t)
+ if setupTestSuite, ok := suite.(SetupTestSuite); ok {
+ setupTestSuite.SetupTest()
+ }
+ method.Func.Call([]reflect.Value{reflect.ValueOf(suite)})
+ if tearDownTestSuite, ok := suite.(TearDownTestSuite); ok {
+ tearDownTestSuite.TearDownTest()
+ }
+ suite.SetT(parentT)
+ },
+ }
+ tests = append(tests, test)
+ }
+ }
+
+ if !testing.RunTests(func(_, _ string) (bool, error) { return true, nil },
+ tests) {
+ t.Fail()
+ }
+
+ if tearDownAllSuite, ok := suite.(TearDownAllSuite); ok {
+ tearDownAllSuite.TearDownSuite()
+ }
+}
+
+// Filtering method according to set regular expression
+// specified command-line argument -m
+func methodFilter(name string) (bool, error) {
+ if ok, _ := regexp.MatchString("^Test", name); !ok {
+ return false, nil
+ }
+ return regexp.MatchString(*matchMethod, name)
+}
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/suite/suite_test.go b/Godeps/_workspace/src/github.com/stretchr/testify/suite/suite_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..dff244157f6ec2064a9419a242eef0abf02dd163
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/suite/suite_test.go
@@ -0,0 +1,166 @@
+package suite
+
+import (
+ "errors"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+ "io/ioutil"
+ "os"
+ "testing"
+)
+
+// This suite is intended to store values to make sure that only
+// testing-suite-related methods are run. It's also a fully
+// functional example of a testing suite, using setup/teardown methods
+// and a helper method that is ignored by testify. To make this look
+// more like a real world example, all tests in the suite perform some
+// type of assertion.
+type SuiteTester struct {
+ // Include our basic suite logic.
+ Suite
+
+ // Keep counts of how many times each method is run.
+ SetupSuiteRunCount int
+ TearDownSuiteRunCount int
+ SetupTestRunCount int
+ TearDownTestRunCount int
+ TestOneRunCount int
+ TestTwoRunCount int
+ NonTestMethodRunCount int
+}
+
+// The SetupSuite method will be run by testify once, at the very
+// start of the testing suite, before any tests are run.
+func (suite *SuiteTester) SetupSuite() {
+ suite.SetupSuiteRunCount++
+}
+
+// The TearDownSuite method will be run by testify once, at the very
+// end of the testing suite, after all tests have been run.
+func (suite *SuiteTester) TearDownSuite() {
+ suite.TearDownSuiteRunCount++
+}
+
+// The SetupTest method will be run before every test in the suite.
+func (suite *SuiteTester) SetupTest() {
+ suite.SetupTestRunCount++
+}
+
+// The TearDownTest method will be run after every test in the suite.
+func (suite *SuiteTester) TearDownTest() {
+ suite.TearDownTestRunCount++
+}
+
+// Every method in a testing suite that begins with "Test" will be run
+// as a test. TestOne is an example of a test. For the purposes of
+// this example, we've included assertions in the tests, since most
+// tests will issue assertions.
+func (suite *SuiteTester) TestOne() {
+ beforeCount := suite.TestOneRunCount
+ suite.TestOneRunCount++
+ assert.Equal(suite.T(), suite.TestOneRunCount, beforeCount+1)
+ suite.Equal(suite.TestOneRunCount, beforeCount+1)
+}
+
+// TestTwo is another example of a test.
+func (suite *SuiteTester) TestTwo() {
+ beforeCount := suite.TestTwoRunCount
+ suite.TestTwoRunCount++
+ assert.NotEqual(suite.T(), suite.TestTwoRunCount, beforeCount)
+ suite.NotEqual(suite.TestTwoRunCount, beforeCount)
+}
+
+// NonTestMethod does not begin with "Test", so it will not be run by
+// testify as a test in the suite. This is useful for creating helper
+// methods for your tests.
+func (suite *SuiteTester) NonTestMethod() {
+ suite.NonTestMethodRunCount++
+}
+
+// TestRunSuite will be run by the 'go test' command, so within it, we
+// can run our suite using the Run(*testing.T, TestingSuite) function.
+func TestRunSuite(t *testing.T) {
+ suiteTester := new(SuiteTester)
+ Run(t, suiteTester)
+
+ // Normally, the test would end here. The following are simply
+ // some assertions to ensure that the Run function is working as
+ // intended - they are not part of the example.
+
+ // The suite was only run once, so the SetupSuite and TearDownSuite
+ // methods should have each been run only once.
+ assert.Equal(t, suiteTester.SetupSuiteRunCount, 1)
+ assert.Equal(t, suiteTester.TearDownSuiteRunCount, 1)
+
+ // There are two test methods (TestOne and TestTwo), so the
+ // SetupTest and TearDownTest methods (which should be run once for
+ // each test) should have been run twice.
+ assert.Equal(t, suiteTester.SetupTestRunCount, 2)
+ assert.Equal(t, suiteTester.TearDownTestRunCount, 2)
+
+ // Each test should have been run once.
+ assert.Equal(t, suiteTester.TestOneRunCount, 1)
+ assert.Equal(t, suiteTester.TestTwoRunCount, 1)
+
+ // Methods that don't match the test method identifier shouldn't
+ // have been run at all.
+ assert.Equal(t, suiteTester.NonTestMethodRunCount, 0)
+}
+
+type SuiteLoggingTester struct {
+ Suite
+}
+
+func (s *SuiteLoggingTester) TestLoggingPass() {
+ s.T().Log("TESTLOGPASS")
+}
+
+func (s *SuiteLoggingTester) TestLoggingFail() {
+ s.T().Log("TESTLOGFAIL")
+ assert.NotNil(s.T(), nil) // expected to fail
+}
+
+type StdoutCapture struct {
+ oldStdout *os.File
+ readPipe *os.File
+}
+
+func (sc *StdoutCapture) StartCapture() {
+ sc.oldStdout = os.Stdout
+ sc.readPipe, os.Stdout, _ = os.Pipe()
+}
+
+func (sc *StdoutCapture) StopCapture() (string, error) {
+ if sc.oldStdout == nil || sc.readPipe == nil {
+ return "", errors.New("StartCapture not called before StopCapture")
+ }
+ os.Stdout.Close()
+ os.Stdout = sc.oldStdout
+ bytes, err := ioutil.ReadAll(sc.readPipe)
+ if err != nil {
+ return "", err
+ }
+ return string(bytes), nil
+}
+
+func TestSuiteLogging(t *testing.T) {
+ testT := testing.T{}
+
+ suiteLoggingTester := new(SuiteLoggingTester)
+
+ capture := StdoutCapture{}
+ capture.StartCapture()
+ Run(&testT, suiteLoggingTester)
+ output, err := capture.StopCapture()
+
+ assert.Nil(t, err, "Got an error trying to capture stdout!")
+
+ // Failed tests' output is always printed
+ assert.Contains(t, output, "TESTLOGFAIL")
+
+ if testing.Verbose() {
+ // In verbose mode, output from successful tests is also printed
+ assert.Contains(t, output, "TESTLOGPASS")
+ } else {
+ assert.NotContains(t, output, "TESTLOGPASS")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/batch.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/batch.go
new file mode 100644
index 0000000000000000000000000000000000000000..354ebe4fee5f2bfd622b5ec8700f5de7cc45af56
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/batch.go
@@ -0,0 +1,252 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "encoding/binary"
+ "fmt"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb"
+)
+
+type ErrBatchCorrupted struct {
+ Reason string
+}
+
+func (e *ErrBatchCorrupted) Error() string {
+ return fmt.Sprintf("leveldb: batch corrupted: %s", e.Reason)
+}
+
+func newErrBatchCorrupted(reason string) error {
+ return errors.NewErrCorrupted(nil, &ErrBatchCorrupted{reason})
+}
+
+const (
+ batchHdrLen = 8 + 4
+ batchGrowRec = 3000
+)
+
+type BatchReplay interface {
+ Put(key, value []byte)
+ Delete(key []byte)
+}
+
+// Batch is a write batch.
+type Batch struct {
+ data []byte
+ rLen, bLen int
+ seq uint64
+ sync bool
+}
+
+func (b *Batch) grow(n int) {
+ off := len(b.data)
+ if off == 0 {
+ off = batchHdrLen
+ if b.data != nil {
+ b.data = b.data[:off]
+ }
+ }
+ if cap(b.data)-off < n {
+ if b.data == nil {
+ b.data = make([]byte, off, off+n)
+ } else {
+ odata := b.data
+ div := 1
+ if b.rLen > batchGrowRec {
+ div = b.rLen / batchGrowRec
+ }
+ b.data = make([]byte, off, off+n+(off-batchHdrLen)/div)
+ copy(b.data, odata)
+ }
+ }
+}
+
+func (b *Batch) appendRec(kt kType, key, value []byte) {
+ n := 1 + binary.MaxVarintLen32 + len(key)
+ if kt == ktVal {
+ n += binary.MaxVarintLen32 + len(value)
+ }
+ b.grow(n)
+ off := len(b.data)
+ data := b.data[:off+n]
+ data[off] = byte(kt)
+ off += 1
+ off += binary.PutUvarint(data[off:], uint64(len(key)))
+ copy(data[off:], key)
+ off += len(key)
+ if kt == ktVal {
+ off += binary.PutUvarint(data[off:], uint64(len(value)))
+ copy(data[off:], value)
+ off += len(value)
+ }
+ b.data = data[:off]
+ b.rLen++
+ // Include 8-byte ikey header
+ b.bLen += len(key) + len(value) + 8
+}
+
+// Put appends 'put operation' of the given key/value pair to the batch.
+// It is safe to modify the contents of the argument after Put returns.
+func (b *Batch) Put(key, value []byte) {
+ b.appendRec(ktVal, key, value)
+}
+
+// Delete appends 'delete operation' of the given key to the batch.
+// It is safe to modify the contents of the argument after Delete returns.
+func (b *Batch) Delete(key []byte) {
+ b.appendRec(ktDel, key, nil)
+}
+
+// Dump dumps batch contents. The returned slice can be loaded into the
+// batch using Load method.
+// The returned slice is not its own copy, so the contents should not be
+// modified.
+func (b *Batch) Dump() []byte {
+ return b.encode()
+}
+
+// Load loads given slice into the batch. Previous contents of the batch
+// will be discarded.
+// The given slice will not be copied and will be used as batch buffer, so
+// it is not safe to modify the contents of the slice.
+func (b *Batch) Load(data []byte) error {
+ return b.decode(0, data)
+}
+
+// Replay replays batch contents.
+func (b *Batch) Replay(r BatchReplay) error {
+ return b.decodeRec(func(i int, kt kType, key, value []byte) {
+ switch kt {
+ case ktVal:
+ r.Put(key, value)
+ case ktDel:
+ r.Delete(key)
+ }
+ })
+}
+
+// Len returns number of records in the batch.
+func (b *Batch) Len() int {
+ return b.rLen
+}
+
+// Reset resets the batch.
+func (b *Batch) Reset() {
+ b.data = b.data[:0]
+ b.seq = 0
+ b.rLen = 0
+ b.bLen = 0
+ b.sync = false
+}
+
+func (b *Batch) init(sync bool) {
+ b.sync = sync
+}
+
+func (b *Batch) append(p *Batch) {
+ if p.rLen > 0 {
+ b.grow(len(p.data) - batchHdrLen)
+ b.data = append(b.data, p.data[batchHdrLen:]...)
+ b.rLen += p.rLen
+ }
+ if p.sync {
+ b.sync = true
+ }
+}
+
+// size returns sums of key/value pair length plus 8-bytes ikey.
+func (b *Batch) size() int {
+ return b.bLen
+}
+
+func (b *Batch) encode() []byte {
+ b.grow(0)
+ binary.LittleEndian.PutUint64(b.data, b.seq)
+ binary.LittleEndian.PutUint32(b.data[8:], uint32(b.rLen))
+
+ return b.data
+}
+
+func (b *Batch) decode(prevSeq uint64, data []byte) error {
+ if len(data) < batchHdrLen {
+ return newErrBatchCorrupted("too short")
+ }
+
+ b.seq = binary.LittleEndian.Uint64(data)
+ if b.seq < prevSeq {
+ return newErrBatchCorrupted("invalid sequence number")
+ }
+ b.rLen = int(binary.LittleEndian.Uint32(data[8:]))
+ if b.rLen < 0 {
+ return newErrBatchCorrupted("invalid records length")
+ }
+ // No need to be precise at this point, it won't be used anyway
+ b.bLen = len(data) - batchHdrLen
+ b.data = data
+
+ return nil
+}
+
+func (b *Batch) decodeRec(f func(i int, kt kType, key, value []byte)) (err error) {
+ off := batchHdrLen
+ for i := 0; i < b.rLen; i++ {
+ if off >= len(b.data) {
+ return newErrBatchCorrupted("invalid records length")
+ }
+
+ kt := kType(b.data[off])
+ if kt > ktVal {
+ return newErrBatchCorrupted("bad record: invalid type")
+ }
+ off += 1
+
+ x, n := binary.Uvarint(b.data[off:])
+ off += n
+ if n <= 0 || off+int(x) > len(b.data) {
+ return newErrBatchCorrupted("bad record: invalid key length")
+ }
+ key := b.data[off : off+int(x)]
+ off += int(x)
+ var value []byte
+ if kt == ktVal {
+ x, n := binary.Uvarint(b.data[off:])
+ off += n
+ if n <= 0 || off+int(x) > len(b.data) {
+ return newErrBatchCorrupted("bad record: invalid value length")
+ }
+ value = b.data[off : off+int(x)]
+ off += int(x)
+ }
+
+ f(i, kt, key, value)
+ }
+
+ return nil
+}
+
+func (b *Batch) memReplay(to *memdb.DB) error {
+ return b.decodeRec(func(i int, kt kType, key, value []byte) {
+ ikey := newIkey(key, b.seq+uint64(i), kt)
+ to.Put(ikey, value)
+ })
+}
+
+func (b *Batch) memDecodeAndReplay(prevSeq uint64, data []byte, to *memdb.DB) error {
+ if err := b.decode(prevSeq, data); err != nil {
+ return err
+ }
+ return b.memReplay(to)
+}
+
+func (b *Batch) revertMemReplay(to *memdb.DB) error {
+ return b.decodeRec(func(i int, kt kType, key, value []byte) {
+ ikey := newIkey(key, b.seq+uint64(i), kt)
+ to.Delete(ikey)
+ })
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/batch_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/batch_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..e98b683cde11ad97fa83134167be6b7f74eb6b13
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/batch_test.go
@@ -0,0 +1,120 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "bytes"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb"
+)
+
+type tbRec struct {
+ kt kType
+ key, value []byte
+}
+
+type testBatch struct {
+ rec []*tbRec
+}
+
+func (p *testBatch) Put(key, value []byte) {
+ p.rec = append(p.rec, &tbRec{ktVal, key, value})
+}
+
+func (p *testBatch) Delete(key []byte) {
+ p.rec = append(p.rec, &tbRec{ktDel, key, nil})
+}
+
+func compareBatch(t *testing.T, b1, b2 *Batch) {
+ if b1.seq != b2.seq {
+ t.Errorf("invalid seq number want %d, got %d", b1.seq, b2.seq)
+ }
+ if b1.Len() != b2.Len() {
+ t.Fatalf("invalid record length want %d, got %d", b1.Len(), b2.Len())
+ }
+ p1, p2 := new(testBatch), new(testBatch)
+ err := b1.Replay(p1)
+ if err != nil {
+ t.Fatal("error when replaying batch 1: ", err)
+ }
+ err = b2.Replay(p2)
+ if err != nil {
+ t.Fatal("error when replaying batch 2: ", err)
+ }
+ for i := range p1.rec {
+ r1, r2 := p1.rec[i], p2.rec[i]
+ if r1.kt != r2.kt {
+ t.Errorf("invalid type on record '%d' want %d, got %d", i, r1.kt, r2.kt)
+ }
+ if !bytes.Equal(r1.key, r2.key) {
+ t.Errorf("invalid key on record '%d' want %s, got %s", i, string(r1.key), string(r2.key))
+ }
+ if r1.kt == ktVal {
+ if !bytes.Equal(r1.value, r2.value) {
+ t.Errorf("invalid value on record '%d' want %s, got %s", i, string(r1.value), string(r2.value))
+ }
+ }
+ }
+}
+
+func TestBatch_EncodeDecode(t *testing.T) {
+ b1 := new(Batch)
+ b1.seq = 10009
+ b1.Put([]byte("key1"), []byte("value1"))
+ b1.Put([]byte("key2"), []byte("value2"))
+ b1.Delete([]byte("key1"))
+ b1.Put([]byte("k"), []byte(""))
+ b1.Put([]byte("zzzzzzzzzzz"), []byte("zzzzzzzzzzzzzzzzzzzzzzzz"))
+ b1.Delete([]byte("key10000"))
+ b1.Delete([]byte("k"))
+ buf := b1.encode()
+ b2 := new(Batch)
+ err := b2.decode(0, buf)
+ if err != nil {
+ t.Error("error when decoding batch: ", err)
+ }
+ compareBatch(t, b1, b2)
+}
+
+func TestBatch_Append(t *testing.T) {
+ b1 := new(Batch)
+ b1.seq = 10009
+ b1.Put([]byte("key1"), []byte("value1"))
+ b1.Put([]byte("key2"), []byte("value2"))
+ b1.Delete([]byte("key1"))
+ b1.Put([]byte("foo"), []byte("foovalue"))
+ b1.Put([]byte("bar"), []byte("barvalue"))
+ b2a := new(Batch)
+ b2a.seq = 10009
+ b2a.Put([]byte("key1"), []byte("value1"))
+ b2a.Put([]byte("key2"), []byte("value2"))
+ b2a.Delete([]byte("key1"))
+ b2b := new(Batch)
+ b2b.Put([]byte("foo"), []byte("foovalue"))
+ b2b.Put([]byte("bar"), []byte("barvalue"))
+ b2a.append(b2b)
+ compareBatch(t, b1, b2a)
+}
+
+func TestBatch_Size(t *testing.T) {
+ b := new(Batch)
+ for i := 0; i < 2; i++ {
+ b.Put([]byte("key1"), []byte("value1"))
+ b.Put([]byte("key2"), []byte("value2"))
+ b.Delete([]byte("key1"))
+ b.Put([]byte("foo"), []byte("foovalue"))
+ b.Put([]byte("bar"), []byte("barvalue"))
+ mem := memdb.New(&iComparer{comparer.DefaultComparer}, 0)
+ b.memReplay(mem)
+ if b.size() != mem.Size() {
+ t.Errorf("invalid batch size calculation, want=%d got=%d", mem.Size(), b.size())
+ }
+ b.Reset()
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/bench2_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/bench2_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..0dd60fd829bb83fbe497a9838e6c73e462729c6b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/bench2_test.go
@@ -0,0 +1,58 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// +build !go1.2
+
+package leveldb
+
+import (
+ "sync/atomic"
+ "testing"
+)
+
+func BenchmarkDBReadConcurrent(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.fill()
+ p.gc()
+ defer p.close()
+
+ b.ResetTimer()
+ b.SetBytes(116)
+
+ b.RunParallel(func(pb *testing.PB) {
+ iter := p.newIter()
+ defer iter.Release()
+ for pb.Next() && iter.Next() {
+ }
+ })
+}
+
+func BenchmarkDBReadConcurrent2(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.fill()
+ p.gc()
+ defer p.close()
+
+ b.ResetTimer()
+ b.SetBytes(116)
+
+ var dir uint32
+ b.RunParallel(func(pb *testing.PB) {
+ iter := p.newIter()
+ defer iter.Release()
+ if atomic.AddUint32(&dir, 1)%2 == 0 {
+ for pb.Next() && iter.Next() {
+ }
+ } else {
+ if pb.Next() && iter.Last() {
+ for pb.Next() && iter.Prev() {
+ }
+ }
+ }
+ })
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/bench_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/bench_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..621e52db283da81202a19a0f464ae3ab0b0a0fb4
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/bench_test.go
@@ -0,0 +1,464 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "bytes"
+ "fmt"
+ "math/rand"
+ "os"
+ "path/filepath"
+ "runtime"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage"
+)
+
+func randomString(r *rand.Rand, n int) []byte {
+ b := new(bytes.Buffer)
+ for i := 0; i < n; i++ {
+ b.WriteByte(' ' + byte(r.Intn(95)))
+ }
+ return b.Bytes()
+}
+
+func compressibleStr(r *rand.Rand, frac float32, n int) []byte {
+ nn := int(float32(n) * frac)
+ rb := randomString(r, nn)
+ b := make([]byte, 0, n+nn)
+ for len(b) < n {
+ b = append(b, rb...)
+ }
+ return b[:n]
+}
+
+type valueGen struct {
+ src []byte
+ pos int
+}
+
+func newValueGen(frac float32) *valueGen {
+ v := new(valueGen)
+ r := rand.New(rand.NewSource(301))
+ v.src = make([]byte, 0, 1048576+100)
+ for len(v.src) < 1048576 {
+ v.src = append(v.src, compressibleStr(r, frac, 100)...)
+ }
+ return v
+}
+
+func (v *valueGen) get(n int) []byte {
+ if v.pos+n > len(v.src) {
+ v.pos = 0
+ }
+ v.pos += n
+ return v.src[v.pos-n : v.pos]
+}
+
+var benchDB = filepath.Join(os.TempDir(), fmt.Sprintf("goleveldbbench-%d", os.Getuid()))
+
+type dbBench struct {
+ b *testing.B
+ stor storage.Storage
+ db *DB
+
+ o *opt.Options
+ ro *opt.ReadOptions
+ wo *opt.WriteOptions
+
+ keys, values [][]byte
+}
+
+func openDBBench(b *testing.B, noCompress bool) *dbBench {
+ _, err := os.Stat(benchDB)
+ if err == nil {
+ err = os.RemoveAll(benchDB)
+ if err != nil {
+ b.Fatal("cannot remove old db: ", err)
+ }
+ }
+
+ p := &dbBench{
+ b: b,
+ o: &opt.Options{},
+ ro: &opt.ReadOptions{},
+ wo: &opt.WriteOptions{},
+ }
+ p.stor, err = storage.OpenFile(benchDB)
+ if err != nil {
+ b.Fatal("cannot open stor: ", err)
+ }
+ if noCompress {
+ p.o.Compression = opt.NoCompression
+ }
+
+ p.db, err = Open(p.stor, p.o)
+ if err != nil {
+ b.Fatal("cannot open db: ", err)
+ }
+
+ runtime.GOMAXPROCS(runtime.NumCPU())
+ return p
+}
+
+func (p *dbBench) reopen() {
+ p.db.Close()
+ var err error
+ p.db, err = Open(p.stor, p.o)
+ if err != nil {
+ p.b.Fatal("Reopen: got error: ", err)
+ }
+}
+
+func (p *dbBench) populate(n int) {
+ p.keys, p.values = make([][]byte, n), make([][]byte, n)
+ v := newValueGen(0.5)
+ for i := range p.keys {
+ p.keys[i], p.values[i] = []byte(fmt.Sprintf("%016d", i)), v.get(100)
+ }
+}
+
+func (p *dbBench) randomize() {
+ m := len(p.keys)
+ times := m * 2
+ r1, r2 := rand.New(rand.NewSource(0xdeadbeef)), rand.New(rand.NewSource(0xbeefface))
+ for n := 0; n < times; n++ {
+ i, j := r1.Int()%m, r2.Int()%m
+ if i == j {
+ continue
+ }
+ p.keys[i], p.keys[j] = p.keys[j], p.keys[i]
+ p.values[i], p.values[j] = p.values[j], p.values[i]
+ }
+}
+
+func (p *dbBench) writes(perBatch int) {
+ b := p.b
+ db := p.db
+
+ n := len(p.keys)
+ m := n / perBatch
+ if n%perBatch > 0 {
+ m++
+ }
+ batches := make([]Batch, m)
+ j := 0
+ for i := range batches {
+ first := true
+ for ; j < n && ((j+1)%perBatch != 0 || first); j++ {
+ first = false
+ batches[i].Put(p.keys[j], p.values[j])
+ }
+ }
+ runtime.GC()
+
+ b.ResetTimer()
+ b.StartTimer()
+ for i := range batches {
+ err := db.Write(&(batches[i]), p.wo)
+ if err != nil {
+ b.Fatal("write failed: ", err)
+ }
+ }
+ b.StopTimer()
+ b.SetBytes(116)
+}
+
+func (p *dbBench) gc() {
+ p.keys, p.values = nil, nil
+ runtime.GC()
+}
+
+func (p *dbBench) puts() {
+ b := p.b
+ db := p.db
+
+ b.ResetTimer()
+ b.StartTimer()
+ for i := range p.keys {
+ err := db.Put(p.keys[i], p.values[i], p.wo)
+ if err != nil {
+ b.Fatal("put failed: ", err)
+ }
+ }
+ b.StopTimer()
+ b.SetBytes(116)
+}
+
+func (p *dbBench) fill() {
+ b := p.b
+ db := p.db
+
+ perBatch := 10000
+ batch := new(Batch)
+ for i, n := 0, len(p.keys); i < n; {
+ first := true
+ for ; i < n && ((i+1)%perBatch != 0 || first); i++ {
+ first = false
+ batch.Put(p.keys[i], p.values[i])
+ }
+ err := db.Write(batch, p.wo)
+ if err != nil {
+ b.Fatal("write failed: ", err)
+ }
+ batch.Reset()
+ }
+}
+
+func (p *dbBench) gets() {
+ b := p.b
+ db := p.db
+
+ b.ResetTimer()
+ for i := range p.keys {
+ _, err := db.Get(p.keys[i], p.ro)
+ if err != nil {
+ b.Error("got error: ", err)
+ }
+ }
+ b.StopTimer()
+}
+
+func (p *dbBench) seeks() {
+ b := p.b
+
+ iter := p.newIter()
+ defer iter.Release()
+ b.ResetTimer()
+ for i := range p.keys {
+ if !iter.Seek(p.keys[i]) {
+ b.Error("value not found for: ", string(p.keys[i]))
+ }
+ }
+ b.StopTimer()
+}
+
+func (p *dbBench) newIter() iterator.Iterator {
+ iter := p.db.NewIterator(nil, p.ro)
+ err := iter.Error()
+ if err != nil {
+ p.b.Fatal("cannot create iterator: ", err)
+ }
+ return iter
+}
+
+func (p *dbBench) close() {
+ if bp, err := p.db.GetProperty("leveldb.blockpool"); err == nil {
+ p.b.Log("Block pool stats: ", bp)
+ }
+ p.db.Close()
+ p.stor.Close()
+ os.RemoveAll(benchDB)
+ p.db = nil
+ p.keys = nil
+ p.values = nil
+ runtime.GC()
+ runtime.GOMAXPROCS(1)
+}
+
+func BenchmarkDBWrite(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.writes(1)
+ p.close()
+}
+
+func BenchmarkDBWriteBatch(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.writes(1000)
+ p.close()
+}
+
+func BenchmarkDBWriteUncompressed(b *testing.B) {
+ p := openDBBench(b, true)
+ p.populate(b.N)
+ p.writes(1)
+ p.close()
+}
+
+func BenchmarkDBWriteBatchUncompressed(b *testing.B) {
+ p := openDBBench(b, true)
+ p.populate(b.N)
+ p.writes(1000)
+ p.close()
+}
+
+func BenchmarkDBWriteRandom(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.randomize()
+ p.writes(1)
+ p.close()
+}
+
+func BenchmarkDBWriteRandomSync(b *testing.B) {
+ p := openDBBench(b, false)
+ p.wo.Sync = true
+ p.populate(b.N)
+ p.writes(1)
+ p.close()
+}
+
+func BenchmarkDBOverwrite(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.writes(1)
+ p.writes(1)
+ p.close()
+}
+
+func BenchmarkDBOverwriteRandom(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.writes(1)
+ p.randomize()
+ p.writes(1)
+ p.close()
+}
+
+func BenchmarkDBPut(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.puts()
+ p.close()
+}
+
+func BenchmarkDBRead(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.fill()
+ p.gc()
+
+ iter := p.newIter()
+ b.ResetTimer()
+ for iter.Next() {
+ }
+ iter.Release()
+ b.StopTimer()
+ b.SetBytes(116)
+ p.close()
+}
+
+func BenchmarkDBReadGC(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.fill()
+
+ iter := p.newIter()
+ b.ResetTimer()
+ for iter.Next() {
+ }
+ iter.Release()
+ b.StopTimer()
+ b.SetBytes(116)
+ p.close()
+}
+
+func BenchmarkDBReadUncompressed(b *testing.B) {
+ p := openDBBench(b, true)
+ p.populate(b.N)
+ p.fill()
+ p.gc()
+
+ iter := p.newIter()
+ b.ResetTimer()
+ for iter.Next() {
+ }
+ iter.Release()
+ b.StopTimer()
+ b.SetBytes(116)
+ p.close()
+}
+
+func BenchmarkDBReadTable(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.fill()
+ p.reopen()
+ p.gc()
+
+ iter := p.newIter()
+ b.ResetTimer()
+ for iter.Next() {
+ }
+ iter.Release()
+ b.StopTimer()
+ b.SetBytes(116)
+ p.close()
+}
+
+func BenchmarkDBReadReverse(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.fill()
+ p.gc()
+
+ iter := p.newIter()
+ b.ResetTimer()
+ iter.Last()
+ for iter.Prev() {
+ }
+ iter.Release()
+ b.StopTimer()
+ b.SetBytes(116)
+ p.close()
+}
+
+func BenchmarkDBReadReverseTable(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.fill()
+ p.reopen()
+ p.gc()
+
+ iter := p.newIter()
+ b.ResetTimer()
+ iter.Last()
+ for iter.Prev() {
+ }
+ iter.Release()
+ b.StopTimer()
+ b.SetBytes(116)
+ p.close()
+}
+
+func BenchmarkDBSeek(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.fill()
+ p.seeks()
+ p.close()
+}
+
+func BenchmarkDBSeekRandom(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.fill()
+ p.randomize()
+ p.seeks()
+ p.close()
+}
+
+func BenchmarkDBGet(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.fill()
+ p.gets()
+ p.close()
+}
+
+func BenchmarkDBGetRandom(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.fill()
+ p.randomize()
+ p.gets()
+ p.close()
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/bench2_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/bench2_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..175e2220323c8428957d1cad24aa9e8604f8a23e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/bench2_test.go
@@ -0,0 +1,30 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// +build !go1.2
+
+package cache
+
+import (
+ "math/rand"
+ "testing"
+)
+
+func BenchmarkLRUCache(b *testing.B) {
+ c := NewCache(NewLRU(10000))
+
+ b.SetParallelism(10)
+ b.RunParallel(func(pb *testing.PB) {
+ r := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+ for pb.Next() {
+ key := uint64(r.Intn(1000000))
+ c.Get(0, key, func() (int, Value) {
+ return 1, key
+ }).Release()
+ }
+ })
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/cache.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/cache.go
new file mode 100644
index 0000000000000000000000000000000000000000..9ae499311026ce392b16b641577337f946754ef0
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/cache.go
@@ -0,0 +1,676 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package cache provides interface and implementation of a cache algorithms.
+package cache
+
+import (
+ "sync"
+ "sync/atomic"
+ "unsafe"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+// Cacher provides interface to implements a caching functionality.
+// An implementation must be goroutine-safe.
+type Cacher interface {
+ // Capacity returns cache capacity.
+ Capacity() int
+
+ // SetCapacity sets cache capacity.
+ SetCapacity(capacity int)
+
+ // Promote promotes the 'cache node'.
+ Promote(n *Node)
+
+ // Ban evicts the 'cache node' and prevent subsequent 'promote'.
+ Ban(n *Node)
+
+ // Evict evicts the 'cache node'.
+ Evict(n *Node)
+
+ // EvictNS evicts 'cache node' with the given namespace.
+ EvictNS(ns uint64)
+
+ // EvictAll evicts all 'cache node'.
+ EvictAll()
+
+ // Close closes the 'cache tree'
+ Close() error
+}
+
+// Value is a 'cacheable object'. It may implements util.Releaser, if
+// so the the Release method will be called once object is released.
+type Value interface{}
+
+type CacheGetter struct {
+ Cache *Cache
+ NS uint64
+}
+
+func (g *CacheGetter) Get(key uint64, setFunc func() (size int, value Value)) *Handle {
+ return g.Cache.Get(g.NS, key, setFunc)
+}
+
+// The hash tables implementation is based on:
+// "Dynamic-Sized Nonblocking Hash Tables", by Yujie Liu, Kunlong Zhang, and Michael Spear. ACM Symposium on Principles of Distributed Computing, Jul 2014.
+
+const (
+ mInitialSize = 1 << 4
+ mOverflowThreshold = 1 << 5
+ mOverflowGrowThreshold = 1 << 7
+)
+
+type mBucket struct {
+ mu sync.Mutex
+ node []*Node
+ frozen bool
+}
+
+func (b *mBucket) freeze() []*Node {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+ if !b.frozen {
+ b.frozen = true
+ }
+ return b.node
+}
+
+func (b *mBucket) get(r *Cache, h *mNode, hash uint32, ns, key uint64, noset bool) (done, added bool, n *Node) {
+ b.mu.Lock()
+
+ if b.frozen {
+ b.mu.Unlock()
+ return
+ }
+
+ // Scan the node.
+ for _, n := range b.node {
+ if n.hash == hash && n.ns == ns && n.key == key {
+ atomic.AddInt32(&n.ref, 1)
+ b.mu.Unlock()
+ return true, false, n
+ }
+ }
+
+ // Get only.
+ if noset {
+ b.mu.Unlock()
+ return true, false, nil
+ }
+
+ // Create node.
+ n = &Node{
+ r: r,
+ hash: hash,
+ ns: ns,
+ key: key,
+ ref: 1,
+ }
+ // Add node to bucket.
+ b.node = append(b.node, n)
+ bLen := len(b.node)
+ b.mu.Unlock()
+
+ // Update counter.
+ grow := atomic.AddInt32(&r.nodes, 1) >= h.growThreshold
+ if bLen > mOverflowThreshold {
+ grow = grow || atomic.AddInt32(&h.overflow, 1) >= mOverflowGrowThreshold
+ }
+
+ // Grow.
+ if grow && atomic.CompareAndSwapInt32(&h.resizeInProgess, 0, 1) {
+ nhLen := len(h.buckets) << 1
+ nh := &mNode{
+ buckets: make([]unsafe.Pointer, nhLen),
+ mask: uint32(nhLen) - 1,
+ pred: unsafe.Pointer(h),
+ growThreshold: int32(nhLen * mOverflowThreshold),
+ shrinkThreshold: int32(nhLen >> 1),
+ }
+ ok := atomic.CompareAndSwapPointer(&r.mHead, unsafe.Pointer(h), unsafe.Pointer(nh))
+ if !ok {
+ panic("BUG: failed swapping head")
+ }
+ go nh.initBuckets()
+ }
+
+ return true, true, n
+}
+
+func (b *mBucket) delete(r *Cache, h *mNode, hash uint32, ns, key uint64) (done, deleted bool) {
+ b.mu.Lock()
+
+ if b.frozen {
+ b.mu.Unlock()
+ return
+ }
+
+ // Scan the node.
+ var (
+ n *Node
+ bLen int
+ )
+ for i := range b.node {
+ n = b.node[i]
+ if n.ns == ns && n.key == key {
+ if atomic.LoadInt32(&n.ref) == 0 {
+ deleted = true
+
+ // Call releaser.
+ if n.value != nil {
+ if r, ok := n.value.(util.Releaser); ok {
+ r.Release()
+ }
+ n.value = nil
+ }
+
+ // Remove node from bucket.
+ b.node = append(b.node[:i], b.node[i+1:]...)
+ bLen = len(b.node)
+ }
+ break
+ }
+ }
+ b.mu.Unlock()
+
+ if deleted {
+ // Call OnDel.
+ for _, f := range n.onDel {
+ f()
+ }
+
+ // Update counter.
+ atomic.AddInt32(&r.size, int32(n.size)*-1)
+ shrink := atomic.AddInt32(&r.nodes, -1) < h.shrinkThreshold
+ if bLen >= mOverflowThreshold {
+ atomic.AddInt32(&h.overflow, -1)
+ }
+
+ // Shrink.
+ if shrink && len(h.buckets) > mInitialSize && atomic.CompareAndSwapInt32(&h.resizeInProgess, 0, 1) {
+ nhLen := len(h.buckets) >> 1
+ nh := &mNode{
+ buckets: make([]unsafe.Pointer, nhLen),
+ mask: uint32(nhLen) - 1,
+ pred: unsafe.Pointer(h),
+ growThreshold: int32(nhLen * mOverflowThreshold),
+ shrinkThreshold: int32(nhLen >> 1),
+ }
+ ok := atomic.CompareAndSwapPointer(&r.mHead, unsafe.Pointer(h), unsafe.Pointer(nh))
+ if !ok {
+ panic("BUG: failed swapping head")
+ }
+ go nh.initBuckets()
+ }
+ }
+
+ return true, deleted
+}
+
+type mNode struct {
+ buckets []unsafe.Pointer // []*mBucket
+ mask uint32
+ pred unsafe.Pointer // *mNode
+ resizeInProgess int32
+
+ overflow int32
+ growThreshold int32
+ shrinkThreshold int32
+}
+
+func (n *mNode) initBucket(i uint32) *mBucket {
+ if b := (*mBucket)(atomic.LoadPointer(&n.buckets[i])); b != nil {
+ return b
+ }
+
+ p := (*mNode)(atomic.LoadPointer(&n.pred))
+ if p != nil {
+ var node []*Node
+ if n.mask > p.mask {
+ // Grow.
+ pb := (*mBucket)(atomic.LoadPointer(&p.buckets[i&p.mask]))
+ if pb == nil {
+ pb = p.initBucket(i & p.mask)
+ }
+ m := pb.freeze()
+ // Split nodes.
+ for _, x := range m {
+ if x.hash&n.mask == i {
+ node = append(node, x)
+ }
+ }
+ } else {
+ // Shrink.
+ pb0 := (*mBucket)(atomic.LoadPointer(&p.buckets[i]))
+ if pb0 == nil {
+ pb0 = p.initBucket(i)
+ }
+ pb1 := (*mBucket)(atomic.LoadPointer(&p.buckets[i+uint32(len(n.buckets))]))
+ if pb1 == nil {
+ pb1 = p.initBucket(i + uint32(len(n.buckets)))
+ }
+ m0 := pb0.freeze()
+ m1 := pb1.freeze()
+ // Merge nodes.
+ node = make([]*Node, 0, len(m0)+len(m1))
+ node = append(node, m0...)
+ node = append(node, m1...)
+ }
+ b := &mBucket{node: node}
+ if atomic.CompareAndSwapPointer(&n.buckets[i], nil, unsafe.Pointer(b)) {
+ if len(node) > mOverflowThreshold {
+ atomic.AddInt32(&n.overflow, int32(len(node)-mOverflowThreshold))
+ }
+ return b
+ }
+ }
+
+ return (*mBucket)(atomic.LoadPointer(&n.buckets[i]))
+}
+
+func (n *mNode) initBuckets() {
+ for i := range n.buckets {
+ n.initBucket(uint32(i))
+ }
+ atomic.StorePointer(&n.pred, nil)
+}
+
+// Cache is a 'cache map'.
+type Cache struct {
+ mu sync.RWMutex
+ mHead unsafe.Pointer // *mNode
+ nodes int32
+ size int32
+ cacher Cacher
+ closed bool
+}
+
+// NewCache creates a new 'cache map'. The cacher is optional and
+// may be nil.
+func NewCache(cacher Cacher) *Cache {
+ h := &mNode{
+ buckets: make([]unsafe.Pointer, mInitialSize),
+ mask: mInitialSize - 1,
+ growThreshold: int32(mInitialSize * mOverflowThreshold),
+ shrinkThreshold: 0,
+ }
+ for i := range h.buckets {
+ h.buckets[i] = unsafe.Pointer(&mBucket{})
+ }
+ r := &Cache{
+ mHead: unsafe.Pointer(h),
+ cacher: cacher,
+ }
+ return r
+}
+
+func (r *Cache) getBucket(hash uint32) (*mNode, *mBucket) {
+ h := (*mNode)(atomic.LoadPointer(&r.mHead))
+ i := hash & h.mask
+ b := (*mBucket)(atomic.LoadPointer(&h.buckets[i]))
+ if b == nil {
+ b = h.initBucket(i)
+ }
+ return h, b
+}
+
+func (r *Cache) delete(n *Node) bool {
+ for {
+ h, b := r.getBucket(n.hash)
+ done, deleted := b.delete(r, h, n.hash, n.ns, n.key)
+ if done {
+ return deleted
+ }
+ }
+ return false
+}
+
+// Nodes returns number of 'cache node' in the map.
+func (r *Cache) Nodes() int {
+ return int(atomic.LoadInt32(&r.nodes))
+}
+
+// Size returns sums of 'cache node' size in the map.
+func (r *Cache) Size() int {
+ return int(atomic.LoadInt32(&r.size))
+}
+
+// Capacity returns cache capacity.
+func (r *Cache) Capacity() int {
+ if r.cacher == nil {
+ return 0
+ }
+ return r.cacher.Capacity()
+}
+
+// SetCapacity sets cache capacity.
+func (r *Cache) SetCapacity(capacity int) {
+ if r.cacher != nil {
+ r.cacher.SetCapacity(capacity)
+ }
+}
+
+// Get gets 'cache node' with the given namespace and key.
+// If cache node is not found and setFunc is not nil, Get will atomically creates
+// the 'cache node' by calling setFunc. Otherwise Get will returns nil.
+//
+// The returned 'cache handle' should be released after use by calling Release
+// method.
+func (r *Cache) Get(ns, key uint64, setFunc func() (size int, value Value)) *Handle {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+ if r.closed {
+ return nil
+ }
+
+ hash := murmur32(ns, key, 0xf00)
+ for {
+ h, b := r.getBucket(hash)
+ done, _, n := b.get(r, h, hash, ns, key, setFunc == nil)
+ if done {
+ if n != nil {
+ n.mu.Lock()
+ if n.value == nil {
+ if setFunc == nil {
+ n.mu.Unlock()
+ n.unref()
+ return nil
+ }
+
+ n.size, n.value = setFunc()
+ if n.value == nil {
+ n.size = 0
+ n.mu.Unlock()
+ n.unref()
+ return nil
+ }
+ atomic.AddInt32(&r.size, int32(n.size))
+ }
+ n.mu.Unlock()
+ if r.cacher != nil {
+ r.cacher.Promote(n)
+ }
+ return &Handle{unsafe.Pointer(n)}
+ }
+
+ break
+ }
+ }
+ return nil
+}
+
+// Delete removes and ban 'cache node' with the given namespace and key.
+// A banned 'cache node' will never inserted into the 'cache tree'. Ban
+// only attributed to the particular 'cache node', so when a 'cache node'
+// is recreated it will not be banned.
+//
+// If onDel is not nil, then it will be executed if such 'cache node'
+// doesn't exist or once the 'cache node' is released.
+//
+// Delete return true is such 'cache node' exist.
+func (r *Cache) Delete(ns, key uint64, onDel func()) bool {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+ if r.closed {
+ return false
+ }
+
+ hash := murmur32(ns, key, 0xf00)
+ for {
+ h, b := r.getBucket(hash)
+ done, _, n := b.get(r, h, hash, ns, key, true)
+ if done {
+ if n != nil {
+ if onDel != nil {
+ n.mu.Lock()
+ n.onDel = append(n.onDel, onDel)
+ n.mu.Unlock()
+ }
+ if r.cacher != nil {
+ r.cacher.Ban(n)
+ }
+ n.unref()
+ return true
+ }
+
+ break
+ }
+ }
+
+ if onDel != nil {
+ onDel()
+ }
+
+ return false
+}
+
+// Evict evicts 'cache node' with the given namespace and key. This will
+// simply call Cacher.Evict.
+//
+// Evict return true is such 'cache node' exist.
+func (r *Cache) Evict(ns, key uint64) bool {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+ if r.closed {
+ return false
+ }
+
+ hash := murmur32(ns, key, 0xf00)
+ for {
+ h, b := r.getBucket(hash)
+ done, _, n := b.get(r, h, hash, ns, key, true)
+ if done {
+ if n != nil {
+ if r.cacher != nil {
+ r.cacher.Evict(n)
+ }
+ n.unref()
+ return true
+ }
+
+ break
+ }
+ }
+
+ return false
+}
+
+// EvictNS evicts 'cache node' with the given namespace. This will
+// simply call Cacher.EvictNS.
+func (r *Cache) EvictNS(ns uint64) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+ if r.closed {
+ return
+ }
+
+ if r.cacher != nil {
+ r.cacher.EvictNS(ns)
+ }
+}
+
+// EvictAll evicts all 'cache node'. This will simply call Cacher.EvictAll.
+func (r *Cache) EvictAll() {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+ if r.closed {
+ return
+ }
+
+ if r.cacher != nil {
+ r.cacher.EvictAll()
+ }
+}
+
+// Close closes the 'cache map' and releases all 'cache node'.
+func (r *Cache) Close() error {
+ r.mu.Lock()
+ if !r.closed {
+ r.closed = true
+
+ if r.cacher != nil {
+ if err := r.cacher.Close(); err != nil {
+ return err
+ }
+ }
+
+ h := (*mNode)(r.mHead)
+ h.initBuckets()
+
+ for i := range h.buckets {
+ b := (*mBucket)(h.buckets[i])
+ for _, n := range b.node {
+ // Call releaser.
+ if n.value != nil {
+ if r, ok := n.value.(util.Releaser); ok {
+ r.Release()
+ }
+ n.value = nil
+ }
+
+ // Call OnDel.
+ for _, f := range n.onDel {
+ f()
+ }
+ }
+ }
+ }
+ r.mu.Unlock()
+ return nil
+}
+
+// Node is a 'cache node'.
+type Node struct {
+ r *Cache
+
+ hash uint32
+ ns, key uint64
+
+ mu sync.Mutex
+ size int
+ value Value
+
+ ref int32
+ onDel []func()
+
+ CacheData unsafe.Pointer
+}
+
+// NS returns this 'cache node' namespace.
+func (n *Node) NS() uint64 {
+ return n.ns
+}
+
+// Key returns this 'cache node' key.
+func (n *Node) Key() uint64 {
+ return n.key
+}
+
+// Size returns this 'cache node' size.
+func (n *Node) Size() int {
+ return n.size
+}
+
+// Value returns this 'cache node' value.
+func (n *Node) Value() Value {
+ return n.value
+}
+
+// Ref returns this 'cache node' ref counter.
+func (n *Node) Ref() int32 {
+ return atomic.LoadInt32(&n.ref)
+}
+
+// GetHandle returns an handle for this 'cache node'.
+func (n *Node) GetHandle() *Handle {
+ if atomic.AddInt32(&n.ref, 1) <= 1 {
+ panic("BUG: Node.GetHandle on zero ref")
+ }
+ return &Handle{unsafe.Pointer(n)}
+}
+
+func (n *Node) unref() {
+ if atomic.AddInt32(&n.ref, -1) == 0 {
+ n.r.delete(n)
+ }
+}
+
+func (n *Node) unrefLocked() {
+ if atomic.AddInt32(&n.ref, -1) == 0 {
+ n.r.mu.RLock()
+ if !n.r.closed {
+ n.r.delete(n)
+ }
+ n.r.mu.RUnlock()
+ }
+}
+
+type Handle struct {
+ n unsafe.Pointer // *Node
+}
+
+func (h *Handle) Value() Value {
+ n := (*Node)(atomic.LoadPointer(&h.n))
+ if n != nil {
+ return n.value
+ }
+ return nil
+}
+
+func (h *Handle) Release() {
+ nPtr := atomic.LoadPointer(&h.n)
+ if nPtr != nil && atomic.CompareAndSwapPointer(&h.n, nPtr, nil) {
+ n := (*Node)(nPtr)
+ n.unrefLocked()
+ }
+}
+
+func murmur32(ns, key uint64, seed uint32) uint32 {
+ const (
+ m = uint32(0x5bd1e995)
+ r = 24
+ )
+
+ k1 := uint32(ns >> 32)
+ k2 := uint32(ns)
+ k3 := uint32(key >> 32)
+ k4 := uint32(key)
+
+ k1 *= m
+ k1 ^= k1 >> r
+ k1 *= m
+
+ k2 *= m
+ k2 ^= k2 >> r
+ k2 *= m
+
+ k3 *= m
+ k3 ^= k3 >> r
+ k3 *= m
+
+ k4 *= m
+ k4 ^= k4 >> r
+ k4 *= m
+
+ h := seed
+
+ h *= m
+ h ^= k1
+ h *= m
+ h ^= k2
+ h *= m
+ h ^= k3
+ h *= m
+ h ^= k4
+
+ h ^= h >> 13
+ h *= m
+ h ^= h >> 15
+
+ return h
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/cache_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/cache_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..c2a50156f0472c99d3b60022781435fc18cf8947
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/cache_test.go
@@ -0,0 +1,554 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package cache
+
+import (
+ "math/rand"
+ "runtime"
+ "sync"
+ "sync/atomic"
+ "testing"
+ "time"
+ "unsafe"
+)
+
+type int32o int32
+
+func (o *int32o) acquire() {
+ if atomic.AddInt32((*int32)(o), 1) != 1 {
+ panic("BUG: invalid ref")
+ }
+}
+
+func (o *int32o) Release() {
+ if atomic.AddInt32((*int32)(o), -1) != 0 {
+ panic("BUG: invalid ref")
+ }
+}
+
+type releaserFunc struct {
+ fn func()
+ value Value
+}
+
+func (r releaserFunc) Release() {
+ if r.fn != nil {
+ r.fn()
+ }
+}
+
+func set(c *Cache, ns, key uint64, value Value, charge int, relf func()) *Handle {
+ return c.Get(ns, key, func() (int, Value) {
+ if relf != nil {
+ return charge, releaserFunc{relf, value}
+ } else {
+ return charge, value
+ }
+ })
+}
+
+func TestCacheMap(t *testing.T) {
+ runtime.GOMAXPROCS(runtime.NumCPU())
+
+ nsx := []struct {
+ nobjects, nhandles, concurrent, repeat int
+ }{
+ {10000, 400, 50, 3},
+ {100000, 1000, 100, 10},
+ }
+
+ var (
+ objects [][]int32o
+ handles [][]unsafe.Pointer
+ )
+
+ for _, x := range nsx {
+ objects = append(objects, make([]int32o, x.nobjects))
+ handles = append(handles, make([]unsafe.Pointer, x.nhandles))
+ }
+
+ c := NewCache(nil)
+
+ wg := new(sync.WaitGroup)
+ var done int32
+
+ for ns, x := range nsx {
+ for i := 0; i < x.concurrent; i++ {
+ wg.Add(1)
+ go func(ns, i, repeat int, objects []int32o, handles []unsafe.Pointer) {
+ defer wg.Done()
+ r := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+ for j := len(objects) * repeat; j >= 0; j-- {
+ key := uint64(r.Intn(len(objects)))
+ h := c.Get(uint64(ns), key, func() (int, Value) {
+ o := &objects[key]
+ o.acquire()
+ return 1, o
+ })
+ if v := h.Value().(*int32o); v != &objects[key] {
+ t.Fatalf("#%d invalid value: want=%p got=%p", ns, &objects[key], v)
+ }
+ if objects[key] != 1 {
+ t.Fatalf("#%d invalid object %d: %d", ns, key, objects[key])
+ }
+ if !atomic.CompareAndSwapPointer(&handles[r.Intn(len(handles))], nil, unsafe.Pointer(h)) {
+ h.Release()
+ }
+ }
+ }(ns, i, x.repeat, objects[ns], handles[ns])
+ }
+
+ go func(handles []unsafe.Pointer) {
+ r := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+ for atomic.LoadInt32(&done) == 0 {
+ i := r.Intn(len(handles))
+ h := (*Handle)(atomic.LoadPointer(&handles[i]))
+ if h != nil && atomic.CompareAndSwapPointer(&handles[i], unsafe.Pointer(h), nil) {
+ h.Release()
+ }
+ time.Sleep(time.Millisecond)
+ }
+ }(handles[ns])
+ }
+
+ go func() {
+ handles := make([]*Handle, 100000)
+ for atomic.LoadInt32(&done) == 0 {
+ for i := range handles {
+ handles[i] = c.Get(999999999, uint64(i), func() (int, Value) {
+ return 1, 1
+ })
+ }
+ for _, h := range handles {
+ h.Release()
+ }
+ }
+ }()
+
+ wg.Wait()
+
+ atomic.StoreInt32(&done, 1)
+
+ for _, handles0 := range handles {
+ for i := range handles0 {
+ h := (*Handle)(atomic.LoadPointer(&handles0[i]))
+ if h != nil && atomic.CompareAndSwapPointer(&handles0[i], unsafe.Pointer(h), nil) {
+ h.Release()
+ }
+ }
+ }
+
+ for ns, objects0 := range objects {
+ for i, o := range objects0 {
+ if o != 0 {
+ t.Fatalf("invalid object #%d.%d: ref=%d", ns, i, o)
+ }
+ }
+ }
+}
+
+func TestCacheMap_NodesAndSize(t *testing.T) {
+ c := NewCache(nil)
+ if c.Nodes() != 0 {
+ t.Errorf("invalid nodes counter: want=%d got=%d", 0, c.Nodes())
+ }
+ if c.Size() != 0 {
+ t.Errorf("invalid size counter: want=%d got=%d", 0, c.Size())
+ }
+ set(c, 0, 1, 1, 1, nil)
+ set(c, 0, 2, 2, 2, nil)
+ set(c, 1, 1, 3, 3, nil)
+ set(c, 2, 1, 4, 1, nil)
+ if c.Nodes() != 4 {
+ t.Errorf("invalid nodes counter: want=%d got=%d", 4, c.Nodes())
+ }
+ if c.Size() != 7 {
+ t.Errorf("invalid size counter: want=%d got=%d", 4, c.Size())
+ }
+}
+
+func TestLRUCache_Capacity(t *testing.T) {
+ c := NewCache(NewLRU(10))
+ if c.Capacity() != 10 {
+ t.Errorf("invalid capacity: want=%d got=%d", 10, c.Capacity())
+ }
+ set(c, 0, 1, 1, 1, nil).Release()
+ set(c, 0, 2, 2, 2, nil).Release()
+ set(c, 1, 1, 3, 3, nil).Release()
+ set(c, 2, 1, 4, 1, nil).Release()
+ set(c, 2, 2, 5, 1, nil).Release()
+ set(c, 2, 3, 6, 1, nil).Release()
+ set(c, 2, 4, 7, 1, nil).Release()
+ set(c, 2, 5, 8, 1, nil).Release()
+ if c.Nodes() != 7 {
+ t.Errorf("invalid nodes counter: want=%d got=%d", 7, c.Nodes())
+ }
+ if c.Size() != 10 {
+ t.Errorf("invalid size counter: want=%d got=%d", 10, c.Size())
+ }
+ c.SetCapacity(9)
+ if c.Capacity() != 9 {
+ t.Errorf("invalid capacity: want=%d got=%d", 9, c.Capacity())
+ }
+ if c.Nodes() != 6 {
+ t.Errorf("invalid nodes counter: want=%d got=%d", 6, c.Nodes())
+ }
+ if c.Size() != 8 {
+ t.Errorf("invalid size counter: want=%d got=%d", 8, c.Size())
+ }
+}
+
+func TestCacheMap_NilValue(t *testing.T) {
+ c := NewCache(NewLRU(10))
+ h := c.Get(0, 0, func() (size int, value Value) {
+ return 1, nil
+ })
+ if h != nil {
+ t.Error("cache handle is non-nil")
+ }
+ if c.Nodes() != 0 {
+ t.Errorf("invalid nodes counter: want=%d got=%d", 0, c.Nodes())
+ }
+ if c.Size() != 0 {
+ t.Errorf("invalid size counter: want=%d got=%d", 0, c.Size())
+ }
+}
+
+func TestLRUCache_GetLatency(t *testing.T) {
+ runtime.GOMAXPROCS(runtime.NumCPU())
+
+ const (
+ concurrentSet = 30
+ concurrentGet = 3
+ duration = 3 * time.Second
+ delay = 3 * time.Millisecond
+ maxkey = 100000
+ )
+
+ var (
+ set, getHit, getAll int32
+ getMaxLatency, getDuration int64
+ )
+
+ c := NewCache(NewLRU(5000))
+ wg := &sync.WaitGroup{}
+ until := time.Now().Add(duration)
+ for i := 0; i < concurrentSet; i++ {
+ wg.Add(1)
+ go func(i int) {
+ defer wg.Done()
+ r := rand.New(rand.NewSource(time.Now().UnixNano()))
+ for time.Now().Before(until) {
+ c.Get(0, uint64(r.Intn(maxkey)), func() (int, Value) {
+ time.Sleep(delay)
+ atomic.AddInt32(&set, 1)
+ return 1, 1
+ }).Release()
+ }
+ }(i)
+ }
+ for i := 0; i < concurrentGet; i++ {
+ wg.Add(1)
+ go func(i int) {
+ defer wg.Done()
+ r := rand.New(rand.NewSource(time.Now().UnixNano()))
+ for {
+ mark := time.Now()
+ if mark.Before(until) {
+ h := c.Get(0, uint64(r.Intn(maxkey)), nil)
+ latency := int64(time.Now().Sub(mark))
+ m := atomic.LoadInt64(&getMaxLatency)
+ if latency > m {
+ atomic.CompareAndSwapInt64(&getMaxLatency, m, latency)
+ }
+ atomic.AddInt64(&getDuration, latency)
+ if h != nil {
+ atomic.AddInt32(&getHit, 1)
+ h.Release()
+ }
+ atomic.AddInt32(&getAll, 1)
+ } else {
+ break
+ }
+ }
+ }(i)
+ }
+
+ wg.Wait()
+ getAvglatency := time.Duration(getDuration) / time.Duration(getAll)
+ t.Logf("set=%d getHit=%d getAll=%d getMaxLatency=%v getAvgLatency=%v",
+ set, getHit, getAll, time.Duration(getMaxLatency), getAvglatency)
+
+ if getAvglatency > delay/3 {
+ t.Errorf("get avg latency > %v: got=%v", delay/3, getAvglatency)
+ }
+}
+
+func TestLRUCache_HitMiss(t *testing.T) {
+ cases := []struct {
+ key uint64
+ value string
+ }{
+ {1, "vvvvvvvvv"},
+ {100, "v1"},
+ {0, "v2"},
+ {12346, "v3"},
+ {777, "v4"},
+ {999, "v5"},
+ {7654, "v6"},
+ {2, "v7"},
+ {3, "v8"},
+ {9, "v9"},
+ }
+
+ setfin := 0
+ c := NewCache(NewLRU(1000))
+ for i, x := range cases {
+ set(c, 0, x.key, x.value, len(x.value), func() {
+ setfin++
+ }).Release()
+ for j, y := range cases {
+ h := c.Get(0, y.key, nil)
+ if j <= i {
+ // should hit
+ if h == nil {
+ t.Errorf("case '%d' iteration '%d' is miss", i, j)
+ } else {
+ if x := h.Value().(releaserFunc).value.(string); x != y.value {
+ t.Errorf("case '%d' iteration '%d' has invalid value got '%s', want '%s'", i, j, x, y.value)
+ }
+ }
+ } else {
+ // should miss
+ if h != nil {
+ t.Errorf("case '%d' iteration '%d' is hit , value '%s'", i, j, h.Value().(releaserFunc).value.(string))
+ }
+ }
+ if h != nil {
+ h.Release()
+ }
+ }
+ }
+
+ for i, x := range cases {
+ finalizerOk := false
+ c.Delete(0, x.key, func() {
+ finalizerOk = true
+ })
+
+ if !finalizerOk {
+ t.Errorf("case %d delete finalizer not executed", i)
+ }
+
+ for j, y := range cases {
+ h := c.Get(0, y.key, nil)
+ if j > i {
+ // should hit
+ if h == nil {
+ t.Errorf("case '%d' iteration '%d' is miss", i, j)
+ } else {
+ if x := h.Value().(releaserFunc).value.(string); x != y.value {
+ t.Errorf("case '%d' iteration '%d' has invalid value got '%s', want '%s'", i, j, x, y.value)
+ }
+ }
+ } else {
+ // should miss
+ if h != nil {
+ t.Errorf("case '%d' iteration '%d' is hit, value '%s'", i, j, h.Value().(releaserFunc).value.(string))
+ }
+ }
+ if h != nil {
+ h.Release()
+ }
+ }
+ }
+
+ if setfin != len(cases) {
+ t.Errorf("some set finalizer may not be executed, want=%d got=%d", len(cases), setfin)
+ }
+}
+
+func TestLRUCache_Eviction(t *testing.T) {
+ c := NewCache(NewLRU(12))
+ o1 := set(c, 0, 1, 1, 1, nil)
+ set(c, 0, 2, 2, 1, nil).Release()
+ set(c, 0, 3, 3, 1, nil).Release()
+ set(c, 0, 4, 4, 1, nil).Release()
+ set(c, 0, 5, 5, 1, nil).Release()
+ if h := c.Get(0, 2, nil); h != nil { // 1,3,4,5,2
+ h.Release()
+ }
+ set(c, 0, 9, 9, 10, nil).Release() // 5,2,9
+
+ for _, key := range []uint64{9, 2, 5, 1} {
+ h := c.Get(0, key, nil)
+ if h == nil {
+ t.Errorf("miss for key '%d'", key)
+ } else {
+ if x := h.Value().(int); x != int(key) {
+ t.Errorf("invalid value for key '%d' want '%d', got '%d'", key, key, x)
+ }
+ h.Release()
+ }
+ }
+ o1.Release()
+ for _, key := range []uint64{1, 2, 5} {
+ h := c.Get(0, key, nil)
+ if h == nil {
+ t.Errorf("miss for key '%d'", key)
+ } else {
+ if x := h.Value().(int); x != int(key) {
+ t.Errorf("invalid value for key '%d' want '%d', got '%d'", key, key, x)
+ }
+ h.Release()
+ }
+ }
+ for _, key := range []uint64{3, 4, 9} {
+ h := c.Get(0, key, nil)
+ if h != nil {
+ t.Errorf("hit for key '%d'", key)
+ if x := h.Value().(int); x != int(key) {
+ t.Errorf("invalid value for key '%d' want '%d', got '%d'", key, key, x)
+ }
+ h.Release()
+ }
+ }
+}
+
+func TestLRUCache_Evict(t *testing.T) {
+ c := NewCache(NewLRU(6))
+ set(c, 0, 1, 1, 1, nil).Release()
+ set(c, 0, 2, 2, 1, nil).Release()
+ set(c, 1, 1, 4, 1, nil).Release()
+ set(c, 1, 2, 5, 1, nil).Release()
+ set(c, 2, 1, 6, 1, nil).Release()
+ set(c, 2, 2, 7, 1, nil).Release()
+
+ for ns := 0; ns < 3; ns++ {
+ for key := 1; key < 3; key++ {
+ if h := c.Get(uint64(ns), uint64(key), nil); h != nil {
+ h.Release()
+ } else {
+ t.Errorf("Cache.Get on #%d.%d return nil", ns, key)
+ }
+ }
+ }
+
+ if ok := c.Evict(0, 1); !ok {
+ t.Error("first Cache.Evict on #0.1 return false")
+ }
+ if ok := c.Evict(0, 1); ok {
+ t.Error("second Cache.Evict on #0.1 return true")
+ }
+ if h := c.Get(0, 1, nil); h != nil {
+ t.Errorf("Cache.Get on #0.1 return non-nil: %v", h.Value())
+ }
+
+ c.EvictNS(1)
+ if h := c.Get(1, 1, nil); h != nil {
+ t.Errorf("Cache.Get on #1.1 return non-nil: %v", h.Value())
+ }
+ if h := c.Get(1, 2, nil); h != nil {
+ t.Errorf("Cache.Get on #1.2 return non-nil: %v", h.Value())
+ }
+
+ c.EvictAll()
+ for ns := 0; ns < 3; ns++ {
+ for key := 1; key < 3; key++ {
+ if h := c.Get(uint64(ns), uint64(key), nil); h != nil {
+ t.Errorf("Cache.Get on #%d.%d return non-nil: %v", ns, key, h.Value())
+ }
+ }
+ }
+}
+
+func TestLRUCache_Delete(t *testing.T) {
+ delFuncCalled := 0
+ delFunc := func() {
+ delFuncCalled++
+ }
+
+ c := NewCache(NewLRU(2))
+ set(c, 0, 1, 1, 1, nil).Release()
+ set(c, 0, 2, 2, 1, nil).Release()
+
+ if ok := c.Delete(0, 1, delFunc); !ok {
+ t.Error("Cache.Delete on #1 return false")
+ }
+ if h := c.Get(0, 1, nil); h != nil {
+ t.Errorf("Cache.Get on #1 return non-nil: %v", h.Value())
+ }
+ if ok := c.Delete(0, 1, delFunc); ok {
+ t.Error("Cache.Delete on #1 return true")
+ }
+
+ h2 := c.Get(0, 2, nil)
+ if h2 == nil {
+ t.Error("Cache.Get on #2 return nil")
+ }
+ if ok := c.Delete(0, 2, delFunc); !ok {
+ t.Error("(1) Cache.Delete on #2 return false")
+ }
+ if ok := c.Delete(0, 2, delFunc); !ok {
+ t.Error("(2) Cache.Delete on #2 return false")
+ }
+
+ set(c, 0, 3, 3, 1, nil).Release()
+ set(c, 0, 4, 4, 1, nil).Release()
+ c.Get(0, 2, nil).Release()
+
+ for key := 2; key <= 4; key++ {
+ if h := c.Get(0, uint64(key), nil); h != nil {
+ h.Release()
+ } else {
+ t.Errorf("Cache.Get on #%d return nil", key)
+ }
+ }
+
+ h2.Release()
+ if h := c.Get(0, 2, nil); h != nil {
+ t.Errorf("Cache.Get on #2 return non-nil: %v", h.Value())
+ }
+
+ if delFuncCalled != 4 {
+ t.Errorf("delFunc isn't called 4 times: got=%d", delFuncCalled)
+ }
+}
+
+func TestLRUCache_Close(t *testing.T) {
+ relFuncCalled := 0
+ relFunc := func() {
+ relFuncCalled++
+ }
+ delFuncCalled := 0
+ delFunc := func() {
+ delFuncCalled++
+ }
+
+ c := NewCache(NewLRU(2))
+ set(c, 0, 1, 1, 1, relFunc).Release()
+ set(c, 0, 2, 2, 1, relFunc).Release()
+
+ h3 := set(c, 0, 3, 3, 1, relFunc)
+ if h3 == nil {
+ t.Error("Cache.Get on #3 return nil")
+ }
+ if ok := c.Delete(0, 3, delFunc); !ok {
+ t.Error("Cache.Delete on #3 return false")
+ }
+
+ c.Close()
+
+ if relFuncCalled != 3 {
+ t.Errorf("relFunc isn't called 3 times: got=%d", relFuncCalled)
+ }
+ if delFuncCalled != 1 {
+ t.Errorf("delFunc isn't called 1 times: got=%d", delFuncCalled)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/lru.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/lru.go
new file mode 100644
index 0000000000000000000000000000000000000000..d9a84cde15e8a0c892dc419ace7679616943d54c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/lru.go
@@ -0,0 +1,195 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package cache
+
+import (
+ "sync"
+ "unsafe"
+)
+
+type lruNode struct {
+ n *Node
+ h *Handle
+ ban bool
+
+ next, prev *lruNode
+}
+
+func (n *lruNode) insert(at *lruNode) {
+ x := at.next
+ at.next = n
+ n.prev = at
+ n.next = x
+ x.prev = n
+}
+
+func (n *lruNode) remove() {
+ if n.prev != nil {
+ n.prev.next = n.next
+ n.next.prev = n.prev
+ n.prev = nil
+ n.next = nil
+ } else {
+ panic("BUG: removing removed node")
+ }
+}
+
+type lru struct {
+ mu sync.Mutex
+ capacity int
+ used int
+ recent lruNode
+}
+
+func (r *lru) reset() {
+ r.recent.next = &r.recent
+ r.recent.prev = &r.recent
+ r.used = 0
+}
+
+func (r *lru) Capacity() int {
+ r.mu.Lock()
+ defer r.mu.Unlock()
+ return r.capacity
+}
+
+func (r *lru) SetCapacity(capacity int) {
+ var evicted []*lruNode
+
+ r.mu.Lock()
+ r.capacity = capacity
+ for r.used > r.capacity {
+ rn := r.recent.prev
+ if rn == nil {
+ panic("BUG: invalid LRU used or capacity counter")
+ }
+ rn.remove()
+ rn.n.CacheData = nil
+ r.used -= rn.n.Size()
+ evicted = append(evicted, rn)
+ }
+ r.mu.Unlock()
+
+ for _, rn := range evicted {
+ rn.h.Release()
+ }
+}
+
+func (r *lru) Promote(n *Node) {
+ var evicted []*lruNode
+
+ r.mu.Lock()
+ if n.CacheData == nil {
+ if n.Size() <= r.capacity {
+ rn := &lruNode{n: n, h: n.GetHandle()}
+ rn.insert(&r.recent)
+ n.CacheData = unsafe.Pointer(rn)
+ r.used += n.Size()
+
+ for r.used > r.capacity {
+ rn := r.recent.prev
+ if rn == nil {
+ panic("BUG: invalid LRU used or capacity counter")
+ }
+ rn.remove()
+ rn.n.CacheData = nil
+ r.used -= rn.n.Size()
+ evicted = append(evicted, rn)
+ }
+ }
+ } else {
+ rn := (*lruNode)(n.CacheData)
+ if !rn.ban {
+ rn.remove()
+ rn.insert(&r.recent)
+ }
+ }
+ r.mu.Unlock()
+
+ for _, rn := range evicted {
+ rn.h.Release()
+ }
+}
+
+func (r *lru) Ban(n *Node) {
+ r.mu.Lock()
+ if n.CacheData == nil {
+ n.CacheData = unsafe.Pointer(&lruNode{n: n, ban: true})
+ } else {
+ rn := (*lruNode)(n.CacheData)
+ if !rn.ban {
+ rn.remove()
+ rn.ban = true
+ r.used -= rn.n.Size()
+ r.mu.Unlock()
+
+ rn.h.Release()
+ rn.h = nil
+ return
+ }
+ }
+ r.mu.Unlock()
+}
+
+func (r *lru) Evict(n *Node) {
+ r.mu.Lock()
+ rn := (*lruNode)(n.CacheData)
+ if rn == nil || rn.ban {
+ r.mu.Unlock()
+ return
+ }
+ n.CacheData = nil
+ r.mu.Unlock()
+
+ rn.h.Release()
+}
+
+func (r *lru) EvictNS(ns uint64) {
+ var evicted []*lruNode
+
+ r.mu.Lock()
+ for e := r.recent.prev; e != &r.recent; {
+ rn := e
+ e = e.prev
+ if rn.n.NS() == ns {
+ rn.remove()
+ rn.n.CacheData = nil
+ r.used -= rn.n.Size()
+ evicted = append(evicted, rn)
+ }
+ }
+ r.mu.Unlock()
+
+ for _, rn := range evicted {
+ rn.h.Release()
+ }
+}
+
+func (r *lru) EvictAll() {
+ r.mu.Lock()
+ back := r.recent.prev
+ for rn := back; rn != &r.recent; rn = rn.prev {
+ rn.n.CacheData = nil
+ }
+ r.reset()
+ r.mu.Unlock()
+
+ for rn := back; rn != &r.recent; rn = rn.prev {
+ rn.h.Release()
+ }
+}
+
+func (r *lru) Close() error {
+ return nil
+}
+
+// NewLRU create a new LRU-cache.
+func NewLRU(capacity int) Cacher {
+ r := &lru{capacity: capacity}
+ r.reset()
+ return r
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer.go
new file mode 100644
index 0000000000000000000000000000000000000000..6e57fab707a08b08c1bd088dac3088c7bd6e48a9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer.go
@@ -0,0 +1,75 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer"
+
+type iComparer struct {
+ ucmp comparer.Comparer
+}
+
+func (icmp *iComparer) uName() string {
+ return icmp.ucmp.Name()
+}
+
+func (icmp *iComparer) uCompare(a, b []byte) int {
+ return icmp.ucmp.Compare(a, b)
+}
+
+func (icmp *iComparer) uSeparator(dst, a, b []byte) []byte {
+ return icmp.ucmp.Separator(dst, a, b)
+}
+
+func (icmp *iComparer) uSuccessor(dst, b []byte) []byte {
+ return icmp.ucmp.Successor(dst, b)
+}
+
+func (icmp *iComparer) Name() string {
+ return icmp.uName()
+}
+
+func (icmp *iComparer) Compare(a, b []byte) int {
+ x := icmp.ucmp.Compare(iKey(a).ukey(), iKey(b).ukey())
+ if x == 0 {
+ if m, n := iKey(a).num(), iKey(b).num(); m > n {
+ x = -1
+ } else if m < n {
+ x = 1
+ }
+ }
+ return x
+}
+
+func (icmp *iComparer) Separator(dst, a, b []byte) []byte {
+ ua, ub := iKey(a).ukey(), iKey(b).ukey()
+ dst = icmp.ucmp.Separator(dst, ua, ub)
+ if dst == nil {
+ return nil
+ }
+ if len(dst) < len(ua) && icmp.uCompare(ua, dst) < 0 {
+ dst = append(dst, kMaxNumBytes...)
+ } else {
+ // Did not close possibilities that n maybe longer than len(ub).
+ dst = append(dst, a[len(a)-8:]...)
+ }
+ return dst
+}
+
+func (icmp *iComparer) Successor(dst, b []byte) []byte {
+ ub := iKey(b).ukey()
+ dst = icmp.ucmp.Successor(dst, ub)
+ if dst == nil {
+ return nil
+ }
+ if len(dst) < len(ub) && icmp.uCompare(ub, dst) < 0 {
+ dst = append(dst, kMaxNumBytes...)
+ } else {
+ // Did not close possibilities that n maybe longer than len(ub).
+ dst = append(dst, b[len(b)-8:]...)
+ }
+ return dst
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer/bytes_comparer.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer/bytes_comparer.go
new file mode 100644
index 0000000000000000000000000000000000000000..14dddf88dd207d0e9f7a0f6635fd6bd46682da1b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer/bytes_comparer.go
@@ -0,0 +1,51 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package comparer
+
+import "bytes"
+
+type bytesComparer struct{}
+
+func (bytesComparer) Compare(a, b []byte) int {
+ return bytes.Compare(a, b)
+}
+
+func (bytesComparer) Name() string {
+ return "leveldb.BytewiseComparator"
+}
+
+func (bytesComparer) Separator(dst, a, b []byte) []byte {
+ i, n := 0, len(a)
+ if n > len(b) {
+ n = len(b)
+ }
+ for ; i < n && a[i] == b[i]; i++ {
+ }
+ if i >= n {
+ // Do not shorten if one string is a prefix of the other
+ } else if c := a[i]; c < 0xff && c+1 < b[i] {
+ dst = append(dst, a[:i+1]...)
+ dst[i]++
+ return dst
+ }
+ return nil
+}
+
+func (bytesComparer) Successor(dst, b []byte) []byte {
+ for i, c := range b {
+ if c != 0xff {
+ dst = append(dst, b[:i+1]...)
+ dst[i]++
+ return dst
+ }
+ }
+ return nil
+}
+
+// DefaultComparer are default implementation of the Comparer interface.
+// It uses the natural ordering, consistent with bytes.Compare.
+var DefaultComparer = bytesComparer{}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer/comparer.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer/comparer.go
new file mode 100644
index 0000000000000000000000000000000000000000..14a28f16fcee51ce6b4cb4d8087cb7a7c5f576e2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer/comparer.go
@@ -0,0 +1,57 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package comparer provides interface and implementation for ordering
+// sets of data.
+package comparer
+
+// BasicComparer is the interface that wraps the basic Compare method.
+type BasicComparer interface {
+ // Compare returns -1, 0, or +1 depending on whether a is 'less than',
+ // 'equal to' or 'greater than' b. The two arguments can only be 'equal'
+ // if their contents are exactly equal. Furthermore, the empty slice
+ // must be 'less than' any non-empty slice.
+ Compare(a, b []byte) int
+}
+
+// Comparer defines a total ordering over the space of []byte keys: a 'less
+// than' relationship.
+type Comparer interface {
+ BasicComparer
+
+ // Name returns name of the comparer.
+ //
+ // The Level-DB on-disk format stores the comparer name, and opening a
+ // database with a different comparer from the one it was created with
+ // will result in an error.
+ //
+ // An implementation to a new name whenever the comparer implementation
+ // changes in a way that will cause the relative ordering of any two keys
+ // to change.
+ //
+ // Names starting with "leveldb." are reserved and should not be used
+ // by any users of this package.
+ Name() string
+
+ // Bellow are advanced functions used used to reduce the space requirements
+ // for internal data structures such as index blocks.
+
+ // Separator appends a sequence of bytes x to dst such that a <= x && x < b,
+ // where 'less than' is consistent with Compare. An implementation should
+ // return nil if x equal to a.
+ //
+ // Either contents of a or b should not by any means modified. Doing so
+ // may cause corruption on the internal state.
+ Separator(dst, a, b []byte) []byte
+
+ // Successor appends a sequence of bytes x to dst such that x >= b, where
+ // 'less than' is consistent with Compare. An implementation should return
+ // nil if x equal to b.
+ //
+ // Contents of b should not by any means modified. Doing so may cause
+ // corruption on the internal state.
+ Successor(dst, b []byte) []byte
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/corrupt_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/corrupt_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..f1ef0743e955f114cea9018d051e45d898787464
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/corrupt_test.go
@@ -0,0 +1,500 @@
+// Copyright (c) 2013, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "bytes"
+ "fmt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage"
+ "io"
+ "math/rand"
+ "testing"
+)
+
+const ctValSize = 1000
+
+type dbCorruptHarness struct {
+ dbHarness
+}
+
+func newDbCorruptHarnessWopt(t *testing.T, o *opt.Options) *dbCorruptHarness {
+ h := new(dbCorruptHarness)
+ h.init(t, o)
+ return h
+}
+
+func newDbCorruptHarness(t *testing.T) *dbCorruptHarness {
+ return newDbCorruptHarnessWopt(t, &opt.Options{
+ BlockCacheCapacity: 100,
+ Strict: opt.StrictJournalChecksum,
+ })
+}
+
+func (h *dbCorruptHarness) recover() {
+ p := &h.dbHarness
+ t := p.t
+
+ var err error
+ p.db, err = Recover(h.stor, h.o)
+ if err != nil {
+ t.Fatal("Repair: got error: ", err)
+ }
+}
+
+func (h *dbCorruptHarness) build(n int) {
+ p := &h.dbHarness
+ t := p.t
+ db := p.db
+
+ batch := new(Batch)
+ for i := 0; i < n; i++ {
+ batch.Reset()
+ batch.Put(tkey(i), tval(i, ctValSize))
+ err := db.Write(batch, p.wo)
+ if err != nil {
+ t.Fatal("write error: ", err)
+ }
+ }
+}
+
+func (h *dbCorruptHarness) buildShuffled(n int, rnd *rand.Rand) {
+ p := &h.dbHarness
+ t := p.t
+ db := p.db
+
+ batch := new(Batch)
+ for i := range rnd.Perm(n) {
+ batch.Reset()
+ batch.Put(tkey(i), tval(i, ctValSize))
+ err := db.Write(batch, p.wo)
+ if err != nil {
+ t.Fatal("write error: ", err)
+ }
+ }
+}
+
+func (h *dbCorruptHarness) deleteRand(n, max int, rnd *rand.Rand) {
+ p := &h.dbHarness
+ t := p.t
+ db := p.db
+
+ batch := new(Batch)
+ for i := 0; i < n; i++ {
+ batch.Reset()
+ batch.Delete(tkey(rnd.Intn(max)))
+ err := db.Write(batch, p.wo)
+ if err != nil {
+ t.Fatal("write error: ", err)
+ }
+ }
+}
+
+func (h *dbCorruptHarness) corrupt(ft storage.FileType, fi, offset, n int) {
+ p := &h.dbHarness
+ t := p.t
+
+ ff, _ := p.stor.GetFiles(ft)
+ sff := files(ff)
+ sff.sort()
+ if fi < 0 {
+ fi = len(sff) - 1
+ }
+ if fi >= len(sff) {
+ t.Fatalf("no such file with type %q with index %d", ft, fi)
+ }
+
+ file := sff[fi]
+
+ r, err := file.Open()
+ if err != nil {
+ t.Fatal("cannot open file: ", err)
+ }
+ x, err := r.Seek(0, 2)
+ if err != nil {
+ t.Fatal("cannot query file size: ", err)
+ }
+ m := int(x)
+ if _, err := r.Seek(0, 0); err != nil {
+ t.Fatal(err)
+ }
+
+ if offset < 0 {
+ if -offset > m {
+ offset = 0
+ } else {
+ offset = m + offset
+ }
+ }
+ if offset > m {
+ offset = m
+ }
+ if offset+n > m {
+ n = m - offset
+ }
+
+ buf := make([]byte, m)
+ _, err = io.ReadFull(r, buf)
+ if err != nil {
+ t.Fatal("cannot read file: ", err)
+ }
+ r.Close()
+
+ for i := 0; i < n; i++ {
+ buf[offset+i] ^= 0x80
+ }
+
+ err = file.Remove()
+ if err != nil {
+ t.Fatal("cannot remove old file: ", err)
+ }
+ w, err := file.Create()
+ if err != nil {
+ t.Fatal("cannot create new file: ", err)
+ }
+ _, err = w.Write(buf)
+ if err != nil {
+ t.Fatal("cannot write new file: ", err)
+ }
+ w.Close()
+}
+
+func (h *dbCorruptHarness) removeAll(ft storage.FileType) {
+ ff, err := h.stor.GetFiles(ft)
+ if err != nil {
+ h.t.Fatal("get files: ", err)
+ }
+ for _, f := range ff {
+ if err := f.Remove(); err != nil {
+ h.t.Error("remove file: ", err)
+ }
+ }
+}
+
+func (h *dbCorruptHarness) removeOne(ft storage.FileType) {
+ ff, err := h.stor.GetFiles(ft)
+ if err != nil {
+ h.t.Fatal("get files: ", err)
+ }
+ f := ff[rand.Intn(len(ff))]
+ h.t.Logf("removing file @%d", f.Num())
+ if err := f.Remove(); err != nil {
+ h.t.Error("remove file: ", err)
+ }
+}
+
+func (h *dbCorruptHarness) check(min, max int) {
+ p := &h.dbHarness
+ t := p.t
+ db := p.db
+
+ var n, badk, badv, missed, good int
+ iter := db.NewIterator(nil, p.ro)
+ for iter.Next() {
+ k := 0
+ fmt.Sscanf(string(iter.Key()), "%d", &k)
+ if k < n {
+ badk++
+ continue
+ }
+ missed += k - n
+ n = k + 1
+ if !bytes.Equal(iter.Value(), tval(k, ctValSize)) {
+ badv++
+ } else {
+ good++
+ }
+ }
+ err := iter.Error()
+ iter.Release()
+ t.Logf("want=%d..%d got=%d badkeys=%d badvalues=%d missed=%d, err=%v",
+ min, max, good, badk, badv, missed, err)
+ if good < min || good > max {
+ t.Errorf("good entries number not in range")
+ }
+}
+
+func TestCorruptDB_Journal(t *testing.T) {
+ h := newDbCorruptHarness(t)
+
+ h.build(100)
+ h.check(100, 100)
+ h.closeDB()
+ h.corrupt(storage.TypeJournal, -1, 19, 1)
+ h.corrupt(storage.TypeJournal, -1, 32*1024+1000, 1)
+
+ h.openDB()
+ h.check(36, 36)
+
+ h.close()
+}
+
+func TestCorruptDB_Table(t *testing.T) {
+ h := newDbCorruptHarness(t)
+
+ h.build(100)
+ h.compactMem()
+ h.compactRangeAt(0, "", "")
+ h.compactRangeAt(1, "", "")
+ h.closeDB()
+ h.corrupt(storage.TypeTable, -1, 100, 1)
+
+ h.openDB()
+ h.check(99, 99)
+
+ h.close()
+}
+
+func TestCorruptDB_TableIndex(t *testing.T) {
+ h := newDbCorruptHarness(t)
+
+ h.build(10000)
+ h.compactMem()
+ h.closeDB()
+ h.corrupt(storage.TypeTable, -1, -2000, 500)
+
+ h.openDB()
+ h.check(5000, 9999)
+
+ h.close()
+}
+
+func TestCorruptDB_MissingManifest(t *testing.T) {
+ rnd := rand.New(rand.NewSource(0x0badda7a))
+ h := newDbCorruptHarnessWopt(t, &opt.Options{
+ BlockCacheCapacity: 100,
+ Strict: opt.StrictJournalChecksum,
+ WriteBuffer: 1000 * 60,
+ })
+
+ h.build(1000)
+ h.compactMem()
+ h.buildShuffled(1000, rnd)
+ h.compactMem()
+ h.deleteRand(500, 1000, rnd)
+ h.compactMem()
+ h.buildShuffled(1000, rnd)
+ h.compactMem()
+ h.deleteRand(500, 1000, rnd)
+ h.compactMem()
+ h.buildShuffled(1000, rnd)
+ h.compactMem()
+ h.closeDB()
+
+ h.stor.SetIgnoreOpenErr(storage.TypeManifest)
+ h.removeAll(storage.TypeManifest)
+ h.openAssert(false)
+ h.stor.SetIgnoreOpenErr(0)
+
+ h.recover()
+ h.check(1000, 1000)
+ h.build(1000)
+ h.compactMem()
+ h.compactRange("", "")
+ h.closeDB()
+
+ h.recover()
+ h.check(1000, 1000)
+
+ h.close()
+}
+
+func TestCorruptDB_SequenceNumberRecovery(t *testing.T) {
+ h := newDbCorruptHarness(t)
+
+ h.put("foo", "v1")
+ h.put("foo", "v2")
+ h.put("foo", "v3")
+ h.put("foo", "v4")
+ h.put("foo", "v5")
+ h.closeDB()
+
+ h.recover()
+ h.getVal("foo", "v5")
+ h.put("foo", "v6")
+ h.getVal("foo", "v6")
+
+ h.reopenDB()
+ h.getVal("foo", "v6")
+
+ h.close()
+}
+
+func TestCorruptDB_SequenceNumberRecoveryTable(t *testing.T) {
+ h := newDbCorruptHarness(t)
+
+ h.put("foo", "v1")
+ h.put("foo", "v2")
+ h.put("foo", "v3")
+ h.compactMem()
+ h.put("foo", "v4")
+ h.put("foo", "v5")
+ h.compactMem()
+ h.closeDB()
+
+ h.recover()
+ h.getVal("foo", "v5")
+ h.put("foo", "v6")
+ h.getVal("foo", "v6")
+
+ h.reopenDB()
+ h.getVal("foo", "v6")
+
+ h.close()
+}
+
+func TestCorruptDB_CorruptedManifest(t *testing.T) {
+ h := newDbCorruptHarness(t)
+
+ h.put("foo", "hello")
+ h.compactMem()
+ h.compactRange("", "")
+ h.closeDB()
+ h.corrupt(storage.TypeManifest, -1, 0, 1000)
+ h.openAssert(false)
+
+ h.recover()
+ h.getVal("foo", "hello")
+
+ h.close()
+}
+
+func TestCorruptDB_CompactionInputError(t *testing.T) {
+ h := newDbCorruptHarness(t)
+
+ h.build(10)
+ h.compactMem()
+ h.closeDB()
+ h.corrupt(storage.TypeTable, -1, 100, 1)
+
+ h.openDB()
+ h.check(9, 9)
+
+ h.build(10000)
+ h.check(10000, 10000)
+
+ h.close()
+}
+
+func TestCorruptDB_UnrelatedKeys(t *testing.T) {
+ h := newDbCorruptHarness(t)
+
+ h.build(10)
+ h.compactMem()
+ h.closeDB()
+ h.corrupt(storage.TypeTable, -1, 100, 1)
+
+ h.openDB()
+ h.put(string(tkey(1000)), string(tval(1000, ctValSize)))
+ h.getVal(string(tkey(1000)), string(tval(1000, ctValSize)))
+ h.compactMem()
+ h.getVal(string(tkey(1000)), string(tval(1000, ctValSize)))
+
+ h.close()
+}
+
+func TestCorruptDB_Level0NewerFileHasOlderSeqnum(t *testing.T) {
+ h := newDbCorruptHarness(t)
+
+ h.put("a", "v1")
+ h.put("b", "v1")
+ h.compactMem()
+ h.put("a", "v2")
+ h.put("b", "v2")
+ h.compactMem()
+ h.put("a", "v3")
+ h.put("b", "v3")
+ h.compactMem()
+ h.put("c", "v0")
+ h.put("d", "v0")
+ h.compactMem()
+ h.compactRangeAt(1, "", "")
+ h.closeDB()
+
+ h.recover()
+ h.getVal("a", "v3")
+ h.getVal("b", "v3")
+ h.getVal("c", "v0")
+ h.getVal("d", "v0")
+
+ h.close()
+}
+
+func TestCorruptDB_RecoverInvalidSeq_Issue53(t *testing.T) {
+ h := newDbCorruptHarness(t)
+
+ h.put("a", "v1")
+ h.put("b", "v1")
+ h.compactMem()
+ h.put("a", "v2")
+ h.put("b", "v2")
+ h.compactMem()
+ h.put("a", "v3")
+ h.put("b", "v3")
+ h.compactMem()
+ h.put("c", "v0")
+ h.put("d", "v0")
+ h.compactMem()
+ h.compactRangeAt(0, "", "")
+ h.closeDB()
+
+ h.recover()
+ h.getVal("a", "v3")
+ h.getVal("b", "v3")
+ h.getVal("c", "v0")
+ h.getVal("d", "v0")
+
+ h.close()
+}
+
+func TestCorruptDB_MissingTableFiles(t *testing.T) {
+ h := newDbCorruptHarness(t)
+
+ h.put("a", "v1")
+ h.put("b", "v1")
+ h.compactMem()
+ h.put("c", "v2")
+ h.put("d", "v2")
+ h.compactMem()
+ h.put("e", "v3")
+ h.put("f", "v3")
+ h.closeDB()
+
+ h.removeOne(storage.TypeTable)
+ h.openAssert(false)
+
+ h.close()
+}
+
+func TestCorruptDB_RecoverTable(t *testing.T) {
+ h := newDbCorruptHarnessWopt(t, &opt.Options{
+ WriteBuffer: 112 * opt.KiB,
+ CompactionTableSize: 90 * opt.KiB,
+ Filter: filter.NewBloomFilter(10),
+ })
+
+ h.build(1000)
+ h.compactMem()
+ h.compactRangeAt(0, "", "")
+ h.compactRangeAt(1, "", "")
+ seq := h.db.seq
+ h.closeDB()
+ h.corrupt(storage.TypeTable, 0, 1000, 1)
+ h.corrupt(storage.TypeTable, 3, 10000, 1)
+ // Corrupted filter shouldn't affect recovery.
+ h.corrupt(storage.TypeTable, 3, 113888, 10)
+ h.corrupt(storage.TypeTable, -1, 20000, 1)
+
+ h.recover()
+ if h.db.seq != seq {
+ t.Errorf("invalid seq, want=%d got=%d", seq, h.db.seq)
+ }
+ h.check(985, 985)
+
+ h.close()
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db.go
new file mode 100644
index 0000000000000000000000000000000000000000..365d311f6f0d408ff5da18ebf9dd0a803565dca3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db.go
@@ -0,0 +1,1068 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "container/list"
+ "fmt"
+ "io"
+ "os"
+ "runtime"
+ "strings"
+ "sync"
+ "sync/atomic"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/journal"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+// DB is a LevelDB database.
+type DB struct {
+ // Need 64-bit alignment.
+ seq uint64
+
+ // Session.
+ s *session
+
+ // MemDB.
+ memMu sync.RWMutex
+ memPool chan *memdb.DB
+ mem, frozenMem *memDB
+ journal *journal.Writer
+ journalWriter storage.Writer
+ journalFile storage.File
+ frozenJournalFile storage.File
+ frozenSeq uint64
+
+ // Snapshot.
+ snapsMu sync.Mutex
+ snapsList *list.List
+
+ // Stats.
+ aliveSnaps, aliveIters int32
+
+ // Write.
+ writeC chan *Batch
+ writeMergedC chan bool
+ writeLockC chan struct{}
+ writeAckC chan error
+ writeDelay time.Duration
+ writeDelayN int
+ journalC chan *Batch
+ journalAckC chan error
+
+ // Compaction.
+ tcompCmdC chan cCmd
+ tcompPauseC chan chan<- struct{}
+ mcompCmdC chan cCmd
+ compErrC chan error
+ compPerErrC chan error
+ compErrSetC chan error
+ compWriteLocking bool
+ compStats []cStats
+
+ // Close.
+ closeW sync.WaitGroup
+ closeC chan struct{}
+ closed uint32
+ closer io.Closer
+}
+
+func openDB(s *session) (*DB, error) {
+ s.log("db@open opening")
+ start := time.Now()
+ db := &DB{
+ s: s,
+ // Initial sequence
+ seq: s.stSeqNum,
+ // MemDB
+ memPool: make(chan *memdb.DB, 1),
+ // Snapshot
+ snapsList: list.New(),
+ // Write
+ writeC: make(chan *Batch),
+ writeMergedC: make(chan bool),
+ writeLockC: make(chan struct{}, 1),
+ writeAckC: make(chan error),
+ journalC: make(chan *Batch),
+ journalAckC: make(chan error),
+ // Compaction
+ tcompCmdC: make(chan cCmd),
+ tcompPauseC: make(chan chan<- struct{}),
+ mcompCmdC: make(chan cCmd),
+ compErrC: make(chan error),
+ compPerErrC: make(chan error),
+ compErrSetC: make(chan error),
+ compStats: make([]cStats, s.o.GetNumLevel()),
+ // Close
+ closeC: make(chan struct{}),
+ }
+
+ // Read-only mode.
+ readOnly := s.o.GetReadOnly()
+
+ if readOnly {
+ // Recover journals (read-only mode).
+ if err := db.recoverJournalRO(); err != nil {
+ return nil, err
+ }
+ } else {
+ // Recover journals.
+ if err := db.recoverJournal(); err != nil {
+ return nil, err
+ }
+
+ // Remove any obsolete files.
+ if err := db.checkAndCleanFiles(); err != nil {
+ // Close journal.
+ if db.journal != nil {
+ db.journal.Close()
+ db.journalWriter.Close()
+ }
+ return nil, err
+ }
+
+ }
+
+ // Doesn't need to be included in the wait group.
+ go db.compactionError()
+ go db.mpoolDrain()
+
+ if readOnly {
+ db.SetReadOnly()
+ } else {
+ db.closeW.Add(3)
+ go db.tCompaction()
+ go db.mCompaction()
+ go db.jWriter()
+ }
+
+ s.logf("db@open done T·%v", time.Since(start))
+
+ runtime.SetFinalizer(db, (*DB).Close)
+ return db, nil
+}
+
+// Open opens or creates a DB for the given storage.
+// The DB will be created if not exist, unless ErrorIfMissing is true.
+// Also, if ErrorIfExist is true and the DB exist Open will returns
+// os.ErrExist error.
+//
+// Open will return an error with type of ErrCorrupted if corruption
+// detected in the DB. Corrupted DB can be recovered with Recover
+// function.
+//
+// The returned DB instance is goroutine-safe.
+// The DB must be closed after use, by calling Close method.
+func Open(stor storage.Storage, o *opt.Options) (db *DB, err error) {
+ s, err := newSession(stor, o)
+ if err != nil {
+ return
+ }
+ defer func() {
+ if err != nil {
+ s.close()
+ s.release()
+ }
+ }()
+
+ err = s.recover()
+ if err != nil {
+ if !os.IsNotExist(err) || s.o.GetErrorIfMissing() {
+ return
+ }
+ err = s.create()
+ if err != nil {
+ return
+ }
+ } else if s.o.GetErrorIfExist() {
+ err = os.ErrExist
+ return
+ }
+
+ return openDB(s)
+}
+
+// OpenFile opens or creates a DB for the given path.
+// The DB will be created if not exist, unless ErrorIfMissing is true.
+// Also, if ErrorIfExist is true and the DB exist OpenFile will returns
+// os.ErrExist error.
+//
+// OpenFile uses standard file-system backed storage implementation as
+// desribed in the leveldb/storage package.
+//
+// OpenFile will return an error with type of ErrCorrupted if corruption
+// detected in the DB. Corrupted DB can be recovered with Recover
+// function.
+//
+// The returned DB instance is goroutine-safe.
+// The DB must be closed after use, by calling Close method.
+func OpenFile(path string, o *opt.Options) (db *DB, err error) {
+ stor, err := storage.OpenFile(path)
+ if err != nil {
+ return
+ }
+ db, err = Open(stor, o)
+ if err != nil {
+ stor.Close()
+ } else {
+ db.closer = stor
+ }
+ return
+}
+
+// Recover recovers and opens a DB with missing or corrupted manifest files
+// for the given storage. It will ignore any manifest files, valid or not.
+// The DB must already exist or it will returns an error.
+// Also, Recover will ignore ErrorIfMissing and ErrorIfExist options.
+//
+// The returned DB instance is goroutine-safe.
+// The DB must be closed after use, by calling Close method.
+func Recover(stor storage.Storage, o *opt.Options) (db *DB, err error) {
+ s, err := newSession(stor, o)
+ if err != nil {
+ return
+ }
+ defer func() {
+ if err != nil {
+ s.close()
+ s.release()
+ }
+ }()
+
+ err = recoverTable(s, o)
+ if err != nil {
+ return
+ }
+ return openDB(s)
+}
+
+// RecoverFile recovers and opens a DB with missing or corrupted manifest files
+// for the given path. It will ignore any manifest files, valid or not.
+// The DB must already exist or it will returns an error.
+// Also, Recover will ignore ErrorIfMissing and ErrorIfExist options.
+//
+// RecoverFile uses standard file-system backed storage implementation as desribed
+// in the leveldb/storage package.
+//
+// The returned DB instance is goroutine-safe.
+// The DB must be closed after use, by calling Close method.
+func RecoverFile(path string, o *opt.Options) (db *DB, err error) {
+ stor, err := storage.OpenFile(path)
+ if err != nil {
+ return
+ }
+ db, err = Recover(stor, o)
+ if err != nil {
+ stor.Close()
+ } else {
+ db.closer = stor
+ }
+ return
+}
+
+func recoverTable(s *session, o *opt.Options) error {
+ o = dupOptions(o)
+ // Mask StrictReader, lets StrictRecovery doing its job.
+ o.Strict &= ^opt.StrictReader
+
+ // Get all tables and sort it by file number.
+ tableFiles_, err := s.getFiles(storage.TypeTable)
+ if err != nil {
+ return err
+ }
+ tableFiles := files(tableFiles_)
+ tableFiles.sort()
+
+ var (
+ maxSeq uint64
+ recoveredKey, goodKey, corruptedKey, corruptedBlock, droppedTable int
+
+ // We will drop corrupted table.
+ strict = o.GetStrict(opt.StrictRecovery)
+
+ rec = &sessionRecord{}
+ bpool = util.NewBufferPool(o.GetBlockSize() + 5)
+ )
+ buildTable := func(iter iterator.Iterator) (tmp storage.File, size int64, err error) {
+ tmp = s.newTemp()
+ writer, err := tmp.Create()
+ if err != nil {
+ return
+ }
+ defer func() {
+ writer.Close()
+ if err != nil {
+ tmp.Remove()
+ tmp = nil
+ }
+ }()
+
+ // Copy entries.
+ tw := table.NewWriter(writer, o)
+ for iter.Next() {
+ key := iter.Key()
+ if validIkey(key) {
+ err = tw.Append(key, iter.Value())
+ if err != nil {
+ return
+ }
+ }
+ }
+ err = iter.Error()
+ if err != nil {
+ return
+ }
+ err = tw.Close()
+ if err != nil {
+ return
+ }
+ err = writer.Sync()
+ if err != nil {
+ return
+ }
+ size = int64(tw.BytesLen())
+ return
+ }
+ recoverTable := func(file storage.File) error {
+ s.logf("table@recovery recovering @%d", file.Num())
+ reader, err := file.Open()
+ if err != nil {
+ return err
+ }
+ var closed bool
+ defer func() {
+ if !closed {
+ reader.Close()
+ }
+ }()
+
+ // Get file size.
+ size, err := reader.Seek(0, 2)
+ if err != nil {
+ return err
+ }
+
+ var (
+ tSeq uint64
+ tgoodKey, tcorruptedKey, tcorruptedBlock int
+ imin, imax []byte
+ )
+ tr, err := table.NewReader(reader, size, storage.NewFileInfo(file), nil, bpool, o)
+ if err != nil {
+ return err
+ }
+ iter := tr.NewIterator(nil, nil)
+ if itererr, ok := iter.(iterator.ErrorCallbackSetter); ok {
+ itererr.SetErrorCallback(func(err error) {
+ if errors.IsCorrupted(err) {
+ s.logf("table@recovery block corruption @%d %q", file.Num(), err)
+ tcorruptedBlock++
+ }
+ })
+ }
+
+ // Scan the table.
+ for iter.Next() {
+ key := iter.Key()
+ _, seq, _, kerr := parseIkey(key)
+ if kerr != nil {
+ tcorruptedKey++
+ continue
+ }
+ tgoodKey++
+ if seq > tSeq {
+ tSeq = seq
+ }
+ if imin == nil {
+ imin = append([]byte{}, key...)
+ }
+ imax = append(imax[:0], key...)
+ }
+ if err := iter.Error(); err != nil {
+ iter.Release()
+ return err
+ }
+ iter.Release()
+
+ goodKey += tgoodKey
+ corruptedKey += tcorruptedKey
+ corruptedBlock += tcorruptedBlock
+
+ if strict && (tcorruptedKey > 0 || tcorruptedBlock > 0) {
+ droppedTable++
+ s.logf("table@recovery dropped @%d Gk·%d Ck·%d Cb·%d S·%d Q·%d", file.Num(), tgoodKey, tcorruptedKey, tcorruptedBlock, size, tSeq)
+ return nil
+ }
+
+ if tgoodKey > 0 {
+ if tcorruptedKey > 0 || tcorruptedBlock > 0 {
+ // Rebuild the table.
+ s.logf("table@recovery rebuilding @%d", file.Num())
+ iter := tr.NewIterator(nil, nil)
+ tmp, newSize, err := buildTable(iter)
+ iter.Release()
+ if err != nil {
+ return err
+ }
+ closed = true
+ reader.Close()
+ if err := file.Replace(tmp); err != nil {
+ return err
+ }
+ size = newSize
+ }
+ if tSeq > maxSeq {
+ maxSeq = tSeq
+ }
+ recoveredKey += tgoodKey
+ // Add table to level 0.
+ rec.addTable(0, file.Num(), uint64(size), imin, imax)
+ s.logf("table@recovery recovered @%d Gk·%d Ck·%d Cb·%d S·%d Q·%d", file.Num(), tgoodKey, tcorruptedKey, tcorruptedBlock, size, tSeq)
+ } else {
+ droppedTable++
+ s.logf("table@recovery unrecoverable @%d Ck·%d Cb·%d S·%d", file.Num(), tcorruptedKey, tcorruptedBlock, size)
+ }
+
+ return nil
+ }
+
+ // Recover all tables.
+ if len(tableFiles) > 0 {
+ s.logf("table@recovery F·%d", len(tableFiles))
+
+ // Mark file number as used.
+ s.markFileNum(tableFiles[len(tableFiles)-1].Num())
+
+ for _, file := range tableFiles {
+ if err := recoverTable(file); err != nil {
+ return err
+ }
+ }
+
+ s.logf("table@recovery recovered F·%d N·%d Gk·%d Ck·%d Q·%d", len(tableFiles), recoveredKey, goodKey, corruptedKey, maxSeq)
+ }
+
+ // Set sequence number.
+ rec.setSeqNum(maxSeq)
+
+ // Create new manifest.
+ if err := s.create(); err != nil {
+ return err
+ }
+
+ // Commit.
+ return s.commit(rec)
+}
+
+func (db *DB) recoverJournal() error {
+ // Get all journals and sort it by file number.
+ allJournalFiles, err := db.s.getFiles(storage.TypeJournal)
+ if err != nil {
+ return err
+ }
+ files(allJournalFiles).sort()
+
+ // Journals that will be recovered.
+ var recJournalFiles []storage.File
+ for _, jf := range allJournalFiles {
+ if jf.Num() >= db.s.stJournalNum || jf.Num() == db.s.stPrevJournalNum {
+ recJournalFiles = append(recJournalFiles, jf)
+ }
+ }
+
+ var (
+ of storage.File // Obsolete file.
+ rec = &sessionRecord{}
+ )
+
+ // Recover journals.
+ if len(recJournalFiles) > 0 {
+ db.logf("journal@recovery F·%d", len(recJournalFiles))
+
+ // Mark file number as used.
+ db.s.markFileNum(recJournalFiles[len(recJournalFiles)-1].Num())
+
+ var (
+ // Options.
+ strict = db.s.o.GetStrict(opt.StrictJournal)
+ checksum = db.s.o.GetStrict(opt.StrictJournalChecksum)
+ writeBuffer = db.s.o.GetWriteBuffer()
+
+ jr *journal.Reader
+ mdb = memdb.New(db.s.icmp, writeBuffer)
+ buf = &util.Buffer{}
+ batch = &Batch{}
+ )
+
+ for _, jf := range recJournalFiles {
+ db.logf("journal@recovery recovering @%d", jf.Num())
+
+ fr, err := jf.Open()
+ if err != nil {
+ return err
+ }
+
+ // Create or reset journal reader instance.
+ if jr == nil {
+ jr = journal.NewReader(fr, dropper{db.s, jf}, strict, checksum)
+ } else {
+ jr.Reset(fr, dropper{db.s, jf}, strict, checksum)
+ }
+
+ // Flush memdb and remove obsolete journal file.
+ if of != nil {
+ if mdb.Len() > 0 {
+ if _, err := db.s.flushMemdb(rec, mdb, -1); err != nil {
+ fr.Close()
+ return err
+ }
+ }
+
+ rec.setJournalNum(jf.Num())
+ rec.setSeqNum(db.seq)
+ if err := db.s.commit(rec); err != nil {
+ fr.Close()
+ return err
+ }
+ rec.resetAddedTables()
+
+ of.Remove()
+ of = nil
+ }
+
+ // Replay journal to memdb.
+ mdb.Reset()
+ for {
+ r, err := jr.Next()
+ if err != nil {
+ if err == io.EOF {
+ break
+ }
+
+ fr.Close()
+ return errors.SetFile(err, jf)
+ }
+
+ buf.Reset()
+ if _, err := buf.ReadFrom(r); err != nil {
+ if err == io.ErrUnexpectedEOF {
+ // This is error returned due to corruption, with strict == false.
+ continue
+ }
+
+ fr.Close()
+ return errors.SetFile(err, jf)
+ }
+ if err := batch.memDecodeAndReplay(db.seq, buf.Bytes(), mdb); err != nil {
+ if !strict && errors.IsCorrupted(err) {
+ db.s.logf("journal error: %v (skipped)", err)
+ // We won't apply sequence number as it might be corrupted.
+ continue
+ }
+
+ fr.Close()
+ return errors.SetFile(err, jf)
+ }
+
+ // Save sequence number.
+ db.seq = batch.seq + uint64(batch.Len())
+
+ // Flush it if large enough.
+ if mdb.Size() >= writeBuffer {
+ if _, err := db.s.flushMemdb(rec, mdb, 0); err != nil {
+ fr.Close()
+ return err
+ }
+
+ mdb.Reset()
+ }
+ }
+
+ fr.Close()
+ of = jf
+ }
+
+ // Flush the last memdb.
+ if mdb.Len() > 0 {
+ if _, err := db.s.flushMemdb(rec, mdb, 0); err != nil {
+ return err
+ }
+ }
+ }
+
+ // Create a new journal.
+ if _, err := db.newMem(0); err != nil {
+ return err
+ }
+
+ // Commit.
+ rec.setJournalNum(db.journalFile.Num())
+ rec.setSeqNum(db.seq)
+ if err := db.s.commit(rec); err != nil {
+ // Close journal on error.
+ if db.journal != nil {
+ db.journal.Close()
+ db.journalWriter.Close()
+ }
+ return err
+ }
+
+ // Remove the last obsolete journal file.
+ if of != nil {
+ of.Remove()
+ }
+
+ return nil
+}
+
+func (db *DB) recoverJournalRO() error {
+ // Get all journals and sort it by file number.
+ allJournalFiles, err := db.s.getFiles(storage.TypeJournal)
+ if err != nil {
+ return err
+ }
+ files(allJournalFiles).sort()
+
+ // Journals that will be recovered.
+ var recJournalFiles []storage.File
+ for _, jf := range allJournalFiles {
+ if jf.Num() >= db.s.stJournalNum || jf.Num() == db.s.stPrevJournalNum {
+ recJournalFiles = append(recJournalFiles, jf)
+ }
+ }
+
+ var (
+ // Options.
+ strict = db.s.o.GetStrict(opt.StrictJournal)
+ checksum = db.s.o.GetStrict(opt.StrictJournalChecksum)
+ writeBuffer = db.s.o.GetWriteBuffer()
+
+ mdb = memdb.New(db.s.icmp, writeBuffer)
+ )
+
+ // Recover journals.
+ if len(recJournalFiles) > 0 {
+ db.logf("journal@recovery RO·Mode F·%d", len(recJournalFiles))
+
+ var (
+ jr *journal.Reader
+ buf = &util.Buffer{}
+ batch = &Batch{}
+ )
+
+ for _, jf := range recJournalFiles {
+ db.logf("journal@recovery recovering @%d", jf.Num())
+
+ fr, err := jf.Open()
+ if err != nil {
+ return err
+ }
+
+ // Create or reset journal reader instance.
+ if jr == nil {
+ jr = journal.NewReader(fr, dropper{db.s, jf}, strict, checksum)
+ } else {
+ jr.Reset(fr, dropper{db.s, jf}, strict, checksum)
+ }
+
+ // Replay journal to memdb.
+ for {
+ r, err := jr.Next()
+ if err != nil {
+ if err == io.EOF {
+ break
+ }
+
+ fr.Close()
+ return errors.SetFile(err, jf)
+ }
+
+ buf.Reset()
+ if _, err := buf.ReadFrom(r); err != nil {
+ if err == io.ErrUnexpectedEOF {
+ // This is error returned due to corruption, with strict == false.
+ continue
+ }
+
+ fr.Close()
+ return errors.SetFile(err, jf)
+ }
+ if err := batch.memDecodeAndReplay(db.seq, buf.Bytes(), mdb); err != nil {
+ if !strict && errors.IsCorrupted(err) {
+ db.s.logf("journal error: %v (skipped)", err)
+ // We won't apply sequence number as it might be corrupted.
+ continue
+ }
+
+ fr.Close()
+ return errors.SetFile(err, jf)
+ }
+
+ // Save sequence number.
+ db.seq = batch.seq + uint64(batch.Len())
+ }
+
+ fr.Close()
+ }
+ }
+
+ // Set memDB.
+ db.mem = &memDB{db: db, DB: mdb, ref: 1}
+
+ return nil
+}
+
+func (db *DB) get(key []byte, seq uint64, ro *opt.ReadOptions) (value []byte, err error) {
+ ikey := newIkey(key, seq, ktSeek)
+
+ em, fm := db.getMems()
+ for _, m := range [...]*memDB{em, fm} {
+ if m == nil {
+ continue
+ }
+ defer m.decref()
+
+ mk, mv, me := m.Find(ikey)
+ if me == nil {
+ ukey, _, kt, kerr := parseIkey(mk)
+ if kerr != nil {
+ // Shouldn't have had happen.
+ panic(kerr)
+ }
+ if db.s.icmp.uCompare(ukey, key) == 0 {
+ if kt == ktDel {
+ return nil, ErrNotFound
+ }
+ return append([]byte{}, mv...), nil
+ }
+ } else if me != ErrNotFound {
+ return nil, me
+ }
+ }
+
+ v := db.s.version()
+ value, cSched, err := v.get(ikey, ro, false)
+ v.release()
+ if cSched {
+ // Trigger table compaction.
+ db.compSendTrigger(db.tcompCmdC)
+ }
+ return
+}
+
+func (db *DB) has(key []byte, seq uint64, ro *opt.ReadOptions) (ret bool, err error) {
+ ikey := newIkey(key, seq, ktSeek)
+
+ em, fm := db.getMems()
+ for _, m := range [...]*memDB{em, fm} {
+ if m == nil {
+ continue
+ }
+ defer m.decref()
+
+ mk, _, me := m.Find(ikey)
+ if me == nil {
+ ukey, _, kt, kerr := parseIkey(mk)
+ if kerr != nil {
+ // Shouldn't have had happen.
+ panic(kerr)
+ }
+ if db.s.icmp.uCompare(ukey, key) == 0 {
+ if kt == ktDel {
+ return false, nil
+ }
+ return true, nil
+ }
+ } else if me != ErrNotFound {
+ return false, me
+ }
+ }
+
+ v := db.s.version()
+ _, cSched, err := v.get(ikey, ro, true)
+ v.release()
+ if cSched {
+ // Trigger table compaction.
+ db.compSendTrigger(db.tcompCmdC)
+ }
+ if err == nil {
+ ret = true
+ } else if err == ErrNotFound {
+ err = nil
+ }
+ return
+}
+
+// Get gets the value for the given key. It returns ErrNotFound if the
+// DB does not contains the key.
+//
+// The returned slice is its own copy, it is safe to modify the contents
+// of the returned slice.
+// It is safe to modify the contents of the argument after Get returns.
+func (db *DB) Get(key []byte, ro *opt.ReadOptions) (value []byte, err error) {
+ err = db.ok()
+ if err != nil {
+ return
+ }
+
+ se := db.acquireSnapshot()
+ defer db.releaseSnapshot(se)
+ return db.get(key, se.seq, ro)
+}
+
+// Has returns true if the DB does contains the given key.
+//
+// It is safe to modify the contents of the argument after Get returns.
+func (db *DB) Has(key []byte, ro *opt.ReadOptions) (ret bool, err error) {
+ err = db.ok()
+ if err != nil {
+ return
+ }
+
+ se := db.acquireSnapshot()
+ defer db.releaseSnapshot(se)
+ return db.has(key, se.seq, ro)
+}
+
+// NewIterator returns an iterator for the latest snapshot of the
+// uderlying DB.
+// The returned iterator is not goroutine-safe, but it is safe to use
+// multiple iterators concurrently, with each in a dedicated goroutine.
+// It is also safe to use an iterator concurrently with modifying its
+// underlying DB. The resultant key/value pairs are guaranteed to be
+// consistent.
+//
+// Slice allows slicing the iterator to only contains keys in the given
+// range. A nil Range.Start is treated as a key before all keys in the
+// DB. And a nil Range.Limit is treated as a key after all keys in
+// the DB.
+//
+// The iterator must be released after use, by calling Release method.
+//
+// Also read Iterator documentation of the leveldb/iterator package.
+func (db *DB) NewIterator(slice *util.Range, ro *opt.ReadOptions) iterator.Iterator {
+ if err := db.ok(); err != nil {
+ return iterator.NewEmptyIterator(err)
+ }
+
+ se := db.acquireSnapshot()
+ defer db.releaseSnapshot(se)
+ // Iterator holds 'version' lock, 'version' is immutable so snapshot
+ // can be released after iterator created.
+ return db.newIterator(se.seq, slice, ro)
+}
+
+// GetSnapshot returns a latest snapshot of the underlying DB. A snapshot
+// is a frozen snapshot of a DB state at a particular point in time. The
+// content of snapshot are guaranteed to be consistent.
+//
+// The snapshot must be released after use, by calling Release method.
+func (db *DB) GetSnapshot() (*Snapshot, error) {
+ if err := db.ok(); err != nil {
+ return nil, err
+ }
+
+ return db.newSnapshot(), nil
+}
+
+// GetProperty returns value of the given property name.
+//
+// Property names:
+// leveldb.num-files-at-level{n}
+// Returns the number of files at level 'n'.
+// leveldb.stats
+// Returns statistics of the underlying DB.
+// leveldb.sstables
+// Returns sstables list for each level.
+// leveldb.blockpool
+// Returns block pool stats.
+// leveldb.cachedblock
+// Returns size of cached block.
+// leveldb.openedtables
+// Returns number of opened tables.
+// leveldb.alivesnaps
+// Returns number of alive snapshots.
+// leveldb.aliveiters
+// Returns number of alive iterators.
+func (db *DB) GetProperty(name string) (value string, err error) {
+ err = db.ok()
+ if err != nil {
+ return
+ }
+
+ const prefix = "leveldb."
+ if !strings.HasPrefix(name, prefix) {
+ return "", ErrNotFound
+ }
+ p := name[len(prefix):]
+
+ v := db.s.version()
+ defer v.release()
+
+ numFilesPrefix := "num-files-at-level"
+ switch {
+ case strings.HasPrefix(p, numFilesPrefix):
+ var level uint
+ var rest string
+ n, _ := fmt.Sscanf(p[len(numFilesPrefix):], "%d%s", &level, &rest)
+ if n != 1 || int(level) >= db.s.o.GetNumLevel() {
+ err = ErrNotFound
+ } else {
+ value = fmt.Sprint(v.tLen(int(level)))
+ }
+ case p == "stats":
+ value = "Compactions\n" +
+ " Level | Tables | Size(MB) | Time(sec) | Read(MB) | Write(MB)\n" +
+ "-------+------------+---------------+---------------+---------------+---------------\n"
+ for level, tables := range v.tables {
+ duration, read, write := db.compStats[level].get()
+ if len(tables) == 0 && duration == 0 {
+ continue
+ }
+ value += fmt.Sprintf(" %3d | %10d | %13.5f | %13.5f | %13.5f | %13.5f\n",
+ level, len(tables), float64(tables.size())/1048576.0, duration.Seconds(),
+ float64(read)/1048576.0, float64(write)/1048576.0)
+ }
+ case p == "sstables":
+ for level, tables := range v.tables {
+ value += fmt.Sprintf("--- level %d ---\n", level)
+ for _, t := range tables {
+ value += fmt.Sprintf("%d:%d[%q .. %q]\n", t.file.Num(), t.size, t.imin, t.imax)
+ }
+ }
+ case p == "blockpool":
+ value = fmt.Sprintf("%v", db.s.tops.bpool)
+ case p == "cachedblock":
+ if db.s.tops.bcache != nil {
+ value = fmt.Sprintf("%d", db.s.tops.bcache.Size())
+ } else {
+ value = "<nil>"
+ }
+ case p == "openedtables":
+ value = fmt.Sprintf("%d", db.s.tops.cache.Size())
+ case p == "alivesnaps":
+ value = fmt.Sprintf("%d", atomic.LoadInt32(&db.aliveSnaps))
+ case p == "aliveiters":
+ value = fmt.Sprintf("%d", atomic.LoadInt32(&db.aliveIters))
+ default:
+ err = ErrNotFound
+ }
+
+ return
+}
+
+// SizeOf calculates approximate sizes of the given key ranges.
+// The length of the returned sizes are equal with the length of the given
+// ranges. The returned sizes measure storage space usage, so if the user
+// data compresses by a factor of ten, the returned sizes will be one-tenth
+// the size of the corresponding user data size.
+// The results may not include the sizes of recently written data.
+func (db *DB) SizeOf(ranges []util.Range) (Sizes, error) {
+ if err := db.ok(); err != nil {
+ return nil, err
+ }
+
+ v := db.s.version()
+ defer v.release()
+
+ sizes := make(Sizes, 0, len(ranges))
+ for _, r := range ranges {
+ imin := newIkey(r.Start, kMaxSeq, ktSeek)
+ imax := newIkey(r.Limit, kMaxSeq, ktSeek)
+ start, err := v.offsetOf(imin)
+ if err != nil {
+ return nil, err
+ }
+ limit, err := v.offsetOf(imax)
+ if err != nil {
+ return nil, err
+ }
+ var size uint64
+ if limit >= start {
+ size = limit - start
+ }
+ sizes = append(sizes, size)
+ }
+
+ return sizes, nil
+}
+
+// Close closes the DB. This will also releases any outstanding snapshot and
+// abort any in-flight compaction.
+//
+// It is not safe to close a DB until all outstanding iterators are released.
+// It is valid to call Close multiple times. Other methods should not be
+// called after the DB has been closed.
+func (db *DB) Close() error {
+ if !db.setClosed() {
+ return ErrClosed
+ }
+
+ start := time.Now()
+ db.log("db@close closing")
+
+ // Clear the finalizer.
+ runtime.SetFinalizer(db, nil)
+
+ // Get compaction error.
+ var err error
+ select {
+ case err = <-db.compErrC:
+ if err == ErrReadOnly {
+ err = nil
+ }
+ default:
+ }
+
+ // Signal all goroutines.
+ close(db.closeC)
+
+ // Wait for all gorotines to exit.
+ db.closeW.Wait()
+
+ // Lock writer and closes journal.
+ db.writeLockC <- struct{}{}
+ if db.journal != nil {
+ db.journal.Close()
+ db.journalWriter.Close()
+ }
+
+ if db.writeDelayN > 0 {
+ db.logf("db@write was delayed N·%d T·%v", db.writeDelayN, db.writeDelay)
+ }
+
+ // Close session.
+ db.s.close()
+ db.logf("db@close done T·%v", time.Since(start))
+ db.s.release()
+
+ if db.closer != nil {
+ if err1 := db.closer.Close(); err == nil {
+ err = err1
+ }
+ }
+
+ // NIL'ing pointers.
+ db.s = nil
+ db.mem = nil
+ db.frozenMem = nil
+ db.journal = nil
+ db.journalWriter = nil
+ db.journalFile = nil
+ db.frozenJournalFile = nil
+ db.closer = nil
+
+ return err
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_compaction.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_compaction.go
new file mode 100644
index 0000000000000000000000000000000000000000..2c2f409322e134a286f0d01edb1e98b697e92837
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_compaction.go
@@ -0,0 +1,791 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "sync"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+)
+
+var (
+ errCompactionTransactExiting = errors.New("leveldb: compaction transact exiting")
+)
+
+type cStats struct {
+ sync.Mutex
+ duration time.Duration
+ read uint64
+ write uint64
+}
+
+func (p *cStats) add(n *cStatsStaging) {
+ p.Lock()
+ p.duration += n.duration
+ p.read += n.read
+ p.write += n.write
+ p.Unlock()
+}
+
+func (p *cStats) get() (duration time.Duration, read, write uint64) {
+ p.Lock()
+ defer p.Unlock()
+ return p.duration, p.read, p.write
+}
+
+type cStatsStaging struct {
+ start time.Time
+ duration time.Duration
+ on bool
+ read uint64
+ write uint64
+}
+
+func (p *cStatsStaging) startTimer() {
+ if !p.on {
+ p.start = time.Now()
+ p.on = true
+ }
+}
+
+func (p *cStatsStaging) stopTimer() {
+ if p.on {
+ p.duration += time.Since(p.start)
+ p.on = false
+ }
+}
+
+func (db *DB) compactionError() {
+ var err error
+noerr:
+ // No error.
+ for {
+ select {
+ case err = <-db.compErrSetC:
+ switch {
+ case err == nil:
+ case err == ErrReadOnly, errors.IsCorrupted(err):
+ goto hasperr
+ default:
+ goto haserr
+ }
+ case _, _ = <-db.closeC:
+ return
+ }
+ }
+haserr:
+ // Transient error.
+ for {
+ select {
+ case db.compErrC <- err:
+ case err = <-db.compErrSetC:
+ switch {
+ case err == nil:
+ goto noerr
+ case err == ErrReadOnly, errors.IsCorrupted(err):
+ goto hasperr
+ default:
+ }
+ case _, _ = <-db.closeC:
+ return
+ }
+ }
+hasperr:
+ // Persistent error.
+ for {
+ select {
+ case db.compErrC <- err:
+ case db.compPerErrC <- err:
+ case db.writeLockC <- struct{}{}:
+ // Hold write lock, so that write won't pass-through.
+ db.compWriteLocking = true
+ case _, _ = <-db.closeC:
+ if db.compWriteLocking {
+ // We should release the lock or Close will hang.
+ <-db.writeLockC
+ }
+ return
+ }
+ }
+}
+
+type compactionTransactCounter int
+
+func (cnt *compactionTransactCounter) incr() {
+ *cnt++
+}
+
+type compactionTransactInterface interface {
+ run(cnt *compactionTransactCounter) error
+ revert() error
+}
+
+func (db *DB) compactionTransact(name string, t compactionTransactInterface) {
+ defer func() {
+ if x := recover(); x != nil {
+ if x == errCompactionTransactExiting {
+ if err := t.revert(); err != nil {
+ db.logf("%s revert error %q", name, err)
+ }
+ }
+ panic(x)
+ }
+ }()
+
+ const (
+ backoffMin = 1 * time.Second
+ backoffMax = 8 * time.Second
+ backoffMul = 2 * time.Second
+ )
+ var (
+ backoff = backoffMin
+ backoffT = time.NewTimer(backoff)
+ lastCnt = compactionTransactCounter(0)
+
+ disableBackoff = db.s.o.GetDisableCompactionBackoff()
+ )
+ for n := 0; ; n++ {
+ // Check wether the DB is closed.
+ if db.isClosed() {
+ db.logf("%s exiting", name)
+ db.compactionExitTransact()
+ } else if n > 0 {
+ db.logf("%s retrying N·%d", name, n)
+ }
+
+ // Execute.
+ cnt := compactionTransactCounter(0)
+ err := t.run(&cnt)
+ if err != nil {
+ db.logf("%s error I·%d %q", name, cnt, err)
+ }
+
+ // Set compaction error status.
+ select {
+ case db.compErrSetC <- err:
+ case perr := <-db.compPerErrC:
+ if err != nil {
+ db.logf("%s exiting (persistent error %q)", name, perr)
+ db.compactionExitTransact()
+ }
+ case _, _ = <-db.closeC:
+ db.logf("%s exiting", name)
+ db.compactionExitTransact()
+ }
+ if err == nil {
+ return
+ }
+ if errors.IsCorrupted(err) {
+ db.logf("%s exiting (corruption detected)", name)
+ db.compactionExitTransact()
+ }
+
+ if !disableBackoff {
+ // Reset backoff duration if counter is advancing.
+ if cnt > lastCnt {
+ backoff = backoffMin
+ lastCnt = cnt
+ }
+
+ // Backoff.
+ backoffT.Reset(backoff)
+ if backoff < backoffMax {
+ backoff *= backoffMul
+ if backoff > backoffMax {
+ backoff = backoffMax
+ }
+ }
+ select {
+ case <-backoffT.C:
+ case _, _ = <-db.closeC:
+ db.logf("%s exiting", name)
+ db.compactionExitTransact()
+ }
+ }
+ }
+}
+
+type compactionTransactFunc struct {
+ runFunc func(cnt *compactionTransactCounter) error
+ revertFunc func() error
+}
+
+func (t *compactionTransactFunc) run(cnt *compactionTransactCounter) error {
+ return t.runFunc(cnt)
+}
+
+func (t *compactionTransactFunc) revert() error {
+ if t.revertFunc != nil {
+ return t.revertFunc()
+ }
+ return nil
+}
+
+func (db *DB) compactionTransactFunc(name string, run func(cnt *compactionTransactCounter) error, revert func() error) {
+ db.compactionTransact(name, &compactionTransactFunc{run, revert})
+}
+
+func (db *DB) compactionExitTransact() {
+ panic(errCompactionTransactExiting)
+}
+
+func (db *DB) memCompaction() {
+ mdb := db.getFrozenMem()
+ if mdb == nil {
+ return
+ }
+ defer mdb.decref()
+
+ db.logf("memdb@flush N·%d S·%s", mdb.Len(), shortenb(mdb.Size()))
+
+ // Don't compact empty memdb.
+ if mdb.Len() == 0 {
+ db.logf("memdb@flush skipping")
+ // drop frozen memdb
+ db.dropFrozenMem()
+ return
+ }
+
+ // Pause table compaction.
+ resumeC := make(chan struct{})
+ select {
+ case db.tcompPauseC <- (chan<- struct{})(resumeC):
+ case <-db.compPerErrC:
+ close(resumeC)
+ resumeC = nil
+ case _, _ = <-db.closeC:
+ return
+ }
+
+ var (
+ rec = &sessionRecord{}
+ stats = &cStatsStaging{}
+ flushLevel int
+ )
+
+ db.compactionTransactFunc("memdb@flush", func(cnt *compactionTransactCounter) (err error) {
+ stats.startTimer()
+ flushLevel, err = db.s.flushMemdb(rec, mdb.DB, -1)
+ stats.stopTimer()
+ return
+ }, func() error {
+ for _, r := range rec.addedTables {
+ db.logf("memdb@flush revert @%d", r.num)
+ f := db.s.getTableFile(r.num)
+ if err := f.Remove(); err != nil {
+ return err
+ }
+ }
+ return nil
+ })
+
+ db.compactionTransactFunc("memdb@commit", func(cnt *compactionTransactCounter) (err error) {
+ stats.startTimer()
+ rec.setJournalNum(db.journalFile.Num())
+ rec.setSeqNum(db.frozenSeq)
+ err = db.s.commit(rec)
+ stats.stopTimer()
+ return
+ }, nil)
+
+ db.logf("memdb@flush committed F·%d T·%v", len(rec.addedTables), stats.duration)
+
+ for _, r := range rec.addedTables {
+ stats.write += r.size
+ }
+ db.compStats[flushLevel].add(stats)
+
+ // Drop frozen memdb.
+ db.dropFrozenMem()
+
+ // Resume table compaction.
+ if resumeC != nil {
+ select {
+ case <-resumeC:
+ close(resumeC)
+ case _, _ = <-db.closeC:
+ return
+ }
+ }
+
+ // Trigger table compaction.
+ db.compSendTrigger(db.tcompCmdC)
+}
+
+type tableCompactionBuilder struct {
+ db *DB
+ s *session
+ c *compaction
+ rec *sessionRecord
+ stat0, stat1 *cStatsStaging
+
+ snapHasLastUkey bool
+ snapLastUkey []byte
+ snapLastSeq uint64
+ snapIter int
+ snapKerrCnt int
+ snapDropCnt int
+
+ kerrCnt int
+ dropCnt int
+
+ minSeq uint64
+ strict bool
+ tableSize int
+
+ tw *tWriter
+}
+
+func (b *tableCompactionBuilder) appendKV(key, value []byte) error {
+ // Create new table if not already.
+ if b.tw == nil {
+ // Check for pause event.
+ if b.db != nil {
+ select {
+ case ch := <-b.db.tcompPauseC:
+ b.db.pauseCompaction(ch)
+ case _, _ = <-b.db.closeC:
+ b.db.compactionExitTransact()
+ default:
+ }
+ }
+
+ // Create new table.
+ var err error
+ b.tw, err = b.s.tops.create()
+ if err != nil {
+ return err
+ }
+ }
+
+ // Write key/value into table.
+ return b.tw.append(key, value)
+}
+
+func (b *tableCompactionBuilder) needFlush() bool {
+ return b.tw.tw.BytesLen() >= b.tableSize
+}
+
+func (b *tableCompactionBuilder) flush() error {
+ t, err := b.tw.finish()
+ if err != nil {
+ return err
+ }
+ b.rec.addTableFile(b.c.level+1, t)
+ b.stat1.write += t.size
+ b.s.logf("table@build created L%d@%d N·%d S·%s %q:%q", b.c.level+1, t.file.Num(), b.tw.tw.EntriesLen(), shortenb(int(t.size)), t.imin, t.imax)
+ b.tw = nil
+ return nil
+}
+
+func (b *tableCompactionBuilder) cleanup() {
+ if b.tw != nil {
+ b.tw.drop()
+ b.tw = nil
+ }
+}
+
+func (b *tableCompactionBuilder) run(cnt *compactionTransactCounter) error {
+ snapResumed := b.snapIter > 0
+ hasLastUkey := b.snapHasLastUkey // The key might has zero length, so this is necessary.
+ lastUkey := append([]byte{}, b.snapLastUkey...)
+ lastSeq := b.snapLastSeq
+ b.kerrCnt = b.snapKerrCnt
+ b.dropCnt = b.snapDropCnt
+ // Restore compaction state.
+ b.c.restore()
+
+ defer b.cleanup()
+
+ b.stat1.startTimer()
+ defer b.stat1.stopTimer()
+
+ iter := b.c.newIterator()
+ defer iter.Release()
+ for i := 0; iter.Next(); i++ {
+ // Incr transact counter.
+ cnt.incr()
+
+ // Skip until last state.
+ if i < b.snapIter {
+ continue
+ }
+
+ resumed := false
+ if snapResumed {
+ resumed = true
+ snapResumed = false
+ }
+
+ ikey := iter.Key()
+ ukey, seq, kt, kerr := parseIkey(ikey)
+
+ if kerr == nil {
+ shouldStop := !resumed && b.c.shouldStopBefore(ikey)
+
+ if !hasLastUkey || b.s.icmp.uCompare(lastUkey, ukey) != 0 {
+ // First occurrence of this user key.
+
+ // Only rotate tables if ukey doesn't hop across.
+ if b.tw != nil && (shouldStop || b.needFlush()) {
+ if err := b.flush(); err != nil {
+ return err
+ }
+
+ // Creates snapshot of the state.
+ b.c.save()
+ b.snapHasLastUkey = hasLastUkey
+ b.snapLastUkey = append(b.snapLastUkey[:0], lastUkey...)
+ b.snapLastSeq = lastSeq
+ b.snapIter = i
+ b.snapKerrCnt = b.kerrCnt
+ b.snapDropCnt = b.dropCnt
+ }
+
+ hasLastUkey = true
+ lastUkey = append(lastUkey[:0], ukey...)
+ lastSeq = kMaxSeq
+ }
+
+ switch {
+ case lastSeq <= b.minSeq:
+ // Dropped because newer entry for same user key exist
+ fallthrough // (A)
+ case kt == ktDel && seq <= b.minSeq && b.c.baseLevelForKey(lastUkey):
+ // For this user key:
+ // (1) there is no data in higher levels
+ // (2) data in lower levels will have larger seq numbers
+ // (3) data in layers that are being compacted here and have
+ // smaller seq numbers will be dropped in the next
+ // few iterations of this loop (by rule (A) above).
+ // Therefore this deletion marker is obsolete and can be dropped.
+ lastSeq = seq
+ b.dropCnt++
+ continue
+ default:
+ lastSeq = seq
+ }
+ } else {
+ if b.strict {
+ return kerr
+ }
+
+ // Don't drop corrupted keys.
+ hasLastUkey = false
+ lastUkey = lastUkey[:0]
+ lastSeq = kMaxSeq
+ b.kerrCnt++
+ }
+
+ if err := b.appendKV(ikey, iter.Value()); err != nil {
+ return err
+ }
+ }
+
+ if err := iter.Error(); err != nil {
+ return err
+ }
+
+ // Finish last table.
+ if b.tw != nil && !b.tw.empty() {
+ return b.flush()
+ }
+ return nil
+}
+
+func (b *tableCompactionBuilder) revert() error {
+ for _, at := range b.rec.addedTables {
+ b.s.logf("table@build revert @%d", at.num)
+ f := b.s.getTableFile(at.num)
+ if err := f.Remove(); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func (db *DB) tableCompaction(c *compaction, noTrivial bool) {
+ defer c.release()
+
+ rec := &sessionRecord{}
+ rec.addCompPtr(c.level, c.imax)
+
+ if !noTrivial && c.trivial() {
+ t := c.tables[0][0]
+ db.logf("table@move L%d@%d -> L%d", c.level, t.file.Num(), c.level+1)
+ rec.delTable(c.level, t.file.Num())
+ rec.addTableFile(c.level+1, t)
+ db.compactionTransactFunc("table@move", func(cnt *compactionTransactCounter) (err error) {
+ return db.s.commit(rec)
+ }, nil)
+ return
+ }
+
+ var stats [2]cStatsStaging
+ for i, tables := range c.tables {
+ for _, t := range tables {
+ stats[i].read += t.size
+ // Insert deleted tables into record
+ rec.delTable(c.level+i, t.file.Num())
+ }
+ }
+ sourceSize := int(stats[0].read + stats[1].read)
+ minSeq := db.minSeq()
+ db.logf("table@compaction L%d·%d -> L%d·%d S·%s Q·%d", c.level, len(c.tables[0]), c.level+1, len(c.tables[1]), shortenb(sourceSize), minSeq)
+
+ b := &tableCompactionBuilder{
+ db: db,
+ s: db.s,
+ c: c,
+ rec: rec,
+ stat1: &stats[1],
+ minSeq: minSeq,
+ strict: db.s.o.GetStrict(opt.StrictCompaction),
+ tableSize: db.s.o.GetCompactionTableSize(c.level + 1),
+ }
+ db.compactionTransact("table@build", b)
+
+ // Commit changes
+ db.compactionTransactFunc("table@commit", func(cnt *compactionTransactCounter) (err error) {
+ stats[1].startTimer()
+ defer stats[1].stopTimer()
+ return db.s.commit(rec)
+ }, nil)
+
+ resultSize := int(stats[1].write)
+ db.logf("table@compaction committed F%s S%s Ke·%d D·%d T·%v", sint(len(rec.addedTables)-len(rec.deletedTables)), sshortenb(resultSize-sourceSize), b.kerrCnt, b.dropCnt, stats[1].duration)
+
+ // Save compaction stats
+ for i := range stats {
+ db.compStats[c.level+1].add(&stats[i])
+ }
+}
+
+func (db *DB) tableRangeCompaction(level int, umin, umax []byte) {
+ db.logf("table@compaction range L%d %q:%q", level, umin, umax)
+
+ if level >= 0 {
+ if c := db.s.getCompactionRange(level, umin, umax); c != nil {
+ db.tableCompaction(c, true)
+ }
+ } else {
+ v := db.s.version()
+ m := 1
+ for i, t := range v.tables[1:] {
+ if t.overlaps(db.s.icmp, umin, umax, false) {
+ m = i + 1
+ }
+ }
+ v.release()
+
+ for level := 0; level < m; level++ {
+ if c := db.s.getCompactionRange(level, umin, umax); c != nil {
+ db.tableCompaction(c, true)
+ }
+ }
+ }
+}
+
+func (db *DB) tableAutoCompaction() {
+ if c := db.s.pickCompaction(); c != nil {
+ db.tableCompaction(c, false)
+ }
+}
+
+func (db *DB) tableNeedCompaction() bool {
+ v := db.s.version()
+ defer v.release()
+ return v.needCompaction()
+}
+
+func (db *DB) pauseCompaction(ch chan<- struct{}) {
+ select {
+ case ch <- struct{}{}:
+ case _, _ = <-db.closeC:
+ db.compactionExitTransact()
+ }
+}
+
+type cCmd interface {
+ ack(err error)
+}
+
+type cIdle struct {
+ ackC chan<- error
+}
+
+func (r cIdle) ack(err error) {
+ if r.ackC != nil {
+ defer func() {
+ recover()
+ }()
+ r.ackC <- err
+ }
+}
+
+type cRange struct {
+ level int
+ min, max []byte
+ ackC chan<- error
+}
+
+func (r cRange) ack(err error) {
+ if r.ackC != nil {
+ defer func() {
+ recover()
+ }()
+ r.ackC <- err
+ }
+}
+
+// This will trigger auto compation and/or wait for all compaction to be done.
+func (db *DB) compSendIdle(compC chan<- cCmd) (err error) {
+ ch := make(chan error)
+ defer close(ch)
+ // Send cmd.
+ select {
+ case compC <- cIdle{ch}:
+ case err = <-db.compErrC:
+ return
+ case _, _ = <-db.closeC:
+ return ErrClosed
+ }
+ // Wait cmd.
+ select {
+ case err = <-ch:
+ case err = <-db.compErrC:
+ case _, _ = <-db.closeC:
+ return ErrClosed
+ }
+ return err
+}
+
+// This will trigger auto compaction but will not wait for it.
+func (db *DB) compSendTrigger(compC chan<- cCmd) {
+ select {
+ case compC <- cIdle{}:
+ default:
+ }
+}
+
+// Send range compaction request.
+func (db *DB) compSendRange(compC chan<- cCmd, level int, min, max []byte) (err error) {
+ ch := make(chan error)
+ defer close(ch)
+ // Send cmd.
+ select {
+ case compC <- cRange{level, min, max, ch}:
+ case err := <-db.compErrC:
+ return err
+ case _, _ = <-db.closeC:
+ return ErrClosed
+ }
+ // Wait cmd.
+ select {
+ case err = <-ch:
+ case err = <-db.compErrC:
+ case _, _ = <-db.closeC:
+ return ErrClosed
+ }
+ return err
+}
+
+func (db *DB) mCompaction() {
+ var x cCmd
+
+ defer func() {
+ if x := recover(); x != nil {
+ if x != errCompactionTransactExiting {
+ panic(x)
+ }
+ }
+ if x != nil {
+ x.ack(ErrClosed)
+ }
+ db.closeW.Done()
+ }()
+
+ for {
+ select {
+ case x = <-db.mcompCmdC:
+ switch x.(type) {
+ case cIdle:
+ db.memCompaction()
+ x.ack(nil)
+ x = nil
+ default:
+ panic("leveldb: unknown command")
+ }
+ case _, _ = <-db.closeC:
+ return
+ }
+ }
+}
+
+func (db *DB) tCompaction() {
+ var x cCmd
+ var ackQ []cCmd
+
+ defer func() {
+ if x := recover(); x != nil {
+ if x != errCompactionTransactExiting {
+ panic(x)
+ }
+ }
+ for i := range ackQ {
+ ackQ[i].ack(ErrClosed)
+ ackQ[i] = nil
+ }
+ if x != nil {
+ x.ack(ErrClosed)
+ }
+ db.closeW.Done()
+ }()
+
+ for {
+ if db.tableNeedCompaction() {
+ select {
+ case x = <-db.tcompCmdC:
+ case ch := <-db.tcompPauseC:
+ db.pauseCompaction(ch)
+ continue
+ case _, _ = <-db.closeC:
+ return
+ default:
+ }
+ } else {
+ for i := range ackQ {
+ ackQ[i].ack(nil)
+ ackQ[i] = nil
+ }
+ ackQ = ackQ[:0]
+ select {
+ case x = <-db.tcompCmdC:
+ case ch := <-db.tcompPauseC:
+ db.pauseCompaction(ch)
+ continue
+ case _, _ = <-db.closeC:
+ return
+ }
+ }
+ if x != nil {
+ switch cmd := x.(type) {
+ case cIdle:
+ ackQ = append(ackQ, x)
+ case cRange:
+ db.tableRangeCompaction(cmd.level, cmd.min, cmd.max)
+ x.ack(nil)
+ default:
+ panic("leveldb: unknown command")
+ }
+ x = nil
+ }
+ db.tableAutoCompaction()
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_iter.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_iter.go
new file mode 100644
index 0000000000000000000000000000000000000000..453db5b1d20190957631cc2898b96ae72df1f2df
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_iter.go
@@ -0,0 +1,350 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "errors"
+ "math/rand"
+ "runtime"
+ "sync"
+ "sync/atomic"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+var (
+ errInvalidIkey = errors.New("leveldb: Iterator: invalid internal key")
+)
+
+type memdbReleaser struct {
+ once sync.Once
+ m *memDB
+}
+
+func (mr *memdbReleaser) Release() {
+ mr.once.Do(func() {
+ mr.m.decref()
+ })
+}
+
+func (db *DB) newRawIterator(slice *util.Range, ro *opt.ReadOptions) iterator.Iterator {
+ em, fm := db.getMems()
+ v := db.s.version()
+
+ ti := v.getIterators(slice, ro)
+ n := len(ti) + 2
+ i := make([]iterator.Iterator, 0, n)
+ emi := em.NewIterator(slice)
+ emi.SetReleaser(&memdbReleaser{m: em})
+ i = append(i, emi)
+ if fm != nil {
+ fmi := fm.NewIterator(slice)
+ fmi.SetReleaser(&memdbReleaser{m: fm})
+ i = append(i, fmi)
+ }
+ i = append(i, ti...)
+ strict := opt.GetStrict(db.s.o.Options, ro, opt.StrictReader)
+ mi := iterator.NewMergedIterator(i, db.s.icmp, strict)
+ mi.SetReleaser(&versionReleaser{v: v})
+ return mi
+}
+
+func (db *DB) newIterator(seq uint64, slice *util.Range, ro *opt.ReadOptions) *dbIter {
+ var islice *util.Range
+ if slice != nil {
+ islice = &util.Range{}
+ if slice.Start != nil {
+ islice.Start = newIkey(slice.Start, kMaxSeq, ktSeek)
+ }
+ if slice.Limit != nil {
+ islice.Limit = newIkey(slice.Limit, kMaxSeq, ktSeek)
+ }
+ }
+ rawIter := db.newRawIterator(islice, ro)
+ iter := &dbIter{
+ db: db,
+ icmp: db.s.icmp,
+ iter: rawIter,
+ seq: seq,
+ strict: opt.GetStrict(db.s.o.Options, ro, opt.StrictReader),
+ key: make([]byte, 0),
+ value: make([]byte, 0),
+ }
+ atomic.AddInt32(&db.aliveIters, 1)
+ runtime.SetFinalizer(iter, (*dbIter).Release)
+ return iter
+}
+
+func (db *DB) iterSamplingRate() int {
+ return rand.Intn(2 * db.s.o.GetIteratorSamplingRate())
+}
+
+type dir int
+
+const (
+ dirReleased dir = iota - 1
+ dirSOI
+ dirEOI
+ dirBackward
+ dirForward
+)
+
+// dbIter represent an interator states over a database session.
+type dbIter struct {
+ db *DB
+ icmp *iComparer
+ iter iterator.Iterator
+ seq uint64
+ strict bool
+
+ smaplingGap int
+ dir dir
+ key []byte
+ value []byte
+ err error
+ releaser util.Releaser
+}
+
+func (i *dbIter) sampleSeek() {
+ ikey := i.iter.Key()
+ i.smaplingGap -= len(ikey) + len(i.iter.Value())
+ for i.smaplingGap < 0 {
+ i.smaplingGap += i.db.iterSamplingRate()
+ i.db.sampleSeek(ikey)
+ }
+}
+
+func (i *dbIter) setErr(err error) {
+ i.err = err
+ i.key = nil
+ i.value = nil
+}
+
+func (i *dbIter) iterErr() {
+ if err := i.iter.Error(); err != nil {
+ i.setErr(err)
+ }
+}
+
+func (i *dbIter) Valid() bool {
+ return i.err == nil && i.dir > dirEOI
+}
+
+func (i *dbIter) First() bool {
+ if i.err != nil {
+ return false
+ } else if i.dir == dirReleased {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ if i.iter.First() {
+ i.dir = dirSOI
+ return i.next()
+ }
+ i.dir = dirEOI
+ i.iterErr()
+ return false
+}
+
+func (i *dbIter) Last() bool {
+ if i.err != nil {
+ return false
+ } else if i.dir == dirReleased {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ if i.iter.Last() {
+ return i.prev()
+ }
+ i.dir = dirSOI
+ i.iterErr()
+ return false
+}
+
+func (i *dbIter) Seek(key []byte) bool {
+ if i.err != nil {
+ return false
+ } else if i.dir == dirReleased {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ ikey := newIkey(key, i.seq, ktSeek)
+ if i.iter.Seek(ikey) {
+ i.dir = dirSOI
+ return i.next()
+ }
+ i.dir = dirEOI
+ i.iterErr()
+ return false
+}
+
+func (i *dbIter) next() bool {
+ for {
+ if ukey, seq, kt, kerr := parseIkey(i.iter.Key()); kerr == nil {
+ i.sampleSeek()
+ if seq <= i.seq {
+ switch kt {
+ case ktDel:
+ // Skip deleted key.
+ i.key = append(i.key[:0], ukey...)
+ i.dir = dirForward
+ case ktVal:
+ if i.dir == dirSOI || i.icmp.uCompare(ukey, i.key) > 0 {
+ i.key = append(i.key[:0], ukey...)
+ i.value = append(i.value[:0], i.iter.Value()...)
+ i.dir = dirForward
+ return true
+ }
+ }
+ }
+ } else if i.strict {
+ i.setErr(kerr)
+ break
+ }
+ if !i.iter.Next() {
+ i.dir = dirEOI
+ i.iterErr()
+ break
+ }
+ }
+ return false
+}
+
+func (i *dbIter) Next() bool {
+ if i.dir == dirEOI || i.err != nil {
+ return false
+ } else if i.dir == dirReleased {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ if !i.iter.Next() || (i.dir == dirBackward && !i.iter.Next()) {
+ i.dir = dirEOI
+ i.iterErr()
+ return false
+ }
+ return i.next()
+}
+
+func (i *dbIter) prev() bool {
+ i.dir = dirBackward
+ del := true
+ if i.iter.Valid() {
+ for {
+ if ukey, seq, kt, kerr := parseIkey(i.iter.Key()); kerr == nil {
+ i.sampleSeek()
+ if seq <= i.seq {
+ if !del && i.icmp.uCompare(ukey, i.key) < 0 {
+ return true
+ }
+ del = (kt == ktDel)
+ if !del {
+ i.key = append(i.key[:0], ukey...)
+ i.value = append(i.value[:0], i.iter.Value()...)
+ }
+ }
+ } else if i.strict {
+ i.setErr(kerr)
+ return false
+ }
+ if !i.iter.Prev() {
+ break
+ }
+ }
+ }
+ if del {
+ i.dir = dirSOI
+ i.iterErr()
+ return false
+ }
+ return true
+}
+
+func (i *dbIter) Prev() bool {
+ if i.dir == dirSOI || i.err != nil {
+ return false
+ } else if i.dir == dirReleased {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ switch i.dir {
+ case dirEOI:
+ return i.Last()
+ case dirForward:
+ for i.iter.Prev() {
+ if ukey, _, _, kerr := parseIkey(i.iter.Key()); kerr == nil {
+ i.sampleSeek()
+ if i.icmp.uCompare(ukey, i.key) < 0 {
+ goto cont
+ }
+ } else if i.strict {
+ i.setErr(kerr)
+ return false
+ }
+ }
+ i.dir = dirSOI
+ i.iterErr()
+ return false
+ }
+
+cont:
+ return i.prev()
+}
+
+func (i *dbIter) Key() []byte {
+ if i.err != nil || i.dir <= dirEOI {
+ return nil
+ }
+ return i.key
+}
+
+func (i *dbIter) Value() []byte {
+ if i.err != nil || i.dir <= dirEOI {
+ return nil
+ }
+ return i.value
+}
+
+func (i *dbIter) Release() {
+ if i.dir != dirReleased {
+ // Clear the finalizer.
+ runtime.SetFinalizer(i, nil)
+
+ if i.releaser != nil {
+ i.releaser.Release()
+ i.releaser = nil
+ }
+
+ i.dir = dirReleased
+ i.key = nil
+ i.value = nil
+ i.iter.Release()
+ i.iter = nil
+ atomic.AddInt32(&i.db.aliveIters, -1)
+ i.db = nil
+ }
+}
+
+func (i *dbIter) SetReleaser(releaser util.Releaser) {
+ if i.dir == dirReleased {
+ panic(util.ErrReleased)
+ }
+ if i.releaser != nil && releaser != nil {
+ panic(util.ErrHasReleaser)
+ }
+ i.releaser = releaser
+}
+
+func (i *dbIter) Error() error {
+ return i.err
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_snapshot.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_snapshot.go
new file mode 100644
index 0000000000000000000000000000000000000000..4af7403317888b03177c989614003cff84009589
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_snapshot.go
@@ -0,0 +1,183 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "container/list"
+ "fmt"
+ "runtime"
+ "sync"
+ "sync/atomic"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type snapshotElement struct {
+ seq uint64
+ ref int
+ e *list.Element
+}
+
+// Acquires a snapshot, based on latest sequence.
+func (db *DB) acquireSnapshot() *snapshotElement {
+ db.snapsMu.Lock()
+ defer db.snapsMu.Unlock()
+
+ seq := db.getSeq()
+
+ if e := db.snapsList.Back(); e != nil {
+ se := e.Value.(*snapshotElement)
+ if se.seq == seq {
+ se.ref++
+ return se
+ } else if seq < se.seq {
+ panic("leveldb: sequence number is not increasing")
+ }
+ }
+ se := &snapshotElement{seq: seq, ref: 1}
+ se.e = db.snapsList.PushBack(se)
+ return se
+}
+
+// Releases given snapshot element.
+func (db *DB) releaseSnapshot(se *snapshotElement) {
+ db.snapsMu.Lock()
+ defer db.snapsMu.Unlock()
+
+ se.ref--
+ if se.ref == 0 {
+ db.snapsList.Remove(se.e)
+ se.e = nil
+ } else if se.ref < 0 {
+ panic("leveldb: Snapshot: negative element reference")
+ }
+}
+
+// Gets minimum sequence that not being snapshoted.
+func (db *DB) minSeq() uint64 {
+ db.snapsMu.Lock()
+ defer db.snapsMu.Unlock()
+
+ if e := db.snapsList.Front(); e != nil {
+ return e.Value.(*snapshotElement).seq
+ }
+
+ return db.getSeq()
+}
+
+// Snapshot is a DB snapshot.
+type Snapshot struct {
+ db *DB
+ elem *snapshotElement
+ mu sync.RWMutex
+ released bool
+}
+
+// Creates new snapshot object.
+func (db *DB) newSnapshot() *Snapshot {
+ snap := &Snapshot{
+ db: db,
+ elem: db.acquireSnapshot(),
+ }
+ atomic.AddInt32(&db.aliveSnaps, 1)
+ runtime.SetFinalizer(snap, (*Snapshot).Release)
+ return snap
+}
+
+func (snap *Snapshot) String() string {
+ return fmt.Sprintf("leveldb.Snapshot{%d}", snap.elem.seq)
+}
+
+// Get gets the value for the given key. It returns ErrNotFound if
+// the DB does not contains the key.
+//
+// The caller should not modify the contents of the returned slice, but
+// it is safe to modify the contents of the argument after Get returns.
+func (snap *Snapshot) Get(key []byte, ro *opt.ReadOptions) (value []byte, err error) {
+ err = snap.db.ok()
+ if err != nil {
+ return
+ }
+ snap.mu.RLock()
+ defer snap.mu.RUnlock()
+ if snap.released {
+ err = ErrSnapshotReleased
+ return
+ }
+ return snap.db.get(key, snap.elem.seq, ro)
+}
+
+// Has returns true if the DB does contains the given key.
+//
+// It is safe to modify the contents of the argument after Get returns.
+func (snap *Snapshot) Has(key []byte, ro *opt.ReadOptions) (ret bool, err error) {
+ err = snap.db.ok()
+ if err != nil {
+ return
+ }
+ snap.mu.RLock()
+ defer snap.mu.RUnlock()
+ if snap.released {
+ err = ErrSnapshotReleased
+ return
+ }
+ return snap.db.has(key, snap.elem.seq, ro)
+}
+
+// NewIterator returns an iterator for the snapshot of the uderlying DB.
+// The returned iterator is not goroutine-safe, but it is safe to use
+// multiple iterators concurrently, with each in a dedicated goroutine.
+// It is also safe to use an iterator concurrently with modifying its
+// underlying DB. The resultant key/value pairs are guaranteed to be
+// consistent.
+//
+// Slice allows slicing the iterator to only contains keys in the given
+// range. A nil Range.Start is treated as a key before all keys in the
+// DB. And a nil Range.Limit is treated as a key after all keys in
+// the DB.
+//
+// The iterator must be released after use, by calling Release method.
+// Releasing the snapshot doesn't mean releasing the iterator too, the
+// iterator would be still valid until released.
+//
+// Also read Iterator documentation of the leveldb/iterator package.
+func (snap *Snapshot) NewIterator(slice *util.Range, ro *opt.ReadOptions) iterator.Iterator {
+ if err := snap.db.ok(); err != nil {
+ return iterator.NewEmptyIterator(err)
+ }
+ snap.mu.Lock()
+ defer snap.mu.Unlock()
+ if snap.released {
+ return iterator.NewEmptyIterator(ErrSnapshotReleased)
+ }
+ // Since iterator already hold version ref, it doesn't need to
+ // hold snapshot ref.
+ return snap.db.newIterator(snap.elem.seq, slice, ro)
+}
+
+// Release releases the snapshot. This will not release any returned
+// iterators, the iterators would still be valid until released or the
+// underlying DB is closed.
+//
+// Other methods should not be called after the snapshot has been released.
+func (snap *Snapshot) Release() {
+ snap.mu.Lock()
+ defer snap.mu.Unlock()
+
+ if !snap.released {
+ // Clear the finalizer.
+ runtime.SetFinalizer(snap, nil)
+
+ snap.released = true
+ snap.db.releaseSnapshot(snap.elem)
+ atomic.AddInt32(&snap.db.aliveSnaps, -1)
+ snap.db = nil
+ snap.elem = nil
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_state.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_state.go
new file mode 100644
index 0000000000000000000000000000000000000000..87cd33adc6b81ff39e6e2eb7a7b9dcf9823e8d4e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_state.go
@@ -0,0 +1,211 @@
+// Copyright (c) 2013, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "sync/atomic"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/journal"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb"
+)
+
+type memDB struct {
+ db *DB
+ *memdb.DB
+ ref int32
+}
+
+func (m *memDB) incref() {
+ atomic.AddInt32(&m.ref, 1)
+}
+
+func (m *memDB) decref() {
+ if ref := atomic.AddInt32(&m.ref, -1); ref == 0 {
+ // Only put back memdb with std capacity.
+ if m.Capacity() == m.db.s.o.GetWriteBuffer() {
+ m.Reset()
+ m.db.mpoolPut(m.DB)
+ }
+ m.db = nil
+ m.DB = nil
+ } else if ref < 0 {
+ panic("negative memdb ref")
+ }
+}
+
+// Get latest sequence number.
+func (db *DB) getSeq() uint64 {
+ return atomic.LoadUint64(&db.seq)
+}
+
+// Atomically adds delta to seq.
+func (db *DB) addSeq(delta uint64) {
+ atomic.AddUint64(&db.seq, delta)
+}
+
+func (db *DB) sampleSeek(ikey iKey) {
+ v := db.s.version()
+ if v.sampleSeek(ikey) {
+ // Trigger table compaction.
+ db.compSendTrigger(db.tcompCmdC)
+ }
+ v.release()
+}
+
+func (db *DB) mpoolPut(mem *memdb.DB) {
+ defer func() {
+ recover()
+ }()
+ select {
+ case db.memPool <- mem:
+ default:
+ }
+}
+
+func (db *DB) mpoolGet() *memdb.DB {
+ select {
+ case mem := <-db.memPool:
+ return mem
+ default:
+ return nil
+ }
+}
+
+func (db *DB) mpoolDrain() {
+ ticker := time.NewTicker(30 * time.Second)
+ for {
+ select {
+ case <-ticker.C:
+ select {
+ case <-db.memPool:
+ default:
+ }
+ case _, _ = <-db.closeC:
+ close(db.memPool)
+ return
+ }
+ }
+}
+
+// Create new memdb and froze the old one; need external synchronization.
+// newMem only called synchronously by the writer.
+func (db *DB) newMem(n int) (mem *memDB, err error) {
+ num := db.s.allocFileNum()
+ file := db.s.getJournalFile(num)
+ w, err := file.Create()
+ if err != nil {
+ db.s.reuseFileNum(num)
+ return
+ }
+
+ db.memMu.Lock()
+ defer db.memMu.Unlock()
+
+ if db.frozenMem != nil {
+ panic("still has frozen mem")
+ }
+
+ if db.journal == nil {
+ db.journal = journal.NewWriter(w)
+ } else {
+ db.journal.Reset(w)
+ db.journalWriter.Close()
+ db.frozenJournalFile = db.journalFile
+ }
+ db.journalWriter = w
+ db.journalFile = file
+ db.frozenMem = db.mem
+ mdb := db.mpoolGet()
+ if mdb == nil || mdb.Capacity() < n {
+ mdb = memdb.New(db.s.icmp, maxInt(db.s.o.GetWriteBuffer(), n))
+ }
+ mem = &memDB{
+ db: db,
+ DB: mdb,
+ ref: 2,
+ }
+ db.mem = mem
+ // The seq only incremented by the writer. And whoever called newMem
+ // should hold write lock, so no need additional synchronization here.
+ db.frozenSeq = db.seq
+ return
+}
+
+// Get all memdbs.
+func (db *DB) getMems() (e, f *memDB) {
+ db.memMu.RLock()
+ defer db.memMu.RUnlock()
+ if db.mem == nil {
+ panic("nil effective mem")
+ }
+ db.mem.incref()
+ if db.frozenMem != nil {
+ db.frozenMem.incref()
+ }
+ return db.mem, db.frozenMem
+}
+
+// Get frozen memdb.
+func (db *DB) getEffectiveMem() *memDB {
+ db.memMu.RLock()
+ defer db.memMu.RUnlock()
+ if db.mem == nil {
+ panic("nil effective mem")
+ }
+ db.mem.incref()
+ return db.mem
+}
+
+// Check whether we has frozen memdb.
+func (db *DB) hasFrozenMem() bool {
+ db.memMu.RLock()
+ defer db.memMu.RUnlock()
+ return db.frozenMem != nil
+}
+
+// Get frozen memdb.
+func (db *DB) getFrozenMem() *memDB {
+ db.memMu.RLock()
+ defer db.memMu.RUnlock()
+ if db.frozenMem != nil {
+ db.frozenMem.incref()
+ }
+ return db.frozenMem
+}
+
+// Drop frozen memdb; assume that frozen memdb isn't nil.
+func (db *DB) dropFrozenMem() {
+ db.memMu.Lock()
+ if err := db.frozenJournalFile.Remove(); err != nil {
+ db.logf("journal@remove removing @%d %q", db.frozenJournalFile.Num(), err)
+ } else {
+ db.logf("journal@remove removed @%d", db.frozenJournalFile.Num())
+ }
+ db.frozenJournalFile = nil
+ db.frozenMem.decref()
+ db.frozenMem = nil
+ db.memMu.Unlock()
+}
+
+// Set closed flag; return true if not already closed.
+func (db *DB) setClosed() bool {
+ return atomic.CompareAndSwapUint32(&db.closed, 0, 1)
+}
+
+// Check whether DB was closed.
+func (db *DB) isClosed() bool {
+ return atomic.LoadUint32(&db.closed) != 0
+}
+
+// Check read ok status.
+func (db *DB) ok() error {
+ if db.isClosed() {
+ return ErrClosed
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..108fdc00b3d6cd6b072b81135c76ce45329c6f21
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_test.go
@@ -0,0 +1,2701 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "bytes"
+ "container/list"
+ crand "crypto/rand"
+ "encoding/binary"
+ "fmt"
+ "math/rand"
+ "os"
+ "path/filepath"
+ "runtime"
+ "strings"
+ "sync"
+ "sync/atomic"
+ "testing"
+ "time"
+ "unsafe"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+func tkey(i int) []byte {
+ return []byte(fmt.Sprintf("%016d", i))
+}
+
+func tval(seed, n int) []byte {
+ r := rand.New(rand.NewSource(int64(seed)))
+ return randomString(r, n)
+}
+
+type dbHarness struct {
+ t *testing.T
+
+ stor *testStorage
+ db *DB
+ o *opt.Options
+ ro *opt.ReadOptions
+ wo *opt.WriteOptions
+}
+
+func newDbHarnessWopt(t *testing.T, o *opt.Options) *dbHarness {
+ h := new(dbHarness)
+ h.init(t, o)
+ return h
+}
+
+func newDbHarness(t *testing.T) *dbHarness {
+ return newDbHarnessWopt(t, &opt.Options{})
+}
+
+func (h *dbHarness) init(t *testing.T, o *opt.Options) {
+ h.t = t
+ h.stor = newTestStorage(t)
+ h.o = o
+ h.ro = nil
+ h.wo = nil
+
+ if err := h.openDB0(); err != nil {
+ // So that it will come after fatal message.
+ defer h.stor.Close()
+ h.t.Fatal("Open (init): got error: ", err)
+ }
+}
+
+func (h *dbHarness) openDB0() (err error) {
+ h.t.Log("opening DB")
+ h.db, err = Open(h.stor, h.o)
+ return
+}
+
+func (h *dbHarness) openDB() {
+ if err := h.openDB0(); err != nil {
+ h.t.Fatal("Open: got error: ", err)
+ }
+}
+
+func (h *dbHarness) closeDB0() error {
+ h.t.Log("closing DB")
+ return h.db.Close()
+}
+
+func (h *dbHarness) closeDB() {
+ if err := h.closeDB0(); err != nil {
+ h.t.Error("Close: got error: ", err)
+ }
+ h.stor.CloseCheck()
+ runtime.GC()
+}
+
+func (h *dbHarness) reopenDB() {
+ h.closeDB()
+ h.openDB()
+}
+
+func (h *dbHarness) close() {
+ h.closeDB0()
+ h.db = nil
+ h.stor.Close()
+ h.stor = nil
+ runtime.GC()
+}
+
+func (h *dbHarness) openAssert(want bool) {
+ db, err := Open(h.stor, h.o)
+ if err != nil {
+ if want {
+ h.t.Error("Open: assert: got error: ", err)
+ } else {
+ h.t.Log("Open: assert: got error (expected): ", err)
+ }
+ } else {
+ if !want {
+ h.t.Error("Open: assert: expect error")
+ }
+ db.Close()
+ }
+}
+
+func (h *dbHarness) write(batch *Batch) {
+ if err := h.db.Write(batch, h.wo); err != nil {
+ h.t.Error("Write: got error: ", err)
+ }
+}
+
+func (h *dbHarness) put(key, value string) {
+ if err := h.db.Put([]byte(key), []byte(value), h.wo); err != nil {
+ h.t.Error("Put: got error: ", err)
+ }
+}
+
+func (h *dbHarness) putMulti(n int, low, hi string) {
+ for i := 0; i < n; i++ {
+ h.put(low, "begin")
+ h.put(hi, "end")
+ h.compactMem()
+ }
+}
+
+func (h *dbHarness) maxNextLevelOverlappingBytes(want uint64) {
+ t := h.t
+ db := h.db
+
+ var (
+ maxOverlaps uint64
+ maxLevel int
+ )
+ v := db.s.version()
+ for i, tt := range v.tables[1 : len(v.tables)-1] {
+ level := i + 1
+ next := v.tables[level+1]
+ for _, t := range tt {
+ r := next.getOverlaps(nil, db.s.icmp, t.imin.ukey(), t.imax.ukey(), false)
+ sum := r.size()
+ if sum > maxOverlaps {
+ maxOverlaps = sum
+ maxLevel = level
+ }
+ }
+ }
+ v.release()
+
+ if maxOverlaps > want {
+ t.Errorf("next level most overlapping bytes is more than %d, got=%d level=%d", want, maxOverlaps, maxLevel)
+ } else {
+ t.Logf("next level most overlapping bytes is %d, level=%d want=%d", maxOverlaps, maxLevel, want)
+ }
+}
+
+func (h *dbHarness) delete(key string) {
+ t := h.t
+ db := h.db
+
+ err := db.Delete([]byte(key), h.wo)
+ if err != nil {
+ t.Error("Delete: got error: ", err)
+ }
+}
+
+func (h *dbHarness) assertNumKeys(want int) {
+ iter := h.db.NewIterator(nil, h.ro)
+ defer iter.Release()
+ got := 0
+ for iter.Next() {
+ got++
+ }
+ if err := iter.Error(); err != nil {
+ h.t.Error("assertNumKeys: ", err)
+ }
+ if want != got {
+ h.t.Errorf("assertNumKeys: want=%d got=%d", want, got)
+ }
+}
+
+func (h *dbHarness) getr(db Reader, key string, expectFound bool) (found bool, v []byte) {
+ t := h.t
+ v, err := db.Get([]byte(key), h.ro)
+ switch err {
+ case ErrNotFound:
+ if expectFound {
+ t.Errorf("Get: key '%s' not found, want found", key)
+ }
+ case nil:
+ found = true
+ if !expectFound {
+ t.Errorf("Get: key '%s' found, want not found", key)
+ }
+ default:
+ t.Error("Get: got error: ", err)
+ }
+ return
+}
+
+func (h *dbHarness) get(key string, expectFound bool) (found bool, v []byte) {
+ return h.getr(h.db, key, expectFound)
+}
+
+func (h *dbHarness) getValr(db Reader, key, value string) {
+ t := h.t
+ found, r := h.getr(db, key, true)
+ if !found {
+ return
+ }
+ rval := string(r)
+ if rval != value {
+ t.Errorf("Get: invalid value, got '%s', want '%s'", rval, value)
+ }
+}
+
+func (h *dbHarness) getVal(key, value string) {
+ h.getValr(h.db, key, value)
+}
+
+func (h *dbHarness) allEntriesFor(key, want string) {
+ t := h.t
+ db := h.db
+ s := db.s
+
+ ikey := newIkey([]byte(key), kMaxSeq, ktVal)
+ iter := db.newRawIterator(nil, nil)
+ if !iter.Seek(ikey) && iter.Error() != nil {
+ t.Error("AllEntries: error during seek, err: ", iter.Error())
+ return
+ }
+ res := "[ "
+ first := true
+ for iter.Valid() {
+ if ukey, _, kt, kerr := parseIkey(iter.Key()); kerr == nil {
+ if s.icmp.uCompare(ikey.ukey(), ukey) != 0 {
+ break
+ }
+ if !first {
+ res += ", "
+ }
+ first = false
+ switch kt {
+ case ktVal:
+ res += string(iter.Value())
+ case ktDel:
+ res += "DEL"
+ }
+ } else {
+ if !first {
+ res += ", "
+ }
+ first = false
+ res += "CORRUPTED"
+ }
+ iter.Next()
+ }
+ if !first {
+ res += " "
+ }
+ res += "]"
+ if res != want {
+ t.Errorf("AllEntries: assert failed for key %q, got=%q want=%q", key, res, want)
+ }
+}
+
+// Return a string that contains all key,value pairs in order,
+// formatted like "(k1->v1)(k2->v2)".
+func (h *dbHarness) getKeyVal(want string) {
+ t := h.t
+ db := h.db
+
+ s, err := db.GetSnapshot()
+ if err != nil {
+ t.Fatal("GetSnapshot: got error: ", err)
+ }
+ res := ""
+ iter := s.NewIterator(nil, nil)
+ for iter.Next() {
+ res += fmt.Sprintf("(%s->%s)", string(iter.Key()), string(iter.Value()))
+ }
+ iter.Release()
+
+ if res != want {
+ t.Errorf("GetKeyVal: invalid key/value pair, got=%q want=%q", res, want)
+ }
+ s.Release()
+}
+
+func (h *dbHarness) waitCompaction() {
+ t := h.t
+ db := h.db
+ if err := db.compSendIdle(db.tcompCmdC); err != nil {
+ t.Error("compaction error: ", err)
+ }
+}
+
+func (h *dbHarness) waitMemCompaction() {
+ t := h.t
+ db := h.db
+
+ if err := db.compSendIdle(db.mcompCmdC); err != nil {
+ t.Error("compaction error: ", err)
+ }
+}
+
+func (h *dbHarness) compactMem() {
+ t := h.t
+ db := h.db
+
+ t.Log("starting memdb compaction")
+
+ db.writeLockC <- struct{}{}
+ defer func() {
+ <-db.writeLockC
+ }()
+
+ if _, err := db.rotateMem(0); err != nil {
+ t.Error("compaction error: ", err)
+ }
+ if err := db.compSendIdle(db.mcompCmdC); err != nil {
+ t.Error("compaction error: ", err)
+ }
+
+ if h.totalTables() == 0 {
+ t.Error("zero tables after mem compaction")
+ }
+
+ t.Log("memdb compaction done")
+}
+
+func (h *dbHarness) compactRangeAtErr(level int, min, max string, wanterr bool) {
+ t := h.t
+ db := h.db
+
+ var _min, _max []byte
+ if min != "" {
+ _min = []byte(min)
+ }
+ if max != "" {
+ _max = []byte(max)
+ }
+
+ t.Logf("starting table range compaction: level=%d, min=%q, max=%q", level, min, max)
+
+ if err := db.compSendRange(db.tcompCmdC, level, _min, _max); err != nil {
+ if wanterr {
+ t.Log("CompactRangeAt: got error (expected): ", err)
+ } else {
+ t.Error("CompactRangeAt: got error: ", err)
+ }
+ } else if wanterr {
+ t.Error("CompactRangeAt: expect error")
+ }
+
+ t.Log("table range compaction done")
+}
+
+func (h *dbHarness) compactRangeAt(level int, min, max string) {
+ h.compactRangeAtErr(level, min, max, false)
+}
+
+func (h *dbHarness) compactRange(min, max string) {
+ t := h.t
+ db := h.db
+
+ t.Logf("starting DB range compaction: min=%q, max=%q", min, max)
+
+ var r util.Range
+ if min != "" {
+ r.Start = []byte(min)
+ }
+ if max != "" {
+ r.Limit = []byte(max)
+ }
+ if err := db.CompactRange(r); err != nil {
+ t.Error("CompactRange: got error: ", err)
+ }
+
+ t.Log("DB range compaction done")
+}
+
+func (h *dbHarness) sizeOf(start, limit string) uint64 {
+ sz, err := h.db.SizeOf([]util.Range{
+ {[]byte(start), []byte(limit)},
+ })
+ if err != nil {
+ h.t.Error("SizeOf: got error: ", err)
+ }
+ return sz.Sum()
+}
+
+func (h *dbHarness) sizeAssert(start, limit string, low, hi uint64) {
+ sz := h.sizeOf(start, limit)
+ if sz < low || sz > hi {
+ h.t.Errorf("sizeOf %q to %q not in range, want %d - %d, got %d",
+ shorten(start), shorten(limit), low, hi, sz)
+ }
+}
+
+func (h *dbHarness) getSnapshot() (s *Snapshot) {
+ s, err := h.db.GetSnapshot()
+ if err != nil {
+ h.t.Fatal("GetSnapshot: got error: ", err)
+ }
+ return
+}
+func (h *dbHarness) tablesPerLevel(want string) {
+ res := ""
+ nz := 0
+ v := h.db.s.version()
+ for level, tt := range v.tables {
+ if level > 0 {
+ res += ","
+ }
+ res += fmt.Sprint(len(tt))
+ if len(tt) > 0 {
+ nz = len(res)
+ }
+ }
+ v.release()
+ res = res[:nz]
+ if res != want {
+ h.t.Errorf("invalid tables len, want=%s, got=%s", want, res)
+ }
+}
+
+func (h *dbHarness) totalTables() (n int) {
+ v := h.db.s.version()
+ for _, tt := range v.tables {
+ n += len(tt)
+ }
+ v.release()
+ return
+}
+
+type keyValue interface {
+ Key() []byte
+ Value() []byte
+}
+
+func testKeyVal(t *testing.T, kv keyValue, want string) {
+ res := string(kv.Key()) + "->" + string(kv.Value())
+ if res != want {
+ t.Errorf("invalid key/value, want=%q, got=%q", want, res)
+ }
+}
+
+func numKey(num int) string {
+ return fmt.Sprintf("key%06d", num)
+}
+
+var _bloom_filter = filter.NewBloomFilter(10)
+
+func truno(t *testing.T, o *opt.Options, f func(h *dbHarness)) {
+ for i := 0; i < 4; i++ {
+ func() {
+ switch i {
+ case 0:
+ case 1:
+ if o == nil {
+ o = &opt.Options{Filter: _bloom_filter}
+ } else {
+ old := o
+ o = &opt.Options{}
+ *o = *old
+ o.Filter = _bloom_filter
+ }
+ case 2:
+ if o == nil {
+ o = &opt.Options{Compression: opt.NoCompression}
+ } else {
+ old := o
+ o = &opt.Options{}
+ *o = *old
+ o.Compression = opt.NoCompression
+ }
+ }
+ h := newDbHarnessWopt(t, o)
+ defer h.close()
+ switch i {
+ case 3:
+ h.reopenDB()
+ }
+ f(h)
+ }()
+ }
+}
+
+func trun(t *testing.T, f func(h *dbHarness)) {
+ truno(t, nil, f)
+}
+
+func testAligned(t *testing.T, name string, offset uintptr) {
+ if offset%8 != 0 {
+ t.Errorf("field %s offset is not 64-bit aligned", name)
+ }
+}
+
+func Test_FieldsAligned(t *testing.T) {
+ p1 := new(DB)
+ testAligned(t, "DB.seq", unsafe.Offsetof(p1.seq))
+ p2 := new(session)
+ testAligned(t, "session.stNextFileNum", unsafe.Offsetof(p2.stNextFileNum))
+ testAligned(t, "session.stJournalNum", unsafe.Offsetof(p2.stJournalNum))
+ testAligned(t, "session.stPrevJournalNum", unsafe.Offsetof(p2.stPrevJournalNum))
+ testAligned(t, "session.stSeqNum", unsafe.Offsetof(p2.stSeqNum))
+}
+
+func TestDB_Locking(t *testing.T) {
+ h := newDbHarness(t)
+ defer h.stor.Close()
+ h.openAssert(false)
+ h.closeDB()
+ h.openAssert(true)
+}
+
+func TestDB_Empty(t *testing.T) {
+ trun(t, func(h *dbHarness) {
+ h.get("foo", false)
+
+ h.reopenDB()
+ h.get("foo", false)
+ })
+}
+
+func TestDB_ReadWrite(t *testing.T) {
+ trun(t, func(h *dbHarness) {
+ h.put("foo", "v1")
+ h.getVal("foo", "v1")
+ h.put("bar", "v2")
+ h.put("foo", "v3")
+ h.getVal("foo", "v3")
+ h.getVal("bar", "v2")
+
+ h.reopenDB()
+ h.getVal("foo", "v3")
+ h.getVal("bar", "v2")
+ })
+}
+
+func TestDB_PutDeleteGet(t *testing.T) {
+ trun(t, func(h *dbHarness) {
+ h.put("foo", "v1")
+ h.getVal("foo", "v1")
+ h.put("foo", "v2")
+ h.getVal("foo", "v2")
+ h.delete("foo")
+ h.get("foo", false)
+
+ h.reopenDB()
+ h.get("foo", false)
+ })
+}
+
+func TestDB_EmptyBatch(t *testing.T) {
+ h := newDbHarness(t)
+ defer h.close()
+
+ h.get("foo", false)
+ err := h.db.Write(new(Batch), h.wo)
+ if err != nil {
+ t.Error("writing empty batch yield error: ", err)
+ }
+ h.get("foo", false)
+}
+
+func TestDB_GetFromFrozen(t *testing.T) {
+ h := newDbHarnessWopt(t, &opt.Options{WriteBuffer: 100100})
+ defer h.close()
+
+ h.put("foo", "v1")
+ h.getVal("foo", "v1")
+
+ h.stor.DelaySync(storage.TypeTable) // Block sync calls
+ h.put("k1", strings.Repeat("x", 100000)) // Fill memtable
+ h.put("k2", strings.Repeat("y", 100000)) // Trigger compaction
+ for i := 0; h.db.getFrozenMem() == nil && i < 100; i++ {
+ time.Sleep(10 * time.Microsecond)
+ }
+ if h.db.getFrozenMem() == nil {
+ h.stor.ReleaseSync(storage.TypeTable)
+ t.Fatal("No frozen mem")
+ }
+ h.getVal("foo", "v1")
+ h.stor.ReleaseSync(storage.TypeTable) // Release sync calls
+
+ h.reopenDB()
+ h.getVal("foo", "v1")
+ h.get("k1", true)
+ h.get("k2", true)
+}
+
+func TestDB_GetFromTable(t *testing.T) {
+ trun(t, func(h *dbHarness) {
+ h.put("foo", "v1")
+ h.compactMem()
+ h.getVal("foo", "v1")
+ })
+}
+
+func TestDB_GetSnapshot(t *testing.T) {
+ trun(t, func(h *dbHarness) {
+ bar := strings.Repeat("b", 200)
+ h.put("foo", "v1")
+ h.put(bar, "v1")
+
+ snap, err := h.db.GetSnapshot()
+ if err != nil {
+ t.Fatal("GetSnapshot: got error: ", err)
+ }
+
+ h.put("foo", "v2")
+ h.put(bar, "v2")
+
+ h.getVal("foo", "v2")
+ h.getVal(bar, "v2")
+ h.getValr(snap, "foo", "v1")
+ h.getValr(snap, bar, "v1")
+
+ h.compactMem()
+
+ h.getVal("foo", "v2")
+ h.getVal(bar, "v2")
+ h.getValr(snap, "foo", "v1")
+ h.getValr(snap, bar, "v1")
+
+ snap.Release()
+
+ h.reopenDB()
+ h.getVal("foo", "v2")
+ h.getVal(bar, "v2")
+ })
+}
+
+func TestDB_GetLevel0Ordering(t *testing.T) {
+ trun(t, func(h *dbHarness) {
+ for i := 0; i < 4; i++ {
+ h.put("bar", fmt.Sprintf("b%d", i))
+ h.put("foo", fmt.Sprintf("v%d", i))
+ h.compactMem()
+ }
+ h.getVal("foo", "v3")
+ h.getVal("bar", "b3")
+
+ v := h.db.s.version()
+ t0len := v.tLen(0)
+ v.release()
+ if t0len < 2 {
+ t.Errorf("level-0 tables is less than 2, got %d", t0len)
+ }
+
+ h.reopenDB()
+ h.getVal("foo", "v3")
+ h.getVal("bar", "b3")
+ })
+}
+
+func TestDB_GetOrderedByLevels(t *testing.T) {
+ trun(t, func(h *dbHarness) {
+ h.put("foo", "v1")
+ h.compactMem()
+ h.compactRange("a", "z")
+ h.getVal("foo", "v1")
+ h.put("foo", "v2")
+ h.compactMem()
+ h.getVal("foo", "v2")
+ })
+}
+
+func TestDB_GetPicksCorrectFile(t *testing.T) {
+ trun(t, func(h *dbHarness) {
+ // Arrange to have multiple files in a non-level-0 level.
+ h.put("a", "va")
+ h.compactMem()
+ h.compactRange("a", "b")
+ h.put("x", "vx")
+ h.compactMem()
+ h.compactRange("x", "y")
+ h.put("f", "vf")
+ h.compactMem()
+ h.compactRange("f", "g")
+
+ h.getVal("a", "va")
+ h.getVal("f", "vf")
+ h.getVal("x", "vx")
+
+ h.compactRange("", "")
+ h.getVal("a", "va")
+ h.getVal("f", "vf")
+ h.getVal("x", "vx")
+ })
+}
+
+func TestDB_GetEncountersEmptyLevel(t *testing.T) {
+ trun(t, func(h *dbHarness) {
+ // Arrange for the following to happen:
+ // * sstable A in level 0
+ // * nothing in level 1
+ // * sstable B in level 2
+ // Then do enough Get() calls to arrange for an automatic compaction
+ // of sstable A. A bug would cause the compaction to be marked as
+ // occuring at level 1 (instead of the correct level 0).
+
+ // Step 1: First place sstables in levels 0 and 2
+ for i := 0; ; i++ {
+ if i >= 100 {
+ t.Fatal("could not fill levels-0 and level-2")
+ }
+ v := h.db.s.version()
+ if v.tLen(0) > 0 && v.tLen(2) > 0 {
+ v.release()
+ break
+ }
+ v.release()
+ h.put("a", "begin")
+ h.put("z", "end")
+ h.compactMem()
+
+ h.getVal("a", "begin")
+ h.getVal("z", "end")
+ }
+
+ // Step 2: clear level 1 if necessary.
+ h.compactRangeAt(1, "", "")
+ h.tablesPerLevel("1,0,1")
+
+ h.getVal("a", "begin")
+ h.getVal("z", "end")
+
+ // Step 3: read a bunch of times
+ for i := 0; i < 200; i++ {
+ h.get("missing", false)
+ }
+
+ // Step 4: Wait for compaction to finish
+ h.waitCompaction()
+
+ v := h.db.s.version()
+ if v.tLen(0) > 0 {
+ t.Errorf("level-0 tables more than 0, got %d", v.tLen(0))
+ }
+ v.release()
+
+ h.getVal("a", "begin")
+ h.getVal("z", "end")
+ })
+}
+
+func TestDB_IterMultiWithDelete(t *testing.T) {
+ trun(t, func(h *dbHarness) {
+ h.put("a", "va")
+ h.put("b", "vb")
+ h.put("c", "vc")
+ h.delete("b")
+ h.get("b", false)
+
+ iter := h.db.NewIterator(nil, nil)
+ iter.Seek([]byte("c"))
+ testKeyVal(t, iter, "c->vc")
+ iter.Prev()
+ testKeyVal(t, iter, "a->va")
+ iter.Release()
+
+ h.compactMem()
+
+ iter = h.db.NewIterator(nil, nil)
+ iter.Seek([]byte("c"))
+ testKeyVal(t, iter, "c->vc")
+ iter.Prev()
+ testKeyVal(t, iter, "a->va")
+ iter.Release()
+ })
+}
+
+func TestDB_IteratorPinsRef(t *testing.T) {
+ h := newDbHarness(t)
+ defer h.close()
+
+ h.put("foo", "hello")
+
+ // Get iterator that will yield the current contents of the DB.
+ iter := h.db.NewIterator(nil, nil)
+
+ // Write to force compactions
+ h.put("foo", "newvalue1")
+ for i := 0; i < 100; i++ {
+ h.put(numKey(i), strings.Repeat(fmt.Sprintf("v%09d", i), 100000/10))
+ }
+ h.put("foo", "newvalue2")
+
+ iter.First()
+ testKeyVal(t, iter, "foo->hello")
+ if iter.Next() {
+ t.Errorf("expect eof")
+ }
+ iter.Release()
+}
+
+func TestDB_Recover(t *testing.T) {
+ trun(t, func(h *dbHarness) {
+ h.put("foo", "v1")
+ h.put("baz", "v5")
+
+ h.reopenDB()
+ h.getVal("foo", "v1")
+
+ h.getVal("foo", "v1")
+ h.getVal("baz", "v5")
+ h.put("bar", "v2")
+ h.put("foo", "v3")
+
+ h.reopenDB()
+ h.getVal("foo", "v3")
+ h.put("foo", "v4")
+ h.getVal("foo", "v4")
+ h.getVal("bar", "v2")
+ h.getVal("baz", "v5")
+ })
+}
+
+func TestDB_RecoverWithEmptyJournal(t *testing.T) {
+ trun(t, func(h *dbHarness) {
+ h.put("foo", "v1")
+ h.put("foo", "v2")
+
+ h.reopenDB()
+ h.reopenDB()
+ h.put("foo", "v3")
+
+ h.reopenDB()
+ h.getVal("foo", "v3")
+ })
+}
+
+func TestDB_RecoverDuringMemtableCompaction(t *testing.T) {
+ truno(t, &opt.Options{WriteBuffer: 1000000}, func(h *dbHarness) {
+
+ h.stor.DelaySync(storage.TypeTable)
+ h.put("big1", strings.Repeat("x", 10000000))
+ h.put("big2", strings.Repeat("y", 1000))
+ h.put("bar", "v2")
+ h.stor.ReleaseSync(storage.TypeTable)
+
+ h.reopenDB()
+ h.getVal("bar", "v2")
+ h.getVal("big1", strings.Repeat("x", 10000000))
+ h.getVal("big2", strings.Repeat("y", 1000))
+ })
+}
+
+func TestDB_MinorCompactionsHappen(t *testing.T) {
+ h := newDbHarnessWopt(t, &opt.Options{WriteBuffer: 10000})
+ defer h.close()
+
+ n := 500
+
+ key := func(i int) string {
+ return fmt.Sprintf("key%06d", i)
+ }
+
+ for i := 0; i < n; i++ {
+ h.put(key(i), key(i)+strings.Repeat("v", 1000))
+ }
+
+ for i := 0; i < n; i++ {
+ h.getVal(key(i), key(i)+strings.Repeat("v", 1000))
+ }
+
+ h.reopenDB()
+ for i := 0; i < n; i++ {
+ h.getVal(key(i), key(i)+strings.Repeat("v", 1000))
+ }
+}
+
+func TestDB_RecoverWithLargeJournal(t *testing.T) {
+ h := newDbHarness(t)
+ defer h.close()
+
+ h.put("big1", strings.Repeat("1", 200000))
+ h.put("big2", strings.Repeat("2", 200000))
+ h.put("small3", strings.Repeat("3", 10))
+ h.put("small4", strings.Repeat("4", 10))
+ h.tablesPerLevel("")
+
+ // Make sure that if we re-open with a small write buffer size that
+ // we flush table files in the middle of a large journal file.
+ h.o.WriteBuffer = 100000
+ h.reopenDB()
+ h.getVal("big1", strings.Repeat("1", 200000))
+ h.getVal("big2", strings.Repeat("2", 200000))
+ h.getVal("small3", strings.Repeat("3", 10))
+ h.getVal("small4", strings.Repeat("4", 10))
+ v := h.db.s.version()
+ if v.tLen(0) <= 1 {
+ t.Errorf("tables-0 less than one")
+ }
+ v.release()
+}
+
+func TestDB_CompactionsGenerateMultipleFiles(t *testing.T) {
+ h := newDbHarnessWopt(t, &opt.Options{
+ WriteBuffer: 10000000,
+ Compression: opt.NoCompression,
+ })
+ defer h.close()
+
+ v := h.db.s.version()
+ if v.tLen(0) > 0 {
+ t.Errorf("level-0 tables more than 0, got %d", v.tLen(0))
+ }
+ v.release()
+
+ n := 80
+
+ // Write 8MB (80 values, each 100K)
+ for i := 0; i < n; i++ {
+ h.put(numKey(i), strings.Repeat(fmt.Sprintf("v%09d", i), 100000/10))
+ }
+
+ // Reopening moves updates to level-0
+ h.reopenDB()
+ h.compactRangeAt(0, "", "")
+
+ v = h.db.s.version()
+ if v.tLen(0) > 0 {
+ t.Errorf("level-0 tables more than 0, got %d", v.tLen(0))
+ }
+ if v.tLen(1) <= 1 {
+ t.Errorf("level-1 tables less than 1, got %d", v.tLen(1))
+ }
+ v.release()
+
+ for i := 0; i < n; i++ {
+ h.getVal(numKey(i), strings.Repeat(fmt.Sprintf("v%09d", i), 100000/10))
+ }
+}
+
+func TestDB_RepeatedWritesToSameKey(t *testing.T) {
+ h := newDbHarnessWopt(t, &opt.Options{WriteBuffer: 100000})
+ defer h.close()
+
+ maxTables := h.o.GetNumLevel() + h.o.GetWriteL0PauseTrigger()
+
+ value := strings.Repeat("v", 2*h.o.GetWriteBuffer())
+ for i := 0; i < 5*maxTables; i++ {
+ h.put("key", value)
+ n := h.totalTables()
+ if n > maxTables {
+ t.Errorf("total tables exceed %d, got=%d, iter=%d", maxTables, n, i)
+ }
+ }
+}
+
+func TestDB_RepeatedWritesToSameKeyAfterReopen(t *testing.T) {
+ h := newDbHarnessWopt(t, &opt.Options{WriteBuffer: 100000})
+ defer h.close()
+
+ h.reopenDB()
+
+ maxTables := h.o.GetNumLevel() + h.o.GetWriteL0PauseTrigger()
+
+ value := strings.Repeat("v", 2*h.o.GetWriteBuffer())
+ for i := 0; i < 5*maxTables; i++ {
+ h.put("key", value)
+ n := h.totalTables()
+ if n > maxTables {
+ t.Errorf("total tables exceed %d, got=%d, iter=%d", maxTables, n, i)
+ }
+ }
+}
+
+func TestDB_SparseMerge(t *testing.T) {
+ h := newDbHarnessWopt(t, &opt.Options{Compression: opt.NoCompression})
+ defer h.close()
+
+ h.putMulti(h.o.GetNumLevel(), "A", "Z")
+
+ // Suppose there is:
+ // small amount of data with prefix A
+ // large amount of data with prefix B
+ // small amount of data with prefix C
+ // and that recent updates have made small changes to all three prefixes.
+ // Check that we do not do a compaction that merges all of B in one shot.
+ h.put("A", "va")
+ value := strings.Repeat("x", 1000)
+ for i := 0; i < 100000; i++ {
+ h.put(fmt.Sprintf("B%010d", i), value)
+ }
+ h.put("C", "vc")
+ h.compactMem()
+ h.compactRangeAt(0, "", "")
+ h.waitCompaction()
+
+ // Make sparse update
+ h.put("A", "va2")
+ h.put("B100", "bvalue2")
+ h.put("C", "vc2")
+ h.compactMem()
+
+ h.waitCompaction()
+ h.maxNextLevelOverlappingBytes(20 * 1048576)
+ h.compactRangeAt(0, "", "")
+ h.waitCompaction()
+ h.maxNextLevelOverlappingBytes(20 * 1048576)
+ h.compactRangeAt(1, "", "")
+ h.waitCompaction()
+ h.maxNextLevelOverlappingBytes(20 * 1048576)
+}
+
+func TestDB_SizeOf(t *testing.T) {
+ h := newDbHarnessWopt(t, &opt.Options{
+ Compression: opt.NoCompression,
+ WriteBuffer: 10000000,
+ })
+ defer h.close()
+
+ h.sizeAssert("", "xyz", 0, 0)
+ h.reopenDB()
+ h.sizeAssert("", "xyz", 0, 0)
+
+ // Write 8MB (80 values, each 100K)
+ n := 80
+ s1 := 100000
+ s2 := 105000
+
+ for i := 0; i < n; i++ {
+ h.put(numKey(i), strings.Repeat(fmt.Sprintf("v%09d", i), s1/10))
+ }
+
+ // 0 because SizeOf() does not account for memtable space
+ h.sizeAssert("", numKey(50), 0, 0)
+
+ for r := 0; r < 3; r++ {
+ h.reopenDB()
+
+ for cs := 0; cs < n; cs += 10 {
+ for i := 0; i < n; i += 10 {
+ h.sizeAssert("", numKey(i), uint64(s1*i), uint64(s2*i))
+ h.sizeAssert("", numKey(i)+".suffix", uint64(s1*(i+1)), uint64(s2*(i+1)))
+ h.sizeAssert(numKey(i), numKey(i+10), uint64(s1*10), uint64(s2*10))
+ }
+
+ h.sizeAssert("", numKey(50), uint64(s1*50), uint64(s2*50))
+ h.sizeAssert("", numKey(50)+".suffix", uint64(s1*50), uint64(s2*50))
+
+ h.compactRangeAt(0, numKey(cs), numKey(cs+9))
+ }
+
+ v := h.db.s.version()
+ if v.tLen(0) != 0 {
+ t.Errorf("level-0 tables was not zero, got %d", v.tLen(0))
+ }
+ if v.tLen(1) == 0 {
+ t.Error("level-1 tables was zero")
+ }
+ v.release()
+ }
+}
+
+func TestDB_SizeOf_MixOfSmallAndLarge(t *testing.T) {
+ h := newDbHarnessWopt(t, &opt.Options{Compression: opt.NoCompression})
+ defer h.close()
+
+ sizes := []uint64{
+ 10000,
+ 10000,
+ 100000,
+ 10000,
+ 100000,
+ 10000,
+ 300000,
+ 10000,
+ }
+
+ for i, n := range sizes {
+ h.put(numKey(i), strings.Repeat(fmt.Sprintf("v%09d", i), int(n)/10))
+ }
+
+ for r := 0; r < 3; r++ {
+ h.reopenDB()
+
+ var x uint64
+ for i, n := range sizes {
+ y := x
+ if i > 0 {
+ y += 1000
+ }
+ h.sizeAssert("", numKey(i), x, y)
+ x += n
+ }
+
+ h.sizeAssert(numKey(3), numKey(5), 110000, 111000)
+
+ h.compactRangeAt(0, "", "")
+ }
+}
+
+func TestDB_Snapshot(t *testing.T) {
+ trun(t, func(h *dbHarness) {
+ h.put("foo", "v1")
+ s1 := h.getSnapshot()
+ h.put("foo", "v2")
+ s2 := h.getSnapshot()
+ h.put("foo", "v3")
+ s3 := h.getSnapshot()
+ h.put("foo", "v4")
+
+ h.getValr(s1, "foo", "v1")
+ h.getValr(s2, "foo", "v2")
+ h.getValr(s3, "foo", "v3")
+ h.getVal("foo", "v4")
+
+ s3.Release()
+ h.getValr(s1, "foo", "v1")
+ h.getValr(s2, "foo", "v2")
+ h.getVal("foo", "v4")
+
+ s1.Release()
+ h.getValr(s2, "foo", "v2")
+ h.getVal("foo", "v4")
+
+ s2.Release()
+ h.getVal("foo", "v4")
+ })
+}
+
+func TestDB_SnapshotList(t *testing.T) {
+ db := &DB{snapsList: list.New()}
+ e0a := db.acquireSnapshot()
+ e0b := db.acquireSnapshot()
+ db.seq = 1
+ e1 := db.acquireSnapshot()
+ db.seq = 2
+ e2 := db.acquireSnapshot()
+
+ if db.minSeq() != 0 {
+ t.Fatalf("invalid sequence number, got=%d", db.minSeq())
+ }
+ db.releaseSnapshot(e0a)
+ if db.minSeq() != 0 {
+ t.Fatalf("invalid sequence number, got=%d", db.minSeq())
+ }
+ db.releaseSnapshot(e2)
+ if db.minSeq() != 0 {
+ t.Fatalf("invalid sequence number, got=%d", db.minSeq())
+ }
+ db.releaseSnapshot(e0b)
+ if db.minSeq() != 1 {
+ t.Fatalf("invalid sequence number, got=%d", db.minSeq())
+ }
+ e2 = db.acquireSnapshot()
+ if db.minSeq() != 1 {
+ t.Fatalf("invalid sequence number, got=%d", db.minSeq())
+ }
+ db.releaseSnapshot(e1)
+ if db.minSeq() != 2 {
+ t.Fatalf("invalid sequence number, got=%d", db.minSeq())
+ }
+ db.releaseSnapshot(e2)
+ if db.minSeq() != 2 {
+ t.Fatalf("invalid sequence number, got=%d", db.minSeq())
+ }
+}
+
+func TestDB_HiddenValuesAreRemoved(t *testing.T) {
+ trun(t, func(h *dbHarness) {
+ s := h.db.s
+
+ h.put("foo", "v1")
+ h.compactMem()
+ m := h.o.GetMaxMemCompationLevel()
+ v := s.version()
+ num := v.tLen(m)
+ v.release()
+ if num != 1 {
+ t.Errorf("invalid level-%d len, want=1 got=%d", m, num)
+ }
+
+ // Place a table at level last-1 to prevent merging with preceding mutation
+ h.put("a", "begin")
+ h.put("z", "end")
+ h.compactMem()
+ v = s.version()
+ if v.tLen(m) != 1 {
+ t.Errorf("invalid level-%d len, want=1 got=%d", m, v.tLen(m))
+ }
+ if v.tLen(m-1) != 1 {
+ t.Errorf("invalid level-%d len, want=1 got=%d", m-1, v.tLen(m-1))
+ }
+ v.release()
+
+ h.delete("foo")
+ h.put("foo", "v2")
+ h.allEntriesFor("foo", "[ v2, DEL, v1 ]")
+ h.compactMem()
+ h.allEntriesFor("foo", "[ v2, DEL, v1 ]")
+ h.compactRangeAt(m-2, "", "z")
+ // DEL eliminated, but v1 remains because we aren't compacting that level
+ // (DEL can be eliminated because v2 hides v1).
+ h.allEntriesFor("foo", "[ v2, v1 ]")
+ h.compactRangeAt(m-1, "", "")
+ // Merging last-1 w/ last, so we are the base level for "foo", so
+ // DEL is removed. (as is v1).
+ h.allEntriesFor("foo", "[ v2 ]")
+ })
+}
+
+func TestDB_DeletionMarkers2(t *testing.T) {
+ h := newDbHarness(t)
+ defer h.close()
+ s := h.db.s
+
+ h.put("foo", "v1")
+ h.compactMem()
+ m := h.o.GetMaxMemCompationLevel()
+ v := s.version()
+ num := v.tLen(m)
+ v.release()
+ if num != 1 {
+ t.Errorf("invalid level-%d len, want=1 got=%d", m, num)
+ }
+
+ // Place a table at level last-1 to prevent merging with preceding mutation
+ h.put("a", "begin")
+ h.put("z", "end")
+ h.compactMem()
+ v = s.version()
+ if v.tLen(m) != 1 {
+ t.Errorf("invalid level-%d len, want=1 got=%d", m, v.tLen(m))
+ }
+ if v.tLen(m-1) != 1 {
+ t.Errorf("invalid level-%d len, want=1 got=%d", m-1, v.tLen(m-1))
+ }
+ v.release()
+
+ h.delete("foo")
+ h.allEntriesFor("foo", "[ DEL, v1 ]")
+ h.compactMem() // Moves to level last-2
+ h.allEntriesFor("foo", "[ DEL, v1 ]")
+ h.compactRangeAt(m-2, "", "")
+ // DEL kept: "last" file overlaps
+ h.allEntriesFor("foo", "[ DEL, v1 ]")
+ h.compactRangeAt(m-1, "", "")
+ // Merging last-1 w/ last, so we are the base level for "foo", so
+ // DEL is removed. (as is v1).
+ h.allEntriesFor("foo", "[ ]")
+}
+
+func TestDB_CompactionTableOpenError(t *testing.T) {
+ h := newDbHarnessWopt(t, &opt.Options{OpenFilesCacheCapacity: -1})
+ defer h.close()
+
+ im := 10
+ jm := 10
+ for r := 0; r < 2; r++ {
+ for i := 0; i < im; i++ {
+ for j := 0; j < jm; j++ {
+ h.put(fmt.Sprintf("k%d,%d", i, j), fmt.Sprintf("v%d,%d", i, j))
+ }
+ h.compactMem()
+ }
+ }
+
+ if n := h.totalTables(); n != im*2 {
+ t.Errorf("total tables is %d, want %d", n, im)
+ }
+
+ h.stor.SetEmuErr(storage.TypeTable, tsOpOpen)
+ go h.db.CompactRange(util.Range{})
+ if err := h.db.compSendIdle(h.db.tcompCmdC); err != nil {
+ t.Log("compaction error: ", err)
+ }
+ h.closeDB0()
+ h.openDB()
+ h.stor.SetEmuErr(0, tsOpOpen)
+
+ for i := 0; i < im; i++ {
+ for j := 0; j < jm; j++ {
+ h.getVal(fmt.Sprintf("k%d,%d", i, j), fmt.Sprintf("v%d,%d", i, j))
+ }
+ }
+}
+
+func TestDB_OverlapInLevel0(t *testing.T) {
+ trun(t, func(h *dbHarness) {
+ if h.o.GetMaxMemCompationLevel() != 2 {
+ t.Fatal("fix test to reflect the config")
+ }
+
+ // Fill levels 1 and 2 to disable the pushing of new memtables to levels > 0.
+ h.put("100", "v100")
+ h.put("999", "v999")
+ h.compactMem()
+ h.delete("100")
+ h.delete("999")
+ h.compactMem()
+ h.tablesPerLevel("0,1,1")
+
+ // Make files spanning the following ranges in level-0:
+ // files[0] 200 .. 900
+ // files[1] 300 .. 500
+ // Note that files are sorted by min key.
+ h.put("300", "v300")
+ h.put("500", "v500")
+ h.compactMem()
+ h.put("200", "v200")
+ h.put("600", "v600")
+ h.put("900", "v900")
+ h.compactMem()
+ h.tablesPerLevel("2,1,1")
+
+ // Compact away the placeholder files we created initially
+ h.compactRangeAt(1, "", "")
+ h.compactRangeAt(2, "", "")
+ h.tablesPerLevel("2")
+
+ // Do a memtable compaction. Before bug-fix, the compaction would
+ // not detect the overlap with level-0 files and would incorrectly place
+ // the deletion in a deeper level.
+ h.delete("600")
+ h.compactMem()
+ h.tablesPerLevel("3")
+ h.get("600", false)
+ })
+}
+
+func TestDB_L0_CompactionBug_Issue44_a(t *testing.T) {
+ h := newDbHarness(t)
+ defer h.close()
+
+ h.reopenDB()
+ h.put("b", "v")
+ h.reopenDB()
+ h.delete("b")
+ h.delete("a")
+ h.reopenDB()
+ h.delete("a")
+ h.reopenDB()
+ h.put("a", "v")
+ h.reopenDB()
+ h.reopenDB()
+ h.getKeyVal("(a->v)")
+ h.waitCompaction()
+ h.getKeyVal("(a->v)")
+}
+
+func TestDB_L0_CompactionBug_Issue44_b(t *testing.T) {
+ h := newDbHarness(t)
+ defer h.close()
+
+ h.reopenDB()
+ h.put("", "")
+ h.reopenDB()
+ h.delete("e")
+ h.put("", "")
+ h.reopenDB()
+ h.put("c", "cv")
+ h.reopenDB()
+ h.put("", "")
+ h.reopenDB()
+ h.put("", "")
+ h.waitCompaction()
+ h.reopenDB()
+ h.put("d", "dv")
+ h.reopenDB()
+ h.put("", "")
+ h.reopenDB()
+ h.delete("d")
+ h.delete("b")
+ h.reopenDB()
+ h.getKeyVal("(->)(c->cv)")
+ h.waitCompaction()
+ h.getKeyVal("(->)(c->cv)")
+}
+
+func TestDB_SingleEntryMemCompaction(t *testing.T) {
+ trun(t, func(h *dbHarness) {
+ for i := 0; i < 10; i++ {
+ h.put("big", strings.Repeat("v", opt.DefaultWriteBuffer))
+ h.compactMem()
+ h.put("key", strings.Repeat("v", opt.DefaultBlockSize))
+ h.compactMem()
+ h.put("k", "v")
+ h.compactMem()
+ h.put("", "")
+ h.compactMem()
+ h.put("verybig", strings.Repeat("v", opt.DefaultWriteBuffer*2))
+ h.compactMem()
+ }
+ })
+}
+
+func TestDB_ManifestWriteError(t *testing.T) {
+ for i := 0; i < 2; i++ {
+ func() {
+ h := newDbHarness(t)
+ defer h.close()
+
+ h.put("foo", "bar")
+ h.getVal("foo", "bar")
+
+ // Mem compaction (will succeed)
+ h.compactMem()
+ h.getVal("foo", "bar")
+ v := h.db.s.version()
+ if n := v.tLen(h.o.GetMaxMemCompationLevel()); n != 1 {
+ t.Errorf("invalid total tables, want=1 got=%d", n)
+ }
+ v.release()
+
+ if i == 0 {
+ h.stor.SetEmuErr(storage.TypeManifest, tsOpWrite)
+ } else {
+ h.stor.SetEmuErr(storage.TypeManifest, tsOpSync)
+ }
+
+ // Merging compaction (will fail)
+ h.compactRangeAtErr(h.o.GetMaxMemCompationLevel(), "", "", true)
+
+ h.db.Close()
+ h.stor.SetEmuErr(0, tsOpWrite)
+ h.stor.SetEmuErr(0, tsOpSync)
+
+ // Should not lose data
+ h.openDB()
+ h.getVal("foo", "bar")
+ }()
+ }
+}
+
+func assertErr(t *testing.T, err error, wanterr bool) {
+ if err != nil {
+ if wanterr {
+ t.Log("AssertErr: got error (expected): ", err)
+ } else {
+ t.Error("AssertErr: got error: ", err)
+ }
+ } else if wanterr {
+ t.Error("AssertErr: expect error")
+ }
+}
+
+func TestDB_ClosedIsClosed(t *testing.T) {
+ h := newDbHarness(t)
+ db := h.db
+
+ var iter, iter2 iterator.Iterator
+ var snap *Snapshot
+ func() {
+ defer h.close()
+
+ h.put("k", "v")
+ h.getVal("k", "v")
+
+ iter = db.NewIterator(nil, h.ro)
+ iter.Seek([]byte("k"))
+ testKeyVal(t, iter, "k->v")
+
+ var err error
+ snap, err = db.GetSnapshot()
+ if err != nil {
+ t.Fatal("GetSnapshot: got error: ", err)
+ }
+
+ h.getValr(snap, "k", "v")
+
+ iter2 = snap.NewIterator(nil, h.ro)
+ iter2.Seek([]byte("k"))
+ testKeyVal(t, iter2, "k->v")
+
+ h.put("foo", "v2")
+ h.delete("foo")
+
+ // closing DB
+ iter.Release()
+ iter2.Release()
+ }()
+
+ assertErr(t, db.Put([]byte("x"), []byte("y"), h.wo), true)
+ _, err := db.Get([]byte("k"), h.ro)
+ assertErr(t, err, true)
+
+ if iter.Valid() {
+ t.Errorf("iter.Valid should false")
+ }
+ assertErr(t, iter.Error(), false)
+ testKeyVal(t, iter, "->")
+ if iter.Seek([]byte("k")) {
+ t.Errorf("iter.Seek should false")
+ }
+ assertErr(t, iter.Error(), true)
+
+ assertErr(t, iter2.Error(), false)
+
+ _, err = snap.Get([]byte("k"), h.ro)
+ assertErr(t, err, true)
+
+ _, err = db.GetSnapshot()
+ assertErr(t, err, true)
+
+ iter3 := db.NewIterator(nil, h.ro)
+ assertErr(t, iter3.Error(), true)
+
+ iter3 = snap.NewIterator(nil, h.ro)
+ assertErr(t, iter3.Error(), true)
+
+ assertErr(t, db.Delete([]byte("k"), h.wo), true)
+
+ _, err = db.GetProperty("leveldb.stats")
+ assertErr(t, err, true)
+
+ _, err = db.SizeOf([]util.Range{{[]byte("a"), []byte("z")}})
+ assertErr(t, err, true)
+
+ assertErr(t, db.CompactRange(util.Range{}), true)
+
+ assertErr(t, db.Close(), true)
+}
+
+type numberComparer struct{}
+
+func (numberComparer) num(x []byte) (n int) {
+ fmt.Sscan(string(x[1:len(x)-1]), &n)
+ return
+}
+
+func (numberComparer) Name() string {
+ return "test.NumberComparer"
+}
+
+func (p numberComparer) Compare(a, b []byte) int {
+ return p.num(a) - p.num(b)
+}
+
+func (numberComparer) Separator(dst, a, b []byte) []byte { return nil }
+func (numberComparer) Successor(dst, b []byte) []byte { return nil }
+
+func TestDB_CustomComparer(t *testing.T) {
+ h := newDbHarnessWopt(t, &opt.Options{
+ Comparer: numberComparer{},
+ WriteBuffer: 1000,
+ })
+ defer h.close()
+
+ h.put("[10]", "ten")
+ h.put("[0x14]", "twenty")
+ for i := 0; i < 2; i++ {
+ h.getVal("[10]", "ten")
+ h.getVal("[0xa]", "ten")
+ h.getVal("[20]", "twenty")
+ h.getVal("[0x14]", "twenty")
+ h.get("[15]", false)
+ h.get("[0xf]", false)
+ h.compactMem()
+ h.compactRange("[0]", "[9999]")
+ }
+
+ for n := 0; n < 2; n++ {
+ for i := 0; i < 100; i++ {
+ v := fmt.Sprintf("[%d]", i*10)
+ h.put(v, v)
+ }
+ h.compactMem()
+ h.compactRange("[0]", "[1000000]")
+ }
+}
+
+func TestDB_ManualCompaction(t *testing.T) {
+ h := newDbHarness(t)
+ defer h.close()
+
+ if h.o.GetMaxMemCompationLevel() != 2 {
+ t.Fatal("fix test to reflect the config")
+ }
+
+ h.putMulti(3, "p", "q")
+ h.tablesPerLevel("1,1,1")
+
+ // Compaction range falls before files
+ h.compactRange("", "c")
+ h.tablesPerLevel("1,1,1")
+
+ // Compaction range falls after files
+ h.compactRange("r", "z")
+ h.tablesPerLevel("1,1,1")
+
+ // Compaction range overlaps files
+ h.compactRange("p1", "p9")
+ h.tablesPerLevel("0,0,1")
+
+ // Populate a different range
+ h.putMulti(3, "c", "e")
+ h.tablesPerLevel("1,1,2")
+
+ // Compact just the new range
+ h.compactRange("b", "f")
+ h.tablesPerLevel("0,0,2")
+
+ // Compact all
+ h.putMulti(1, "a", "z")
+ h.tablesPerLevel("0,1,2")
+ h.compactRange("", "")
+ h.tablesPerLevel("0,0,1")
+}
+
+func TestDB_BloomFilter(t *testing.T) {
+ h := newDbHarnessWopt(t, &opt.Options{
+ DisableBlockCache: true,
+ Filter: filter.NewBloomFilter(10),
+ })
+ defer h.close()
+
+ key := func(i int) string {
+ return fmt.Sprintf("key%06d", i)
+ }
+
+ const n = 10000
+
+ // Populate multiple layers
+ for i := 0; i < n; i++ {
+ h.put(key(i), key(i))
+ }
+ h.compactMem()
+ h.compactRange("a", "z")
+ for i := 0; i < n; i += 100 {
+ h.put(key(i), key(i))
+ }
+ h.compactMem()
+
+ // Prevent auto compactions triggered by seeks
+ h.stor.DelaySync(storage.TypeTable)
+
+ // Lookup present keys. Should rarely read from small sstable.
+ h.stor.SetReadCounter(storage.TypeTable)
+ for i := 0; i < n; i++ {
+ h.getVal(key(i), key(i))
+ }
+ cnt := int(h.stor.ReadCounter())
+ t.Logf("lookup of %d present keys yield %d sstable I/O reads", n, cnt)
+
+ if min, max := n, n+2*n/100; cnt < min || cnt > max {
+ t.Errorf("num of sstable I/O reads of present keys not in range of %d - %d, got %d", min, max, cnt)
+ }
+
+ // Lookup missing keys. Should rarely read from either sstable.
+ h.stor.ResetReadCounter()
+ for i := 0; i < n; i++ {
+ h.get(key(i)+".missing", false)
+ }
+ cnt = int(h.stor.ReadCounter())
+ t.Logf("lookup of %d missing keys yield %d sstable I/O reads", n, cnt)
+ if max := 3 * n / 100; cnt > max {
+ t.Errorf("num of sstable I/O reads of missing keys was more than %d, got %d", max, cnt)
+ }
+
+ h.stor.ReleaseSync(storage.TypeTable)
+}
+
+func TestDB_Concurrent(t *testing.T) {
+ const n, secs, maxkey = 4, 2, 1000
+
+ runtime.GOMAXPROCS(n)
+ trun(t, func(h *dbHarness) {
+ var closeWg sync.WaitGroup
+ var stop uint32
+ var cnt [n]uint32
+
+ for i := 0; i < n; i++ {
+ closeWg.Add(1)
+ go func(i int) {
+ var put, get, found uint
+ defer func() {
+ t.Logf("goroutine %d stopped after %d ops, put=%d get=%d found=%d missing=%d",
+ i, cnt[i], put, get, found, get-found)
+ closeWg.Done()
+ }()
+
+ rnd := rand.New(rand.NewSource(int64(1000 + i)))
+ for atomic.LoadUint32(&stop) == 0 {
+ x := cnt[i]
+
+ k := rnd.Intn(maxkey)
+ kstr := fmt.Sprintf("%016d", k)
+
+ if (rnd.Int() % 2) > 0 {
+ put++
+ h.put(kstr, fmt.Sprintf("%d.%d.%-1000d", k, i, x))
+ } else {
+ get++
+ v, err := h.db.Get([]byte(kstr), h.ro)
+ if err == nil {
+ found++
+ rk, ri, rx := 0, -1, uint32(0)
+ fmt.Sscanf(string(v), "%d.%d.%d", &rk, &ri, &rx)
+ if rk != k {
+ t.Errorf("invalid key want=%d got=%d", k, rk)
+ }
+ if ri < 0 || ri >= n {
+ t.Error("invalid goroutine number: ", ri)
+ } else {
+ tx := atomic.LoadUint32(&(cnt[ri]))
+ if rx > tx {
+ t.Errorf("invalid seq number, %d > %d ", rx, tx)
+ }
+ }
+ } else if err != ErrNotFound {
+ t.Error("Get: got error: ", err)
+ return
+ }
+ }
+ atomic.AddUint32(&cnt[i], 1)
+ }
+ }(i)
+ }
+
+ time.Sleep(secs * time.Second)
+ atomic.StoreUint32(&stop, 1)
+ closeWg.Wait()
+ })
+
+ runtime.GOMAXPROCS(1)
+}
+
+func TestDB_Concurrent2(t *testing.T) {
+ const n, n2 = 4, 4000
+
+ runtime.GOMAXPROCS(n*2 + 2)
+ truno(t, &opt.Options{WriteBuffer: 30}, func(h *dbHarness) {
+ var closeWg sync.WaitGroup
+ var stop uint32
+
+ for i := 0; i < n; i++ {
+ closeWg.Add(1)
+ go func(i int) {
+ for k := 0; atomic.LoadUint32(&stop) == 0; k++ {
+ h.put(fmt.Sprintf("k%d", k), fmt.Sprintf("%d.%d.", k, i)+strings.Repeat("x", 10))
+ }
+ closeWg.Done()
+ }(i)
+ }
+
+ for i := 0; i < n; i++ {
+ closeWg.Add(1)
+ go func(i int) {
+ for k := 1000000; k < 0 || atomic.LoadUint32(&stop) == 0; k-- {
+ h.put(fmt.Sprintf("k%d", k), fmt.Sprintf("%d.%d.", k, i)+strings.Repeat("x", 10))
+ }
+ closeWg.Done()
+ }(i)
+ }
+
+ cmp := comparer.DefaultComparer
+ for i := 0; i < n2; i++ {
+ closeWg.Add(1)
+ go func(i int) {
+ it := h.db.NewIterator(nil, nil)
+ var pk []byte
+ for it.Next() {
+ kk := it.Key()
+ if cmp.Compare(kk, pk) <= 0 {
+ t.Errorf("iter %d: %q is successor of %q", i, pk, kk)
+ }
+ pk = append(pk[:0], kk...)
+ var k, vk, vi int
+ if n, err := fmt.Sscanf(string(it.Key()), "k%d", &k); err != nil {
+ t.Errorf("iter %d: Scanf error on key %q: %v", i, it.Key(), err)
+ } else if n < 1 {
+ t.Errorf("iter %d: Cannot parse key %q", i, it.Key())
+ }
+ if n, err := fmt.Sscanf(string(it.Value()), "%d.%d", &vk, &vi); err != nil {
+ t.Errorf("iter %d: Scanf error on value %q: %v", i, it.Value(), err)
+ } else if n < 2 {
+ t.Errorf("iter %d: Cannot parse value %q", i, it.Value())
+ }
+
+ if vk != k {
+ t.Errorf("iter %d: invalid value i=%d, want=%d got=%d", i, vi, k, vk)
+ }
+ }
+ if err := it.Error(); err != nil {
+ t.Errorf("iter %d: Got error: %v", i, err)
+ }
+ it.Release()
+ closeWg.Done()
+ }(i)
+ }
+
+ atomic.StoreUint32(&stop, 1)
+ closeWg.Wait()
+ })
+
+ runtime.GOMAXPROCS(1)
+}
+
+func TestDB_CreateReopenDbOnFile(t *testing.T) {
+ dbpath := filepath.Join(os.TempDir(), fmt.Sprintf("goleveldbtestCreateReopenDbOnFile-%d", os.Getuid()))
+ if err := os.RemoveAll(dbpath); err != nil {
+ t.Fatal("cannot remove old db: ", err)
+ }
+ defer os.RemoveAll(dbpath)
+
+ for i := 0; i < 3; i++ {
+ stor, err := storage.OpenFile(dbpath)
+ if err != nil {
+ t.Fatalf("(%d) cannot open storage: %s", i, err)
+ }
+ db, err := Open(stor, nil)
+ if err != nil {
+ t.Fatalf("(%d) cannot open db: %s", i, err)
+ }
+ if err := db.Put([]byte("foo"), []byte("bar"), nil); err != nil {
+ t.Fatalf("(%d) cannot write to db: %s", i, err)
+ }
+ if err := db.Close(); err != nil {
+ t.Fatalf("(%d) cannot close db: %s", i, err)
+ }
+ if err := stor.Close(); err != nil {
+ t.Fatalf("(%d) cannot close storage: %s", i, err)
+ }
+ }
+}
+
+func TestDB_CreateReopenDbOnFile2(t *testing.T) {
+ dbpath := filepath.Join(os.TempDir(), fmt.Sprintf("goleveldbtestCreateReopenDbOnFile2-%d", os.Getuid()))
+ if err := os.RemoveAll(dbpath); err != nil {
+ t.Fatal("cannot remove old db: ", err)
+ }
+ defer os.RemoveAll(dbpath)
+
+ for i := 0; i < 3; i++ {
+ db, err := OpenFile(dbpath, nil)
+ if err != nil {
+ t.Fatalf("(%d) cannot open db: %s", i, err)
+ }
+ if err := db.Put([]byte("foo"), []byte("bar"), nil); err != nil {
+ t.Fatalf("(%d) cannot write to db: %s", i, err)
+ }
+ if err := db.Close(); err != nil {
+ t.Fatalf("(%d) cannot close db: %s", i, err)
+ }
+ }
+}
+
+func TestDB_DeletionMarkersOnMemdb(t *testing.T) {
+ h := newDbHarness(t)
+ defer h.close()
+
+ h.put("foo", "v1")
+ h.compactMem()
+ h.delete("foo")
+ h.get("foo", false)
+ h.getKeyVal("")
+}
+
+func TestDB_LeveldbIssue178(t *testing.T) {
+ nKeys := (opt.DefaultCompactionTableSize / 30) * 5
+ key1 := func(i int) string {
+ return fmt.Sprintf("my_key_%d", i)
+ }
+ key2 := func(i int) string {
+ return fmt.Sprintf("my_key_%d_xxx", i)
+ }
+
+ // Disable compression since it affects the creation of layers and the
+ // code below is trying to test against a very specific scenario.
+ h := newDbHarnessWopt(t, &opt.Options{Compression: opt.NoCompression})
+ defer h.close()
+
+ // Create first key range.
+ batch := new(Batch)
+ for i := 0; i < nKeys; i++ {
+ batch.Put([]byte(key1(i)), []byte("value for range 1 key"))
+ }
+ h.write(batch)
+
+ // Create second key range.
+ batch.Reset()
+ for i := 0; i < nKeys; i++ {
+ batch.Put([]byte(key2(i)), []byte("value for range 2 key"))
+ }
+ h.write(batch)
+
+ // Delete second key range.
+ batch.Reset()
+ for i := 0; i < nKeys; i++ {
+ batch.Delete([]byte(key2(i)))
+ }
+ h.write(batch)
+ h.waitMemCompaction()
+
+ // Run manual compaction.
+ h.compactRange(key1(0), key1(nKeys-1))
+
+ // Checking the keys.
+ h.assertNumKeys(nKeys)
+}
+
+func TestDB_LeveldbIssue200(t *testing.T) {
+ h := newDbHarness(t)
+ defer h.close()
+
+ h.put("1", "b")
+ h.put("2", "c")
+ h.put("3", "d")
+ h.put("4", "e")
+ h.put("5", "f")
+
+ iter := h.db.NewIterator(nil, h.ro)
+
+ // Add an element that should not be reflected in the iterator.
+ h.put("25", "cd")
+
+ iter.Seek([]byte("5"))
+ assertBytes(t, []byte("5"), iter.Key())
+ iter.Prev()
+ assertBytes(t, []byte("4"), iter.Key())
+ iter.Prev()
+ assertBytes(t, []byte("3"), iter.Key())
+ iter.Next()
+ assertBytes(t, []byte("4"), iter.Key())
+ iter.Next()
+ assertBytes(t, []byte("5"), iter.Key())
+}
+
+func TestDB_GoleveldbIssue74(t *testing.T) {
+ h := newDbHarnessWopt(t, &opt.Options{
+ WriteBuffer: 1 * opt.MiB,
+ })
+ defer h.close()
+
+ const n, dur = 10000, 5 * time.Second
+
+ runtime.GOMAXPROCS(runtime.NumCPU())
+
+ until := time.Now().Add(dur)
+ wg := new(sync.WaitGroup)
+ wg.Add(2)
+ var done uint32
+ go func() {
+ var i int
+ defer func() {
+ t.Logf("WRITER DONE #%d", i)
+ atomic.StoreUint32(&done, 1)
+ wg.Done()
+ }()
+
+ b := new(Batch)
+ for ; time.Now().Before(until) && atomic.LoadUint32(&done) == 0; i++ {
+ iv := fmt.Sprintf("VAL%010d", i)
+ for k := 0; k < n; k++ {
+ key := fmt.Sprintf("KEY%06d", k)
+ b.Put([]byte(key), []byte(key+iv))
+ b.Put([]byte(fmt.Sprintf("PTR%06d", k)), []byte(key))
+ }
+ h.write(b)
+
+ b.Reset()
+ snap := h.getSnapshot()
+ iter := snap.NewIterator(util.BytesPrefix([]byte("PTR")), nil)
+ var k int
+ for ; iter.Next(); k++ {
+ ptrKey := iter.Key()
+ key := iter.Value()
+
+ if _, err := snap.Get(ptrKey, nil); err != nil {
+ t.Fatalf("WRITER #%d snapshot.Get %q: %v", i, ptrKey, err)
+ }
+ if value, err := snap.Get(key, nil); err != nil {
+ t.Fatalf("WRITER #%d snapshot.Get %q: %v", i, key, err)
+ } else if string(value) != string(key)+iv {
+ t.Fatalf("WRITER #%d snapshot.Get %q got invalid value, want %q got %q", i, key, string(key)+iv, value)
+ }
+
+ b.Delete(key)
+ b.Delete(ptrKey)
+ }
+ h.write(b)
+ iter.Release()
+ snap.Release()
+ if k != n {
+ t.Fatalf("#%d %d != %d", i, k, n)
+ }
+ }
+ }()
+ go func() {
+ var i int
+ defer func() {
+ t.Logf("READER DONE #%d", i)
+ atomic.StoreUint32(&done, 1)
+ wg.Done()
+ }()
+ for ; time.Now().Before(until) && atomic.LoadUint32(&done) == 0; i++ {
+ snap := h.getSnapshot()
+ iter := snap.NewIterator(util.BytesPrefix([]byte("PTR")), nil)
+ var prevValue string
+ var k int
+ for ; iter.Next(); k++ {
+ ptrKey := iter.Key()
+ key := iter.Value()
+
+ if _, err := snap.Get(ptrKey, nil); err != nil {
+ t.Fatalf("READER #%d snapshot.Get %q: %v", i, ptrKey, err)
+ }
+
+ if value, err := snap.Get(key, nil); err != nil {
+ t.Fatalf("READER #%d snapshot.Get %q: %v", i, key, err)
+ } else if prevValue != "" && string(value) != string(key)+prevValue {
+ t.Fatalf("READER #%d snapshot.Get %q got invalid value, want %q got %q", i, key, string(key)+prevValue, value)
+ } else {
+ prevValue = string(value[len(key):])
+ }
+ }
+ iter.Release()
+ snap.Release()
+ if k > 0 && k != n {
+ t.Fatalf("#%d %d != %d", i, k, n)
+ }
+ }
+ }()
+ wg.Wait()
+}
+
+func TestDB_GetProperties(t *testing.T) {
+ h := newDbHarness(t)
+ defer h.close()
+
+ _, err := h.db.GetProperty("leveldb.num-files-at-level")
+ if err == nil {
+ t.Error("GetProperty() failed to detect missing level")
+ }
+
+ _, err = h.db.GetProperty("leveldb.num-files-at-level0")
+ if err != nil {
+ t.Error("got unexpected error", err)
+ }
+
+ _, err = h.db.GetProperty("leveldb.num-files-at-level0x")
+ if err == nil {
+ t.Error("GetProperty() failed to detect invalid level")
+ }
+}
+
+func TestDB_GoleveldbIssue72and83(t *testing.T) {
+ h := newDbHarnessWopt(t, &opt.Options{
+ WriteBuffer: 1 * opt.MiB,
+ OpenFilesCacheCapacity: 3,
+ })
+ defer h.close()
+
+ const n, wn, dur = 10000, 100, 30 * time.Second
+
+ runtime.GOMAXPROCS(runtime.NumCPU())
+
+ randomData := func(prefix byte, i int) []byte {
+ data := make([]byte, 1+4+32+64+32)
+ _, err := crand.Reader.Read(data[1 : len(data)-8])
+ if err != nil {
+ panic(err)
+ }
+ data[0] = prefix
+ binary.LittleEndian.PutUint32(data[len(data)-8:], uint32(i))
+ binary.LittleEndian.PutUint32(data[len(data)-4:], util.NewCRC(data[:len(data)-4]).Value())
+ return data
+ }
+
+ keys := make([][]byte, n)
+ for i := range keys {
+ keys[i] = randomData(1, 0)
+ }
+
+ until := time.Now().Add(dur)
+ wg := new(sync.WaitGroup)
+ wg.Add(3)
+ var done uint32
+ go func() {
+ i := 0
+ defer func() {
+ t.Logf("WRITER DONE #%d", i)
+ wg.Done()
+ }()
+
+ b := new(Batch)
+ for ; i < wn && atomic.LoadUint32(&done) == 0; i++ {
+ b.Reset()
+ for _, k1 := range keys {
+ k2 := randomData(2, i)
+ b.Put(k2, randomData(42, i))
+ b.Put(k1, k2)
+ }
+ if err := h.db.Write(b, h.wo); err != nil {
+ atomic.StoreUint32(&done, 1)
+ t.Fatalf("WRITER #%d db.Write: %v", i, err)
+ }
+ }
+ }()
+ go func() {
+ var i int
+ defer func() {
+ t.Logf("READER0 DONE #%d", i)
+ atomic.StoreUint32(&done, 1)
+ wg.Done()
+ }()
+ for ; time.Now().Before(until) && atomic.LoadUint32(&done) == 0; i++ {
+ snap := h.getSnapshot()
+ seq := snap.elem.seq
+ if seq == 0 {
+ snap.Release()
+ continue
+ }
+ iter := snap.NewIterator(util.BytesPrefix([]byte{1}), nil)
+ writei := int(seq/(n*2) - 1)
+ var k int
+ for ; iter.Next(); k++ {
+ k1 := iter.Key()
+ k2 := iter.Value()
+ k1checksum0 := binary.LittleEndian.Uint32(k1[len(k1)-4:])
+ k1checksum1 := util.NewCRC(k1[:len(k1)-4]).Value()
+ if k1checksum0 != k1checksum1 {
+ t.Fatalf("READER0 #%d.%d W#%d invalid K1 checksum: %#x != %#x", i, k, k1checksum0, k1checksum0)
+ }
+ k2checksum0 := binary.LittleEndian.Uint32(k2[len(k2)-4:])
+ k2checksum1 := util.NewCRC(k2[:len(k2)-4]).Value()
+ if k2checksum0 != k2checksum1 {
+ t.Fatalf("READER0 #%d.%d W#%d invalid K2 checksum: %#x != %#x", i, k, k2checksum0, k2checksum1)
+ }
+ kwritei := int(binary.LittleEndian.Uint32(k2[len(k2)-8:]))
+ if writei != kwritei {
+ t.Fatalf("READER0 #%d.%d W#%d invalid write iteration num: %d", i, k, writei, kwritei)
+ }
+ if _, err := snap.Get(k2, nil); err != nil {
+ t.Fatalf("READER0 #%d.%d W#%d snap.Get: %v\nk1: %x\n -> k2: %x", i, k, writei, err, k1, k2)
+ }
+ }
+ if err := iter.Error(); err != nil {
+ t.Fatalf("READER0 #%d.%d W#%d snap.Iterator: %v", i, k, writei, err)
+ }
+ iter.Release()
+ snap.Release()
+ if k > 0 && k != n {
+ t.Fatalf("READER0 #%d W#%d short read, got=%d want=%d", i, writei, k, n)
+ }
+ }
+ }()
+ go func() {
+ var i int
+ defer func() {
+ t.Logf("READER1 DONE #%d", i)
+ atomic.StoreUint32(&done, 1)
+ wg.Done()
+ }()
+ for ; time.Now().Before(until) && atomic.LoadUint32(&done) == 0; i++ {
+ iter := h.db.NewIterator(nil, nil)
+ seq := iter.(*dbIter).seq
+ if seq == 0 {
+ iter.Release()
+ continue
+ }
+ writei := int(seq/(n*2) - 1)
+ var k int
+ for ok := iter.Last(); ok; ok = iter.Prev() {
+ k++
+ }
+ if err := iter.Error(); err != nil {
+ t.Fatalf("READER1 #%d.%d W#%d db.Iterator: %v", i, k, writei, err)
+ }
+ iter.Release()
+ if m := (writei+1)*n + n; k != m {
+ t.Fatalf("READER1 #%d W#%d short read, got=%d want=%d", i, writei, k, m)
+ }
+ }
+ }()
+
+ wg.Wait()
+}
+
+func TestDB_TransientError(t *testing.T) {
+ h := newDbHarnessWopt(t, &opt.Options{
+ WriteBuffer: 128 * opt.KiB,
+ OpenFilesCacheCapacity: 3,
+ DisableCompactionBackoff: true,
+ })
+ defer h.close()
+
+ const (
+ nSnap = 20
+ nKey = 10000
+ )
+
+ var (
+ snaps [nSnap]*Snapshot
+ b = &Batch{}
+ )
+ for i := range snaps {
+ vtail := fmt.Sprintf("VAL%030d", i)
+ b.Reset()
+ for k := 0; k < nKey; k++ {
+ key := fmt.Sprintf("KEY%8d", k)
+ b.Put([]byte(key), []byte(key+vtail))
+ }
+ h.stor.SetEmuRandErr(storage.TypeTable, tsOpOpen, tsOpRead, tsOpReadAt)
+ if err := h.db.Write(b, nil); err != nil {
+ t.Logf("WRITE #%d error: %v", i, err)
+ h.stor.SetEmuRandErr(0, tsOpOpen, tsOpRead, tsOpReadAt, tsOpWrite)
+ for {
+ if err := h.db.Write(b, nil); err == nil {
+ break
+ } else if errors.IsCorrupted(err) {
+ t.Fatalf("WRITE #%d corrupted: %v", i, err)
+ }
+ }
+ }
+
+ snaps[i] = h.db.newSnapshot()
+ b.Reset()
+ for k := 0; k < nKey; k++ {
+ key := fmt.Sprintf("KEY%8d", k)
+ b.Delete([]byte(key))
+ }
+ h.stor.SetEmuRandErr(storage.TypeTable, tsOpOpen, tsOpRead, tsOpReadAt)
+ if err := h.db.Write(b, nil); err != nil {
+ t.Logf("WRITE #%d error: %v", i, err)
+ h.stor.SetEmuRandErr(0, tsOpOpen, tsOpRead, tsOpReadAt)
+ for {
+ if err := h.db.Write(b, nil); err == nil {
+ break
+ } else if errors.IsCorrupted(err) {
+ t.Fatalf("WRITE #%d corrupted: %v", i, err)
+ }
+ }
+ }
+ }
+ h.stor.SetEmuRandErr(0, tsOpOpen, tsOpRead, tsOpReadAt)
+
+ runtime.GOMAXPROCS(runtime.NumCPU())
+
+ rnd := rand.New(rand.NewSource(0xecafdaed))
+ wg := &sync.WaitGroup{}
+ for i, snap := range snaps {
+ wg.Add(2)
+
+ go func(i int, snap *Snapshot, sk []int) {
+ defer wg.Done()
+
+ vtail := fmt.Sprintf("VAL%030d", i)
+ for _, k := range sk {
+ key := fmt.Sprintf("KEY%8d", k)
+ xvalue, err := snap.Get([]byte(key), nil)
+ if err != nil {
+ t.Fatalf("READER_GET #%d SEQ=%d K%d error: %v", i, snap.elem.seq, k, err)
+ }
+ value := key + vtail
+ if !bytes.Equal([]byte(value), xvalue) {
+ t.Fatalf("READER_GET #%d SEQ=%d K%d invalid value: want %q, got %q", i, snap.elem.seq, k, value, xvalue)
+ }
+ }
+ }(i, snap, rnd.Perm(nKey))
+
+ go func(i int, snap *Snapshot) {
+ defer wg.Done()
+
+ vtail := fmt.Sprintf("VAL%030d", i)
+ iter := snap.NewIterator(nil, nil)
+ defer iter.Release()
+ for k := 0; k < nKey; k++ {
+ if !iter.Next() {
+ if err := iter.Error(); err != nil {
+ t.Fatalf("READER_ITER #%d K%d error: %v", i, k, err)
+ } else {
+ t.Fatalf("READER_ITER #%d K%d eoi", i, k)
+ }
+ }
+ key := fmt.Sprintf("KEY%8d", k)
+ xkey := iter.Key()
+ if !bytes.Equal([]byte(key), xkey) {
+ t.Fatalf("READER_ITER #%d K%d invalid key: want %q, got %q", i, k, key, xkey)
+ }
+ value := key + vtail
+ xvalue := iter.Value()
+ if !bytes.Equal([]byte(value), xvalue) {
+ t.Fatalf("READER_ITER #%d K%d invalid value: want %q, got %q", i, k, value, xvalue)
+ }
+ }
+ }(i, snap)
+ }
+
+ wg.Wait()
+}
+
+func TestDB_UkeyShouldntHopAcrossTable(t *testing.T) {
+ h := newDbHarnessWopt(t, &opt.Options{
+ WriteBuffer: 112 * opt.KiB,
+ CompactionTableSize: 90 * opt.KiB,
+ CompactionExpandLimitFactor: 1,
+ })
+ defer h.close()
+
+ const (
+ nSnap = 190
+ nKey = 140
+ )
+
+ var (
+ snaps [nSnap]*Snapshot
+ b = &Batch{}
+ )
+ for i := range snaps {
+ vtail := fmt.Sprintf("VAL%030d", i)
+ b.Reset()
+ for k := 0; k < nKey; k++ {
+ key := fmt.Sprintf("KEY%08d", k)
+ b.Put([]byte(key), []byte(key+vtail))
+ }
+ if err := h.db.Write(b, nil); err != nil {
+ t.Fatalf("WRITE #%d error: %v", i, err)
+ }
+
+ snaps[i] = h.db.newSnapshot()
+ b.Reset()
+ for k := 0; k < nKey; k++ {
+ key := fmt.Sprintf("KEY%08d", k)
+ b.Delete([]byte(key))
+ }
+ if err := h.db.Write(b, nil); err != nil {
+ t.Fatalf("WRITE #%d error: %v", i, err)
+ }
+ }
+
+ h.compactMem()
+
+ h.waitCompaction()
+ for level, tables := range h.db.s.stVersion.tables {
+ for _, table := range tables {
+ t.Logf("L%d@%d %q:%q", level, table.file.Num(), table.imin, table.imax)
+ }
+ }
+
+ h.compactRangeAt(0, "", "")
+ h.waitCompaction()
+ for level, tables := range h.db.s.stVersion.tables {
+ for _, table := range tables {
+ t.Logf("L%d@%d %q:%q", level, table.file.Num(), table.imin, table.imax)
+ }
+ }
+ h.compactRangeAt(1, "", "")
+ h.waitCompaction()
+ for level, tables := range h.db.s.stVersion.tables {
+ for _, table := range tables {
+ t.Logf("L%d@%d %q:%q", level, table.file.Num(), table.imin, table.imax)
+ }
+ }
+ runtime.GOMAXPROCS(runtime.NumCPU())
+
+ wg := &sync.WaitGroup{}
+ for i, snap := range snaps {
+ wg.Add(1)
+
+ go func(i int, snap *Snapshot) {
+ defer wg.Done()
+
+ vtail := fmt.Sprintf("VAL%030d", i)
+ for k := 0; k < nKey; k++ {
+ key := fmt.Sprintf("KEY%08d", k)
+ xvalue, err := snap.Get([]byte(key), nil)
+ if err != nil {
+ t.Fatalf("READER_GET #%d SEQ=%d K%d error: %v", i, snap.elem.seq, k, err)
+ }
+ value := key + vtail
+ if !bytes.Equal([]byte(value), xvalue) {
+ t.Fatalf("READER_GET #%d SEQ=%d K%d invalid value: want %q, got %q", i, snap.elem.seq, k, value, xvalue)
+ }
+ }
+ }(i, snap)
+ }
+
+ wg.Wait()
+}
+
+func TestDB_TableCompactionBuilder(t *testing.T) {
+ stor := newTestStorage(t)
+ defer stor.Close()
+
+ const nSeq = 99
+
+ o := &opt.Options{
+ WriteBuffer: 112 * opt.KiB,
+ CompactionTableSize: 43 * opt.KiB,
+ CompactionExpandLimitFactor: 1,
+ CompactionGPOverlapsFactor: 1,
+ DisableBlockCache: true,
+ }
+ s, err := newSession(stor, o)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := s.create(); err != nil {
+ t.Fatal(err)
+ }
+ defer s.close()
+ var (
+ seq uint64
+ targetSize = 5 * o.CompactionTableSize
+ value = bytes.Repeat([]byte{'0'}, 100)
+ )
+ for i := 0; i < 2; i++ {
+ tw, err := s.tops.create()
+ if err != nil {
+ t.Fatal(err)
+ }
+ for k := 0; tw.tw.BytesLen() < targetSize; k++ {
+ key := []byte(fmt.Sprintf("%09d", k))
+ seq += nSeq - 1
+ for x := uint64(0); x < nSeq; x++ {
+ if err := tw.append(newIkey(key, seq-x, ktVal), value); err != nil {
+ t.Fatal(err)
+ }
+ }
+ }
+ tf, err := tw.finish()
+ if err != nil {
+ t.Fatal(err)
+ }
+ rec := &sessionRecord{}
+ rec.addTableFile(i, tf)
+ if err := s.commit(rec); err != nil {
+ t.Fatal(err)
+ }
+ }
+
+ // Build grandparent.
+ v := s.version()
+ c := newCompaction(s, v, 1, append(tFiles{}, v.tables[1]...))
+ rec := &sessionRecord{}
+ b := &tableCompactionBuilder{
+ s: s,
+ c: c,
+ rec: rec,
+ stat1: new(cStatsStaging),
+ minSeq: 0,
+ strict: true,
+ tableSize: o.CompactionTableSize/3 + 961,
+ }
+ if err := b.run(new(compactionTransactCounter)); err != nil {
+ t.Fatal(err)
+ }
+ for _, t := range c.tables[0] {
+ rec.delTable(c.level, t.file.Num())
+ }
+ if err := s.commit(rec); err != nil {
+ t.Fatal(err)
+ }
+ c.release()
+
+ // Build level-1.
+ v = s.version()
+ c = newCompaction(s, v, 0, append(tFiles{}, v.tables[0]...))
+ rec = &sessionRecord{}
+ b = &tableCompactionBuilder{
+ s: s,
+ c: c,
+ rec: rec,
+ stat1: new(cStatsStaging),
+ minSeq: 0,
+ strict: true,
+ tableSize: o.CompactionTableSize,
+ }
+ if err := b.run(new(compactionTransactCounter)); err != nil {
+ t.Fatal(err)
+ }
+ for _, t := range c.tables[0] {
+ rec.delTable(c.level, t.file.Num())
+ }
+ // Move grandparent to level-3
+ for _, t := range v.tables[2] {
+ rec.delTable(2, t.file.Num())
+ rec.addTableFile(3, t)
+ }
+ if err := s.commit(rec); err != nil {
+ t.Fatal(err)
+ }
+ c.release()
+
+ v = s.version()
+ for level, want := range []bool{false, true, false, true, false} {
+ got := len(v.tables[level]) > 0
+ if want != got {
+ t.Fatalf("invalid level-%d tables len: want %v, got %v", level, want, got)
+ }
+ }
+ for i, f := range v.tables[1][:len(v.tables[1])-1] {
+ nf := v.tables[1][i+1]
+ if bytes.Equal(f.imax.ukey(), nf.imin.ukey()) {
+ t.Fatalf("KEY %q hop across table %d .. %d", f.imax.ukey(), f.file.Num(), nf.file.Num())
+ }
+ }
+ v.release()
+
+ // Compaction with transient error.
+ v = s.version()
+ c = newCompaction(s, v, 1, append(tFiles{}, v.tables[1]...))
+ rec = &sessionRecord{}
+ b = &tableCompactionBuilder{
+ s: s,
+ c: c,
+ rec: rec,
+ stat1: new(cStatsStaging),
+ minSeq: 0,
+ strict: true,
+ tableSize: o.CompactionTableSize,
+ }
+ stor.SetEmuErrOnce(storage.TypeTable, tsOpSync)
+ stor.SetEmuRandErr(storage.TypeTable, tsOpRead, tsOpReadAt, tsOpWrite)
+ stor.SetEmuRandErrProb(0xf0)
+ for {
+ if err := b.run(new(compactionTransactCounter)); err != nil {
+ t.Logf("(expected) b.run: %v", err)
+ } else {
+ break
+ }
+ }
+ if err := s.commit(rec); err != nil {
+ t.Fatal(err)
+ }
+ c.release()
+
+ stor.SetEmuErrOnce(0, tsOpSync)
+ stor.SetEmuRandErr(0, tsOpRead, tsOpReadAt, tsOpWrite)
+
+ v = s.version()
+ if len(v.tables[1]) != len(v.tables[2]) {
+ t.Fatalf("invalid tables length, want %d, got %d", len(v.tables[1]), len(v.tables[2]))
+ }
+ for i, f0 := range v.tables[1] {
+ f1 := v.tables[2][i]
+ iter0 := s.tops.newIterator(f0, nil, nil)
+ iter1 := s.tops.newIterator(f1, nil, nil)
+ for j := 0; true; j++ {
+ next0 := iter0.Next()
+ next1 := iter1.Next()
+ if next0 != next1 {
+ t.Fatalf("#%d.%d invalid eoi: want %v, got %v", i, j, next0, next1)
+ }
+ key0 := iter0.Key()
+ key1 := iter1.Key()
+ if !bytes.Equal(key0, key1) {
+ t.Fatalf("#%d.%d invalid key: want %q, got %q", i, j, key0, key1)
+ }
+ if next0 == false {
+ break
+ }
+ }
+ iter0.Release()
+ iter1.Release()
+ }
+ v.release()
+}
+
+func testDB_IterTriggeredCompaction(t *testing.T, limitDiv int) {
+ const (
+ vSize = 200 * opt.KiB
+ tSize = 100 * opt.MiB
+ mIter = 100
+ n = tSize / vSize
+ )
+
+ h := newDbHarnessWopt(t, &opt.Options{
+ Compression: opt.NoCompression,
+ DisableBlockCache: true,
+ })
+ defer h.close()
+
+ key := func(x int) string {
+ return fmt.Sprintf("v%06d", x)
+ }
+
+ // Fill.
+ value := strings.Repeat("x", vSize)
+ for i := 0; i < n; i++ {
+ h.put(key(i), value)
+ }
+ h.compactMem()
+
+ // Delete all.
+ for i := 0; i < n; i++ {
+ h.delete(key(i))
+ }
+ h.compactMem()
+
+ var (
+ limit = n / limitDiv
+
+ startKey = key(0)
+ limitKey = key(limit)
+ maxKey = key(n)
+ slice = &util.Range{Limit: []byte(limitKey)}
+
+ initialSize0 = h.sizeOf(startKey, limitKey)
+ initialSize1 = h.sizeOf(limitKey, maxKey)
+ )
+
+ t.Logf("inital size %s [rest %s]", shortenb(int(initialSize0)), shortenb(int(initialSize1)))
+
+ for r := 0; true; r++ {
+ if r >= mIter {
+ t.Fatal("taking too long to compact")
+ }
+
+ // Iterates.
+ iter := h.db.NewIterator(slice, h.ro)
+ for iter.Next() {
+ }
+ if err := iter.Error(); err != nil {
+ t.Fatalf("Iter err: %v", err)
+ }
+ iter.Release()
+
+ // Wait compaction.
+ h.waitCompaction()
+
+ // Check size.
+ size0 := h.sizeOf(startKey, limitKey)
+ size1 := h.sizeOf(limitKey, maxKey)
+ t.Logf("#%03d size %s [rest %s]", r, shortenb(int(size0)), shortenb(int(size1)))
+ if size0 < initialSize0/10 {
+ break
+ }
+ }
+
+ if initialSize1 > 0 {
+ h.sizeAssert(limitKey, maxKey, initialSize1/4-opt.MiB, initialSize1+opt.MiB)
+ }
+}
+
+func TestDB_IterTriggeredCompaction(t *testing.T) {
+ testDB_IterTriggeredCompaction(t, 1)
+}
+
+func TestDB_IterTriggeredCompactionHalf(t *testing.T) {
+ testDB_IterTriggeredCompaction(t, 2)
+}
+
+func TestDB_ReadOnly(t *testing.T) {
+ h := newDbHarness(t)
+ defer h.close()
+
+ h.put("foo", "v1")
+ h.put("bar", "v2")
+ h.compactMem()
+
+ h.put("xfoo", "v1")
+ h.put("xbar", "v2")
+
+ t.Log("Trigger read-only")
+ if err := h.db.SetReadOnly(); err != nil {
+ h.close()
+ t.Fatalf("SetReadOnly error: %v", err)
+ }
+
+ h.stor.SetEmuErr(storage.TypeAll, tsOpCreate, tsOpReplace, tsOpRemove, tsOpWrite, tsOpWrite, tsOpSync)
+
+ ro := func(key, value, wantValue string) {
+ if err := h.db.Put([]byte(key), []byte(value), h.wo); err != ErrReadOnly {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ h.getVal(key, wantValue)
+ }
+
+ ro("foo", "vx", "v1")
+
+ h.o.ReadOnly = true
+ h.reopenDB()
+
+ ro("foo", "vx", "v1")
+ ro("bar", "vx", "v2")
+ h.assertNumKeys(4)
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_util.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_util.go
new file mode 100644
index 0000000000000000000000000000000000000000..0cd4a99ec78d217d0e84d14e5f1eafece9903ade
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_util.go
@@ -0,0 +1,100 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+// Reader is the interface that wraps basic Get and NewIterator methods.
+// This interface implemented by both DB and Snapshot.
+type Reader interface {
+ Get(key []byte, ro *opt.ReadOptions) (value []byte, err error)
+ NewIterator(slice *util.Range, ro *opt.ReadOptions) iterator.Iterator
+}
+
+type Sizes []uint64
+
+// Sum returns sum of the sizes.
+func (p Sizes) Sum() (n uint64) {
+ for _, s := range p {
+ n += s
+ }
+ return n
+}
+
+// Logging.
+func (db *DB) log(v ...interface{}) { db.s.log(v...) }
+func (db *DB) logf(format string, v ...interface{}) { db.s.logf(format, v...) }
+
+// Check and clean files.
+func (db *DB) checkAndCleanFiles() error {
+ v := db.s.version()
+ defer v.release()
+
+ tablesMap := make(map[uint64]bool)
+ for _, tables := range v.tables {
+ for _, t := range tables {
+ tablesMap[t.file.Num()] = false
+ }
+ }
+
+ files, err := db.s.getFiles(storage.TypeAll)
+ if err != nil {
+ return err
+ }
+
+ var nTables int
+ var rem []storage.File
+ for _, f := range files {
+ keep := true
+ switch f.Type() {
+ case storage.TypeManifest:
+ keep = f.Num() >= db.s.manifestFile.Num()
+ case storage.TypeJournal:
+ if db.frozenJournalFile != nil {
+ keep = f.Num() >= db.frozenJournalFile.Num()
+ } else {
+ keep = f.Num() >= db.journalFile.Num()
+ }
+ case storage.TypeTable:
+ _, keep = tablesMap[f.Num()]
+ if keep {
+ tablesMap[f.Num()] = true
+ nTables++
+ }
+ }
+
+ if !keep {
+ rem = append(rem, f)
+ }
+ }
+
+ if nTables != len(tablesMap) {
+ var missing []*storage.FileInfo
+ for num, present := range tablesMap {
+ if !present {
+ missing = append(missing, &storage.FileInfo{Type: storage.TypeTable, Num: num})
+ db.logf("db@janitor table missing @%d", num)
+ }
+ }
+ return errors.NewErrCorrupted(nil, &errors.ErrMissingFiles{Files: missing})
+ }
+
+ db.logf("db@janitor F·%d G·%d", len(files), len(rem))
+ for _, f := range rem {
+ db.logf("db@janitor removing %s-%d", f.Type(), f.Num())
+ if err := f.Remove(); err != nil {
+ return err
+ }
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_write.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_write.go
new file mode 100644
index 0000000000000000000000000000000000000000..8bc8934100bee10d3b483747d4ab8471a5a8e0c6
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_write.go
@@ -0,0 +1,339 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+func (db *DB) writeJournal(b *Batch) error {
+ w, err := db.journal.Next()
+ if err != nil {
+ return err
+ }
+ if _, err := w.Write(b.encode()); err != nil {
+ return err
+ }
+ if err := db.journal.Flush(); err != nil {
+ return err
+ }
+ if b.sync {
+ return db.journalWriter.Sync()
+ }
+ return nil
+}
+
+func (db *DB) jWriter() {
+ defer db.closeW.Done()
+ for {
+ select {
+ case b := <-db.journalC:
+ if b != nil {
+ db.journalAckC <- db.writeJournal(b)
+ }
+ case _, _ = <-db.closeC:
+ return
+ }
+ }
+}
+
+func (db *DB) rotateMem(n int) (mem *memDB, err error) {
+ // Wait for pending memdb compaction.
+ err = db.compSendIdle(db.mcompCmdC)
+ if err != nil {
+ return
+ }
+
+ // Create new memdb and journal.
+ mem, err = db.newMem(n)
+ if err != nil {
+ return
+ }
+
+ // Schedule memdb compaction.
+ db.compSendTrigger(db.mcompCmdC)
+ return
+}
+
+func (db *DB) flush(n int) (mdb *memDB, mdbFree int, err error) {
+ delayed := false
+ flush := func() (retry bool) {
+ v := db.s.version()
+ defer v.release()
+ mdb = db.getEffectiveMem()
+ defer func() {
+ if retry {
+ mdb.decref()
+ mdb = nil
+ }
+ }()
+ mdbFree = mdb.Free()
+ switch {
+ case v.tLen(0) >= db.s.o.GetWriteL0SlowdownTrigger() && !delayed:
+ delayed = true
+ time.Sleep(time.Millisecond)
+ case mdbFree >= n:
+ return false
+ case v.tLen(0) >= db.s.o.GetWriteL0PauseTrigger():
+ delayed = true
+ err = db.compSendIdle(db.tcompCmdC)
+ if err != nil {
+ return false
+ }
+ default:
+ // Allow memdb to grow if it has no entry.
+ if mdb.Len() == 0 {
+ mdbFree = n
+ } else {
+ mdb.decref()
+ mdb, err = db.rotateMem(n)
+ if err == nil {
+ mdbFree = mdb.Free()
+ } else {
+ mdbFree = 0
+ }
+ }
+ return false
+ }
+ return true
+ }
+ start := time.Now()
+ for flush() {
+ }
+ if delayed {
+ db.writeDelay += time.Since(start)
+ db.writeDelayN++
+ } else if db.writeDelayN > 0 {
+ db.logf("db@write was delayed N·%d T·%v", db.writeDelayN, db.writeDelay)
+ db.writeDelay = 0
+ db.writeDelayN = 0
+ }
+ return
+}
+
+// Write apply the given batch to the DB. The batch will be applied
+// sequentially.
+//
+// It is safe to modify the contents of the arguments after Write returns.
+func (db *DB) Write(b *Batch, wo *opt.WriteOptions) (err error) {
+ err = db.ok()
+ if err != nil || b == nil || b.Len() == 0 {
+ return
+ }
+
+ b.init(wo.GetSync())
+
+ // The write happen synchronously.
+ select {
+ case db.writeC <- b:
+ if <-db.writeMergedC {
+ return <-db.writeAckC
+ }
+ case db.writeLockC <- struct{}{}:
+ case err = <-db.compPerErrC:
+ return
+ case _, _ = <-db.closeC:
+ return ErrClosed
+ }
+
+ merged := 0
+ danglingMerge := false
+ defer func() {
+ if danglingMerge {
+ db.writeMergedC <- false
+ } else {
+ <-db.writeLockC
+ }
+ for i := 0; i < merged; i++ {
+ db.writeAckC <- err
+ }
+ }()
+
+ mdb, mdbFree, err := db.flush(b.size())
+ if err != nil {
+ return
+ }
+ defer mdb.decref()
+
+ // Calculate maximum size of the batch.
+ m := 1 << 20
+ if x := b.size(); x <= 128<<10 {
+ m = x + (128 << 10)
+ }
+ m = minInt(m, mdbFree)
+
+ // Merge with other batch.
+drain:
+ for b.size() < m && !b.sync {
+ select {
+ case nb := <-db.writeC:
+ if b.size()+nb.size() <= m {
+ b.append(nb)
+ db.writeMergedC <- true
+ merged++
+ } else {
+ danglingMerge = true
+ break drain
+ }
+ default:
+ break drain
+ }
+ }
+
+ // Set batch first seq number relative from last seq.
+ b.seq = db.seq + 1
+
+ // Write journal concurrently if it is large enough.
+ if b.size() >= (128 << 10) {
+ // Push the write batch to the journal writer
+ select {
+ case db.journalC <- b:
+ // Write into memdb
+ if berr := b.memReplay(mdb.DB); berr != nil {
+ panic(berr)
+ }
+ case err = <-db.compPerErrC:
+ return
+ case _, _ = <-db.closeC:
+ err = ErrClosed
+ return
+ }
+ // Wait for journal writer
+ select {
+ case err = <-db.journalAckC:
+ if err != nil {
+ // Revert memdb if error detected
+ if berr := b.revertMemReplay(mdb.DB); berr != nil {
+ panic(berr)
+ }
+ return
+ }
+ case _, _ = <-db.closeC:
+ err = ErrClosed
+ return
+ }
+ } else {
+ err = db.writeJournal(b)
+ if err != nil {
+ return
+ }
+ if berr := b.memReplay(mdb.DB); berr != nil {
+ panic(berr)
+ }
+ }
+
+ // Set last seq number.
+ db.addSeq(uint64(b.Len()))
+
+ if b.size() >= mdbFree {
+ db.rotateMem(0)
+ }
+ return
+}
+
+// Put sets the value for the given key. It overwrites any previous value
+// for that key; a DB is not a multi-map.
+//
+// It is safe to modify the contents of the arguments after Put returns.
+func (db *DB) Put(key, value []byte, wo *opt.WriteOptions) error {
+ b := new(Batch)
+ b.Put(key, value)
+ return db.Write(b, wo)
+}
+
+// Delete deletes the value for the given key. It returns ErrNotFound if
+// the DB does not contain the key.
+//
+// It is safe to modify the contents of the arguments after Delete returns.
+func (db *DB) Delete(key []byte, wo *opt.WriteOptions) error {
+ b := new(Batch)
+ b.Delete(key)
+ return db.Write(b, wo)
+}
+
+func isMemOverlaps(icmp *iComparer, mem *memdb.DB, min, max []byte) bool {
+ iter := mem.NewIterator(nil)
+ defer iter.Release()
+ return (max == nil || (iter.First() && icmp.uCompare(max, iKey(iter.Key()).ukey()) >= 0)) &&
+ (min == nil || (iter.Last() && icmp.uCompare(min, iKey(iter.Key()).ukey()) <= 0))
+}
+
+// CompactRange compacts the underlying DB for the given key range.
+// In particular, deleted and overwritten versions are discarded,
+// and the data is rearranged to reduce the cost of operations
+// needed to access the data. This operation should typically only
+// be invoked by users who understand the underlying implementation.
+//
+// A nil Range.Start is treated as a key before all keys in the DB.
+// And a nil Range.Limit is treated as a key after all keys in the DB.
+// Therefore if both is nil then it will compact entire DB.
+func (db *DB) CompactRange(r util.Range) error {
+ if err := db.ok(); err != nil {
+ return err
+ }
+
+ // Lock writer.
+ select {
+ case db.writeLockC <- struct{}{}:
+ case err := <-db.compPerErrC:
+ return err
+ case _, _ = <-db.closeC:
+ return ErrClosed
+ }
+
+ // Check for overlaps in memdb.
+ mdb := db.getEffectiveMem()
+ defer mdb.decref()
+ if isMemOverlaps(db.s.icmp, mdb.DB, r.Start, r.Limit) {
+ // Memdb compaction.
+ if _, err := db.rotateMem(0); err != nil {
+ <-db.writeLockC
+ return err
+ }
+ <-db.writeLockC
+ if err := db.compSendIdle(db.mcompCmdC); err != nil {
+ return err
+ }
+ } else {
+ <-db.writeLockC
+ }
+
+ // Table compaction.
+ return db.compSendRange(db.tcompCmdC, -1, r.Start, r.Limit)
+}
+
+// SetReadOnly makes DB read-only. It will stay read-only until reopened.
+func (db *DB) SetReadOnly() error {
+ if err := db.ok(); err != nil {
+ return err
+ }
+
+ // Lock writer.
+ select {
+ case db.writeLockC <- struct{}{}:
+ db.compWriteLocking = true
+ case err := <-db.compPerErrC:
+ return err
+ case _, _ = <-db.closeC:
+ return ErrClosed
+ }
+
+ // Set compaction read-only.
+ select {
+ case db.compErrSetC <- ErrReadOnly:
+ case perr := <-db.compPerErrC:
+ return perr
+ case _, _ = <-db.closeC:
+ return ErrClosed
+ }
+
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/doc.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..53f13bb24ccfe6f600cfbf381b4a60f7cd173973
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/doc.go
@@ -0,0 +1,90 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package leveldb provides implementation of LevelDB key/value database.
+//
+// Create or open a database:
+//
+// db, err := leveldb.OpenFile("path/to/db", nil)
+// ...
+// defer db.Close()
+// ...
+//
+// Read or modify the database content:
+//
+// // Remember that the contents of the returned slice should not be modified.
+// data, err := db.Get([]byte("key"), nil)
+// ...
+// err = db.Put([]byte("key"), []byte("value"), nil)
+// ...
+// err = db.Delete([]byte("key"), nil)
+// ...
+//
+// Iterate over database content:
+//
+// iter := db.NewIterator(nil, nil)
+// for iter.Next() {
+// // Remember that the contents of the returned slice should not be modified, and
+// // only valid until the next call to Next.
+// key := iter.Key()
+// value := iter.Value()
+// ...
+// }
+// iter.Release()
+// err = iter.Error()
+// ...
+//
+// Iterate over subset of database content with a particular prefix:
+// iter := db.NewIterator(util.BytesPrefix([]byte("foo-")), nil)
+// for iter.Next() {
+// // Use key/value.
+// ...
+// }
+// iter.Release()
+// err = iter.Error()
+// ...
+//
+// Seek-then-Iterate:
+//
+// iter := db.NewIterator(nil, nil)
+// for ok := iter.Seek(key); ok; ok = iter.Next() {
+// // Use key/value.
+// ...
+// }
+// iter.Release()
+// err = iter.Error()
+// ...
+//
+// Iterate over subset of database content:
+//
+// iter := db.NewIterator(&util.Range{Start: []byte("foo"), Limit: []byte("xoo")}, nil)
+// for iter.Next() {
+// // Use key/value.
+// ...
+// }
+// iter.Release()
+// err = iter.Error()
+// ...
+//
+// Batch writes:
+//
+// batch := new(leveldb.Batch)
+// batch.Put([]byte("foo"), []byte("value"))
+// batch.Put([]byte("bar"), []byte("another value"))
+// batch.Delete([]byte("baz"))
+// err = db.Write(batch, nil)
+// ...
+//
+// Use bloom filter:
+//
+// o := &opt.Options{
+// Filter: filter.NewBloomFilter(10),
+// }
+// db, err := leveldb.OpenFile("path/to/db", o)
+// ...
+// defer db.Close()
+// ...
+package leveldb
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors.go
new file mode 100644
index 0000000000000000000000000000000000000000..f45199d11d6f916f8d7a105c83a01c9a60735792
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors.go
@@ -0,0 +1,19 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors"
+)
+
+var (
+ ErrNotFound = errors.ErrNotFound
+ ErrReadOnly = errors.New("leveldb: read-only mode")
+ ErrSnapshotReleased = errors.New("leveldb: snapshot released")
+ ErrIterReleased = errors.New("leveldb: iterator released")
+ ErrClosed = errors.New("leveldb: closed")
+)
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors/errors.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors/errors.go
new file mode 100644
index 0000000000000000000000000000000000000000..a22b4b9d5722df1336e8b14dffeb97d019140681
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors/errors.go
@@ -0,0 +1,76 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package errors provides common error types used throughout leveldb.
+package errors
+
+import (
+ "errors"
+ "fmt"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+var (
+ ErrNotFound = New("leveldb: not found")
+ ErrReleased = util.ErrReleased
+ ErrHasReleaser = util.ErrHasReleaser
+)
+
+// New returns an error that formats as the given text.
+func New(text string) error {
+ return errors.New(text)
+}
+
+// ErrCorrupted is the type that wraps errors that indicate corruption in
+// the database.
+type ErrCorrupted struct {
+ File *storage.FileInfo
+ Err error
+}
+
+func (e *ErrCorrupted) Error() string {
+ if e.File != nil {
+ return fmt.Sprintf("%v [file=%v]", e.Err, e.File)
+ } else {
+ return e.Err.Error()
+ }
+}
+
+// NewErrCorrupted creates new ErrCorrupted error.
+func NewErrCorrupted(f storage.File, err error) error {
+ return &ErrCorrupted{storage.NewFileInfo(f), err}
+}
+
+// IsCorrupted returns a boolean indicating whether the error is indicating
+// a corruption.
+func IsCorrupted(err error) bool {
+ switch err.(type) {
+ case *ErrCorrupted:
+ return true
+ }
+ return false
+}
+
+// ErrMissingFiles is the type that indicating a corruption due to missing
+// files.
+type ErrMissingFiles struct {
+ Files []*storage.FileInfo
+}
+
+func (e *ErrMissingFiles) Error() string { return "file missing" }
+
+// SetFile sets 'file info' of the given error with the given file.
+// Currently only ErrCorrupted is supported, otherwise will do nothing.
+func SetFile(err error, f storage.File) error {
+ switch x := err.(type) {
+ case *ErrCorrupted:
+ x.File = storage.NewFileInfo(f)
+ return x
+ }
+ return err
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/external_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/external_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..8ae2e50e8ea41980e5a5e2a7c3e8fb147fe67a98
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/external_test.go
@@ -0,0 +1,58 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ . "github.com/onsi/ginkgo"
+ . "github.com/onsi/gomega"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil"
+)
+
+var _ = testutil.Defer(func() {
+ Describe("Leveldb external", func() {
+ o := &opt.Options{
+ DisableBlockCache: true,
+ BlockRestartInterval: 5,
+ BlockSize: 80,
+ Compression: opt.NoCompression,
+ OpenFilesCacheCapacity: -1,
+ Strict: opt.StrictAll,
+ WriteBuffer: 1000,
+ CompactionTableSize: 2000,
+ }
+
+ Describe("write test", func() {
+ It("should do write correctly", func(done Done) {
+ db := newTestingDB(o, nil, nil)
+ t := testutil.DBTesting{
+ DB: db,
+ Deleted: testutil.KeyValue_Generate(nil, 500, 1, 50, 5, 5).Clone(),
+ }
+ testutil.DoDBTesting(&t)
+ db.TestClose()
+ done <- true
+ }, 20.0)
+ })
+
+ Describe("read test", func() {
+ testutil.AllKeyValueTesting(nil, nil, func(kv testutil.KeyValue) testutil.DB {
+ // Building the DB.
+ db := newTestingDB(o, nil, nil)
+ kv.IterateShuffled(nil, func(i int, key, value []byte) {
+ err := db.TestPut(key, value)
+ Expect(err).NotTo(HaveOccurred())
+ })
+
+ return db
+ }, func(db testutil.DB) {
+ db.(*testingDB).TestClose()
+ })
+ })
+ })
+})
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter.go
new file mode 100644
index 0000000000000000000000000000000000000000..fcad1fbf8474328d7b01dd20f33e357f40176b40
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter.go
@@ -0,0 +1,31 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter"
+)
+
+type iFilter struct {
+ filter.Filter
+}
+
+func (f iFilter) Contains(filter, key []byte) bool {
+ return f.Filter.Contains(filter, iKey(key).ukey())
+}
+
+func (f iFilter) NewGenerator() filter.FilterGenerator {
+ return iFilterGenerator{f.Filter.NewGenerator()}
+}
+
+type iFilterGenerator struct {
+ filter.FilterGenerator
+}
+
+func (g iFilterGenerator) Add(key []byte) {
+ g.FilterGenerator.Add(iKey(key).ukey())
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter/bloom.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter/bloom.go
new file mode 100644
index 0000000000000000000000000000000000000000..68c925522f4fa25ced117d2b78a4785b53dcb51c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter/bloom.go
@@ -0,0 +1,116 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package filter
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+func bloomHash(key []byte) uint32 {
+ return util.Hash(key, 0xbc9f1d34)
+}
+
+type bloomFilter int
+
+// The bloom filter serializes its parameters and is backward compatible
+// with respect to them. Therefor, its parameters are not added to its
+// name.
+func (bloomFilter) Name() string {
+ return "leveldb.BuiltinBloomFilter"
+}
+
+func (f bloomFilter) Contains(filter, key []byte) bool {
+ nBytes := len(filter) - 1
+ if nBytes < 1 {
+ return false
+ }
+ nBits := uint32(nBytes * 8)
+
+ // Use the encoded k so that we can read filters generated by
+ // bloom filters created using different parameters.
+ k := filter[nBytes]
+ if k > 30 {
+ // Reserved for potentially new encodings for short bloom filters.
+ // Consider it a match.
+ return true
+ }
+
+ kh := bloomHash(key)
+ delta := (kh >> 17) | (kh << 15) // Rotate right 17 bits
+ for j := uint8(0); j < k; j++ {
+ bitpos := kh % nBits
+ if (uint32(filter[bitpos/8]) & (1 << (bitpos % 8))) == 0 {
+ return false
+ }
+ kh += delta
+ }
+ return true
+}
+
+func (f bloomFilter) NewGenerator() FilterGenerator {
+ // Round down to reduce probing cost a little bit.
+ k := uint8(f * 69 / 100) // 0.69 =~ ln(2)
+ if k < 1 {
+ k = 1
+ } else if k > 30 {
+ k = 30
+ }
+ return &bloomFilterGenerator{
+ n: int(f),
+ k: k,
+ }
+}
+
+type bloomFilterGenerator struct {
+ n int
+ k uint8
+
+ keyHashes []uint32
+}
+
+func (g *bloomFilterGenerator) Add(key []byte) {
+ // Use double-hashing to generate a sequence of hash values.
+ // See analysis in [Kirsch,Mitzenmacher 2006].
+ g.keyHashes = append(g.keyHashes, bloomHash(key))
+}
+
+func (g *bloomFilterGenerator) Generate(b Buffer) {
+ // Compute bloom filter size (in both bits and bytes)
+ nBits := uint32(len(g.keyHashes) * g.n)
+ // For small n, we can see a very high false positive rate. Fix it
+ // by enforcing a minimum bloom filter length.
+ if nBits < 64 {
+ nBits = 64
+ }
+ nBytes := (nBits + 7) / 8
+ nBits = nBytes * 8
+
+ dest := b.Alloc(int(nBytes) + 1)
+ dest[nBytes] = g.k
+ for _, kh := range g.keyHashes {
+ delta := (kh >> 17) | (kh << 15) // Rotate right 17 bits
+ for j := uint8(0); j < g.k; j++ {
+ bitpos := kh % nBits
+ dest[bitpos/8] |= (1 << (bitpos % 8))
+ kh += delta
+ }
+ }
+
+ g.keyHashes = g.keyHashes[:0]
+}
+
+// NewBloomFilter creates a new initialized bloom filter for given
+// bitsPerKey.
+//
+// Since bitsPerKey is persisted individually for each bloom filter
+// serialization, bloom filters are backwards compatible with respect to
+// changing bitsPerKey. This means that no big performance penalty will
+// be experienced when changing the parameter. See documentation for
+// opt.Options.Filter for more information.
+func NewBloomFilter(bitsPerKey int) Filter {
+ return bloomFilter(bitsPerKey)
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter/bloom_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter/bloom_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..70bfdaa54ea848419067098e7978a8f61cb9d94a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter/bloom_test.go
@@ -0,0 +1,142 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package filter
+
+import (
+ "encoding/binary"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+ "testing"
+)
+
+type harness struct {
+ t *testing.T
+
+ bloom Filter
+ generator FilterGenerator
+ filter []byte
+}
+
+func newHarness(t *testing.T) *harness {
+ bloom := NewBloomFilter(10)
+ return &harness{
+ t: t,
+ bloom: bloom,
+ generator: bloom.NewGenerator(),
+ }
+}
+
+func (h *harness) add(key []byte) {
+ h.generator.Add(key)
+}
+
+func (h *harness) addNum(key uint32) {
+ var b [4]byte
+ binary.LittleEndian.PutUint32(b[:], key)
+ h.add(b[:])
+}
+
+func (h *harness) build() {
+ b := &util.Buffer{}
+ h.generator.Generate(b)
+ h.filter = b.Bytes()
+}
+
+func (h *harness) reset() {
+ h.filter = nil
+}
+
+func (h *harness) filterLen() int {
+ return len(h.filter)
+}
+
+func (h *harness) assert(key []byte, want, silent bool) bool {
+ got := h.bloom.Contains(h.filter, key)
+ if !silent && got != want {
+ h.t.Errorf("assert on '%v' failed got '%v', want '%v'", key, got, want)
+ }
+ return got
+}
+
+func (h *harness) assertNum(key uint32, want, silent bool) bool {
+ var b [4]byte
+ binary.LittleEndian.PutUint32(b[:], key)
+ return h.assert(b[:], want, silent)
+}
+
+func TestBloomFilter_Empty(t *testing.T) {
+ h := newHarness(t)
+ h.build()
+ h.assert([]byte("hello"), false, false)
+ h.assert([]byte("world"), false, false)
+}
+
+func TestBloomFilter_Small(t *testing.T) {
+ h := newHarness(t)
+ h.add([]byte("hello"))
+ h.add([]byte("world"))
+ h.build()
+ h.assert([]byte("hello"), true, false)
+ h.assert([]byte("world"), true, false)
+ h.assert([]byte("x"), false, false)
+ h.assert([]byte("foo"), false, false)
+}
+
+func nextN(n int) int {
+ switch {
+ case n < 10:
+ n += 1
+ case n < 100:
+ n += 10
+ case n < 1000:
+ n += 100
+ default:
+ n += 1000
+ }
+ return n
+}
+
+func TestBloomFilter_VaryingLengths(t *testing.T) {
+ h := newHarness(t)
+ var mediocre, good int
+ for n := 1; n < 10000; n = nextN(n) {
+ h.reset()
+ for i := 0; i < n; i++ {
+ h.addNum(uint32(i))
+ }
+ h.build()
+
+ got := h.filterLen()
+ want := (n * 10 / 8) + 40
+ if got > want {
+ t.Errorf("filter len test failed, '%d' > '%d'", got, want)
+ }
+
+ for i := 0; i < n; i++ {
+ h.assertNum(uint32(i), true, false)
+ }
+
+ var rate float32
+ for i := 0; i < 10000; i++ {
+ if h.assertNum(uint32(i+1000000000), true, true) {
+ rate++
+ }
+ }
+ rate /= 10000
+ if rate > 0.02 {
+ t.Errorf("false positive rate is more than 2%%, got %v, at len %d", rate, n)
+ }
+ if rate > 0.0125 {
+ mediocre++
+ } else {
+ good++
+ }
+ }
+ t.Logf("false positive rate: %d good, %d mediocre", good, mediocre)
+ if mediocre > good/5 {
+ t.Error("mediocre false positive rate is more than expected")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter/filter.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter/filter.go
new file mode 100644
index 0000000000000000000000000000000000000000..7a925c5a869ed785446228148956c00b2bf80446
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter/filter.go
@@ -0,0 +1,60 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package filter provides interface and implementation of probabilistic
+// data structure.
+//
+// The filter is resposible for creating small filter from a set of keys.
+// These filter will then used to test whether a key is a member of the set.
+// In many cases, a filter can cut down the number of disk seeks from a
+// handful to a single disk seek per DB.Get call.
+package filter
+
+// Buffer is the interface that wraps basic Alloc, Write and WriteByte methods.
+type Buffer interface {
+ // Alloc allocs n bytes of slice from the buffer. This also advancing
+ // write offset.
+ Alloc(n int) []byte
+
+ // Write appends the contents of p to the buffer.
+ Write(p []byte) (n int, err error)
+
+ // WriteByte appends the byte c to the buffer.
+ WriteByte(c byte) error
+}
+
+// Filter is the filter.
+type Filter interface {
+ // Name returns the name of this policy.
+ //
+ // Note that if the filter encoding changes in an incompatible way,
+ // the name returned by this method must be changed. Otherwise, old
+ // incompatible filters may be passed to methods of this type.
+ Name() string
+
+ // NewGenerator creates a new filter generator.
+ NewGenerator() FilterGenerator
+
+ // Contains returns true if the filter contains the given key.
+ //
+ // The filter are filters generated by the filter generator.
+ Contains(filter, key []byte) bool
+}
+
+// FilterGenerator is the filter generator.
+type FilterGenerator interface {
+ // Add adds a key to the filter generator.
+ //
+ // The key may become invalid after call to this method end, therefor
+ // key must be copied if implementation require keeping key for later
+ // use. The key should not modified directly, doing so may cause
+ // undefined results.
+ Add(key []byte)
+
+ // Generate generates filters based on keys passed so far. After call
+ // to Generate the filter generator maybe resetted, depends on implementation.
+ Generate(b Buffer)
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/array_iter.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/array_iter.go
new file mode 100644
index 0000000000000000000000000000000000000000..3050fb86ae651d0dbf9de64f39df378b122825ba
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/array_iter.go
@@ -0,0 +1,184 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package iterator
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+// BasicArray is the interface that wraps basic Len and Search method.
+type BasicArray interface {
+ // Len returns length of the array.
+ Len() int
+
+ // Search finds smallest index that point to a key that is greater
+ // than or equal to the given key.
+ Search(key []byte) int
+}
+
+// Array is the interface that wraps BasicArray and basic Index method.
+type Array interface {
+ BasicArray
+
+ // Index returns key/value pair with index of i.
+ Index(i int) (key, value []byte)
+}
+
+// Array is the interface that wraps BasicArray and basic Get method.
+type ArrayIndexer interface {
+ BasicArray
+
+ // Get returns a new data iterator with index of i.
+ Get(i int) Iterator
+}
+
+type basicArrayIterator struct {
+ util.BasicReleaser
+ array BasicArray
+ pos int
+ err error
+}
+
+func (i *basicArrayIterator) Valid() bool {
+ return i.pos >= 0 && i.pos < i.array.Len() && !i.Released()
+}
+
+func (i *basicArrayIterator) First() bool {
+ if i.Released() {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ if i.array.Len() == 0 {
+ i.pos = -1
+ return false
+ }
+ i.pos = 0
+ return true
+}
+
+func (i *basicArrayIterator) Last() bool {
+ if i.Released() {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ n := i.array.Len()
+ if n == 0 {
+ i.pos = 0
+ return false
+ }
+ i.pos = n - 1
+ return true
+}
+
+func (i *basicArrayIterator) Seek(key []byte) bool {
+ if i.Released() {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ n := i.array.Len()
+ if n == 0 {
+ i.pos = 0
+ return false
+ }
+ i.pos = i.array.Search(key)
+ if i.pos >= n {
+ return false
+ }
+ return true
+}
+
+func (i *basicArrayIterator) Next() bool {
+ if i.Released() {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ i.pos++
+ if n := i.array.Len(); i.pos >= n {
+ i.pos = n
+ return false
+ }
+ return true
+}
+
+func (i *basicArrayIterator) Prev() bool {
+ if i.Released() {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ i.pos--
+ if i.pos < 0 {
+ i.pos = -1
+ return false
+ }
+ return true
+}
+
+func (i *basicArrayIterator) Error() error { return i.err }
+
+type arrayIterator struct {
+ basicArrayIterator
+ array Array
+ pos int
+ key, value []byte
+}
+
+func (i *arrayIterator) updateKV() {
+ if i.pos == i.basicArrayIterator.pos {
+ return
+ }
+ i.pos = i.basicArrayIterator.pos
+ if i.Valid() {
+ i.key, i.value = i.array.Index(i.pos)
+ } else {
+ i.key = nil
+ i.value = nil
+ }
+}
+
+func (i *arrayIterator) Key() []byte {
+ i.updateKV()
+ return i.key
+}
+
+func (i *arrayIterator) Value() []byte {
+ i.updateKV()
+ return i.value
+}
+
+type arrayIteratorIndexer struct {
+ basicArrayIterator
+ array ArrayIndexer
+}
+
+func (i *arrayIteratorIndexer) Get() Iterator {
+ if i.Valid() {
+ return i.array.Get(i.basicArrayIterator.pos)
+ }
+ return nil
+}
+
+// NewArrayIterator returns an iterator from the given array.
+func NewArrayIterator(array Array) Iterator {
+ return &arrayIterator{
+ basicArrayIterator: basicArrayIterator{array: array, pos: -1},
+ array: array,
+ pos: -1,
+ }
+}
+
+// NewArrayIndexer returns an index iterator from the given array.
+func NewArrayIndexer(array ArrayIndexer) IteratorIndexer {
+ return &arrayIteratorIndexer{
+ basicArrayIterator: basicArrayIterator{array: array, pos: -1},
+ array: array,
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/array_iter_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/array_iter_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..9c9c27a686462b1afa5b2a2ffbacfba8292d7c14
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/array_iter_test.go
@@ -0,0 +1,30 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package iterator_test
+
+import (
+ . "github.com/onsi/ginkgo"
+
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil"
+)
+
+var _ = testutil.Defer(func() {
+ Describe("Array iterator", func() {
+ It("Should iterates and seeks correctly", func() {
+ // Build key/value.
+ kv := testutil.KeyValue_Generate(nil, 70, 1, 5, 3, 3)
+
+ // Test the iterator.
+ t := testutil.IteratorTesting{
+ KeyValue: kv.Clone(),
+ Iter: NewArrayIterator(kv),
+ }
+ testutil.DoIteratorTesting(&t)
+ })
+ })
+})
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/indexed_iter.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/indexed_iter.go
new file mode 100644
index 0000000000000000000000000000000000000000..71843607f34ae43d607f25712c91feee5ff7d950
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/indexed_iter.go
@@ -0,0 +1,242 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package iterator
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+// IteratorIndexer is the interface that wraps CommonIterator and basic Get
+// method. IteratorIndexer provides index for indexed iterator.
+type IteratorIndexer interface {
+ CommonIterator
+
+ // Get returns a new data iterator for the current position, or nil if
+ // done.
+ Get() Iterator
+}
+
+type indexedIterator struct {
+ util.BasicReleaser
+ index IteratorIndexer
+ strict bool
+
+ data Iterator
+ err error
+ errf func(err error)
+ closed bool
+}
+
+func (i *indexedIterator) setData() {
+ if i.data != nil {
+ i.data.Release()
+ }
+ i.data = i.index.Get()
+}
+
+func (i *indexedIterator) clearData() {
+ if i.data != nil {
+ i.data.Release()
+ }
+ i.data = nil
+}
+
+func (i *indexedIterator) indexErr() {
+ if err := i.index.Error(); err != nil {
+ if i.errf != nil {
+ i.errf(err)
+ }
+ i.err = err
+ }
+}
+
+func (i *indexedIterator) dataErr() bool {
+ if err := i.data.Error(); err != nil {
+ if i.errf != nil {
+ i.errf(err)
+ }
+ if i.strict || !errors.IsCorrupted(err) {
+ i.err = err
+ return true
+ }
+ }
+ return false
+}
+
+func (i *indexedIterator) Valid() bool {
+ return i.data != nil && i.data.Valid()
+}
+
+func (i *indexedIterator) First() bool {
+ if i.err != nil {
+ return false
+ } else if i.Released() {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ if !i.index.First() {
+ i.indexErr()
+ i.clearData()
+ return false
+ }
+ i.setData()
+ return i.Next()
+}
+
+func (i *indexedIterator) Last() bool {
+ if i.err != nil {
+ return false
+ } else if i.Released() {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ if !i.index.Last() {
+ i.indexErr()
+ i.clearData()
+ return false
+ }
+ i.setData()
+ if !i.data.Last() {
+ if i.dataErr() {
+ return false
+ }
+ i.clearData()
+ return i.Prev()
+ }
+ return true
+}
+
+func (i *indexedIterator) Seek(key []byte) bool {
+ if i.err != nil {
+ return false
+ } else if i.Released() {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ if !i.index.Seek(key) {
+ i.indexErr()
+ i.clearData()
+ return false
+ }
+ i.setData()
+ if !i.data.Seek(key) {
+ if i.dataErr() {
+ return false
+ }
+ i.clearData()
+ return i.Next()
+ }
+ return true
+}
+
+func (i *indexedIterator) Next() bool {
+ if i.err != nil {
+ return false
+ } else if i.Released() {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ switch {
+ case i.data != nil && !i.data.Next():
+ if i.dataErr() {
+ return false
+ }
+ i.clearData()
+ fallthrough
+ case i.data == nil:
+ if !i.index.Next() {
+ i.indexErr()
+ return false
+ }
+ i.setData()
+ return i.Next()
+ }
+ return true
+}
+
+func (i *indexedIterator) Prev() bool {
+ if i.err != nil {
+ return false
+ } else if i.Released() {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ switch {
+ case i.data != nil && !i.data.Prev():
+ if i.dataErr() {
+ return false
+ }
+ i.clearData()
+ fallthrough
+ case i.data == nil:
+ if !i.index.Prev() {
+ i.indexErr()
+ return false
+ }
+ i.setData()
+ if !i.data.Last() {
+ if i.dataErr() {
+ return false
+ }
+ i.clearData()
+ return i.Prev()
+ }
+ }
+ return true
+}
+
+func (i *indexedIterator) Key() []byte {
+ if i.data == nil {
+ return nil
+ }
+ return i.data.Key()
+}
+
+func (i *indexedIterator) Value() []byte {
+ if i.data == nil {
+ return nil
+ }
+ return i.data.Value()
+}
+
+func (i *indexedIterator) Release() {
+ i.clearData()
+ i.index.Release()
+ i.BasicReleaser.Release()
+}
+
+func (i *indexedIterator) Error() error {
+ if i.err != nil {
+ return i.err
+ }
+ if err := i.index.Error(); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (i *indexedIterator) SetErrorCallback(f func(err error)) {
+ i.errf = f
+}
+
+// NewIndexedIterator returns an 'indexed iterator'. An index is iterator
+// that returns another iterator, a 'data iterator'. A 'data iterator' is the
+// iterator that contains actual key/value pairs.
+//
+// If strict is true the any 'corruption errors' (i.e errors.IsCorrupted(err) == true)
+// won't be ignored and will halt 'indexed iterator', otherwise the iterator will
+// continue to the next 'data iterator'. Corruption on 'index iterator' will not be
+// ignored and will halt the iterator.
+func NewIndexedIterator(index IteratorIndexer, strict bool) Iterator {
+ return &indexedIterator{index: index, strict: strict}
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/indexed_iter_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/indexed_iter_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..8d64ed8b4ad803a45f777107ebd51f695f5c692e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/indexed_iter_test.go
@@ -0,0 +1,83 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package iterator_test
+
+import (
+ "sort"
+
+ . "github.com/onsi/ginkgo"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil"
+)
+
+type keyValue struct {
+ key []byte
+ testutil.KeyValue
+}
+
+type keyValueIndex []keyValue
+
+func (x keyValueIndex) Search(key []byte) int {
+ return sort.Search(x.Len(), func(i int) bool {
+ return comparer.DefaultComparer.Compare(x[i].key, key) >= 0
+ })
+}
+
+func (x keyValueIndex) Len() int { return len(x) }
+func (x keyValueIndex) Index(i int) (key, value []byte) { return x[i].key, nil }
+func (x keyValueIndex) Get(i int) Iterator { return NewArrayIterator(x[i]) }
+
+var _ = testutil.Defer(func() {
+ Describe("Indexed iterator", func() {
+ Test := func(n ...int) func() {
+ if len(n) == 0 {
+ rnd := testutil.NewRand()
+ n = make([]int, rnd.Intn(17)+3)
+ for i := range n {
+ n[i] = rnd.Intn(19) + 1
+ }
+ }
+
+ return func() {
+ It("Should iterates and seeks correctly", func(done Done) {
+ // Build key/value.
+ index := make(keyValueIndex, len(n))
+ sum := 0
+ for _, x := range n {
+ sum += x
+ }
+ kv := testutil.KeyValue_Generate(nil, sum, 1, 10, 4, 4)
+ for i, j := 0, 0; i < len(n); i++ {
+ for x := n[i]; x > 0; x-- {
+ key, value := kv.Index(j)
+ index[i].key = key
+ index[i].Put(key, value)
+ j++
+ }
+ }
+
+ // Test the iterator.
+ t := testutil.IteratorTesting{
+ KeyValue: kv.Clone(),
+ Iter: NewIndexedIterator(NewArrayIndexer(index), true),
+ }
+ testutil.DoIteratorTesting(&t)
+ done <- true
+ }, 1.5)
+ }
+ }
+
+ Describe("with 100 keys", Test(100))
+ Describe("with 50-50 keys", Test(50, 50))
+ Describe("with 50-1 keys", Test(50, 1))
+ Describe("with 50-1-50 keys", Test(50, 1, 50))
+ Describe("with 1-50 keys", Test(1, 50))
+ Describe("with random N-keys", Test())
+ })
+})
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/iter.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/iter.go
new file mode 100644
index 0000000000000000000000000000000000000000..f6876eea87fbfd824c77831de93b911c06084f21
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/iter.go
@@ -0,0 +1,131 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package iterator provides interface and implementation to traverse over
+// contents of a database.
+package iterator
+
+import (
+ "errors"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+var (
+ ErrIterReleased = errors.New("leveldb/iterator: iterator released")
+)
+
+// IteratorSeeker is the interface that wraps the 'seeks method'.
+type IteratorSeeker interface {
+ // First moves the iterator to the first key/value pair. If the iterator
+ // only contains one key/value pair then First and Last whould moves
+ // to the same key/value pair.
+ // It returns whether such pair exist.
+ First() bool
+
+ // Last moves the iterator to the last key/value pair. If the iterator
+ // only contains one key/value pair then First and Last whould moves
+ // to the same key/value pair.
+ // It returns whether such pair exist.
+ Last() bool
+
+ // Seek moves the iterator to the first key/value pair whose key is greater
+ // than or equal to the given key.
+ // It returns whether such pair exist.
+ //
+ // It is safe to modify the contents of the argument after Seek returns.
+ Seek(key []byte) bool
+
+ // Next moves the iterator to the next key/value pair.
+ // It returns whether the iterator is exhausted.
+ Next() bool
+
+ // Prev moves the iterator to the previous key/value pair.
+ // It returns whether the iterator is exhausted.
+ Prev() bool
+}
+
+// CommonIterator is the interface that wraps common interator methods.
+type CommonIterator interface {
+ IteratorSeeker
+
+ // util.Releaser is the interface that wraps basic Release method.
+ // When called Release will releases any resources associated with the
+ // iterator.
+ util.Releaser
+
+ // util.ReleaseSetter is the interface that wraps the basic SetReleaser
+ // method.
+ util.ReleaseSetter
+
+ // TODO: Remove this when ready.
+ Valid() bool
+
+ // Error returns any accumulated error. Exhausting all the key/value pairs
+ // is not considered to be an error.
+ Error() error
+}
+
+// Iterator iterates over a DB's key/value pairs in key order.
+//
+// When encouter an error any 'seeks method' will return false and will
+// yield no key/value pairs. The error can be queried by calling the Error
+// method. Calling Release is still necessary.
+//
+// An iterator must be released after use, but it is not necessary to read
+// an iterator until exhaustion.
+// Also, an iterator is not necessarily goroutine-safe, but it is safe to use
+// multiple iterators concurrently, with each in a dedicated goroutine.
+type Iterator interface {
+ CommonIterator
+
+ // Key returns the key of the current key/value pair, or nil if done.
+ // The caller should not modify the contents of the returned slice, and
+ // its contents may change on the next call to any 'seeks method'.
+ Key() []byte
+
+ // Value returns the key of the current key/value pair, or nil if done.
+ // The caller should not modify the contents of the returned slice, and
+ // its contents may change on the next call to any 'seeks method'.
+ Value() []byte
+}
+
+// ErrorCallbackSetter is the interface that wraps basic SetErrorCallback
+// method.
+//
+// ErrorCallbackSetter implemented by indexed and merged iterator.
+type ErrorCallbackSetter interface {
+ // SetErrorCallback allows set an error callback of the coresponding
+ // iterator. Use nil to clear the callback.
+ SetErrorCallback(f func(err error))
+}
+
+type emptyIterator struct {
+ util.BasicReleaser
+ err error
+}
+
+func (i *emptyIterator) rErr() {
+ if i.err == nil && i.Released() {
+ i.err = ErrIterReleased
+ }
+}
+
+func (*emptyIterator) Valid() bool { return false }
+func (i *emptyIterator) First() bool { i.rErr(); return false }
+func (i *emptyIterator) Last() bool { i.rErr(); return false }
+func (i *emptyIterator) Seek(key []byte) bool { i.rErr(); return false }
+func (i *emptyIterator) Next() bool { i.rErr(); return false }
+func (i *emptyIterator) Prev() bool { i.rErr(); return false }
+func (*emptyIterator) Key() []byte { return nil }
+func (*emptyIterator) Value() []byte { return nil }
+func (i *emptyIterator) Error() error { return i.err }
+
+// NewEmptyIterator creates an empty iterator. The err parameter can be
+// nil, but if not nil the given err will be returned by Error method.
+func NewEmptyIterator(err error) Iterator {
+ return &emptyIterator{err: err}
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/iter_suite_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/iter_suite_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..3e54f8b1977d9e29bf744acc78d28163231e77a5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/iter_suite_test.go
@@ -0,0 +1,11 @@
+package iterator_test
+
+import (
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil"
+)
+
+func TestIterator(t *testing.T) {
+ testutil.RunSuite(t, "Iterator Suite")
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/merged_iter.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/merged_iter.go
new file mode 100644
index 0000000000000000000000000000000000000000..df1daffa352f21c63c16e6c6a2429f90be74ec88
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/merged_iter.go
@@ -0,0 +1,304 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package iterator
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type dir int
+
+const (
+ dirReleased dir = iota - 1
+ dirSOI
+ dirEOI
+ dirBackward
+ dirForward
+)
+
+type mergedIterator struct {
+ cmp comparer.Comparer
+ iters []Iterator
+ strict bool
+
+ keys [][]byte
+ index int
+ dir dir
+ err error
+ errf func(err error)
+ releaser util.Releaser
+}
+
+func assertKey(key []byte) []byte {
+ if key == nil {
+ panic("leveldb/iterator: nil key")
+ }
+ return key
+}
+
+func (i *mergedIterator) iterErr(iter Iterator) bool {
+ if err := iter.Error(); err != nil {
+ if i.errf != nil {
+ i.errf(err)
+ }
+ if i.strict || !errors.IsCorrupted(err) {
+ i.err = err
+ return true
+ }
+ }
+ return false
+}
+
+func (i *mergedIterator) Valid() bool {
+ return i.err == nil && i.dir > dirEOI
+}
+
+func (i *mergedIterator) First() bool {
+ if i.err != nil {
+ return false
+ } else if i.dir == dirReleased {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ for x, iter := range i.iters {
+ switch {
+ case iter.First():
+ i.keys[x] = assertKey(iter.Key())
+ case i.iterErr(iter):
+ return false
+ default:
+ i.keys[x] = nil
+ }
+ }
+ i.dir = dirSOI
+ return i.next()
+}
+
+func (i *mergedIterator) Last() bool {
+ if i.err != nil {
+ return false
+ } else if i.dir == dirReleased {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ for x, iter := range i.iters {
+ switch {
+ case iter.Last():
+ i.keys[x] = assertKey(iter.Key())
+ case i.iterErr(iter):
+ return false
+ default:
+ i.keys[x] = nil
+ }
+ }
+ i.dir = dirEOI
+ return i.prev()
+}
+
+func (i *mergedIterator) Seek(key []byte) bool {
+ if i.err != nil {
+ return false
+ } else if i.dir == dirReleased {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ for x, iter := range i.iters {
+ switch {
+ case iter.Seek(key):
+ i.keys[x] = assertKey(iter.Key())
+ case i.iterErr(iter):
+ return false
+ default:
+ i.keys[x] = nil
+ }
+ }
+ i.dir = dirSOI
+ return i.next()
+}
+
+func (i *mergedIterator) next() bool {
+ var key []byte
+ if i.dir == dirForward {
+ key = i.keys[i.index]
+ }
+ for x, tkey := range i.keys {
+ if tkey != nil && (key == nil || i.cmp.Compare(tkey, key) < 0) {
+ key = tkey
+ i.index = x
+ }
+ }
+ if key == nil {
+ i.dir = dirEOI
+ return false
+ }
+ i.dir = dirForward
+ return true
+}
+
+func (i *mergedIterator) Next() bool {
+ if i.dir == dirEOI || i.err != nil {
+ return false
+ } else if i.dir == dirReleased {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ switch i.dir {
+ case dirSOI:
+ return i.First()
+ case dirBackward:
+ key := append([]byte{}, i.keys[i.index]...)
+ if !i.Seek(key) {
+ return false
+ }
+ return i.Next()
+ }
+
+ x := i.index
+ iter := i.iters[x]
+ switch {
+ case iter.Next():
+ i.keys[x] = assertKey(iter.Key())
+ case i.iterErr(iter):
+ return false
+ default:
+ i.keys[x] = nil
+ }
+ return i.next()
+}
+
+func (i *mergedIterator) prev() bool {
+ var key []byte
+ if i.dir == dirBackward {
+ key = i.keys[i.index]
+ }
+ for x, tkey := range i.keys {
+ if tkey != nil && (key == nil || i.cmp.Compare(tkey, key) > 0) {
+ key = tkey
+ i.index = x
+ }
+ }
+ if key == nil {
+ i.dir = dirSOI
+ return false
+ }
+ i.dir = dirBackward
+ return true
+}
+
+func (i *mergedIterator) Prev() bool {
+ if i.dir == dirSOI || i.err != nil {
+ return false
+ } else if i.dir == dirReleased {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ switch i.dir {
+ case dirEOI:
+ return i.Last()
+ case dirForward:
+ key := append([]byte{}, i.keys[i.index]...)
+ for x, iter := range i.iters {
+ if x == i.index {
+ continue
+ }
+ seek := iter.Seek(key)
+ switch {
+ case seek && iter.Prev(), !seek && iter.Last():
+ i.keys[x] = assertKey(iter.Key())
+ case i.iterErr(iter):
+ return false
+ default:
+ i.keys[x] = nil
+ }
+ }
+ }
+
+ x := i.index
+ iter := i.iters[x]
+ switch {
+ case iter.Prev():
+ i.keys[x] = assertKey(iter.Key())
+ case i.iterErr(iter):
+ return false
+ default:
+ i.keys[x] = nil
+ }
+ return i.prev()
+}
+
+func (i *mergedIterator) Key() []byte {
+ if i.err != nil || i.dir <= dirEOI {
+ return nil
+ }
+ return i.keys[i.index]
+}
+
+func (i *mergedIterator) Value() []byte {
+ if i.err != nil || i.dir <= dirEOI {
+ return nil
+ }
+ return i.iters[i.index].Value()
+}
+
+func (i *mergedIterator) Release() {
+ if i.dir != dirReleased {
+ i.dir = dirReleased
+ for _, iter := range i.iters {
+ iter.Release()
+ }
+ i.iters = nil
+ i.keys = nil
+ if i.releaser != nil {
+ i.releaser.Release()
+ i.releaser = nil
+ }
+ }
+}
+
+func (i *mergedIterator) SetReleaser(releaser util.Releaser) {
+ if i.dir == dirReleased {
+ panic(util.ErrReleased)
+ }
+ if i.releaser != nil && releaser != nil {
+ panic(util.ErrHasReleaser)
+ }
+ i.releaser = releaser
+}
+
+func (i *mergedIterator) Error() error {
+ return i.err
+}
+
+func (i *mergedIterator) SetErrorCallback(f func(err error)) {
+ i.errf = f
+}
+
+// NewMergedIterator returns an iterator that merges its input. Walking the
+// resultant iterator will return all key/value pairs of all input iterators
+// in strictly increasing key order, as defined by cmp.
+// The input's key ranges may overlap, but there are assumed to be no duplicate
+// keys: if iters[i] contains a key k then iters[j] will not contain that key k.
+// None of the iters may be nil.
+//
+// If strict is true the any 'corruption errors' (i.e errors.IsCorrupted(err) == true)
+// won't be ignored and will halt 'merged iterator', otherwise the iterator will
+// continue to the next 'input iterator'.
+func NewMergedIterator(iters []Iterator, cmp comparer.Comparer, strict bool) Iterator {
+ return &mergedIterator{
+ iters: iters,
+ cmp: cmp,
+ strict: strict,
+ keys: make([][]byte, len(iters)),
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/merged_iter_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/merged_iter_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..8ef775f31657728ff39962dfda0f6fe890d130da
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/merged_iter_test.go
@@ -0,0 +1,60 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package iterator_test
+
+import (
+ . "github.com/onsi/ginkgo"
+ . "github.com/onsi/gomega"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil"
+)
+
+var _ = testutil.Defer(func() {
+ Describe("Merged iterator", func() {
+ Test := func(filled int, empty int) func() {
+ return func() {
+ It("Should iterates and seeks correctly", func(done Done) {
+ rnd := testutil.NewRand()
+
+ // Build key/value.
+ filledKV := make([]testutil.KeyValue, filled)
+ kv := testutil.KeyValue_Generate(nil, 100, 1, 10, 4, 4)
+ kv.Iterate(func(i int, key, value []byte) {
+ filledKV[rnd.Intn(filled)].Put(key, value)
+ })
+
+ // Create itearators.
+ iters := make([]Iterator, filled+empty)
+ for i := range iters {
+ if empty == 0 || (rnd.Int()%2 == 0 && filled > 0) {
+ filled--
+ Expect(filledKV[filled].Len()).ShouldNot(BeZero())
+ iters[i] = NewArrayIterator(filledKV[filled])
+ } else {
+ empty--
+ iters[i] = NewEmptyIterator(nil)
+ }
+ }
+
+ // Test the iterator.
+ t := testutil.IteratorTesting{
+ KeyValue: kv.Clone(),
+ Iter: NewMergedIterator(iters, comparer.DefaultComparer, true),
+ }
+ testutil.DoIteratorTesting(&t)
+ done <- true
+ }, 1.5)
+ }
+ }
+
+ Describe("with three, all filled iterators", Test(3, 0))
+ Describe("with one filled, one empty iterators", Test(1, 1))
+ Describe("with one filled, two empty iterators", Test(1, 2))
+ })
+})
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/journal/journal.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/journal/journal.go
new file mode 100644
index 0000000000000000000000000000000000000000..4e4aae982c72c8148dd3253050e6c02bc7f8c636
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/journal/journal.go
@@ -0,0 +1,520 @@
+// Copyright 2011 The LevelDB-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Taken from: https://code.google.com/p/leveldb-go/source/browse/leveldb/record/record.go?r=1d5ccbe03246da926391ee12d1c6caae054ff4b0
+// License, authors and contributors informations can be found at bellow URLs respectively:
+// https://code.google.com/p/leveldb-go/source/browse/LICENSE
+// https://code.google.com/p/leveldb-go/source/browse/AUTHORS
+// https://code.google.com/p/leveldb-go/source/browse/CONTRIBUTORS
+
+// Package journal reads and writes sequences of journals. Each journal is a stream
+// of bytes that completes before the next journal starts.
+//
+// When reading, call Next to obtain an io.Reader for the next journal. Next will
+// return io.EOF when there are no more journals. It is valid to call Next
+// without reading the current journal to exhaustion.
+//
+// When writing, call Next to obtain an io.Writer for the next journal. Calling
+// Next finishes the current journal. Call Close to finish the final journal.
+//
+// Optionally, call Flush to finish the current journal and flush the underlying
+// writer without starting a new journal. To start a new journal after flushing,
+// call Next.
+//
+// Neither Readers or Writers are safe to use concurrently.
+//
+// Example code:
+// func read(r io.Reader) ([]string, error) {
+// var ss []string
+// journals := journal.NewReader(r, nil, true, true)
+// for {
+// j, err := journals.Next()
+// if err == io.EOF {
+// break
+// }
+// if err != nil {
+// return nil, err
+// }
+// s, err := ioutil.ReadAll(j)
+// if err != nil {
+// return nil, err
+// }
+// ss = append(ss, string(s))
+// }
+// return ss, nil
+// }
+//
+// func write(w io.Writer, ss []string) error {
+// journals := journal.NewWriter(w)
+// for _, s := range ss {
+// j, err := journals.Next()
+// if err != nil {
+// return err
+// }
+// if _, err := j.Write([]byte(s)), err != nil {
+// return err
+// }
+// }
+// return journals.Close()
+// }
+//
+// The wire format is that the stream is divided into 32KiB blocks, and each
+// block contains a number of tightly packed chunks. Chunks cannot cross block
+// boundaries. The last block may be shorter than 32 KiB. Any unused bytes in a
+// block must be zero.
+//
+// A journal maps to one or more chunks. Each chunk has a 7 byte header (a 4
+// byte checksum, a 2 byte little-endian uint16 length, and a 1 byte chunk type)
+// followed by a payload. The checksum is over the chunk type and the payload.
+//
+// There are four chunk types: whether the chunk is the full journal, or the
+// first, middle or last chunk of a multi-chunk journal. A multi-chunk journal
+// has one first chunk, zero or more middle chunks, and one last chunk.
+//
+// The wire format allows for limited recovery in the face of data corruption:
+// on a format error (such as a checksum mismatch), the reader moves to the
+// next block and looks for the next full or first chunk.
+package journal
+
+import (
+ "encoding/binary"
+ "fmt"
+ "io"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+// These constants are part of the wire format and should not be changed.
+const (
+ fullChunkType = 1
+ firstChunkType = 2
+ middleChunkType = 3
+ lastChunkType = 4
+)
+
+const (
+ blockSize = 32 * 1024
+ headerSize = 7
+)
+
+type flusher interface {
+ Flush() error
+}
+
+// ErrCorrupted is the error type that generated by corrupted block or chunk.
+type ErrCorrupted struct {
+ Size int
+ Reason string
+}
+
+func (e *ErrCorrupted) Error() string {
+ return fmt.Sprintf("leveldb/journal: block/chunk corrupted: %s (%d bytes)", e.Reason, e.Size)
+}
+
+// Dropper is the interface that wrap simple Drop method. The Drop
+// method will be called when the journal reader dropping a block or chunk.
+type Dropper interface {
+ Drop(err error)
+}
+
+// Reader reads journals from an underlying io.Reader.
+type Reader struct {
+ // r is the underlying reader.
+ r io.Reader
+ // the dropper.
+ dropper Dropper
+ // strict flag.
+ strict bool
+ // checksum flag.
+ checksum bool
+ // seq is the sequence number of the current journal.
+ seq int
+ // buf[i:j] is the unread portion of the current chunk's payload.
+ // The low bound, i, excludes the chunk header.
+ i, j int
+ // n is the number of bytes of buf that are valid. Once reading has started,
+ // only the final block can have n < blockSize.
+ n int
+ // last is whether the current chunk is the last chunk of the journal.
+ last bool
+ // err is any accumulated error.
+ err error
+ // buf is the buffer.
+ buf [blockSize]byte
+}
+
+// NewReader returns a new reader. The dropper may be nil, and if
+// strict is true then corrupted or invalid chunk will halt the journal
+// reader entirely.
+func NewReader(r io.Reader, dropper Dropper, strict, checksum bool) *Reader {
+ return &Reader{
+ r: r,
+ dropper: dropper,
+ strict: strict,
+ checksum: checksum,
+ last: true,
+ }
+}
+
+var errSkip = errors.New("leveldb/journal: skipped")
+
+func (r *Reader) corrupt(n int, reason string, skip bool) error {
+ if r.dropper != nil {
+ r.dropper.Drop(&ErrCorrupted{n, reason})
+ }
+ if r.strict && !skip {
+ r.err = errors.NewErrCorrupted(nil, &ErrCorrupted{n, reason})
+ return r.err
+ }
+ return errSkip
+}
+
+// nextChunk sets r.buf[r.i:r.j] to hold the next chunk's payload, reading the
+// next block into the buffer if necessary.
+func (r *Reader) nextChunk(first bool) error {
+ for {
+ if r.j+headerSize <= r.n {
+ checksum := binary.LittleEndian.Uint32(r.buf[r.j+0 : r.j+4])
+ length := binary.LittleEndian.Uint16(r.buf[r.j+4 : r.j+6])
+ chunkType := r.buf[r.j+6]
+
+ if checksum == 0 && length == 0 && chunkType == 0 {
+ // Drop entire block.
+ m := r.n - r.j
+ r.i = r.n
+ r.j = r.n
+ return r.corrupt(m, "zero header", false)
+ } else {
+ m := r.n - r.j
+ r.i = r.j + headerSize
+ r.j = r.j + headerSize + int(length)
+ if r.j > r.n {
+ // Drop entire block.
+ r.i = r.n
+ r.j = r.n
+ return r.corrupt(m, "chunk length overflows block", false)
+ } else if r.checksum && checksum != util.NewCRC(r.buf[r.i-1:r.j]).Value() {
+ // Drop entire block.
+ r.i = r.n
+ r.j = r.n
+ return r.corrupt(m, "checksum mismatch", false)
+ }
+ }
+ if first && chunkType != fullChunkType && chunkType != firstChunkType {
+ m := r.j - r.i
+ r.i = r.j
+ // Report the error, but skip it.
+ return r.corrupt(m+headerSize, "orphan chunk", true)
+ }
+ r.last = chunkType == fullChunkType || chunkType == lastChunkType
+ return nil
+ }
+
+ // The last block.
+ if r.n < blockSize && r.n > 0 {
+ if !first {
+ return r.corrupt(0, "missing chunk part", false)
+ }
+ r.err = io.EOF
+ return r.err
+ }
+
+ // Read block.
+ n, err := io.ReadFull(r.r, r.buf[:])
+ if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF {
+ return err
+ }
+ if n == 0 {
+ if !first {
+ return r.corrupt(0, "missing chunk part", false)
+ }
+ r.err = io.EOF
+ return r.err
+ }
+ r.i, r.j, r.n = 0, 0, n
+ }
+}
+
+// Next returns a reader for the next journal. It returns io.EOF if there are no
+// more journals. The reader returned becomes stale after the next Next call,
+// and should no longer be used. If strict is false, the reader will returns
+// io.ErrUnexpectedEOF error when found corrupted journal.
+func (r *Reader) Next() (io.Reader, error) {
+ r.seq++
+ if r.err != nil {
+ return nil, r.err
+ }
+ r.i = r.j
+ for {
+ if err := r.nextChunk(true); err == nil {
+ break
+ } else if err != errSkip {
+ return nil, err
+ }
+ }
+ return &singleReader{r, r.seq, nil}, nil
+}
+
+// Reset resets the journal reader, allows reuse of the journal reader. Reset returns
+// last accumulated error.
+func (r *Reader) Reset(reader io.Reader, dropper Dropper, strict, checksum bool) error {
+ r.seq++
+ err := r.err
+ r.r = reader
+ r.dropper = dropper
+ r.strict = strict
+ r.checksum = checksum
+ r.i = 0
+ r.j = 0
+ r.n = 0
+ r.last = true
+ r.err = nil
+ return err
+}
+
+type singleReader struct {
+ r *Reader
+ seq int
+ err error
+}
+
+func (x *singleReader) Read(p []byte) (int, error) {
+ r := x.r
+ if r.seq != x.seq {
+ return 0, errors.New("leveldb/journal: stale reader")
+ }
+ if x.err != nil {
+ return 0, x.err
+ }
+ if r.err != nil {
+ return 0, r.err
+ }
+ for r.i == r.j {
+ if r.last {
+ return 0, io.EOF
+ }
+ x.err = r.nextChunk(false)
+ if x.err != nil {
+ if x.err == errSkip {
+ x.err = io.ErrUnexpectedEOF
+ }
+ return 0, x.err
+ }
+ }
+ n := copy(p, r.buf[r.i:r.j])
+ r.i += n
+ return n, nil
+}
+
+func (x *singleReader) ReadByte() (byte, error) {
+ r := x.r
+ if r.seq != x.seq {
+ return 0, errors.New("leveldb/journal: stale reader")
+ }
+ if x.err != nil {
+ return 0, x.err
+ }
+ if r.err != nil {
+ return 0, r.err
+ }
+ for r.i == r.j {
+ if r.last {
+ return 0, io.EOF
+ }
+ x.err = r.nextChunk(false)
+ if x.err != nil {
+ if x.err == errSkip {
+ x.err = io.ErrUnexpectedEOF
+ }
+ return 0, x.err
+ }
+ }
+ c := r.buf[r.i]
+ r.i++
+ return c, nil
+}
+
+// Writer writes journals to an underlying io.Writer.
+type Writer struct {
+ // w is the underlying writer.
+ w io.Writer
+ // seq is the sequence number of the current journal.
+ seq int
+ // f is w as a flusher.
+ f flusher
+ // buf[i:j] is the bytes that will become the current chunk.
+ // The low bound, i, includes the chunk header.
+ i, j int
+ // buf[:written] has already been written to w.
+ // written is zero unless Flush has been called.
+ written int
+ // first is whether the current chunk is the first chunk of the journal.
+ first bool
+ // pending is whether a chunk is buffered but not yet written.
+ pending bool
+ // err is any accumulated error.
+ err error
+ // buf is the buffer.
+ buf [blockSize]byte
+}
+
+// NewWriter returns a new Writer.
+func NewWriter(w io.Writer) *Writer {
+ f, _ := w.(flusher)
+ return &Writer{
+ w: w,
+ f: f,
+ }
+}
+
+// fillHeader fills in the header for the pending chunk.
+func (w *Writer) fillHeader(last bool) {
+ if w.i+headerSize > w.j || w.j > blockSize {
+ panic("leveldb/journal: bad writer state")
+ }
+ if last {
+ if w.first {
+ w.buf[w.i+6] = fullChunkType
+ } else {
+ w.buf[w.i+6] = lastChunkType
+ }
+ } else {
+ if w.first {
+ w.buf[w.i+6] = firstChunkType
+ } else {
+ w.buf[w.i+6] = middleChunkType
+ }
+ }
+ binary.LittleEndian.PutUint32(w.buf[w.i+0:w.i+4], util.NewCRC(w.buf[w.i+6:w.j]).Value())
+ binary.LittleEndian.PutUint16(w.buf[w.i+4:w.i+6], uint16(w.j-w.i-headerSize))
+}
+
+// writeBlock writes the buffered block to the underlying writer, and reserves
+// space for the next chunk's header.
+func (w *Writer) writeBlock() {
+ _, w.err = w.w.Write(w.buf[w.written:])
+ w.i = 0
+ w.j = headerSize
+ w.written = 0
+}
+
+// writePending finishes the current journal and writes the buffer to the
+// underlying writer.
+func (w *Writer) writePending() {
+ if w.err != nil {
+ return
+ }
+ if w.pending {
+ w.fillHeader(true)
+ w.pending = false
+ }
+ _, w.err = w.w.Write(w.buf[w.written:w.j])
+ w.written = w.j
+}
+
+// Close finishes the current journal and closes the writer.
+func (w *Writer) Close() error {
+ w.seq++
+ w.writePending()
+ if w.err != nil {
+ return w.err
+ }
+ w.err = errors.New("leveldb/journal: closed Writer")
+ return nil
+}
+
+// Flush finishes the current journal, writes to the underlying writer, and
+// flushes it if that writer implements interface{ Flush() error }.
+func (w *Writer) Flush() error {
+ w.seq++
+ w.writePending()
+ if w.err != nil {
+ return w.err
+ }
+ if w.f != nil {
+ w.err = w.f.Flush()
+ return w.err
+ }
+ return nil
+}
+
+// Reset resets the journal writer, allows reuse of the journal writer. Reset
+// will also closes the journal writer if not already.
+func (w *Writer) Reset(writer io.Writer) (err error) {
+ w.seq++
+ if w.err == nil {
+ w.writePending()
+ err = w.err
+ }
+ w.w = writer
+ w.f, _ = writer.(flusher)
+ w.i = 0
+ w.j = 0
+ w.written = 0
+ w.first = false
+ w.pending = false
+ w.err = nil
+ return
+}
+
+// Next returns a writer for the next journal. The writer returned becomes stale
+// after the next Close, Flush or Next call, and should no longer be used.
+func (w *Writer) Next() (io.Writer, error) {
+ w.seq++
+ if w.err != nil {
+ return nil, w.err
+ }
+ if w.pending {
+ w.fillHeader(true)
+ }
+ w.i = w.j
+ w.j = w.j + headerSize
+ // Check if there is room in the block for the header.
+ if w.j > blockSize {
+ // Fill in the rest of the block with zeroes.
+ for k := w.i; k < blockSize; k++ {
+ w.buf[k] = 0
+ }
+ w.writeBlock()
+ if w.err != nil {
+ return nil, w.err
+ }
+ }
+ w.first = true
+ w.pending = true
+ return singleWriter{w, w.seq}, nil
+}
+
+type singleWriter struct {
+ w *Writer
+ seq int
+}
+
+func (x singleWriter) Write(p []byte) (int, error) {
+ w := x.w
+ if w.seq != x.seq {
+ return 0, errors.New("leveldb/journal: stale writer")
+ }
+ if w.err != nil {
+ return 0, w.err
+ }
+ n0 := len(p)
+ for len(p) > 0 {
+ // Write a block, if it is full.
+ if w.j == blockSize {
+ w.fillHeader(false)
+ w.writeBlock()
+ if w.err != nil {
+ return 0, w.err
+ }
+ w.first = false
+ }
+ // Copy bytes into the buffer.
+ n := copy(w.buf[w.j:], p)
+ w.j += n
+ p = p[n:]
+ }
+ return n0, nil
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/journal/journal_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/journal/journal_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..0fcf22599f265b23175f0dcf60dda176fc2c33e3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/journal/journal_test.go
@@ -0,0 +1,818 @@
+// Copyright 2011 The LevelDB-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Taken from: https://code.google.com/p/leveldb-go/source/browse/leveldb/record/record_test.go?r=df1fa28f7f3be6c3935548169002309c12967135
+// License, authors and contributors informations can be found at bellow URLs respectively:
+// https://code.google.com/p/leveldb-go/source/browse/LICENSE
+// https://code.google.com/p/leveldb-go/source/browse/AUTHORS
+// https://code.google.com/p/leveldb-go/source/browse/CONTRIBUTORS
+
+package journal
+
+import (
+ "bytes"
+ "encoding/binary"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "math/rand"
+ "strings"
+ "testing"
+)
+
+type dropper struct {
+ t *testing.T
+}
+
+func (d dropper) Drop(err error) {
+ d.t.Log(err)
+}
+
+func short(s string) string {
+ if len(s) < 64 {
+ return s
+ }
+ return fmt.Sprintf("%s...(skipping %d bytes)...%s", s[:20], len(s)-40, s[len(s)-20:])
+}
+
+// big returns a string of length n, composed of repetitions of partial.
+func big(partial string, n int) string {
+ return strings.Repeat(partial, n/len(partial)+1)[:n]
+}
+
+func TestEmpty(t *testing.T) {
+ buf := new(bytes.Buffer)
+ r := NewReader(buf, dropper{t}, true, true)
+ if _, err := r.Next(); err != io.EOF {
+ t.Fatalf("got %v, want %v", err, io.EOF)
+ }
+}
+
+func testGenerator(t *testing.T, reset func(), gen func() (string, bool)) {
+ buf := new(bytes.Buffer)
+
+ reset()
+ w := NewWriter(buf)
+ for {
+ s, ok := gen()
+ if !ok {
+ break
+ }
+ ww, err := w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write([]byte(s)); err != nil {
+ t.Fatal(err)
+ }
+ }
+ if err := w.Close(); err != nil {
+ t.Fatal(err)
+ }
+
+ reset()
+ r := NewReader(buf, dropper{t}, true, true)
+ for {
+ s, ok := gen()
+ if !ok {
+ break
+ }
+ rr, err := r.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ x, err := ioutil.ReadAll(rr)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if string(x) != s {
+ t.Fatalf("got %q, want %q", short(string(x)), short(s))
+ }
+ }
+ if _, err := r.Next(); err != io.EOF {
+ t.Fatalf("got %v, want %v", err, io.EOF)
+ }
+}
+
+func testLiterals(t *testing.T, s []string) {
+ var i int
+ reset := func() {
+ i = 0
+ }
+ gen := func() (string, bool) {
+ if i == len(s) {
+ return "", false
+ }
+ i++
+ return s[i-1], true
+ }
+ testGenerator(t, reset, gen)
+}
+
+func TestMany(t *testing.T) {
+ const n = 1e5
+ var i int
+ reset := func() {
+ i = 0
+ }
+ gen := func() (string, bool) {
+ if i == n {
+ return "", false
+ }
+ i++
+ return fmt.Sprintf("%d.", i-1), true
+ }
+ testGenerator(t, reset, gen)
+}
+
+func TestRandom(t *testing.T) {
+ const n = 1e2
+ var (
+ i int
+ r *rand.Rand
+ )
+ reset := func() {
+ i, r = 0, rand.New(rand.NewSource(0))
+ }
+ gen := func() (string, bool) {
+ if i == n {
+ return "", false
+ }
+ i++
+ return strings.Repeat(string(uint8(i)), r.Intn(2*blockSize+16)), true
+ }
+ testGenerator(t, reset, gen)
+}
+
+func TestBasic(t *testing.T) {
+ testLiterals(t, []string{
+ strings.Repeat("a", 1000),
+ strings.Repeat("b", 97270),
+ strings.Repeat("c", 8000),
+ })
+}
+
+func TestBoundary(t *testing.T) {
+ for i := blockSize - 16; i < blockSize+16; i++ {
+ s0 := big("abcd", i)
+ for j := blockSize - 16; j < blockSize+16; j++ {
+ s1 := big("ABCDE", j)
+ testLiterals(t, []string{s0, s1})
+ testLiterals(t, []string{s0, "", s1})
+ testLiterals(t, []string{s0, "x", s1})
+ }
+ }
+}
+
+func TestFlush(t *testing.T) {
+ buf := new(bytes.Buffer)
+ w := NewWriter(buf)
+ // Write a couple of records. Everything should still be held
+ // in the record.Writer buffer, so that buf.Len should be 0.
+ w0, _ := w.Next()
+ w0.Write([]byte("0"))
+ w1, _ := w.Next()
+ w1.Write([]byte("11"))
+ if got, want := buf.Len(), 0; got != want {
+ t.Fatalf("buffer length #0: got %d want %d", got, want)
+ }
+ // Flush the record.Writer buffer, which should yield 17 bytes.
+ // 17 = 2*7 + 1 + 2, which is two headers and 1 + 2 payload bytes.
+ if err := w.Flush(); err != nil {
+ t.Fatal(err)
+ }
+ if got, want := buf.Len(), 17; got != want {
+ t.Fatalf("buffer length #1: got %d want %d", got, want)
+ }
+ // Do another write, one that isn't large enough to complete the block.
+ // The write should not have flowed through to buf.
+ w2, _ := w.Next()
+ w2.Write(bytes.Repeat([]byte("2"), 10000))
+ if got, want := buf.Len(), 17; got != want {
+ t.Fatalf("buffer length #2: got %d want %d", got, want)
+ }
+ // Flushing should get us up to 10024 bytes written.
+ // 10024 = 17 + 7 + 10000.
+ if err := w.Flush(); err != nil {
+ t.Fatal(err)
+ }
+ if got, want := buf.Len(), 10024; got != want {
+ t.Fatalf("buffer length #3: got %d want %d", got, want)
+ }
+ // Do a bigger write, one that completes the current block.
+ // We should now have 32768 bytes (a complete block), without
+ // an explicit flush.
+ w3, _ := w.Next()
+ w3.Write(bytes.Repeat([]byte("3"), 40000))
+ if got, want := buf.Len(), 32768; got != want {
+ t.Fatalf("buffer length #4: got %d want %d", got, want)
+ }
+ // Flushing should get us up to 50038 bytes written.
+ // 50038 = 10024 + 2*7 + 40000. There are two headers because
+ // the one record was split into two chunks.
+ if err := w.Flush(); err != nil {
+ t.Fatal(err)
+ }
+ if got, want := buf.Len(), 50038; got != want {
+ t.Fatalf("buffer length #5: got %d want %d", got, want)
+ }
+ // Check that reading those records give the right lengths.
+ r := NewReader(buf, dropper{t}, true, true)
+ wants := []int64{1, 2, 10000, 40000}
+ for i, want := range wants {
+ rr, _ := r.Next()
+ n, err := io.Copy(ioutil.Discard, rr)
+ if err != nil {
+ t.Fatalf("read #%d: %v", i, err)
+ }
+ if n != want {
+ t.Fatalf("read #%d: got %d bytes want %d", i, n, want)
+ }
+ }
+}
+
+func TestNonExhaustiveRead(t *testing.T) {
+ const n = 100
+ buf := new(bytes.Buffer)
+ p := make([]byte, 10)
+ rnd := rand.New(rand.NewSource(1))
+
+ w := NewWriter(buf)
+ for i := 0; i < n; i++ {
+ length := len(p) + rnd.Intn(3*blockSize)
+ s := string(uint8(i)) + "123456789abcdefgh"
+ ww, _ := w.Next()
+ ww.Write([]byte(big(s, length)))
+ }
+ if err := w.Close(); err != nil {
+ t.Fatal(err)
+ }
+
+ r := NewReader(buf, dropper{t}, true, true)
+ for i := 0; i < n; i++ {
+ rr, _ := r.Next()
+ _, err := io.ReadFull(rr, p)
+ if err != nil {
+ t.Fatal(err)
+ }
+ want := string(uint8(i)) + "123456789"
+ if got := string(p); got != want {
+ t.Fatalf("read #%d: got %q want %q", i, got, want)
+ }
+ }
+}
+
+func TestStaleReader(t *testing.T) {
+ buf := new(bytes.Buffer)
+
+ w := NewWriter(buf)
+ w0, err := w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ w0.Write([]byte("0"))
+ w1, err := w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ w1.Write([]byte("11"))
+ if err := w.Close(); err != nil {
+ t.Fatal(err)
+ }
+
+ r := NewReader(buf, dropper{t}, true, true)
+ r0, err := r.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ r1, err := r.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ p := make([]byte, 1)
+ if _, err := r0.Read(p); err == nil || !strings.Contains(err.Error(), "stale") {
+ t.Fatalf("stale read #0: unexpected error: %v", err)
+ }
+ if _, err := r1.Read(p); err != nil {
+ t.Fatalf("fresh read #1: got %v want nil error", err)
+ }
+ if p[0] != '1' {
+ t.Fatalf("fresh read #1: byte contents: got '%c' want '1'", p[0])
+ }
+}
+
+func TestStaleWriter(t *testing.T) {
+ buf := new(bytes.Buffer)
+
+ w := NewWriter(buf)
+ w0, err := w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ w1, err := w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := w0.Write([]byte("0")); err == nil || !strings.Contains(err.Error(), "stale") {
+ t.Fatalf("stale write #0: unexpected error: %v", err)
+ }
+ if _, err := w1.Write([]byte("11")); err != nil {
+ t.Fatalf("fresh write #1: got %v want nil error", err)
+ }
+ if err := w.Flush(); err != nil {
+ t.Fatalf("flush: %v", err)
+ }
+ if _, err := w1.Write([]byte("0")); err == nil || !strings.Contains(err.Error(), "stale") {
+ t.Fatalf("stale write #1: unexpected error: %v", err)
+ }
+}
+
+func TestCorrupt_MissingLastBlock(t *testing.T) {
+ buf := new(bytes.Buffer)
+
+ w := NewWriter(buf)
+
+ // First record.
+ ww, err := w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize-1024)); err != nil {
+ t.Fatalf("write #0: unexpected error: %v", err)
+ }
+
+ // Second record.
+ ww, err = w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize-headerSize)); err != nil {
+ t.Fatalf("write #1: unexpected error: %v", err)
+ }
+
+ if err := w.Close(); err != nil {
+ t.Fatal(err)
+ }
+
+ // Cut the last block.
+ b := buf.Bytes()[:blockSize]
+ r := NewReader(bytes.NewReader(b), dropper{t}, false, true)
+
+ // First read.
+ rr, err := r.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ n, err := io.Copy(ioutil.Discard, rr)
+ if err != nil {
+ t.Fatalf("read #0: %v", err)
+ }
+ if n != blockSize-1024 {
+ t.Fatalf("read #0: got %d bytes want %d", n, blockSize-1024)
+ }
+
+ // Second read.
+ rr, err = r.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ n, err = io.Copy(ioutil.Discard, rr)
+ if err != io.ErrUnexpectedEOF {
+ t.Fatalf("read #1: unexpected error: %v", err)
+ }
+
+ if _, err := r.Next(); err != io.EOF {
+ t.Fatalf("last next: unexpected error: %v", err)
+ }
+}
+
+func TestCorrupt_CorruptedFirstBlock(t *testing.T) {
+ buf := new(bytes.Buffer)
+
+ w := NewWriter(buf)
+
+ // First record.
+ ww, err := w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize/2)); err != nil {
+ t.Fatalf("write #0: unexpected error: %v", err)
+ }
+
+ // Second record.
+ ww, err = w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize-headerSize)); err != nil {
+ t.Fatalf("write #1: unexpected error: %v", err)
+ }
+
+ // Third record.
+ ww, err = w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), (blockSize-headerSize)+1)); err != nil {
+ t.Fatalf("write #2: unexpected error: %v", err)
+ }
+
+ // Fourth record.
+ ww, err = w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), (blockSize-headerSize)+2)); err != nil {
+ t.Fatalf("write #3: unexpected error: %v", err)
+ }
+
+ if err := w.Close(); err != nil {
+ t.Fatal(err)
+ }
+
+ b := buf.Bytes()
+ // Corrupting block #0.
+ for i := 0; i < 1024; i++ {
+ b[i] = '1'
+ }
+
+ r := NewReader(bytes.NewReader(b), dropper{t}, false, true)
+
+ // First read (third record).
+ rr, err := r.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ n, err := io.Copy(ioutil.Discard, rr)
+ if err != nil {
+ t.Fatalf("read #0: %v", err)
+ }
+ if want := int64(blockSize-headerSize) + 1; n != want {
+ t.Fatalf("read #0: got %d bytes want %d", n, want)
+ }
+
+ // Second read (fourth record).
+ rr, err = r.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ n, err = io.Copy(ioutil.Discard, rr)
+ if err != nil {
+ t.Fatalf("read #1: %v", err)
+ }
+ if want := int64(blockSize-headerSize) + 2; n != want {
+ t.Fatalf("read #1: got %d bytes want %d", n, want)
+ }
+
+ if _, err := r.Next(); err != io.EOF {
+ t.Fatalf("last next: unexpected error: %v", err)
+ }
+}
+
+func TestCorrupt_CorruptedMiddleBlock(t *testing.T) {
+ buf := new(bytes.Buffer)
+
+ w := NewWriter(buf)
+
+ // First record.
+ ww, err := w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize/2)); err != nil {
+ t.Fatalf("write #0: unexpected error: %v", err)
+ }
+
+ // Second record.
+ ww, err = w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize-headerSize)); err != nil {
+ t.Fatalf("write #1: unexpected error: %v", err)
+ }
+
+ // Third record.
+ ww, err = w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), (blockSize-headerSize)+1)); err != nil {
+ t.Fatalf("write #2: unexpected error: %v", err)
+ }
+
+ // Fourth record.
+ ww, err = w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), (blockSize-headerSize)+2)); err != nil {
+ t.Fatalf("write #3: unexpected error: %v", err)
+ }
+
+ if err := w.Close(); err != nil {
+ t.Fatal(err)
+ }
+
+ b := buf.Bytes()
+ // Corrupting block #1.
+ for i := 0; i < 1024; i++ {
+ b[blockSize+i] = '1'
+ }
+
+ r := NewReader(bytes.NewReader(b), dropper{t}, false, true)
+
+ // First read (first record).
+ rr, err := r.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ n, err := io.Copy(ioutil.Discard, rr)
+ if err != nil {
+ t.Fatalf("read #0: %v", err)
+ }
+ if want := int64(blockSize / 2); n != want {
+ t.Fatalf("read #0: got %d bytes want %d", n, want)
+ }
+
+ // Second read (second record).
+ rr, err = r.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ n, err = io.Copy(ioutil.Discard, rr)
+ if err != io.ErrUnexpectedEOF {
+ t.Fatalf("read #1: unexpected error: %v", err)
+ }
+
+ // Third read (fourth record).
+ rr, err = r.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ n, err = io.Copy(ioutil.Discard, rr)
+ if err != nil {
+ t.Fatalf("read #2: %v", err)
+ }
+ if want := int64(blockSize-headerSize) + 2; n != want {
+ t.Fatalf("read #2: got %d bytes want %d", n, want)
+ }
+
+ if _, err := r.Next(); err != io.EOF {
+ t.Fatalf("last next: unexpected error: %v", err)
+ }
+}
+
+func TestCorrupt_CorruptedLastBlock(t *testing.T) {
+ buf := new(bytes.Buffer)
+
+ w := NewWriter(buf)
+
+ // First record.
+ ww, err := w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize/2)); err != nil {
+ t.Fatalf("write #0: unexpected error: %v", err)
+ }
+
+ // Second record.
+ ww, err = w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize-headerSize)); err != nil {
+ t.Fatalf("write #1: unexpected error: %v", err)
+ }
+
+ // Third record.
+ ww, err = w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), (blockSize-headerSize)+1)); err != nil {
+ t.Fatalf("write #2: unexpected error: %v", err)
+ }
+
+ // Fourth record.
+ ww, err = w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), (blockSize-headerSize)+2)); err != nil {
+ t.Fatalf("write #3: unexpected error: %v", err)
+ }
+
+ if err := w.Close(); err != nil {
+ t.Fatal(err)
+ }
+
+ b := buf.Bytes()
+ // Corrupting block #3.
+ for i := len(b) - 1; i > len(b)-1024; i-- {
+ b[i] = '1'
+ }
+
+ r := NewReader(bytes.NewReader(b), dropper{t}, false, true)
+
+ // First read (first record).
+ rr, err := r.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ n, err := io.Copy(ioutil.Discard, rr)
+ if err != nil {
+ t.Fatalf("read #0: %v", err)
+ }
+ if want := int64(blockSize / 2); n != want {
+ t.Fatalf("read #0: got %d bytes want %d", n, want)
+ }
+
+ // Second read (second record).
+ rr, err = r.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ n, err = io.Copy(ioutil.Discard, rr)
+ if err != nil {
+ t.Fatalf("read #1: %v", err)
+ }
+ if want := int64(blockSize - headerSize); n != want {
+ t.Fatalf("read #1: got %d bytes want %d", n, want)
+ }
+
+ // Third read (third record).
+ rr, err = r.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ n, err = io.Copy(ioutil.Discard, rr)
+ if err != nil {
+ t.Fatalf("read #2: %v", err)
+ }
+ if want := int64(blockSize-headerSize) + 1; n != want {
+ t.Fatalf("read #2: got %d bytes want %d", n, want)
+ }
+
+ // Fourth read (fourth record).
+ rr, err = r.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ n, err = io.Copy(ioutil.Discard, rr)
+ if err != io.ErrUnexpectedEOF {
+ t.Fatalf("read #3: unexpected error: %v", err)
+ }
+
+ if _, err := r.Next(); err != io.EOF {
+ t.Fatalf("last next: unexpected error: %v", err)
+ }
+}
+
+func TestCorrupt_FirstChuckLengthOverflow(t *testing.T) {
+ buf := new(bytes.Buffer)
+
+ w := NewWriter(buf)
+
+ // First record.
+ ww, err := w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize/2)); err != nil {
+ t.Fatalf("write #0: unexpected error: %v", err)
+ }
+
+ // Second record.
+ ww, err = w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize-headerSize)); err != nil {
+ t.Fatalf("write #1: unexpected error: %v", err)
+ }
+
+ // Third record.
+ ww, err = w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), (blockSize-headerSize)+1)); err != nil {
+ t.Fatalf("write #2: unexpected error: %v", err)
+ }
+
+ if err := w.Close(); err != nil {
+ t.Fatal(err)
+ }
+
+ b := buf.Bytes()
+ // Corrupting record #1.
+ x := blockSize
+ binary.LittleEndian.PutUint16(b[x+4:], 0xffff)
+
+ r := NewReader(bytes.NewReader(b), dropper{t}, false, true)
+
+ // First read (first record).
+ rr, err := r.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ n, err := io.Copy(ioutil.Discard, rr)
+ if err != nil {
+ t.Fatalf("read #0: %v", err)
+ }
+ if want := int64(blockSize / 2); n != want {
+ t.Fatalf("read #0: got %d bytes want %d", n, want)
+ }
+
+ // Second read (second record).
+ rr, err = r.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ n, err = io.Copy(ioutil.Discard, rr)
+ if err != io.ErrUnexpectedEOF {
+ t.Fatalf("read #1: unexpected error: %v", err)
+ }
+
+ if _, err := r.Next(); err != io.EOF {
+ t.Fatalf("last next: unexpected error: %v", err)
+ }
+}
+
+func TestCorrupt_MiddleChuckLengthOverflow(t *testing.T) {
+ buf := new(bytes.Buffer)
+
+ w := NewWriter(buf)
+
+ // First record.
+ ww, err := w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize/2)); err != nil {
+ t.Fatalf("write #0: unexpected error: %v", err)
+ }
+
+ // Second record.
+ ww, err = w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize-headerSize)); err != nil {
+ t.Fatalf("write #1: unexpected error: %v", err)
+ }
+
+ // Third record.
+ ww, err = w.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := ww.Write(bytes.Repeat([]byte("0"), (blockSize-headerSize)+1)); err != nil {
+ t.Fatalf("write #2: unexpected error: %v", err)
+ }
+
+ if err := w.Close(); err != nil {
+ t.Fatal(err)
+ }
+
+ b := buf.Bytes()
+ // Corrupting record #1.
+ x := blockSize/2 + headerSize
+ binary.LittleEndian.PutUint16(b[x+4:], 0xffff)
+
+ r := NewReader(bytes.NewReader(b), dropper{t}, false, true)
+
+ // First read (first record).
+ rr, err := r.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ n, err := io.Copy(ioutil.Discard, rr)
+ if err != nil {
+ t.Fatalf("read #0: %v", err)
+ }
+ if want := int64(blockSize / 2); n != want {
+ t.Fatalf("read #0: got %d bytes want %d", n, want)
+ }
+
+ // Second read (third record).
+ rr, err = r.Next()
+ if err != nil {
+ t.Fatal(err)
+ }
+ n, err = io.Copy(ioutil.Discard, rr)
+ if err != nil {
+ t.Fatalf("read #1: %v", err)
+ }
+ if want := int64(blockSize-headerSize) + 1; n != want {
+ t.Fatalf("read #1: got %d bytes want %d", n, want)
+ }
+
+ if _, err := r.Next(); err != io.EOF {
+ t.Fatalf("last next: unexpected error: %v", err)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/key.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/key.go
new file mode 100644
index 0000000000000000000000000000000000000000..eeff53321e810198c67d6920ea6c437bd22eab99
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/key.go
@@ -0,0 +1,142 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "encoding/binary"
+ "fmt"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors"
+)
+
+type ErrIkeyCorrupted struct {
+ Ikey []byte
+ Reason string
+}
+
+func (e *ErrIkeyCorrupted) Error() string {
+ return fmt.Sprintf("leveldb: iKey %q corrupted: %s", e.Ikey, e.Reason)
+}
+
+func newErrIkeyCorrupted(ikey []byte, reason string) error {
+ return errors.NewErrCorrupted(nil, &ErrIkeyCorrupted{append([]byte{}, ikey...), reason})
+}
+
+type kType int
+
+func (kt kType) String() string {
+ switch kt {
+ case ktDel:
+ return "d"
+ case ktVal:
+ return "v"
+ }
+ return "x"
+}
+
+// Value types encoded as the last component of internal keys.
+// Don't modify; this value are saved to disk.
+const (
+ ktDel kType = iota
+ ktVal
+)
+
+// ktSeek defines the kType that should be passed when constructing an
+// internal key for seeking to a particular sequence number (since we
+// sort sequence numbers in decreasing order and the value type is
+// embedded as the low 8 bits in the sequence number in internal keys,
+// we need to use the highest-numbered ValueType, not the lowest).
+const ktSeek = ktVal
+
+const (
+ // Maximum value possible for sequence number; the 8-bits are
+ // used by value type, so its can packed together in single
+ // 64-bit integer.
+ kMaxSeq uint64 = (uint64(1) << 56) - 1
+ // Maximum value possible for packed sequence number and type.
+ kMaxNum uint64 = (kMaxSeq << 8) | uint64(ktSeek)
+)
+
+// Maximum number encoded in bytes.
+var kMaxNumBytes = make([]byte, 8)
+
+func init() {
+ binary.LittleEndian.PutUint64(kMaxNumBytes, kMaxNum)
+}
+
+type iKey []byte
+
+func newIkey(ukey []byte, seq uint64, kt kType) iKey {
+ if seq > kMaxSeq {
+ panic("leveldb: invalid sequence number")
+ } else if kt > ktVal {
+ panic("leveldb: invalid type")
+ }
+
+ ik := make(iKey, len(ukey)+8)
+ copy(ik, ukey)
+ binary.LittleEndian.PutUint64(ik[len(ukey):], (seq<<8)|uint64(kt))
+ return ik
+}
+
+func parseIkey(ik []byte) (ukey []byte, seq uint64, kt kType, err error) {
+ if len(ik) < 8 {
+ return nil, 0, 0, newErrIkeyCorrupted(ik, "invalid length")
+ }
+ num := binary.LittleEndian.Uint64(ik[len(ik)-8:])
+ seq, kt = uint64(num>>8), kType(num&0xff)
+ if kt > ktVal {
+ return nil, 0, 0, newErrIkeyCorrupted(ik, "invalid type")
+ }
+ ukey = ik[:len(ik)-8]
+ return
+}
+
+func validIkey(ik []byte) bool {
+ _, _, _, err := parseIkey(ik)
+ return err == nil
+}
+
+func (ik iKey) assert() {
+ if ik == nil {
+ panic("leveldb: nil iKey")
+ }
+ if len(ik) < 8 {
+ panic(fmt.Sprintf("leveldb: iKey %q, len=%d: invalid length", []byte(ik), len(ik)))
+ }
+}
+
+func (ik iKey) ukey() []byte {
+ ik.assert()
+ return ik[:len(ik)-8]
+}
+
+func (ik iKey) num() uint64 {
+ ik.assert()
+ return binary.LittleEndian.Uint64(ik[len(ik)-8:])
+}
+
+func (ik iKey) parseNum() (seq uint64, kt kType) {
+ num := ik.num()
+ seq, kt = uint64(num>>8), kType(num&0xff)
+ if kt > ktVal {
+ panic(fmt.Sprintf("leveldb: iKey %q, len=%d: invalid type %#x", []byte(ik), len(ik), kt))
+ }
+ return
+}
+
+func (ik iKey) String() string {
+ if ik == nil {
+ return "<nil>"
+ }
+
+ if ukey, seq, kt, err := parseIkey(ik); err == nil {
+ return fmt.Sprintf("%s,%s%d", shorten(string(ukey)), kt, seq)
+ } else {
+ return "<invalid>"
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/key_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/key_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..eb9526f751f320238b90945a2dd4e8db359247cb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/key_test.go
@@ -0,0 +1,133 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "bytes"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer"
+)
+
+var defaultIComparer = &iComparer{comparer.DefaultComparer}
+
+func ikey(key string, seq uint64, kt kType) iKey {
+ return newIkey([]byte(key), uint64(seq), kt)
+}
+
+func shortSep(a, b []byte) []byte {
+ dst := make([]byte, len(a))
+ dst = defaultIComparer.Separator(dst[:0], a, b)
+ if dst == nil {
+ return a
+ }
+ return dst
+}
+
+func shortSuccessor(b []byte) []byte {
+ dst := make([]byte, len(b))
+ dst = defaultIComparer.Successor(dst[:0], b)
+ if dst == nil {
+ return b
+ }
+ return dst
+}
+
+func testSingleKey(t *testing.T, key string, seq uint64, kt kType) {
+ ik := ikey(key, seq, kt)
+
+ if !bytes.Equal(ik.ukey(), []byte(key)) {
+ t.Errorf("user key does not equal, got %v, want %v", string(ik.ukey()), key)
+ }
+
+ rseq, rt := ik.parseNum()
+ if rseq != seq {
+ t.Errorf("seq number does not equal, got %v, want %v", rseq, seq)
+ }
+ if rt != kt {
+ t.Errorf("type does not equal, got %v, want %v", rt, kt)
+ }
+
+ if rukey, rseq, rt, kerr := parseIkey(ik); kerr == nil {
+ if !bytes.Equal(rukey, []byte(key)) {
+ t.Errorf("user key does not equal, got %v, want %v", string(ik.ukey()), key)
+ }
+ if rseq != seq {
+ t.Errorf("seq number does not equal, got %v, want %v", rseq, seq)
+ }
+ if rt != kt {
+ t.Errorf("type does not equal, got %v, want %v", rt, kt)
+ }
+ } else {
+ t.Errorf("key error: %v", kerr)
+ }
+}
+
+func TestIkey_EncodeDecode(t *testing.T) {
+ keys := []string{"", "k", "hello", "longggggggggggggggggggggg"}
+ seqs := []uint64{
+ 1, 2, 3,
+ (1 << 8) - 1, 1 << 8, (1 << 8) + 1,
+ (1 << 16) - 1, 1 << 16, (1 << 16) + 1,
+ (1 << 32) - 1, 1 << 32, (1 << 32) + 1,
+ }
+ for _, key := range keys {
+ for _, seq := range seqs {
+ testSingleKey(t, key, seq, ktVal)
+ testSingleKey(t, "hello", 1, ktDel)
+ }
+ }
+}
+
+func assertBytes(t *testing.T, want, got []byte) {
+ if !bytes.Equal(got, want) {
+ t.Errorf("assert failed, got %v, want %v", got, want)
+ }
+}
+
+func TestIkeyShortSeparator(t *testing.T) {
+ // When user keys are same
+ assertBytes(t, ikey("foo", 100, ktVal),
+ shortSep(ikey("foo", 100, ktVal),
+ ikey("foo", 99, ktVal)))
+ assertBytes(t, ikey("foo", 100, ktVal),
+ shortSep(ikey("foo", 100, ktVal),
+ ikey("foo", 101, ktVal)))
+ assertBytes(t, ikey("foo", 100, ktVal),
+ shortSep(ikey("foo", 100, ktVal),
+ ikey("foo", 100, ktVal)))
+ assertBytes(t, ikey("foo", 100, ktVal),
+ shortSep(ikey("foo", 100, ktVal),
+ ikey("foo", 100, ktDel)))
+
+ // When user keys are misordered
+ assertBytes(t, ikey("foo", 100, ktVal),
+ shortSep(ikey("foo", 100, ktVal),
+ ikey("bar", 99, ktVal)))
+
+ // When user keys are different, but correctly ordered
+ assertBytes(t, ikey("g", uint64(kMaxSeq), ktSeek),
+ shortSep(ikey("foo", 100, ktVal),
+ ikey("hello", 200, ktVal)))
+
+ // When start user key is prefix of limit user key
+ assertBytes(t, ikey("foo", 100, ktVal),
+ shortSep(ikey("foo", 100, ktVal),
+ ikey("foobar", 200, ktVal)))
+
+ // When limit user key is prefix of start user key
+ assertBytes(t, ikey("foobar", 100, ktVal),
+ shortSep(ikey("foobar", 100, ktVal),
+ ikey("foo", 200, ktVal)))
+}
+
+func TestIkeyShortestSuccessor(t *testing.T) {
+ assertBytes(t, ikey("g", uint64(kMaxSeq), ktSeek),
+ shortSuccessor(ikey("foo", 100, ktVal)))
+ assertBytes(t, ikey("\xff\xff", 100, ktVal),
+ shortSuccessor(ikey("\xff\xff", 100, ktVal)))
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/leveldb_suite_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/leveldb_suite_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..33be15d6b59ec77c8b2ff71f8e9bf146c9b106fa
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/leveldb_suite_test.go
@@ -0,0 +1,11 @@
+package leveldb
+
+import (
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil"
+)
+
+func TestLevelDB(t *testing.T) {
+ testutil.RunSuite(t, "LevelDB Suite")
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb/bench_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb/bench_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..51ca66ba7d1b1125136ff074d13f2b314f0d78a1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb/bench_test.go
@@ -0,0 +1,75 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package memdb
+
+import (
+ "encoding/binary"
+ "math/rand"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer"
+)
+
+func BenchmarkPut(b *testing.B) {
+ buf := make([][4]byte, b.N)
+ for i := range buf {
+ binary.LittleEndian.PutUint32(buf[i][:], uint32(i))
+ }
+
+ b.ResetTimer()
+ p := New(comparer.DefaultComparer, 0)
+ for i := range buf {
+ p.Put(buf[i][:], nil)
+ }
+}
+
+func BenchmarkPutRandom(b *testing.B) {
+ buf := make([][4]byte, b.N)
+ for i := range buf {
+ binary.LittleEndian.PutUint32(buf[i][:], uint32(rand.Int()))
+ }
+
+ b.ResetTimer()
+ p := New(comparer.DefaultComparer, 0)
+ for i := range buf {
+ p.Put(buf[i][:], nil)
+ }
+}
+
+func BenchmarkGet(b *testing.B) {
+ buf := make([][4]byte, b.N)
+ for i := range buf {
+ binary.LittleEndian.PutUint32(buf[i][:], uint32(i))
+ }
+
+ p := New(comparer.DefaultComparer, 0)
+ for i := range buf {
+ p.Put(buf[i][:], nil)
+ }
+
+ b.ResetTimer()
+ for i := range buf {
+ p.Get(buf[i][:])
+ }
+}
+
+func BenchmarkGetRandom(b *testing.B) {
+ buf := make([][4]byte, b.N)
+ for i := range buf {
+ binary.LittleEndian.PutUint32(buf[i][:], uint32(i))
+ }
+
+ p := New(comparer.DefaultComparer, 0)
+ for i := range buf {
+ p.Put(buf[i][:], nil)
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ p.Get(buf[rand.Int()%b.N][:])
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb/memdb.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb/memdb.go
new file mode 100644
index 0000000000000000000000000000000000000000..c90c3561d25aa7dc789351348fbf6041cfaf75d8
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb/memdb.go
@@ -0,0 +1,471 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package memdb provides in-memory key/value database implementation.
+package memdb
+
+import (
+ "math/rand"
+ "sync"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+var (
+ ErrNotFound = errors.ErrNotFound
+ ErrIterReleased = errors.New("leveldb/memdb: iterator released")
+)
+
+const tMaxHeight = 12
+
+type dbIter struct {
+ util.BasicReleaser
+ p *DB
+ slice *util.Range
+ node int
+ forward bool
+ key, value []byte
+ err error
+}
+
+func (i *dbIter) fill(checkStart, checkLimit bool) bool {
+ if i.node != 0 {
+ n := i.p.nodeData[i.node]
+ m := n + i.p.nodeData[i.node+nKey]
+ i.key = i.p.kvData[n:m]
+ if i.slice != nil {
+ switch {
+ case checkLimit && i.slice.Limit != nil && i.p.cmp.Compare(i.key, i.slice.Limit) >= 0:
+ fallthrough
+ case checkStart && i.slice.Start != nil && i.p.cmp.Compare(i.key, i.slice.Start) < 0:
+ i.node = 0
+ goto bail
+ }
+ }
+ i.value = i.p.kvData[m : m+i.p.nodeData[i.node+nVal]]
+ return true
+ }
+bail:
+ i.key = nil
+ i.value = nil
+ return false
+}
+
+func (i *dbIter) Valid() bool {
+ return i.node != 0
+}
+
+func (i *dbIter) First() bool {
+ if i.Released() {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ i.forward = true
+ i.p.mu.RLock()
+ defer i.p.mu.RUnlock()
+ if i.slice != nil && i.slice.Start != nil {
+ i.node, _ = i.p.findGE(i.slice.Start, false)
+ } else {
+ i.node = i.p.nodeData[nNext]
+ }
+ return i.fill(false, true)
+}
+
+func (i *dbIter) Last() bool {
+ if i.Released() {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ i.forward = false
+ i.p.mu.RLock()
+ defer i.p.mu.RUnlock()
+ if i.slice != nil && i.slice.Limit != nil {
+ i.node = i.p.findLT(i.slice.Limit)
+ } else {
+ i.node = i.p.findLast()
+ }
+ return i.fill(true, false)
+}
+
+func (i *dbIter) Seek(key []byte) bool {
+ if i.Released() {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ i.forward = true
+ i.p.mu.RLock()
+ defer i.p.mu.RUnlock()
+ if i.slice != nil && i.slice.Start != nil && i.p.cmp.Compare(key, i.slice.Start) < 0 {
+ key = i.slice.Start
+ }
+ i.node, _ = i.p.findGE(key, false)
+ return i.fill(false, true)
+}
+
+func (i *dbIter) Next() bool {
+ if i.Released() {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ if i.node == 0 {
+ if !i.forward {
+ return i.First()
+ }
+ return false
+ }
+ i.forward = true
+ i.p.mu.RLock()
+ defer i.p.mu.RUnlock()
+ i.node = i.p.nodeData[i.node+nNext]
+ return i.fill(false, true)
+}
+
+func (i *dbIter) Prev() bool {
+ if i.Released() {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ if i.node == 0 {
+ if i.forward {
+ return i.Last()
+ }
+ return false
+ }
+ i.forward = false
+ i.p.mu.RLock()
+ defer i.p.mu.RUnlock()
+ i.node = i.p.findLT(i.key)
+ return i.fill(true, false)
+}
+
+func (i *dbIter) Key() []byte {
+ return i.key
+}
+
+func (i *dbIter) Value() []byte {
+ return i.value
+}
+
+func (i *dbIter) Error() error { return i.err }
+
+func (i *dbIter) Release() {
+ if !i.Released() {
+ i.p = nil
+ i.node = 0
+ i.key = nil
+ i.value = nil
+ i.BasicReleaser.Release()
+ }
+}
+
+const (
+ nKV = iota
+ nKey
+ nVal
+ nHeight
+ nNext
+)
+
+// DB is an in-memory key/value database.
+type DB struct {
+ cmp comparer.BasicComparer
+ rnd *rand.Rand
+
+ mu sync.RWMutex
+ kvData []byte
+ // Node data:
+ // [0] : KV offset
+ // [1] : Key length
+ // [2] : Value length
+ // [3] : Height
+ // [3..height] : Next nodes
+ nodeData []int
+ prevNode [tMaxHeight]int
+ maxHeight int
+ n int
+ kvSize int
+}
+
+func (p *DB) randHeight() (h int) {
+ const branching = 4
+ h = 1
+ for h < tMaxHeight && p.rnd.Int()%branching == 0 {
+ h++
+ }
+ return
+}
+
+// Must hold RW-lock if prev == true, as it use shared prevNode slice.
+func (p *DB) findGE(key []byte, prev bool) (int, bool) {
+ node := 0
+ h := p.maxHeight - 1
+ for {
+ next := p.nodeData[node+nNext+h]
+ cmp := 1
+ if next != 0 {
+ o := p.nodeData[next]
+ cmp = p.cmp.Compare(p.kvData[o:o+p.nodeData[next+nKey]], key)
+ }
+ if cmp < 0 {
+ // Keep searching in this list
+ node = next
+ } else {
+ if prev {
+ p.prevNode[h] = node
+ } else if cmp == 0 {
+ return next, true
+ }
+ if h == 0 {
+ return next, cmp == 0
+ }
+ h--
+ }
+ }
+}
+
+func (p *DB) findLT(key []byte) int {
+ node := 0
+ h := p.maxHeight - 1
+ for {
+ next := p.nodeData[node+nNext+h]
+ o := p.nodeData[next]
+ if next == 0 || p.cmp.Compare(p.kvData[o:o+p.nodeData[next+nKey]], key) >= 0 {
+ if h == 0 {
+ break
+ }
+ h--
+ } else {
+ node = next
+ }
+ }
+ return node
+}
+
+func (p *DB) findLast() int {
+ node := 0
+ h := p.maxHeight - 1
+ for {
+ next := p.nodeData[node+nNext+h]
+ if next == 0 {
+ if h == 0 {
+ break
+ }
+ h--
+ } else {
+ node = next
+ }
+ }
+ return node
+}
+
+// Put sets the value for the given key. It overwrites any previous value
+// for that key; a DB is not a multi-map.
+//
+// It is safe to modify the contents of the arguments after Put returns.
+func (p *DB) Put(key []byte, value []byte) error {
+ p.mu.Lock()
+ defer p.mu.Unlock()
+
+ if node, exact := p.findGE(key, true); exact {
+ kvOffset := len(p.kvData)
+ p.kvData = append(p.kvData, key...)
+ p.kvData = append(p.kvData, value...)
+ p.nodeData[node] = kvOffset
+ m := p.nodeData[node+nVal]
+ p.nodeData[node+nVal] = len(value)
+ p.kvSize += len(value) - m
+ return nil
+ }
+
+ h := p.randHeight()
+ if h > p.maxHeight {
+ for i := p.maxHeight; i < h; i++ {
+ p.prevNode[i] = 0
+ }
+ p.maxHeight = h
+ }
+
+ kvOffset := len(p.kvData)
+ p.kvData = append(p.kvData, key...)
+ p.kvData = append(p.kvData, value...)
+ // Node
+ node := len(p.nodeData)
+ p.nodeData = append(p.nodeData, kvOffset, len(key), len(value), h)
+ for i, n := range p.prevNode[:h] {
+ m := n + nNext + i
+ p.nodeData = append(p.nodeData, p.nodeData[m])
+ p.nodeData[m] = node
+ }
+
+ p.kvSize += len(key) + len(value)
+ p.n++
+ return nil
+}
+
+// Delete deletes the value for the given key. It returns ErrNotFound if
+// the DB does not contain the key.
+//
+// It is safe to modify the contents of the arguments after Delete returns.
+func (p *DB) Delete(key []byte) error {
+ p.mu.Lock()
+ defer p.mu.Unlock()
+
+ node, exact := p.findGE(key, true)
+ if !exact {
+ return ErrNotFound
+ }
+
+ h := p.nodeData[node+nHeight]
+ for i, n := range p.prevNode[:h] {
+ m := n + 4 + i
+ p.nodeData[m] = p.nodeData[p.nodeData[m]+nNext+i]
+ }
+
+ p.kvSize -= p.nodeData[node+nKey] + p.nodeData[node+nVal]
+ p.n--
+ return nil
+}
+
+// Contains returns true if the given key are in the DB.
+//
+// It is safe to modify the contents of the arguments after Contains returns.
+func (p *DB) Contains(key []byte) bool {
+ p.mu.RLock()
+ _, exact := p.findGE(key, false)
+ p.mu.RUnlock()
+ return exact
+}
+
+// Get gets the value for the given key. It returns error.ErrNotFound if the
+// DB does not contain the key.
+//
+// The caller should not modify the contents of the returned slice, but
+// it is safe to modify the contents of the argument after Get returns.
+func (p *DB) Get(key []byte) (value []byte, err error) {
+ p.mu.RLock()
+ if node, exact := p.findGE(key, false); exact {
+ o := p.nodeData[node] + p.nodeData[node+nKey]
+ value = p.kvData[o : o+p.nodeData[node+nVal]]
+ } else {
+ err = ErrNotFound
+ }
+ p.mu.RUnlock()
+ return
+}
+
+// Find finds key/value pair whose key is greater than or equal to the
+// given key. It returns ErrNotFound if the table doesn't contain
+// such pair.
+//
+// The caller should not modify the contents of the returned slice, but
+// it is safe to modify the contents of the argument after Find returns.
+func (p *DB) Find(key []byte) (rkey, value []byte, err error) {
+ p.mu.RLock()
+ if node, _ := p.findGE(key, false); node != 0 {
+ n := p.nodeData[node]
+ m := n + p.nodeData[node+nKey]
+ rkey = p.kvData[n:m]
+ value = p.kvData[m : m+p.nodeData[node+nVal]]
+ } else {
+ err = ErrNotFound
+ }
+ p.mu.RUnlock()
+ return
+}
+
+// NewIterator returns an iterator of the DB.
+// The returned iterator is not goroutine-safe, but it is safe to use
+// multiple iterators concurrently, with each in a dedicated goroutine.
+// It is also safe to use an iterator concurrently with modifying its
+// underlying DB. However, the resultant key/value pairs are not guaranteed
+// to be a consistent snapshot of the DB at a particular point in time.
+//
+// Slice allows slicing the iterator to only contains keys in the given
+// range. A nil Range.Start is treated as a key before all keys in the
+// DB. And a nil Range.Limit is treated as a key after all keys in
+// the DB.
+//
+// The iterator must be released after use, by calling Release method.
+//
+// Also read Iterator documentation of the leveldb/iterator package.
+func (p *DB) NewIterator(slice *util.Range) iterator.Iterator {
+ return &dbIter{p: p, slice: slice}
+}
+
+// Capacity returns keys/values buffer capacity.
+func (p *DB) Capacity() int {
+ p.mu.RLock()
+ defer p.mu.RUnlock()
+ return cap(p.kvData)
+}
+
+// Size returns sum of keys and values length. Note that deleted
+// key/value will not be accouted for, but it will still consume
+// the buffer, since the buffer is append only.
+func (p *DB) Size() int {
+ p.mu.RLock()
+ defer p.mu.RUnlock()
+ return p.kvSize
+}
+
+// Free returns keys/values free buffer before need to grow.
+func (p *DB) Free() int {
+ p.mu.RLock()
+ defer p.mu.RUnlock()
+ return cap(p.kvData) - len(p.kvData)
+}
+
+// Len returns the number of entries in the DB.
+func (p *DB) Len() int {
+ p.mu.RLock()
+ defer p.mu.RUnlock()
+ return p.n
+}
+
+// Reset resets the DB to initial empty state. Allows reuse the buffer.
+func (p *DB) Reset() {
+ p.mu.Lock()
+ p.rnd = rand.New(rand.NewSource(0xdeadbeef))
+ p.maxHeight = 1
+ p.n = 0
+ p.kvSize = 0
+ p.kvData = p.kvData[:0]
+ p.nodeData = p.nodeData[:nNext+tMaxHeight]
+ p.nodeData[nKV] = 0
+ p.nodeData[nKey] = 0
+ p.nodeData[nVal] = 0
+ p.nodeData[nHeight] = tMaxHeight
+ for n := 0; n < tMaxHeight; n++ {
+ p.nodeData[nNext+n] = 0
+ p.prevNode[n] = 0
+ }
+ p.mu.Unlock()
+}
+
+// New creates a new initalized in-memory key/value DB. The capacity
+// is the initial key/value buffer capacity. The capacity is advisory,
+// not enforced.
+//
+// The returned DB instance is goroutine-safe.
+func New(cmp comparer.BasicComparer, capacity int) *DB {
+ p := &DB{
+ cmp: cmp,
+ rnd: rand.New(rand.NewSource(0xdeadbeef)),
+ maxHeight: 1,
+ kvData: make([]byte, 0, capacity),
+ nodeData: make([]int, 4+tMaxHeight),
+ }
+ p.nodeData[nHeight] = tMaxHeight
+ return p
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb/memdb_suite_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb/memdb_suite_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..7be1214f39d1186edb10e096581599af7b08f5b7
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb/memdb_suite_test.go
@@ -0,0 +1,11 @@
+package memdb
+
+import (
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil"
+)
+
+func TestMemDB(t *testing.T) {
+ testutil.RunSuite(t, "MemDB Suite")
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb/memdb_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb/memdb_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..131333c16a033197f9ba0da6b7fdcd6a6bbbf39f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb/memdb_test.go
@@ -0,0 +1,135 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package memdb
+
+import (
+ . "github.com/onsi/ginkgo"
+ . "github.com/onsi/gomega"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+func (p *DB) TestFindLT(key []byte) (rkey, value []byte, err error) {
+ p.mu.RLock()
+ if node := p.findLT(key); node != 0 {
+ n := p.nodeData[node]
+ m := n + p.nodeData[node+nKey]
+ rkey = p.kvData[n:m]
+ value = p.kvData[m : m+p.nodeData[node+nVal]]
+ } else {
+ err = ErrNotFound
+ }
+ p.mu.RUnlock()
+ return
+}
+
+func (p *DB) TestFindLast() (rkey, value []byte, err error) {
+ p.mu.RLock()
+ if node := p.findLast(); node != 0 {
+ n := p.nodeData[node]
+ m := n + p.nodeData[node+nKey]
+ rkey = p.kvData[n:m]
+ value = p.kvData[m : m+p.nodeData[node+nVal]]
+ } else {
+ err = ErrNotFound
+ }
+ p.mu.RUnlock()
+ return
+}
+
+func (p *DB) TestPut(key []byte, value []byte) error {
+ p.Put(key, value)
+ return nil
+}
+
+func (p *DB) TestDelete(key []byte) error {
+ p.Delete(key)
+ return nil
+}
+
+func (p *DB) TestFind(key []byte) (rkey, rvalue []byte, err error) {
+ return p.Find(key)
+}
+
+func (p *DB) TestGet(key []byte) (value []byte, err error) {
+ return p.Get(key)
+}
+
+func (p *DB) TestNewIterator(slice *util.Range) iterator.Iterator {
+ return p.NewIterator(slice)
+}
+
+var _ = testutil.Defer(func() {
+ Describe("Memdb", func() {
+ Describe("write test", func() {
+ It("should do write correctly", func() {
+ db := New(comparer.DefaultComparer, 0)
+ t := testutil.DBTesting{
+ DB: db,
+ Deleted: testutil.KeyValue_Generate(nil, 1000, 1, 30, 5, 5).Clone(),
+ PostFn: func(t *testutil.DBTesting) {
+ Expect(db.Len()).Should(Equal(t.Present.Len()))
+ Expect(db.Size()).Should(Equal(t.Present.Size()))
+ switch t.Act {
+ case testutil.DBPut, testutil.DBOverwrite:
+ Expect(db.Contains(t.ActKey)).Should(BeTrue())
+ default:
+ Expect(db.Contains(t.ActKey)).Should(BeFalse())
+ }
+ },
+ }
+ testutil.DoDBTesting(&t)
+ })
+ })
+
+ Describe("read test", func() {
+ testutil.AllKeyValueTesting(nil, func(kv testutil.KeyValue) testutil.DB {
+ // Building the DB.
+ db := New(comparer.DefaultComparer, 0)
+ kv.IterateShuffled(nil, func(i int, key, value []byte) {
+ db.Put(key, value)
+ })
+
+ if kv.Len() > 1 {
+ It("Should find correct keys with findLT", func() {
+ testutil.ShuffledIndex(nil, kv.Len()-1, 1, func(i int) {
+ key_, key, _ := kv.IndexInexact(i + 1)
+ expectedKey, expectedValue := kv.Index(i)
+
+ // Using key that exist.
+ rkey, rvalue, err := db.TestFindLT(key)
+ Expect(err).ShouldNot(HaveOccurred(), "Error for key %q -> %q", key, expectedKey)
+ Expect(rkey).Should(Equal(expectedKey), "Key")
+ Expect(rvalue).Should(Equal(expectedValue), "Value for key %q -> %q", key, expectedKey)
+
+ // Using key that doesn't exist.
+ rkey, rvalue, err = db.TestFindLT(key_)
+ Expect(err).ShouldNot(HaveOccurred(), "Error for key %q (%q) -> %q", key_, key, expectedKey)
+ Expect(rkey).Should(Equal(expectedKey))
+ Expect(rvalue).Should(Equal(expectedValue), "Value for key %q (%q) -> %q", key_, key, expectedKey)
+ })
+ })
+ }
+
+ if kv.Len() > 0 {
+ It("Should find last key with findLast", func() {
+ key, value := kv.Index(kv.Len() - 1)
+ rkey, rvalue, err := db.TestFindLast()
+ Expect(err).ShouldNot(HaveOccurred())
+ Expect(rkey).Should(Equal(key))
+ Expect(rvalue).Should(Equal(value))
+ })
+ }
+
+ return db
+ }, nil, nil)
+ })
+ })
+})
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt/options.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt/options.go
new file mode 100644
index 0000000000000000000000000000000000000000..09cf9b6cffedfe9ef4f2efaaddcdce462c5fd37f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt/options.go
@@ -0,0 +1,670 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package opt provides sets of options used by LevelDB.
+package opt
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter"
+ "math"
+)
+
+const (
+ KiB = 1024
+ MiB = KiB * 1024
+ GiB = MiB * 1024
+)
+
+var (
+ DefaultBlockCacher = LRUCacher
+ DefaultBlockCacheCapacity = 8 * MiB
+ DefaultBlockRestartInterval = 16
+ DefaultBlockSize = 4 * KiB
+ DefaultCompactionExpandLimitFactor = 25
+ DefaultCompactionGPOverlapsFactor = 10
+ DefaultCompactionL0Trigger = 4
+ DefaultCompactionSourceLimitFactor = 1
+ DefaultCompactionTableSize = 2 * MiB
+ DefaultCompactionTableSizeMultiplier = 1.0
+ DefaultCompactionTotalSize = 10 * MiB
+ DefaultCompactionTotalSizeMultiplier = 10.0
+ DefaultCompressionType = SnappyCompression
+ DefaultIteratorSamplingRate = 1 * MiB
+ DefaultMaxMemCompationLevel = 2
+ DefaultNumLevel = 7
+ DefaultOpenFilesCacher = LRUCacher
+ DefaultOpenFilesCacheCapacity = 500
+ DefaultWriteBuffer = 4 * MiB
+ DefaultWriteL0PauseTrigger = 12
+ DefaultWriteL0SlowdownTrigger = 8
+)
+
+// Cacher is a caching algorithm.
+type Cacher interface {
+ New(capacity int) cache.Cacher
+}
+
+type CacherFunc struct {
+ NewFunc func(capacity int) cache.Cacher
+}
+
+func (f *CacherFunc) New(capacity int) cache.Cacher {
+ if f.NewFunc != nil {
+ return f.NewFunc(capacity)
+ }
+ return nil
+}
+
+func noCacher(int) cache.Cacher { return nil }
+
+var (
+ // LRUCacher is the LRU-cache algorithm.
+ LRUCacher = &CacherFunc{cache.NewLRU}
+
+ // NoCacher is the value to disable caching algorithm.
+ NoCacher = &CacherFunc{}
+)
+
+// Compression is the 'sorted table' block compression algorithm to use.
+type Compression uint
+
+func (c Compression) String() string {
+ switch c {
+ case DefaultCompression:
+ return "default"
+ case NoCompression:
+ return "none"
+ case SnappyCompression:
+ return "snappy"
+ }
+ return "invalid"
+}
+
+const (
+ DefaultCompression Compression = iota
+ NoCompression
+ SnappyCompression
+ nCompression
+)
+
+// Strict is the DB 'strict level'.
+type Strict uint
+
+const (
+ // If present then a corrupted or invalid chunk or block in manifest
+ // journal will cause an error instead of being dropped.
+ // This will prevent database with corrupted manifest to be opened.
+ StrictManifest Strict = 1 << iota
+
+ // If present then journal chunk checksum will be verified.
+ StrictJournalChecksum
+
+ // If present then a corrupted or invalid chunk or block in journal
+ // will cause an error instead of being dropped.
+ // This will prevent database with corrupted journal to be opened.
+ StrictJournal
+
+ // If present then 'sorted table' block checksum will be verified.
+ // This has effect on both 'read operation' and compaction.
+ StrictBlockChecksum
+
+ // If present then a corrupted 'sorted table' will fails compaction.
+ // The database will enter read-only mode.
+ StrictCompaction
+
+ // If present then a corrupted 'sorted table' will halts 'read operation'.
+ StrictReader
+
+ // If present then leveldb.Recover will drop corrupted 'sorted table'.
+ StrictRecovery
+
+ // This only applicable for ReadOptions, if present then this ReadOptions
+ // 'strict level' will override global ones.
+ StrictOverride
+
+ // StrictAll enables all strict flags.
+ StrictAll = StrictManifest | StrictJournalChecksum | StrictJournal | StrictBlockChecksum | StrictCompaction | StrictReader | StrictRecovery
+
+ // DefaultStrict is the default strict flags. Specify any strict flags
+ // will override default strict flags as whole (i.e. not OR'ed).
+ DefaultStrict = StrictJournalChecksum | StrictBlockChecksum | StrictCompaction | StrictReader
+
+ // NoStrict disables all strict flags. Override default strict flags.
+ NoStrict = ^StrictAll
+)
+
+// Options holds the optional parameters for the DB at large.
+type Options struct {
+ // AltFilters defines one or more 'alternative filters'.
+ // 'alternative filters' will be used during reads if a filter block
+ // does not match with the 'effective filter'.
+ //
+ // The default value is nil
+ AltFilters []filter.Filter
+
+ // BlockCacher provides cache algorithm for LevelDB 'sorted table' block caching.
+ // Specify NoCacher to disable caching algorithm.
+ //
+ // The default value is LRUCacher.
+ BlockCacher Cacher
+
+ // BlockCacheCapacity defines the capacity of the 'sorted table' block caching.
+ // Use -1 for zero, this has same effect as specifying NoCacher to BlockCacher.
+ //
+ // The default value is 8MiB.
+ BlockCacheCapacity int
+
+ // BlockRestartInterval is the number of keys between restart points for
+ // delta encoding of keys.
+ //
+ // The default value is 16.
+ BlockRestartInterval int
+
+ // BlockSize is the minimum uncompressed size in bytes of each 'sorted table'
+ // block.
+ //
+ // The default value is 4KiB.
+ BlockSize int
+
+ // CompactionExpandLimitFactor limits compaction size after expanded.
+ // This will be multiplied by table size limit at compaction target level.
+ //
+ // The default value is 25.
+ CompactionExpandLimitFactor int
+
+ // CompactionGPOverlapsFactor limits overlaps in grandparent (Level + 2) that a
+ // single 'sorted table' generates.
+ // This will be multiplied by table size limit at grandparent level.
+ //
+ // The default value is 10.
+ CompactionGPOverlapsFactor int
+
+ // CompactionL0Trigger defines number of 'sorted table' at level-0 that will
+ // trigger compaction.
+ //
+ // The default value is 4.
+ CompactionL0Trigger int
+
+ // CompactionSourceLimitFactor limits compaction source size. This doesn't apply to
+ // level-0.
+ // This will be multiplied by table size limit at compaction target level.
+ //
+ // The default value is 1.
+ CompactionSourceLimitFactor int
+
+ // CompactionTableSize limits size of 'sorted table' that compaction generates.
+ // The limits for each level will be calculated as:
+ // CompactionTableSize * (CompactionTableSizeMultiplier ^ Level)
+ // The multiplier for each level can also fine-tuned using CompactionTableSizeMultiplierPerLevel.
+ //
+ // The default value is 2MiB.
+ CompactionTableSize int
+
+ // CompactionTableSizeMultiplier defines multiplier for CompactionTableSize.
+ //
+ // The default value is 1.
+ CompactionTableSizeMultiplier float64
+
+ // CompactionTableSizeMultiplierPerLevel defines per-level multiplier for
+ // CompactionTableSize.
+ // Use zero to skip a level.
+ //
+ // The default value is nil.
+ CompactionTableSizeMultiplierPerLevel []float64
+
+ // CompactionTotalSize limits total size of 'sorted table' for each level.
+ // The limits for each level will be calculated as:
+ // CompactionTotalSize * (CompactionTotalSizeMultiplier ^ Level)
+ // The multiplier for each level can also fine-tuned using
+ // CompactionTotalSizeMultiplierPerLevel.
+ //
+ // The default value is 10MiB.
+ CompactionTotalSize int
+
+ // CompactionTotalSizeMultiplier defines multiplier for CompactionTotalSize.
+ //
+ // The default value is 10.
+ CompactionTotalSizeMultiplier float64
+
+ // CompactionTotalSizeMultiplierPerLevel defines per-level multiplier for
+ // CompactionTotalSize.
+ // Use zero to skip a level.
+ //
+ // The default value is nil.
+ CompactionTotalSizeMultiplierPerLevel []float64
+
+ // Comparer defines a total ordering over the space of []byte keys: a 'less
+ // than' relationship. The same comparison algorithm must be used for reads
+ // and writes over the lifetime of the DB.
+ //
+ // The default value uses the same ordering as bytes.Compare.
+ Comparer comparer.Comparer
+
+ // Compression defines the 'sorted table' block compression to use.
+ //
+ // The default value (DefaultCompression) uses snappy compression.
+ Compression Compression
+
+ // DisableBufferPool allows disable use of util.BufferPool functionality.
+ //
+ // The default value is false.
+ DisableBufferPool bool
+
+ // DisableBlockCache allows disable use of cache.Cache functionality on
+ // 'sorted table' block.
+ //
+ // The default value is false.
+ DisableBlockCache bool
+
+ // DisableCompactionBackoff allows disable compaction retry backoff.
+ //
+ // The default value is false.
+ DisableCompactionBackoff bool
+
+ // ErrorIfExist defines whether an error should returned if the DB already
+ // exist.
+ //
+ // The default value is false.
+ ErrorIfExist bool
+
+ // ErrorIfMissing defines whether an error should returned if the DB is
+ // missing. If false then the database will be created if missing, otherwise
+ // an error will be returned.
+ //
+ // The default value is false.
+ ErrorIfMissing bool
+
+ // Filter defines an 'effective filter' to use. An 'effective filter'
+ // if defined will be used to generate per-table filter block.
+ // The filter name will be stored on disk.
+ // During reads LevelDB will try to find matching filter from
+ // 'effective filter' and 'alternative filters'.
+ //
+ // Filter can be changed after a DB has been created. It is recommended
+ // to put old filter to the 'alternative filters' to mitigate lack of
+ // filter during transition period.
+ //
+ // A filter is used to reduce disk reads when looking for a specific key.
+ //
+ // The default value is nil.
+ Filter filter.Filter
+
+ // IteratorSamplingRate defines approximate gap (in bytes) between read
+ // sampling of an iterator. The samples will be used to determine when
+ // compaction should be triggered.
+ //
+ // The default is 1MiB.
+ IteratorSamplingRate int
+
+ // MaxMemCompationLevel defines maximum level a newly compacted 'memdb'
+ // will be pushed into if doesn't creates overlap. This should less than
+ // NumLevel. Use -1 for level-0.
+ //
+ // The default is 2.
+ MaxMemCompationLevel int
+
+ // NumLevel defines number of database level. The level shouldn't changed
+ // between opens, or the database will panic.
+ //
+ // The default is 7.
+ NumLevel int
+
+ // OpenFilesCacher provides cache algorithm for open files caching.
+ // Specify NoCacher to disable caching algorithm.
+ //
+ // The default value is LRUCacher.
+ OpenFilesCacher Cacher
+
+ // OpenFilesCacheCapacity defines the capacity of the open files caching.
+ // Use -1 for zero, this has same effect as specifying NoCacher to OpenFilesCacher.
+ //
+ // The default value is 500.
+ OpenFilesCacheCapacity int
+
+ // If true then opens DB in read-only mode.
+ //
+ // The default value is false.
+ ReadOnly bool
+
+ // Strict defines the DB strict level.
+ Strict Strict
+
+ // WriteBuffer defines maximum size of a 'memdb' before flushed to
+ // 'sorted table'. 'memdb' is an in-memory DB backed by an on-disk
+ // unsorted journal.
+ //
+ // LevelDB may held up to two 'memdb' at the same time.
+ //
+ // The default value is 4MiB.
+ WriteBuffer int
+
+ // WriteL0StopTrigger defines number of 'sorted table' at level-0 that will
+ // pause write.
+ //
+ // The default value is 12.
+ WriteL0PauseTrigger int
+
+ // WriteL0SlowdownTrigger defines number of 'sorted table' at level-0 that
+ // will trigger write slowdown.
+ //
+ // The default value is 8.
+ WriteL0SlowdownTrigger int
+}
+
+func (o *Options) GetAltFilters() []filter.Filter {
+ if o == nil {
+ return nil
+ }
+ return o.AltFilters
+}
+
+func (o *Options) GetBlockCacher() Cacher {
+ if o == nil || o.BlockCacher == nil {
+ return DefaultBlockCacher
+ } else if o.BlockCacher == NoCacher {
+ return nil
+ }
+ return o.BlockCacher
+}
+
+func (o *Options) GetBlockCacheCapacity() int {
+ if o == nil || o.BlockCacheCapacity == 0 {
+ return DefaultBlockCacheCapacity
+ } else if o.BlockCacheCapacity < 0 {
+ return 0
+ }
+ return o.BlockCacheCapacity
+}
+
+func (o *Options) GetBlockRestartInterval() int {
+ if o == nil || o.BlockRestartInterval <= 0 {
+ return DefaultBlockRestartInterval
+ }
+ return o.BlockRestartInterval
+}
+
+func (o *Options) GetBlockSize() int {
+ if o == nil || o.BlockSize <= 0 {
+ return DefaultBlockSize
+ }
+ return o.BlockSize
+}
+
+func (o *Options) GetCompactionExpandLimit(level int) int {
+ factor := DefaultCompactionExpandLimitFactor
+ if o != nil && o.CompactionExpandLimitFactor > 0 {
+ factor = o.CompactionExpandLimitFactor
+ }
+ return o.GetCompactionTableSize(level+1) * factor
+}
+
+func (o *Options) GetCompactionGPOverlaps(level int) int {
+ factor := DefaultCompactionGPOverlapsFactor
+ if o != nil && o.CompactionGPOverlapsFactor > 0 {
+ factor = o.CompactionGPOverlapsFactor
+ }
+ return o.GetCompactionTableSize(level+2) * factor
+}
+
+func (o *Options) GetCompactionL0Trigger() int {
+ if o == nil || o.CompactionL0Trigger == 0 {
+ return DefaultCompactionL0Trigger
+ }
+ return o.CompactionL0Trigger
+}
+
+func (o *Options) GetCompactionSourceLimit(level int) int {
+ factor := DefaultCompactionSourceLimitFactor
+ if o != nil && o.CompactionSourceLimitFactor > 0 {
+ factor = o.CompactionSourceLimitFactor
+ }
+ return o.GetCompactionTableSize(level+1) * factor
+}
+
+func (o *Options) GetCompactionTableSize(level int) int {
+ var (
+ base = DefaultCompactionTableSize
+ mult float64
+ )
+ if o != nil {
+ if o.CompactionTableSize > 0 {
+ base = o.CompactionTableSize
+ }
+ if len(o.CompactionTableSizeMultiplierPerLevel) > level && o.CompactionTableSizeMultiplierPerLevel[level] > 0 {
+ mult = o.CompactionTableSizeMultiplierPerLevel[level]
+ } else if o.CompactionTableSizeMultiplier > 0 {
+ mult = math.Pow(o.CompactionTableSizeMultiplier, float64(level))
+ }
+ }
+ if mult == 0 {
+ mult = math.Pow(DefaultCompactionTableSizeMultiplier, float64(level))
+ }
+ return int(float64(base) * mult)
+}
+
+func (o *Options) GetCompactionTotalSize(level int) int64 {
+ var (
+ base = DefaultCompactionTotalSize
+ mult float64
+ )
+ if o != nil {
+ if o.CompactionTotalSize > 0 {
+ base = o.CompactionTotalSize
+ }
+ if len(o.CompactionTotalSizeMultiplierPerLevel) > level && o.CompactionTotalSizeMultiplierPerLevel[level] > 0 {
+ mult = o.CompactionTotalSizeMultiplierPerLevel[level]
+ } else if o.CompactionTotalSizeMultiplier > 0 {
+ mult = math.Pow(o.CompactionTotalSizeMultiplier, float64(level))
+ }
+ }
+ if mult == 0 {
+ mult = math.Pow(DefaultCompactionTotalSizeMultiplier, float64(level))
+ }
+ return int64(float64(base) * mult)
+}
+
+func (o *Options) GetComparer() comparer.Comparer {
+ if o == nil || o.Comparer == nil {
+ return comparer.DefaultComparer
+ }
+ return o.Comparer
+}
+
+func (o *Options) GetCompression() Compression {
+ if o == nil || o.Compression <= DefaultCompression || o.Compression >= nCompression {
+ return DefaultCompressionType
+ }
+ return o.Compression
+}
+
+func (o *Options) GetDisableBufferPool() bool {
+ if o == nil {
+ return false
+ }
+ return o.DisableBufferPool
+}
+
+func (o *Options) GetDisableBlockCache() bool {
+ if o == nil {
+ return false
+ }
+ return o.DisableBlockCache
+}
+
+func (o *Options) GetDisableCompactionBackoff() bool {
+ if o == nil {
+ return false
+ }
+ return o.DisableCompactionBackoff
+}
+
+func (o *Options) GetErrorIfExist() bool {
+ if o == nil {
+ return false
+ }
+ return o.ErrorIfExist
+}
+
+func (o *Options) GetErrorIfMissing() bool {
+ if o == nil {
+ return false
+ }
+ return o.ErrorIfMissing
+}
+
+func (o *Options) GetFilter() filter.Filter {
+ if o == nil {
+ return nil
+ }
+ return o.Filter
+}
+
+func (o *Options) GetIteratorSamplingRate() int {
+ if o == nil || o.IteratorSamplingRate <= 0 {
+ return DefaultIteratorSamplingRate
+ }
+ return o.IteratorSamplingRate
+}
+
+func (o *Options) GetMaxMemCompationLevel() int {
+ level := DefaultMaxMemCompationLevel
+ if o != nil {
+ if o.MaxMemCompationLevel > 0 {
+ level = o.MaxMemCompationLevel
+ } else if o.MaxMemCompationLevel < 0 {
+ level = 0
+ }
+ }
+ if level >= o.GetNumLevel() {
+ return o.GetNumLevel() - 1
+ }
+ return level
+}
+
+func (o *Options) GetNumLevel() int {
+ if o == nil || o.NumLevel <= 0 {
+ return DefaultNumLevel
+ }
+ return o.NumLevel
+}
+
+func (o *Options) GetOpenFilesCacher() Cacher {
+ if o == nil || o.OpenFilesCacher == nil {
+ return DefaultOpenFilesCacher
+ }
+ if o.OpenFilesCacher == NoCacher {
+ return nil
+ }
+ return o.OpenFilesCacher
+}
+
+func (o *Options) GetOpenFilesCacheCapacity() int {
+ if o == nil || o.OpenFilesCacheCapacity == 0 {
+ return DefaultOpenFilesCacheCapacity
+ } else if o.OpenFilesCacheCapacity < 0 {
+ return 0
+ }
+ return o.OpenFilesCacheCapacity
+}
+
+func (o *Options) GetReadOnly() bool {
+ if o == nil {
+ return false
+ }
+ return o.ReadOnly
+}
+
+func (o *Options) GetStrict(strict Strict) bool {
+ if o == nil || o.Strict == 0 {
+ return DefaultStrict&strict != 0
+ }
+ return o.Strict&strict != 0
+}
+
+func (o *Options) GetWriteBuffer() int {
+ if o == nil || o.WriteBuffer <= 0 {
+ return DefaultWriteBuffer
+ }
+ return o.WriteBuffer
+}
+
+func (o *Options) GetWriteL0PauseTrigger() int {
+ if o == nil || o.WriteL0PauseTrigger == 0 {
+ return DefaultWriteL0PauseTrigger
+ }
+ return o.WriteL0PauseTrigger
+}
+
+func (o *Options) GetWriteL0SlowdownTrigger() int {
+ if o == nil || o.WriteL0SlowdownTrigger == 0 {
+ return DefaultWriteL0SlowdownTrigger
+ }
+ return o.WriteL0SlowdownTrigger
+}
+
+// ReadOptions holds the optional parameters for 'read operation'. The
+// 'read operation' includes Get, Find and NewIterator.
+type ReadOptions struct {
+ // DontFillCache defines whether block reads for this 'read operation'
+ // should be cached. If false then the block will be cached. This does
+ // not affects already cached block.
+ //
+ // The default value is false.
+ DontFillCache bool
+
+ // Strict will be OR'ed with global DB 'strict level' unless StrictOverride
+ // is present. Currently only StrictReader that has effect here.
+ Strict Strict
+}
+
+func (ro *ReadOptions) GetDontFillCache() bool {
+ if ro == nil {
+ return false
+ }
+ return ro.DontFillCache
+}
+
+func (ro *ReadOptions) GetStrict(strict Strict) bool {
+ if ro == nil {
+ return false
+ }
+ return ro.Strict&strict != 0
+}
+
+// WriteOptions holds the optional parameters for 'write operation'. The
+// 'write operation' includes Write, Put and Delete.
+type WriteOptions struct {
+ // Sync is whether to sync underlying writes from the OS buffer cache
+ // through to actual disk, if applicable. Setting Sync can result in
+ // slower writes.
+ //
+ // If false, and the machine crashes, then some recent writes may be lost.
+ // Note that if it is just the process that crashes (and the machine does
+ // not) then no writes will be lost.
+ //
+ // In other words, Sync being false has the same semantics as a write
+ // system call. Sync being true means write followed by fsync.
+ //
+ // The default value is false.
+ Sync bool
+}
+
+func (wo *WriteOptions) GetSync() bool {
+ if wo == nil {
+ return false
+ }
+ return wo.Sync
+}
+
+func GetStrict(o *Options, ro *ReadOptions, strict Strict) bool {
+ if ro.GetStrict(StrictOverride) {
+ return ro.GetStrict(strict)
+ } else {
+ return o.GetStrict(strict) || ro.GetStrict(strict)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/options.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/options.go
new file mode 100644
index 0000000000000000000000000000000000000000..a13abb675a960c430b5acb5084812c3794922d9e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/options.go
@@ -0,0 +1,92 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+)
+
+func dupOptions(o *opt.Options) *opt.Options {
+ newo := &opt.Options{}
+ if o != nil {
+ *newo = *o
+ }
+ if newo.Strict == 0 {
+ newo.Strict = opt.DefaultStrict
+ }
+ return newo
+}
+
+func (s *session) setOptions(o *opt.Options) {
+ no := dupOptions(o)
+ // Alternative filters.
+ if filters := o.GetAltFilters(); len(filters) > 0 {
+ no.AltFilters = make([]filter.Filter, len(filters))
+ for i, filter := range filters {
+ no.AltFilters[i] = &iFilter{filter}
+ }
+ }
+ // Comparer.
+ s.icmp = &iComparer{o.GetComparer()}
+ no.Comparer = s.icmp
+ // Filter.
+ if filter := o.GetFilter(); filter != nil {
+ no.Filter = &iFilter{filter}
+ }
+
+ s.o = &cachedOptions{Options: no}
+ s.o.cache()
+}
+
+type cachedOptions struct {
+ *opt.Options
+
+ compactionExpandLimit []int
+ compactionGPOverlaps []int
+ compactionSourceLimit []int
+ compactionTableSize []int
+ compactionTotalSize []int64
+}
+
+func (co *cachedOptions) cache() {
+ numLevel := co.Options.GetNumLevel()
+
+ co.compactionExpandLimit = make([]int, numLevel)
+ co.compactionGPOverlaps = make([]int, numLevel)
+ co.compactionSourceLimit = make([]int, numLevel)
+ co.compactionTableSize = make([]int, numLevel)
+ co.compactionTotalSize = make([]int64, numLevel)
+
+ for level := 0; level < numLevel; level++ {
+ co.compactionExpandLimit[level] = co.Options.GetCompactionExpandLimit(level)
+ co.compactionGPOverlaps[level] = co.Options.GetCompactionGPOverlaps(level)
+ co.compactionSourceLimit[level] = co.Options.GetCompactionSourceLimit(level)
+ co.compactionTableSize[level] = co.Options.GetCompactionTableSize(level)
+ co.compactionTotalSize[level] = co.Options.GetCompactionTotalSize(level)
+ }
+}
+
+func (co *cachedOptions) GetCompactionExpandLimit(level int) int {
+ return co.compactionExpandLimit[level]
+}
+
+func (co *cachedOptions) GetCompactionGPOverlaps(level int) int {
+ return co.compactionGPOverlaps[level]
+}
+
+func (co *cachedOptions) GetCompactionSourceLimit(level int) int {
+ return co.compactionSourceLimit[level]
+}
+
+func (co *cachedOptions) GetCompactionTableSize(level int) int {
+ return co.compactionTableSize[level]
+}
+
+func (co *cachedOptions) GetCompactionTotalSize(level int) int64 {
+ return co.compactionTotalSize[level]
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/session.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/session.go
new file mode 100644
index 0000000000000000000000000000000000000000..cb07209eb0544b2c02d6af299c8dbd0886bb46ff
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/session.go
@@ -0,0 +1,211 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "fmt"
+ "io"
+ "os"
+ "sync"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/journal"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type ErrManifestCorrupted struct {
+ Field string
+ Reason string
+}
+
+func (e *ErrManifestCorrupted) Error() string {
+ return fmt.Sprintf("leveldb: manifest corrupted (field '%s'): %s", e.Field, e.Reason)
+}
+
+func newErrManifestCorrupted(f storage.File, field, reason string) error {
+ return errors.NewErrCorrupted(f, &ErrManifestCorrupted{field, reason})
+}
+
+// session represent a persistent database session.
+type session struct {
+ // Need 64-bit alignment.
+ stNextFileNum uint64 // current unused file number
+ stJournalNum uint64 // current journal file number; need external synchronization
+ stPrevJournalNum uint64 // prev journal file number; no longer used; for compatibility with older version of leveldb
+ stSeqNum uint64 // last mem compacted seq; need external synchronization
+ stTempFileNum uint64
+
+ stor storage.Storage
+ storLock util.Releaser
+ o *cachedOptions
+ icmp *iComparer
+ tops *tOps
+
+ manifest *journal.Writer
+ manifestWriter storage.Writer
+ manifestFile storage.File
+
+ stCompPtrs []iKey // compaction pointers; need external synchronization
+ stVersion *version // current version
+ vmu sync.Mutex
+}
+
+// Creates new initialized session instance.
+func newSession(stor storage.Storage, o *opt.Options) (s *session, err error) {
+ if stor == nil {
+ return nil, os.ErrInvalid
+ }
+ storLock, err := stor.Lock()
+ if err != nil {
+ return
+ }
+ s = &session{
+ stor: stor,
+ storLock: storLock,
+ stCompPtrs: make([]iKey, o.GetNumLevel()),
+ }
+ s.setOptions(o)
+ s.tops = newTableOps(s)
+ s.setVersion(newVersion(s))
+ s.log("log@legend F·NumFile S·FileSize N·Entry C·BadEntry B·BadBlock Ke·KeyError D·DroppedEntry L·Level Q·SeqNum T·TimeElapsed")
+ return
+}
+
+// Close session.
+func (s *session) close() {
+ s.tops.close()
+ if s.manifest != nil {
+ s.manifest.Close()
+ }
+ if s.manifestWriter != nil {
+ s.manifestWriter.Close()
+ }
+ s.manifest = nil
+ s.manifestWriter = nil
+ s.manifestFile = nil
+ s.stVersion = nil
+}
+
+// Release session lock.
+func (s *session) release() {
+ s.storLock.Release()
+}
+
+// Create a new database session; need external synchronization.
+func (s *session) create() error {
+ // create manifest
+ return s.newManifest(nil, nil)
+}
+
+// Recover a database session; need external synchronization.
+func (s *session) recover() (err error) {
+ defer func() {
+ if os.IsNotExist(err) {
+ // Don't return os.ErrNotExist if the underlying storage contains
+ // other files that belong to LevelDB. So the DB won't get trashed.
+ if files, _ := s.stor.GetFiles(storage.TypeAll); len(files) > 0 {
+ err = &errors.ErrCorrupted{File: &storage.FileInfo{Type: storage.TypeManifest}, Err: &errors.ErrMissingFiles{}}
+ }
+ }
+ }()
+
+ m, err := s.stor.GetManifest()
+ if err != nil {
+ return
+ }
+
+ reader, err := m.Open()
+ if err != nil {
+ return
+ }
+ defer reader.Close()
+
+ var (
+ // Options.
+ numLevel = s.o.GetNumLevel()
+ strict = s.o.GetStrict(opt.StrictManifest)
+
+ jr = journal.NewReader(reader, dropper{s, m}, strict, true)
+ rec = &sessionRecord{}
+ staging = s.stVersion.newStaging()
+ )
+ for {
+ var r io.Reader
+ r, err = jr.Next()
+ if err != nil {
+ if err == io.EOF {
+ err = nil
+ break
+ }
+ return errors.SetFile(err, m)
+ }
+
+ err = rec.decode(r, numLevel)
+ if err == nil {
+ // save compact pointers
+ for _, r := range rec.compPtrs {
+ s.stCompPtrs[r.level] = iKey(r.ikey)
+ }
+ // commit record to version staging
+ staging.commit(rec)
+ } else {
+ err = errors.SetFile(err, m)
+ if strict || !errors.IsCorrupted(err) {
+ return
+ } else {
+ s.logf("manifest error: %v (skipped)", errors.SetFile(err, m))
+ }
+ }
+ rec.resetCompPtrs()
+ rec.resetAddedTables()
+ rec.resetDeletedTables()
+ }
+
+ switch {
+ case !rec.has(recComparer):
+ return newErrManifestCorrupted(m, "comparer", "missing")
+ case rec.comparer != s.icmp.uName():
+ return newErrManifestCorrupted(m, "comparer", fmt.Sprintf("mismatch: want '%s', got '%s'", s.icmp.uName(), rec.comparer))
+ case !rec.has(recNextFileNum):
+ return newErrManifestCorrupted(m, "next-file-num", "missing")
+ case !rec.has(recJournalNum):
+ return newErrManifestCorrupted(m, "journal-file-num", "missing")
+ case !rec.has(recSeqNum):
+ return newErrManifestCorrupted(m, "seq-num", "missing")
+ }
+
+ s.manifestFile = m
+ s.setVersion(staging.finish())
+ s.setNextFileNum(rec.nextFileNum)
+ s.recordCommited(rec)
+ return nil
+}
+
+// Commit session; need external synchronization.
+func (s *session) commit(r *sessionRecord) (err error) {
+ v := s.version()
+ defer v.release()
+
+ // spawn new version based on current version
+ nv := v.spawn(r)
+
+ if s.manifest == nil {
+ // manifest journal writer not yet created, create one
+ err = s.newManifest(r, nv)
+ } else {
+ err = s.flushManifest(r)
+ }
+
+ // finally, apply new version if no error rise
+ if err == nil {
+ s.setVersion(nv)
+ }
+
+ return
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/session_compaction.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/session_compaction.go
new file mode 100644
index 0000000000000000000000000000000000000000..0c785f4d31ee454f618163a137413874682a07bf
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/session_compaction.go
@@ -0,0 +1,287 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "sync/atomic"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+)
+
+func (s *session) pickMemdbLevel(umin, umax []byte) int {
+ v := s.version()
+ defer v.release()
+ return v.pickMemdbLevel(umin, umax)
+}
+
+func (s *session) flushMemdb(rec *sessionRecord, mdb *memdb.DB, level int) (level_ int, err error) {
+ // Create sorted table.
+ iter := mdb.NewIterator(nil)
+ defer iter.Release()
+ t, n, err := s.tops.createFrom(iter)
+ if err != nil {
+ return level, err
+ }
+
+ // Pick level and add to record.
+ if level < 0 {
+ level = s.pickMemdbLevel(t.imin.ukey(), t.imax.ukey())
+ }
+ rec.addTableFile(level, t)
+
+ s.logf("memdb@flush created L%d@%d N·%d S·%s %q:%q", level, t.file.Num(), n, shortenb(int(t.size)), t.imin, t.imax)
+ return level, nil
+}
+
+// Pick a compaction based on current state; need external synchronization.
+func (s *session) pickCompaction() *compaction {
+ v := s.version()
+
+ var level int
+ var t0 tFiles
+ if v.cScore >= 1 {
+ level = v.cLevel
+ cptr := s.stCompPtrs[level]
+ tables := v.tables[level]
+ for _, t := range tables {
+ if cptr == nil || s.icmp.Compare(t.imax, cptr) > 0 {
+ t0 = append(t0, t)
+ break
+ }
+ }
+ if len(t0) == 0 {
+ t0 = append(t0, tables[0])
+ }
+ } else {
+ if p := atomic.LoadPointer(&v.cSeek); p != nil {
+ ts := (*tSet)(p)
+ level = ts.level
+ t0 = append(t0, ts.table)
+ } else {
+ v.release()
+ return nil
+ }
+ }
+
+ return newCompaction(s, v, level, t0)
+}
+
+// Create compaction from given level and range; need external synchronization.
+func (s *session) getCompactionRange(level int, umin, umax []byte) *compaction {
+ v := s.version()
+
+ t0 := v.tables[level].getOverlaps(nil, s.icmp, umin, umax, level == 0)
+ if len(t0) == 0 {
+ v.release()
+ return nil
+ }
+
+ // Avoid compacting too much in one shot in case the range is large.
+ // But we cannot do this for level-0 since level-0 files can overlap
+ // and we must not pick one file and drop another older file if the
+ // two files overlap.
+ if level > 0 {
+ limit := uint64(v.s.o.GetCompactionSourceLimit(level))
+ total := uint64(0)
+ for i, t := range t0 {
+ total += t.size
+ if total >= limit {
+ s.logf("table@compaction limiting F·%d -> F·%d", len(t0), i+1)
+ t0 = t0[:i+1]
+ break
+ }
+ }
+ }
+
+ return newCompaction(s, v, level, t0)
+}
+
+func newCompaction(s *session, v *version, level int, t0 tFiles) *compaction {
+ c := &compaction{
+ s: s,
+ v: v,
+ level: level,
+ tables: [2]tFiles{t0, nil},
+ maxGPOverlaps: uint64(s.o.GetCompactionGPOverlaps(level)),
+ tPtrs: make([]int, s.o.GetNumLevel()),
+ }
+ c.expand()
+ c.save()
+ return c
+}
+
+// compaction represent a compaction state.
+type compaction struct {
+ s *session
+ v *version
+
+ level int
+ tables [2]tFiles
+ maxGPOverlaps uint64
+
+ gp tFiles
+ gpi int
+ seenKey bool
+ gpOverlappedBytes uint64
+ imin, imax iKey
+ tPtrs []int
+ released bool
+
+ snapGPI int
+ snapSeenKey bool
+ snapGPOverlappedBytes uint64
+ snapTPtrs []int
+}
+
+func (c *compaction) save() {
+ c.snapGPI = c.gpi
+ c.snapSeenKey = c.seenKey
+ c.snapGPOverlappedBytes = c.gpOverlappedBytes
+ c.snapTPtrs = append(c.snapTPtrs[:0], c.tPtrs...)
+}
+
+func (c *compaction) restore() {
+ c.gpi = c.snapGPI
+ c.seenKey = c.snapSeenKey
+ c.gpOverlappedBytes = c.snapGPOverlappedBytes
+ c.tPtrs = append(c.tPtrs[:0], c.snapTPtrs...)
+}
+
+func (c *compaction) release() {
+ if !c.released {
+ c.released = true
+ c.v.release()
+ }
+}
+
+// Expand compacted tables; need external synchronization.
+func (c *compaction) expand() {
+ limit := uint64(c.s.o.GetCompactionExpandLimit(c.level))
+ vt0, vt1 := c.v.tables[c.level], c.v.tables[c.level+1]
+
+ t0, t1 := c.tables[0], c.tables[1]
+ imin, imax := t0.getRange(c.s.icmp)
+ // We expand t0 here just incase ukey hop across tables.
+ t0 = vt0.getOverlaps(t0, c.s.icmp, imin.ukey(), imax.ukey(), c.level == 0)
+ if len(t0) != len(c.tables[0]) {
+ imin, imax = t0.getRange(c.s.icmp)
+ }
+ t1 = vt1.getOverlaps(t1, c.s.icmp, imin.ukey(), imax.ukey(), false)
+ // Get entire range covered by compaction.
+ amin, amax := append(t0, t1...).getRange(c.s.icmp)
+
+ // See if we can grow the number of inputs in "level" without
+ // changing the number of "level+1" files we pick up.
+ if len(t1) > 0 {
+ exp0 := vt0.getOverlaps(nil, c.s.icmp, amin.ukey(), amax.ukey(), c.level == 0)
+ if len(exp0) > len(t0) && t1.size()+exp0.size() < limit {
+ xmin, xmax := exp0.getRange(c.s.icmp)
+ exp1 := vt1.getOverlaps(nil, c.s.icmp, xmin.ukey(), xmax.ukey(), false)
+ if len(exp1) == len(t1) {
+ c.s.logf("table@compaction expanding L%d+L%d (F·%d S·%s)+(F·%d S·%s) -> (F·%d S·%s)+(F·%d S·%s)",
+ c.level, c.level+1, len(t0), shortenb(int(t0.size())), len(t1), shortenb(int(t1.size())),
+ len(exp0), shortenb(int(exp0.size())), len(exp1), shortenb(int(exp1.size())))
+ imin, imax = xmin, xmax
+ t0, t1 = exp0, exp1
+ amin, amax = append(t0, t1...).getRange(c.s.icmp)
+ }
+ }
+ }
+
+ // Compute the set of grandparent files that overlap this compaction
+ // (parent == level+1; grandparent == level+2)
+ if c.level+2 < c.s.o.GetNumLevel() {
+ c.gp = c.v.tables[c.level+2].getOverlaps(c.gp, c.s.icmp, amin.ukey(), amax.ukey(), false)
+ }
+
+ c.tables[0], c.tables[1] = t0, t1
+ c.imin, c.imax = imin, imax
+}
+
+// Check whether compaction is trivial.
+func (c *compaction) trivial() bool {
+ return len(c.tables[0]) == 1 && len(c.tables[1]) == 0 && c.gp.size() <= c.maxGPOverlaps
+}
+
+func (c *compaction) baseLevelForKey(ukey []byte) bool {
+ for level, tables := range c.v.tables[c.level+2:] {
+ for c.tPtrs[level] < len(tables) {
+ t := tables[c.tPtrs[level]]
+ if c.s.icmp.uCompare(ukey, t.imax.ukey()) <= 0 {
+ // We've advanced far enough.
+ if c.s.icmp.uCompare(ukey, t.imin.ukey()) >= 0 {
+ // Key falls in this file's range, so definitely not base level.
+ return false
+ }
+ break
+ }
+ c.tPtrs[level]++
+ }
+ }
+ return true
+}
+
+func (c *compaction) shouldStopBefore(ikey iKey) bool {
+ for ; c.gpi < len(c.gp); c.gpi++ {
+ gp := c.gp[c.gpi]
+ if c.s.icmp.Compare(ikey, gp.imax) <= 0 {
+ break
+ }
+ if c.seenKey {
+ c.gpOverlappedBytes += gp.size
+ }
+ }
+ c.seenKey = true
+
+ if c.gpOverlappedBytes > c.maxGPOverlaps {
+ // Too much overlap for current output; start new output.
+ c.gpOverlappedBytes = 0
+ return true
+ }
+ return false
+}
+
+// Creates an iterator.
+func (c *compaction) newIterator() iterator.Iterator {
+ // Creates iterator slice.
+ icap := len(c.tables)
+ if c.level == 0 {
+ // Special case for level-0.
+ icap = len(c.tables[0]) + 1
+ }
+ its := make([]iterator.Iterator, 0, icap)
+
+ // Options.
+ ro := &opt.ReadOptions{
+ DontFillCache: true,
+ Strict: opt.StrictOverride,
+ }
+ strict := c.s.o.GetStrict(opt.StrictCompaction)
+ if strict {
+ ro.Strict |= opt.StrictReader
+ }
+
+ for i, tables := range c.tables {
+ if len(tables) == 0 {
+ continue
+ }
+
+ // Level-0 is not sorted and may overlaps each other.
+ if c.level+i == 0 {
+ for _, t := range tables {
+ its = append(its, c.s.tops.newIterator(t, nil, ro))
+ }
+ } else {
+ it := iterator.NewIndexedIterator(tables.newIndexIterator(c.s.tops, c.s.icmp, nil, ro), strict)
+ its = append(its, it)
+ }
+ }
+
+ return iterator.NewMergedIterator(its, c.s.icmp, strict)
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/session_record.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/session_record.go
new file mode 100644
index 0000000000000000000000000000000000000000..b774bafac504552d75253d0943739e7e8229ef42
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/session_record.go
@@ -0,0 +1,311 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "bufio"
+ "encoding/binary"
+ "io"
+ "strings"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors"
+)
+
+type byteReader interface {
+ io.Reader
+ io.ByteReader
+}
+
+// These numbers are written to disk and should not be changed.
+const (
+ recComparer = 1
+ recJournalNum = 2
+ recNextFileNum = 3
+ recSeqNum = 4
+ recCompPtr = 5
+ recDelTable = 6
+ recAddTable = 7
+ // 8 was used for large value refs
+ recPrevJournalNum = 9
+)
+
+type cpRecord struct {
+ level int
+ ikey iKey
+}
+
+type atRecord struct {
+ level int
+ num uint64
+ size uint64
+ imin iKey
+ imax iKey
+}
+
+type dtRecord struct {
+ level int
+ num uint64
+}
+
+type sessionRecord struct {
+ hasRec int
+ comparer string
+ journalNum uint64
+ prevJournalNum uint64
+ nextFileNum uint64
+ seqNum uint64
+ compPtrs []cpRecord
+ addedTables []atRecord
+ deletedTables []dtRecord
+
+ scratch [binary.MaxVarintLen64]byte
+ err error
+}
+
+func (p *sessionRecord) has(rec int) bool {
+ return p.hasRec&(1<<uint(rec)) != 0
+}
+
+func (p *sessionRecord) setComparer(name string) {
+ p.hasRec |= 1 << recComparer
+ p.comparer = name
+}
+
+func (p *sessionRecord) setJournalNum(num uint64) {
+ p.hasRec |= 1 << recJournalNum
+ p.journalNum = num
+}
+
+func (p *sessionRecord) setPrevJournalNum(num uint64) {
+ p.hasRec |= 1 << recPrevJournalNum
+ p.prevJournalNum = num
+}
+
+func (p *sessionRecord) setNextFileNum(num uint64) {
+ p.hasRec |= 1 << recNextFileNum
+ p.nextFileNum = num
+}
+
+func (p *sessionRecord) setSeqNum(num uint64) {
+ p.hasRec |= 1 << recSeqNum
+ p.seqNum = num
+}
+
+func (p *sessionRecord) addCompPtr(level int, ikey iKey) {
+ p.hasRec |= 1 << recCompPtr
+ p.compPtrs = append(p.compPtrs, cpRecord{level, ikey})
+}
+
+func (p *sessionRecord) resetCompPtrs() {
+ p.hasRec &= ^(1 << recCompPtr)
+ p.compPtrs = p.compPtrs[:0]
+}
+
+func (p *sessionRecord) addTable(level int, num, size uint64, imin, imax iKey) {
+ p.hasRec |= 1 << recAddTable
+ p.addedTables = append(p.addedTables, atRecord{level, num, size, imin, imax})
+}
+
+func (p *sessionRecord) addTableFile(level int, t *tFile) {
+ p.addTable(level, t.file.Num(), t.size, t.imin, t.imax)
+}
+
+func (p *sessionRecord) resetAddedTables() {
+ p.hasRec &= ^(1 << recAddTable)
+ p.addedTables = p.addedTables[:0]
+}
+
+func (p *sessionRecord) delTable(level int, num uint64) {
+ p.hasRec |= 1 << recDelTable
+ p.deletedTables = append(p.deletedTables, dtRecord{level, num})
+}
+
+func (p *sessionRecord) resetDeletedTables() {
+ p.hasRec &= ^(1 << recDelTable)
+ p.deletedTables = p.deletedTables[:0]
+}
+
+func (p *sessionRecord) putUvarint(w io.Writer, x uint64) {
+ if p.err != nil {
+ return
+ }
+ n := binary.PutUvarint(p.scratch[:], x)
+ _, p.err = w.Write(p.scratch[:n])
+}
+
+func (p *sessionRecord) putBytes(w io.Writer, x []byte) {
+ if p.err != nil {
+ return
+ }
+ p.putUvarint(w, uint64(len(x)))
+ if p.err != nil {
+ return
+ }
+ _, p.err = w.Write(x)
+}
+
+func (p *sessionRecord) encode(w io.Writer) error {
+ p.err = nil
+ if p.has(recComparer) {
+ p.putUvarint(w, recComparer)
+ p.putBytes(w, []byte(p.comparer))
+ }
+ if p.has(recJournalNum) {
+ p.putUvarint(w, recJournalNum)
+ p.putUvarint(w, p.journalNum)
+ }
+ if p.has(recNextFileNum) {
+ p.putUvarint(w, recNextFileNum)
+ p.putUvarint(w, p.nextFileNum)
+ }
+ if p.has(recSeqNum) {
+ p.putUvarint(w, recSeqNum)
+ p.putUvarint(w, p.seqNum)
+ }
+ for _, r := range p.compPtrs {
+ p.putUvarint(w, recCompPtr)
+ p.putUvarint(w, uint64(r.level))
+ p.putBytes(w, r.ikey)
+ }
+ for _, r := range p.deletedTables {
+ p.putUvarint(w, recDelTable)
+ p.putUvarint(w, uint64(r.level))
+ p.putUvarint(w, r.num)
+ }
+ for _, r := range p.addedTables {
+ p.putUvarint(w, recAddTable)
+ p.putUvarint(w, uint64(r.level))
+ p.putUvarint(w, r.num)
+ p.putUvarint(w, r.size)
+ p.putBytes(w, r.imin)
+ p.putBytes(w, r.imax)
+ }
+ return p.err
+}
+
+func (p *sessionRecord) readUvarintMayEOF(field string, r io.ByteReader, mayEOF bool) uint64 {
+ if p.err != nil {
+ return 0
+ }
+ x, err := binary.ReadUvarint(r)
+ if err != nil {
+ if err == io.ErrUnexpectedEOF || (mayEOF == false && err == io.EOF) {
+ p.err = errors.NewErrCorrupted(nil, &ErrManifestCorrupted{field, "short read"})
+ } else if strings.HasPrefix(err.Error(), "binary:") {
+ p.err = errors.NewErrCorrupted(nil, &ErrManifestCorrupted{field, err.Error()})
+ } else {
+ p.err = err
+ }
+ return 0
+ }
+ return x
+}
+
+func (p *sessionRecord) readUvarint(field string, r io.ByteReader) uint64 {
+ return p.readUvarintMayEOF(field, r, false)
+}
+
+func (p *sessionRecord) readBytes(field string, r byteReader) []byte {
+ if p.err != nil {
+ return nil
+ }
+ n := p.readUvarint(field, r)
+ if p.err != nil {
+ return nil
+ }
+ x := make([]byte, n)
+ _, p.err = io.ReadFull(r, x)
+ if p.err != nil {
+ if p.err == io.ErrUnexpectedEOF {
+ p.err = errors.NewErrCorrupted(nil, &ErrManifestCorrupted{field, "short read"})
+ }
+ return nil
+ }
+ return x
+}
+
+func (p *sessionRecord) readLevel(field string, r io.ByteReader, numLevel int) int {
+ if p.err != nil {
+ return 0
+ }
+ x := p.readUvarint(field, r)
+ if p.err != nil {
+ return 0
+ }
+ if x >= uint64(numLevel) {
+ p.err = errors.NewErrCorrupted(nil, &ErrManifestCorrupted{field, "invalid level number"})
+ return 0
+ }
+ return int(x)
+}
+
+func (p *sessionRecord) decode(r io.Reader, numLevel int) error {
+ br, ok := r.(byteReader)
+ if !ok {
+ br = bufio.NewReader(r)
+ }
+ p.err = nil
+ for p.err == nil {
+ rec := p.readUvarintMayEOF("field-header", br, true)
+ if p.err != nil {
+ if p.err == io.EOF {
+ return nil
+ }
+ return p.err
+ }
+ switch rec {
+ case recComparer:
+ x := p.readBytes("comparer", br)
+ if p.err == nil {
+ p.setComparer(string(x))
+ }
+ case recJournalNum:
+ x := p.readUvarint("journal-num", br)
+ if p.err == nil {
+ p.setJournalNum(x)
+ }
+ case recPrevJournalNum:
+ x := p.readUvarint("prev-journal-num", br)
+ if p.err == nil {
+ p.setPrevJournalNum(x)
+ }
+ case recNextFileNum:
+ x := p.readUvarint("next-file-num", br)
+ if p.err == nil {
+ p.setNextFileNum(x)
+ }
+ case recSeqNum:
+ x := p.readUvarint("seq-num", br)
+ if p.err == nil {
+ p.setSeqNum(x)
+ }
+ case recCompPtr:
+ level := p.readLevel("comp-ptr.level", br, numLevel)
+ ikey := p.readBytes("comp-ptr.ikey", br)
+ if p.err == nil {
+ p.addCompPtr(level, iKey(ikey))
+ }
+ case recAddTable:
+ level := p.readLevel("add-table.level", br, numLevel)
+ num := p.readUvarint("add-table.num", br)
+ size := p.readUvarint("add-table.size", br)
+ imin := p.readBytes("add-table.imin", br)
+ imax := p.readBytes("add-table.imax", br)
+ if p.err == nil {
+ p.addTable(level, num, size, imin, imax)
+ }
+ case recDelTable:
+ level := p.readLevel("del-table.level", br, numLevel)
+ num := p.readUvarint("del-table.num", br)
+ if p.err == nil {
+ p.delTable(level, num)
+ }
+ }
+ }
+
+ return p.err
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/session_record_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/session_record_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..7a18cf448a7524a4d891bec7dccb150b48f70c06
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/session_record_test.go
@@ -0,0 +1,64 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "bytes"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+)
+
+func decodeEncode(v *sessionRecord) (res bool, err error) {
+ b := new(bytes.Buffer)
+ err = v.encode(b)
+ if err != nil {
+ return
+ }
+ v2 := &sessionRecord{}
+ err = v.decode(b, opt.DefaultNumLevel)
+ if err != nil {
+ return
+ }
+ b2 := new(bytes.Buffer)
+ err = v2.encode(b2)
+ if err != nil {
+ return
+ }
+ return bytes.Equal(b.Bytes(), b2.Bytes()), nil
+}
+
+func TestSessionRecord_EncodeDecode(t *testing.T) {
+ big := uint64(1) << 50
+ v := &sessionRecord{}
+ i := uint64(0)
+ test := func() {
+ res, err := decodeEncode(v)
+ if err != nil {
+ t.Fatalf("error when testing encode/decode sessionRecord: %v", err)
+ }
+ if !res {
+ t.Error("encode/decode test failed at iteration:", i)
+ }
+ }
+
+ for ; i < 4; i++ {
+ test()
+ v.addTable(3, big+300+i, big+400+i,
+ newIkey([]byte("foo"), big+500+1, ktVal),
+ newIkey([]byte("zoo"), big+600+1, ktDel))
+ v.delTable(4, big+700+i)
+ v.addCompPtr(int(i), newIkey([]byte("x"), big+900+1, ktVal))
+ }
+
+ v.setComparer("foo")
+ v.setJournalNum(big + 100)
+ v.setPrevJournalNum(big + 99)
+ v.setNextFileNum(big + 200)
+ v.setSeqNum(big + 1000)
+ test()
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/session_util.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/session_util.go
new file mode 100644
index 0000000000000000000000000000000000000000..740f3447e21286a394507a1c3fbf53df1d8022f6
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/session_util.go
@@ -0,0 +1,249 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "fmt"
+ "sync/atomic"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/journal"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage"
+)
+
+// Logging.
+
+type dropper struct {
+ s *session
+ file storage.File
+}
+
+func (d dropper) Drop(err error) {
+ if e, ok := err.(*journal.ErrCorrupted); ok {
+ d.s.logf("journal@drop %s-%d S·%s %q", d.file.Type(), d.file.Num(), shortenb(e.Size), e.Reason)
+ } else {
+ d.s.logf("journal@drop %s-%d %q", d.file.Type(), d.file.Num(), err)
+ }
+}
+
+func (s *session) log(v ...interface{}) { s.stor.Log(fmt.Sprint(v...)) }
+func (s *session) logf(format string, v ...interface{}) { s.stor.Log(fmt.Sprintf(format, v...)) }
+
+// File utils.
+
+func (s *session) getJournalFile(num uint64) storage.File {
+ return s.stor.GetFile(num, storage.TypeJournal)
+}
+
+func (s *session) getTableFile(num uint64) storage.File {
+ return s.stor.GetFile(num, storage.TypeTable)
+}
+
+func (s *session) getFiles(t storage.FileType) ([]storage.File, error) {
+ return s.stor.GetFiles(t)
+}
+
+func (s *session) newTemp() storage.File {
+ num := atomic.AddUint64(&s.stTempFileNum, 1) - 1
+ return s.stor.GetFile(num, storage.TypeTemp)
+}
+
+func (s *session) tableFileFromRecord(r atRecord) *tFile {
+ return newTableFile(s.getTableFile(r.num), r.size, r.imin, r.imax)
+}
+
+// Session state.
+
+// Get current version. This will incr version ref, must call
+// version.release (exactly once) after use.
+func (s *session) version() *version {
+ s.vmu.Lock()
+ defer s.vmu.Unlock()
+ s.stVersion.ref++
+ return s.stVersion
+}
+
+// Set current version to v.
+func (s *session) setVersion(v *version) {
+ s.vmu.Lock()
+ v.ref = 1 // Holds by session.
+ if old := s.stVersion; old != nil {
+ v.ref++ // Holds by old version.
+ old.next = v
+ old.releaseNB()
+ }
+ s.stVersion = v
+ s.vmu.Unlock()
+}
+
+// Get current unused file number.
+func (s *session) nextFileNum() uint64 {
+ return atomic.LoadUint64(&s.stNextFileNum)
+}
+
+// Set current unused file number to num.
+func (s *session) setNextFileNum(num uint64) {
+ atomic.StoreUint64(&s.stNextFileNum, num)
+}
+
+// Mark file number as used.
+func (s *session) markFileNum(num uint64) {
+ nextFileNum := num + 1
+ for {
+ old, x := s.stNextFileNum, nextFileNum
+ if old > x {
+ x = old
+ }
+ if atomic.CompareAndSwapUint64(&s.stNextFileNum, old, x) {
+ break
+ }
+ }
+}
+
+// Allocate a file number.
+func (s *session) allocFileNum() uint64 {
+ return atomic.AddUint64(&s.stNextFileNum, 1) - 1
+}
+
+// Reuse given file number.
+func (s *session) reuseFileNum(num uint64) {
+ for {
+ old, x := s.stNextFileNum, num
+ if old != x+1 {
+ x = old
+ }
+ if atomic.CompareAndSwapUint64(&s.stNextFileNum, old, x) {
+ break
+ }
+ }
+}
+
+// Manifest related utils.
+
+// Fill given session record obj with current states; need external
+// synchronization.
+func (s *session) fillRecord(r *sessionRecord, snapshot bool) {
+ r.setNextFileNum(s.nextFileNum())
+
+ if snapshot {
+ if !r.has(recJournalNum) {
+ r.setJournalNum(s.stJournalNum)
+ }
+
+ if !r.has(recSeqNum) {
+ r.setSeqNum(s.stSeqNum)
+ }
+
+ for level, ik := range s.stCompPtrs {
+ if ik != nil {
+ r.addCompPtr(level, ik)
+ }
+ }
+
+ r.setComparer(s.icmp.uName())
+ }
+}
+
+// Mark if record has been committed, this will update session state;
+// need external synchronization.
+func (s *session) recordCommited(r *sessionRecord) {
+ if r.has(recJournalNum) {
+ s.stJournalNum = r.journalNum
+ }
+
+ if r.has(recPrevJournalNum) {
+ s.stPrevJournalNum = r.prevJournalNum
+ }
+
+ if r.has(recSeqNum) {
+ s.stSeqNum = r.seqNum
+ }
+
+ for _, p := range r.compPtrs {
+ s.stCompPtrs[p.level] = iKey(p.ikey)
+ }
+}
+
+// Create a new manifest file; need external synchronization.
+func (s *session) newManifest(rec *sessionRecord, v *version) (err error) {
+ num := s.allocFileNum()
+ file := s.stor.GetFile(num, storage.TypeManifest)
+ writer, err := file.Create()
+ if err != nil {
+ return
+ }
+ jw := journal.NewWriter(writer)
+
+ if v == nil {
+ v = s.version()
+ defer v.release()
+ }
+ if rec == nil {
+ rec = &sessionRecord{}
+ }
+ s.fillRecord(rec, true)
+ v.fillRecord(rec)
+
+ defer func() {
+ if err == nil {
+ s.recordCommited(rec)
+ if s.manifest != nil {
+ s.manifest.Close()
+ }
+ if s.manifestWriter != nil {
+ s.manifestWriter.Close()
+ }
+ if s.manifestFile != nil {
+ s.manifestFile.Remove()
+ }
+ s.manifestFile = file
+ s.manifestWriter = writer
+ s.manifest = jw
+ } else {
+ writer.Close()
+ file.Remove()
+ s.reuseFileNum(num)
+ }
+ }()
+
+ w, err := jw.Next()
+ if err != nil {
+ return
+ }
+ err = rec.encode(w)
+ if err != nil {
+ return
+ }
+ err = jw.Flush()
+ if err != nil {
+ return
+ }
+ err = s.stor.SetManifest(file)
+ return
+}
+
+// Flush record to disk.
+func (s *session) flushManifest(rec *sessionRecord) (err error) {
+ s.fillRecord(rec, false)
+ w, err := s.manifest.Next()
+ if err != nil {
+ return
+ }
+ err = rec.encode(w)
+ if err != nil {
+ return
+ }
+ err = s.manifest.Flush()
+ if err != nil {
+ return
+ }
+ err = s.manifestWriter.Sync()
+ if err != nil {
+ return
+ }
+ s.recordCommited(rec)
+ return
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage.go
new file mode 100644
index 0000000000000000000000000000000000000000..9329faf7a7676b75572f4ef612e6d7e320272858
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage.go
@@ -0,0 +1,534 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reservefs.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package storage
+
+import (
+ "errors"
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "runtime"
+ "strconv"
+ "strings"
+ "sync"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+var errFileOpen = errors.New("leveldb/storage: file still open")
+
+type fileLock interface {
+ release() error
+}
+
+type fileStorageLock struct {
+ fs *fileStorage
+}
+
+func (lock *fileStorageLock) Release() {
+ fs := lock.fs
+ fs.mu.Lock()
+ defer fs.mu.Unlock()
+ if fs.slock == lock {
+ fs.slock = nil
+ }
+ return
+}
+
+// fileStorage is a file-system backed storage.
+type fileStorage struct {
+ path string
+
+ mu sync.Mutex
+ flock fileLock
+ slock *fileStorageLock
+ logw *os.File
+ buf []byte
+ // Opened file counter; if open < 0 means closed.
+ open int
+ day int
+}
+
+// OpenFile returns a new filesytem-backed storage implementation with the given
+// path. This also hold a file lock, so any subsequent attempt to open the same
+// path will fail.
+//
+// The storage must be closed after use, by calling Close method.
+func OpenFile(path string) (Storage, error) {
+ if err := os.MkdirAll(path, 0755); err != nil {
+ return nil, err
+ }
+
+ flock, err := newFileLock(filepath.Join(path, "LOCK"))
+ if err != nil {
+ return nil, err
+ }
+
+ defer func() {
+ if err != nil {
+ flock.release()
+ }
+ }()
+
+ rename(filepath.Join(path, "LOG"), filepath.Join(path, "LOG.old"))
+ logw, err := os.OpenFile(filepath.Join(path, "LOG"), os.O_WRONLY|os.O_CREATE, 0644)
+ if err != nil {
+ return nil, err
+ }
+
+ fs := &fileStorage{path: path, flock: flock, logw: logw}
+ runtime.SetFinalizer(fs, (*fileStorage).Close)
+ return fs, nil
+}
+
+func (fs *fileStorage) Lock() (util.Releaser, error) {
+ fs.mu.Lock()
+ defer fs.mu.Unlock()
+ if fs.open < 0 {
+ return nil, ErrClosed
+ }
+ if fs.slock != nil {
+ return nil, ErrLocked
+ }
+ fs.slock = &fileStorageLock{fs: fs}
+ return fs.slock, nil
+}
+
+func itoa(buf []byte, i int, wid int) []byte {
+ var u uint = uint(i)
+ if u == 0 && wid <= 1 {
+ return append(buf, '0')
+ }
+
+ // Assemble decimal in reverse order.
+ var b [32]byte
+ bp := len(b)
+ for ; u > 0 || wid > 0; u /= 10 {
+ bp--
+ wid--
+ b[bp] = byte(u%10) + '0'
+ }
+ return append(buf, b[bp:]...)
+}
+
+func (fs *fileStorage) printDay(t time.Time) {
+ if fs.day == t.Day() {
+ return
+ }
+ fs.day = t.Day()
+ fs.logw.Write([]byte("=============== " + t.Format("Jan 2, 2006 (MST)") + " ===============\n"))
+}
+
+func (fs *fileStorage) doLog(t time.Time, str string) {
+ fs.printDay(t)
+ hour, min, sec := t.Clock()
+ msec := t.Nanosecond() / 1e3
+ // time
+ fs.buf = itoa(fs.buf[:0], hour, 2)
+ fs.buf = append(fs.buf, ':')
+ fs.buf = itoa(fs.buf, min, 2)
+ fs.buf = append(fs.buf, ':')
+ fs.buf = itoa(fs.buf, sec, 2)
+ fs.buf = append(fs.buf, '.')
+ fs.buf = itoa(fs.buf, msec, 6)
+ fs.buf = append(fs.buf, ' ')
+ // write
+ fs.buf = append(fs.buf, []byte(str)...)
+ fs.buf = append(fs.buf, '\n')
+ fs.logw.Write(fs.buf)
+}
+
+func (fs *fileStorage) Log(str string) {
+ t := time.Now()
+ fs.mu.Lock()
+ defer fs.mu.Unlock()
+ if fs.open < 0 {
+ return
+ }
+ fs.doLog(t, str)
+}
+
+func (fs *fileStorage) log(str string) {
+ fs.doLog(time.Now(), str)
+}
+
+func (fs *fileStorage) GetFile(num uint64, t FileType) File {
+ return &file{fs: fs, num: num, t: t}
+}
+
+func (fs *fileStorage) GetFiles(t FileType) (ff []File, err error) {
+ fs.mu.Lock()
+ defer fs.mu.Unlock()
+ if fs.open < 0 {
+ return nil, ErrClosed
+ }
+ dir, err := os.Open(fs.path)
+ if err != nil {
+ return
+ }
+ fnn, err := dir.Readdirnames(0)
+ // Close the dir first before checking for Readdirnames error.
+ if err := dir.Close(); err != nil {
+ fs.log(fmt.Sprintf("close dir: %v", err))
+ }
+ if err != nil {
+ return
+ }
+ f := &file{fs: fs}
+ for _, fn := range fnn {
+ if f.parse(fn) && (f.t&t) != 0 {
+ ff = append(ff, f)
+ f = &file{fs: fs}
+ }
+ }
+ return
+}
+
+func (fs *fileStorage) GetManifest() (f File, err error) {
+ fs.mu.Lock()
+ defer fs.mu.Unlock()
+ if fs.open < 0 {
+ return nil, ErrClosed
+ }
+ dir, err := os.Open(fs.path)
+ if err != nil {
+ return
+ }
+ fnn, err := dir.Readdirnames(0)
+ // Close the dir first before checking for Readdirnames error.
+ if err := dir.Close(); err != nil {
+ fs.log(fmt.Sprintf("close dir: %v", err))
+ }
+ if err != nil {
+ return
+ }
+ // Find latest CURRENT file.
+ var rem []string
+ var pend bool
+ var cerr error
+ for _, fn := range fnn {
+ if strings.HasPrefix(fn, "CURRENT") {
+ pend1 := len(fn) > 7
+ // Make sure it is valid name for a CURRENT file, otherwise skip it.
+ if pend1 {
+ if fn[7] != '.' || len(fn) < 9 {
+ fs.log(fmt.Sprintf("skipping %s: invalid file name", fn))
+ continue
+ }
+ if _, e1 := strconv.ParseUint(fn[8:], 10, 0); e1 != nil {
+ fs.log(fmt.Sprintf("skipping %s: invalid file num: %v", fn, e1))
+ continue
+ }
+ }
+ path := filepath.Join(fs.path, fn)
+ r, e1 := os.OpenFile(path, os.O_RDONLY, 0)
+ if e1 != nil {
+ return nil, e1
+ }
+ b, e1 := ioutil.ReadAll(r)
+ if e1 != nil {
+ r.Close()
+ return nil, e1
+ }
+ f1 := &file{fs: fs}
+ if len(b) < 1 || b[len(b)-1] != '\n' || !f1.parse(string(b[:len(b)-1])) {
+ fs.log(fmt.Sprintf("skipping %s: corrupted or incomplete", fn))
+ if pend1 {
+ rem = append(rem, fn)
+ }
+ if !pend1 || cerr == nil {
+ cerr = fmt.Errorf("leveldb/storage: corrupted or incomplete %s file", fn)
+ }
+ } else if f != nil && f1.Num() < f.Num() {
+ fs.log(fmt.Sprintf("skipping %s: obsolete", fn))
+ if pend1 {
+ rem = append(rem, fn)
+ }
+ } else {
+ f = f1
+ pend = pend1
+ }
+ if err := r.Close(); err != nil {
+ fs.log(fmt.Sprintf("close %s: %v", fn, err))
+ }
+ }
+ }
+ // Don't remove any files if there is no valid CURRENT file.
+ if f == nil {
+ if cerr != nil {
+ err = cerr
+ } else {
+ err = os.ErrNotExist
+ }
+ return
+ }
+ // Rename pending CURRENT file to an effective CURRENT.
+ if pend {
+ path := fmt.Sprintf("%s.%d", filepath.Join(fs.path, "CURRENT"), f.Num())
+ if err := rename(path, filepath.Join(fs.path, "CURRENT")); err != nil {
+ fs.log(fmt.Sprintf("CURRENT.%d -> CURRENT: %v", f.Num(), err))
+ }
+ }
+ // Remove obsolete or incomplete pending CURRENT files.
+ for _, fn := range rem {
+ path := filepath.Join(fs.path, fn)
+ if err := os.Remove(path); err != nil {
+ fs.log(fmt.Sprintf("remove %s: %v", fn, err))
+ }
+ }
+ return
+}
+
+func (fs *fileStorage) SetManifest(f File) (err error) {
+ fs.mu.Lock()
+ defer fs.mu.Unlock()
+ if fs.open < 0 {
+ return ErrClosed
+ }
+ f2, ok := f.(*file)
+ if !ok || f2.t != TypeManifest {
+ return ErrInvalidFile
+ }
+ defer func() {
+ if err != nil {
+ fs.log(fmt.Sprintf("CURRENT: %v", err))
+ }
+ }()
+ path := fmt.Sprintf("%s.%d", filepath.Join(fs.path, "CURRENT"), f2.Num())
+ w, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
+ if err != nil {
+ return err
+ }
+ _, err = fmt.Fprintln(w, f2.name())
+ // Close the file first.
+ if err := w.Close(); err != nil {
+ fs.log(fmt.Sprintf("close CURRENT.%d: %v", f2.num, err))
+ }
+ if err != nil {
+ return err
+ }
+ return rename(path, filepath.Join(fs.path, "CURRENT"))
+}
+
+func (fs *fileStorage) Close() error {
+ fs.mu.Lock()
+ defer fs.mu.Unlock()
+ if fs.open < 0 {
+ return ErrClosed
+ }
+ // Clear the finalizer.
+ runtime.SetFinalizer(fs, nil)
+
+ if fs.open > 0 {
+ fs.log(fmt.Sprintf("refuse to close, %d files still open", fs.open))
+ return fmt.Errorf("leveldb/storage: cannot close, %d files still open", fs.open)
+ }
+ fs.open = -1
+ e1 := fs.logw.Close()
+ err := fs.flock.release()
+ if err == nil {
+ err = e1
+ }
+ return err
+}
+
+type fileWrap struct {
+ *os.File
+ f *file
+}
+
+func (fw fileWrap) Sync() error {
+ if err := fw.File.Sync(); err != nil {
+ return err
+ }
+ if fw.f.Type() == TypeManifest {
+ // Also sync parent directory if file type is manifest.
+ // See: https://code.google.com/p/leveldb/issues/detail?id=190.
+ if err := syncDir(fw.f.fs.path); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func (fw fileWrap) Close() error {
+ f := fw.f
+ f.fs.mu.Lock()
+ defer f.fs.mu.Unlock()
+ if !f.open {
+ return ErrClosed
+ }
+ f.open = false
+ f.fs.open--
+ err := fw.File.Close()
+ if err != nil {
+ f.fs.log(fmt.Sprintf("close %s.%d: %v", f.Type(), f.Num(), err))
+ }
+ return err
+}
+
+type file struct {
+ fs *fileStorage
+ num uint64
+ t FileType
+ open bool
+}
+
+func (f *file) Open() (Reader, error) {
+ f.fs.mu.Lock()
+ defer f.fs.mu.Unlock()
+ if f.fs.open < 0 {
+ return nil, ErrClosed
+ }
+ if f.open {
+ return nil, errFileOpen
+ }
+ of, err := os.OpenFile(f.path(), os.O_RDONLY, 0)
+ if err != nil {
+ if f.hasOldName() && os.IsNotExist(err) {
+ of, err = os.OpenFile(f.oldPath(), os.O_RDONLY, 0)
+ if err == nil {
+ goto ok
+ }
+ }
+ return nil, err
+ }
+ok:
+ f.open = true
+ f.fs.open++
+ return fileWrap{of, f}, nil
+}
+
+func (f *file) Create() (Writer, error) {
+ f.fs.mu.Lock()
+ defer f.fs.mu.Unlock()
+ if f.fs.open < 0 {
+ return nil, ErrClosed
+ }
+ if f.open {
+ return nil, errFileOpen
+ }
+ of, err := os.OpenFile(f.path(), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
+ if err != nil {
+ return nil, err
+ }
+ f.open = true
+ f.fs.open++
+ return fileWrap{of, f}, nil
+}
+
+func (f *file) Replace(newfile File) error {
+ f.fs.mu.Lock()
+ defer f.fs.mu.Unlock()
+ if f.fs.open < 0 {
+ return ErrClosed
+ }
+ newfile2, ok := newfile.(*file)
+ if !ok {
+ return ErrInvalidFile
+ }
+ if f.open || newfile2.open {
+ return errFileOpen
+ }
+ return rename(newfile2.path(), f.path())
+}
+
+func (f *file) Type() FileType {
+ return f.t
+}
+
+func (f *file) Num() uint64 {
+ return f.num
+}
+
+func (f *file) Remove() error {
+ f.fs.mu.Lock()
+ defer f.fs.mu.Unlock()
+ if f.fs.open < 0 {
+ return ErrClosed
+ }
+ if f.open {
+ return errFileOpen
+ }
+ err := os.Remove(f.path())
+ if err != nil {
+ f.fs.log(fmt.Sprintf("remove %s.%d: %v", f.Type(), f.Num(), err))
+ }
+ // Also try remove file with old name, just in case.
+ if f.hasOldName() {
+ if e1 := os.Remove(f.oldPath()); !os.IsNotExist(e1) {
+ f.fs.log(fmt.Sprintf("remove %s.%d: %v (old name)", f.Type(), f.Num(), err))
+ err = e1
+ }
+ }
+ return err
+}
+
+func (f *file) hasOldName() bool {
+ return f.t == TypeTable
+}
+
+func (f *file) oldName() string {
+ switch f.t {
+ case TypeTable:
+ return fmt.Sprintf("%06d.sst", f.num)
+ }
+ return f.name()
+}
+
+func (f *file) oldPath() string {
+ return filepath.Join(f.fs.path, f.oldName())
+}
+
+func (f *file) name() string {
+ switch f.t {
+ case TypeManifest:
+ return fmt.Sprintf("MANIFEST-%06d", f.num)
+ case TypeJournal:
+ return fmt.Sprintf("%06d.log", f.num)
+ case TypeTable:
+ return fmt.Sprintf("%06d.ldb", f.num)
+ case TypeTemp:
+ return fmt.Sprintf("%06d.tmp", f.num)
+ default:
+ panic("invalid file type")
+ }
+}
+
+func (f *file) path() string {
+ return filepath.Join(f.fs.path, f.name())
+}
+
+func (f *file) parse(name string) bool {
+ var num uint64
+ var tail string
+ _, err := fmt.Sscanf(name, "%d.%s", &num, &tail)
+ if err == nil {
+ switch tail {
+ case "log":
+ f.t = TypeJournal
+ case "ldb", "sst":
+ f.t = TypeTable
+ case "tmp":
+ f.t = TypeTemp
+ default:
+ return false
+ }
+ f.num = num
+ return true
+ }
+ n, _ := fmt.Sscanf(name, "MANIFEST-%d%s", &num, &tail)
+ if n == 1 {
+ f.t = TypeManifest
+ f.num = num
+ return true
+ }
+
+ return false
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage_plan9.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage_plan9.go
new file mode 100644
index 0000000000000000000000000000000000000000..42940d769f8a88447e1b478fad3a5467af868245
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage_plan9.go
@@ -0,0 +1,52 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package storage
+
+import (
+ "os"
+ "path/filepath"
+)
+
+type plan9FileLock struct {
+ f *os.File
+}
+
+func (fl *plan9FileLock) release() error {
+ return fl.f.Close()
+}
+
+func newFileLock(path string) (fl fileLock, err error) {
+ f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, os.ModeExclusive|0644)
+ if err != nil {
+ return
+ }
+ fl = &plan9FileLock{f: f}
+ return
+}
+
+func rename(oldpath, newpath string) error {
+ if _, err := os.Stat(newpath); err == nil {
+ if err := os.Remove(newpath); err != nil {
+ return err
+ }
+ }
+
+ _, fname := filepath.Split(newpath)
+ return os.Rename(oldpath, fname)
+}
+
+func syncDir(name string) error {
+ f, err := os.Open(name)
+ if err != nil {
+ return err
+ }
+ defer f.Close()
+ if err := f.Sync(); err != nil {
+ return err
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage_solaris.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage_solaris.go
new file mode 100644
index 0000000000000000000000000000000000000000..102031bfd5455256384bf332bc221598162788fa
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage_solaris.go
@@ -0,0 +1,68 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// +build solaris
+
+package storage
+
+import (
+ "os"
+ "syscall"
+)
+
+type unixFileLock struct {
+ f *os.File
+}
+
+func (fl *unixFileLock) release() error {
+ if err := setFileLock(fl.f, false); err != nil {
+ return err
+ }
+ return fl.f.Close()
+}
+
+func newFileLock(path string) (fl fileLock, err error) {
+ f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0644)
+ if err != nil {
+ return
+ }
+ err = setFileLock(f, true)
+ if err != nil {
+ f.Close()
+ return
+ }
+ fl = &unixFileLock{f: f}
+ return
+}
+
+func setFileLock(f *os.File, lock bool) error {
+ flock := syscall.Flock_t{
+ Type: syscall.F_UNLCK,
+ Start: 0,
+ Len: 0,
+ Whence: 1,
+ }
+ if lock {
+ flock.Type = syscall.F_WRLCK
+ }
+ return syscall.FcntlFlock(f.Fd(), syscall.F_SETLK, &flock)
+}
+
+func rename(oldpath, newpath string) error {
+ return os.Rename(oldpath, newpath)
+}
+
+func syncDir(name string) error {
+ f, err := os.Open(name)
+ if err != nil {
+ return err
+ }
+ defer f.Close()
+ if err := f.Sync(); err != nil {
+ return err
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..92abcbb7d0c4ec2956ca240e983d7606b7d50645
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage_test.go
@@ -0,0 +1,142 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package storage
+
+import (
+ "fmt"
+ "os"
+ "path/filepath"
+ "testing"
+)
+
+var cases = []struct {
+ oldName []string
+ name string
+ ftype FileType
+ num uint64
+}{
+ {nil, "000100.log", TypeJournal, 100},
+ {nil, "000000.log", TypeJournal, 0},
+ {[]string{"000000.sst"}, "000000.ldb", TypeTable, 0},
+ {nil, "MANIFEST-000002", TypeManifest, 2},
+ {nil, "MANIFEST-000007", TypeManifest, 7},
+ {nil, "18446744073709551615.log", TypeJournal, 18446744073709551615},
+ {nil, "000100.tmp", TypeTemp, 100},
+}
+
+var invalidCases = []string{
+ "",
+ "foo",
+ "foo-dx-100.log",
+ ".log",
+ "",
+ "manifest",
+ "CURREN",
+ "CURRENTX",
+ "MANIFES",
+ "MANIFEST",
+ "MANIFEST-",
+ "XMANIFEST-3",
+ "MANIFEST-3x",
+ "LOC",
+ "LOCKx",
+ "LO",
+ "LOGx",
+ "18446744073709551616.log",
+ "184467440737095516150.log",
+ "100",
+ "100.",
+ "100.lop",
+}
+
+func TestFileStorage_CreateFileName(t *testing.T) {
+ for _, c := range cases {
+ f := &file{num: c.num, t: c.ftype}
+ if f.name() != c.name {
+ t.Errorf("invalid filename got '%s', want '%s'", f.name(), c.name)
+ }
+ }
+}
+
+func TestFileStorage_ParseFileName(t *testing.T) {
+ for _, c := range cases {
+ for _, name := range append([]string{c.name}, c.oldName...) {
+ f := new(file)
+ if !f.parse(name) {
+ t.Errorf("cannot parse filename '%s'", name)
+ continue
+ }
+ if f.Type() != c.ftype {
+ t.Errorf("filename '%s' invalid type got '%d', want '%d'", name, f.Type(), c.ftype)
+ }
+ if f.Num() != c.num {
+ t.Errorf("filename '%s' invalid number got '%d', want '%d'", name, f.Num(), c.num)
+ }
+ }
+ }
+}
+
+func TestFileStorage_InvalidFileName(t *testing.T) {
+ for _, name := range invalidCases {
+ f := new(file)
+ if f.parse(name) {
+ t.Errorf("filename '%s' should be invalid", name)
+ }
+ }
+}
+
+func TestFileStorage_Locking(t *testing.T) {
+ path := filepath.Join(os.TempDir(), fmt.Sprintf("goleveldbtestfd-%d", os.Getuid()))
+
+ _, err := os.Stat(path)
+ if err == nil {
+ err = os.RemoveAll(path)
+ if err != nil {
+ t.Fatal("RemoveAll: got error: ", err)
+ }
+ }
+
+ p1, err := OpenFile(path)
+ if err != nil {
+ t.Fatal("OpenFile(1): got error: ", err)
+ }
+
+ defer os.RemoveAll(path)
+
+ p2, err := OpenFile(path)
+ if err != nil {
+ t.Logf("OpenFile(2): got error: %s (expected)", err)
+ } else {
+ p2.Close()
+ p1.Close()
+ t.Fatal("OpenFile(2): expect error")
+ }
+
+ p1.Close()
+
+ p3, err := OpenFile(path)
+ if err != nil {
+ t.Fatal("OpenFile(3): got error: ", err)
+ }
+ defer p3.Close()
+
+ l, err := p3.Lock()
+ if err != nil {
+ t.Fatal("storage lock failed(1): ", err)
+ }
+ _, err = p3.Lock()
+ if err == nil {
+ t.Fatal("expect error for second storage lock attempt")
+ } else {
+ t.Logf("storage lock got error: %s (expected)", err)
+ }
+ l.Release()
+ _, err = p3.Lock()
+ if err != nil {
+ t.Fatal("storage lock failed(2): ", err)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage_unix.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage_unix.go
new file mode 100644
index 0000000000000000000000000000000000000000..d0a604b7ab4c646df9d57b466d0a2205e219e419
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage_unix.go
@@ -0,0 +1,63 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// +build darwin dragonfly freebsd linux netbsd openbsd
+
+package storage
+
+import (
+ "os"
+ "syscall"
+)
+
+type unixFileLock struct {
+ f *os.File
+}
+
+func (fl *unixFileLock) release() error {
+ if err := setFileLock(fl.f, false); err != nil {
+ return err
+ }
+ return fl.f.Close()
+}
+
+func newFileLock(path string) (fl fileLock, err error) {
+ f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0644)
+ if err != nil {
+ return
+ }
+ err = setFileLock(f, true)
+ if err != nil {
+ f.Close()
+ return
+ }
+ fl = &unixFileLock{f: f}
+ return
+}
+
+func setFileLock(f *os.File, lock bool) error {
+ how := syscall.LOCK_UN
+ if lock {
+ how = syscall.LOCK_EX
+ }
+ return syscall.Flock(int(f.Fd()), how|syscall.LOCK_NB)
+}
+
+func rename(oldpath, newpath string) error {
+ return os.Rename(oldpath, newpath)
+}
+
+func syncDir(name string) error {
+ f, err := os.Open(name)
+ if err != nil {
+ return err
+ }
+ defer f.Close()
+ if err := f.Sync(); err != nil {
+ return err
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage_windows.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage_windows.go
new file mode 100644
index 0000000000000000000000000000000000000000..50c3c454e7511bd182843bbb0a48b2bf947c7ac5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage_windows.go
@@ -0,0 +1,69 @@
+// Copyright (c) 2013, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package storage
+
+import (
+ "syscall"
+ "unsafe"
+)
+
+var (
+ modkernel32 = syscall.NewLazyDLL("kernel32.dll")
+
+ procMoveFileExW = modkernel32.NewProc("MoveFileExW")
+)
+
+const (
+ _MOVEFILE_REPLACE_EXISTING = 1
+)
+
+type windowsFileLock struct {
+ fd syscall.Handle
+}
+
+func (fl *windowsFileLock) release() error {
+ return syscall.Close(fl.fd)
+}
+
+func newFileLock(path string) (fl fileLock, err error) {
+ pathp, err := syscall.UTF16PtrFromString(path)
+ if err != nil {
+ return
+ }
+ fd, err := syscall.CreateFile(pathp, syscall.GENERIC_READ|syscall.GENERIC_WRITE, 0, nil, syscall.CREATE_ALWAYS, syscall.FILE_ATTRIBUTE_NORMAL, 0)
+ if err != nil {
+ return
+ }
+ fl = &windowsFileLock{fd: fd}
+ return
+}
+
+func moveFileEx(from *uint16, to *uint16, flags uint32) error {
+ r1, _, e1 := syscall.Syscall(procMoveFileExW.Addr(), 3, uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(to)), uintptr(flags))
+ if r1 == 0 {
+ if e1 != 0 {
+ return error(e1)
+ } else {
+ return syscall.EINVAL
+ }
+ }
+ return nil
+}
+
+func rename(oldpath, newpath string) error {
+ from, err := syscall.UTF16PtrFromString(oldpath)
+ if err != nil {
+ return err
+ }
+ to, err := syscall.UTF16PtrFromString(newpath)
+ if err != nil {
+ return err
+ }
+ return moveFileEx(from, to, _MOVEFILE_REPLACE_EXISTING)
+}
+
+func syncDir(name string) error { return nil }
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/mem_storage.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/mem_storage.go
new file mode 100644
index 0000000000000000000000000000000000000000..8952193112728a24485df4d5cfca73ebae92ca6d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/mem_storage.go
@@ -0,0 +1,203 @@
+// Copyright (c) 2013, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package storage
+
+import (
+ "bytes"
+ "os"
+ "sync"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+const typeShift = 3
+
+type memStorageLock struct {
+ ms *memStorage
+}
+
+func (lock *memStorageLock) Release() {
+ ms := lock.ms
+ ms.mu.Lock()
+ defer ms.mu.Unlock()
+ if ms.slock == lock {
+ ms.slock = nil
+ }
+ return
+}
+
+// memStorage is a memory-backed storage.
+type memStorage struct {
+ mu sync.Mutex
+ slock *memStorageLock
+ files map[uint64]*memFile
+ manifest *memFilePtr
+}
+
+// NewMemStorage returns a new memory-backed storage implementation.
+func NewMemStorage() Storage {
+ return &memStorage{
+ files: make(map[uint64]*memFile),
+ }
+}
+
+func (ms *memStorage) Lock() (util.Releaser, error) {
+ ms.mu.Lock()
+ defer ms.mu.Unlock()
+ if ms.slock != nil {
+ return nil, ErrLocked
+ }
+ ms.slock = &memStorageLock{ms: ms}
+ return ms.slock, nil
+}
+
+func (*memStorage) Log(str string) {}
+
+func (ms *memStorage) GetFile(num uint64, t FileType) File {
+ return &memFilePtr{ms: ms, num: num, t: t}
+}
+
+func (ms *memStorage) GetFiles(t FileType) ([]File, error) {
+ ms.mu.Lock()
+ var ff []File
+ for x, _ := range ms.files {
+ num, mt := x>>typeShift, FileType(x)&TypeAll
+ if mt&t == 0 {
+ continue
+ }
+ ff = append(ff, &memFilePtr{ms: ms, num: num, t: mt})
+ }
+ ms.mu.Unlock()
+ return ff, nil
+}
+
+func (ms *memStorage) GetManifest() (File, error) {
+ ms.mu.Lock()
+ defer ms.mu.Unlock()
+ if ms.manifest == nil {
+ return nil, os.ErrNotExist
+ }
+ return ms.manifest, nil
+}
+
+func (ms *memStorage) SetManifest(f File) error {
+ fm, ok := f.(*memFilePtr)
+ if !ok || fm.t != TypeManifest {
+ return ErrInvalidFile
+ }
+ ms.mu.Lock()
+ ms.manifest = fm
+ ms.mu.Unlock()
+ return nil
+}
+
+func (*memStorage) Close() error { return nil }
+
+type memReader struct {
+ *bytes.Reader
+ m *memFile
+}
+
+func (mr *memReader) Close() error {
+ return mr.m.Close()
+}
+
+type memFile struct {
+ bytes.Buffer
+ ms *memStorage
+ open bool
+}
+
+func (*memFile) Sync() error { return nil }
+func (m *memFile) Close() error {
+ m.ms.mu.Lock()
+ m.open = false
+ m.ms.mu.Unlock()
+ return nil
+}
+
+type memFilePtr struct {
+ ms *memStorage
+ num uint64
+ t FileType
+}
+
+func (p *memFilePtr) x() uint64 {
+ return p.Num()<<typeShift | uint64(p.Type())
+}
+
+func (p *memFilePtr) Open() (Reader, error) {
+ ms := p.ms
+ ms.mu.Lock()
+ defer ms.mu.Unlock()
+ if m, exist := ms.files[p.x()]; exist {
+ if m.open {
+ return nil, errFileOpen
+ }
+ m.open = true
+ return &memReader{Reader: bytes.NewReader(m.Bytes()), m: m}, nil
+ }
+ return nil, os.ErrNotExist
+}
+
+func (p *memFilePtr) Create() (Writer, error) {
+ ms := p.ms
+ ms.mu.Lock()
+ defer ms.mu.Unlock()
+ m, exist := ms.files[p.x()]
+ if exist {
+ if m.open {
+ return nil, errFileOpen
+ }
+ m.Reset()
+ } else {
+ m = &memFile{ms: ms}
+ ms.files[p.x()] = m
+ }
+ m.open = true
+ return m, nil
+}
+
+func (p *memFilePtr) Replace(newfile File) error {
+ p1, ok := newfile.(*memFilePtr)
+ if !ok {
+ return ErrInvalidFile
+ }
+ ms := p.ms
+ ms.mu.Lock()
+ defer ms.mu.Unlock()
+ m1, exist := ms.files[p1.x()]
+ if !exist {
+ return os.ErrNotExist
+ }
+ m0, exist := ms.files[p.x()]
+ if (exist && m0.open) || m1.open {
+ return errFileOpen
+ }
+ delete(ms.files, p1.x())
+ ms.files[p.x()] = m1
+ return nil
+}
+
+func (p *memFilePtr) Type() FileType {
+ return p.t
+}
+
+func (p *memFilePtr) Num() uint64 {
+ return p.num
+}
+
+func (p *memFilePtr) Remove() error {
+ ms := p.ms
+ ms.mu.Lock()
+ defer ms.mu.Unlock()
+ if _, exist := ms.files[p.x()]; exist {
+ delete(ms.files, p.x())
+ return nil
+ }
+ return os.ErrNotExist
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/mem_storage_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/mem_storage_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..23bb074b49a77b3d61f482d0aaf26237151dafef
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/mem_storage_test.go
@@ -0,0 +1,66 @@
+// Copyright (c) 2013, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package storage
+
+import (
+ "bytes"
+ "testing"
+)
+
+func TestMemStorage(t *testing.T) {
+ m := NewMemStorage()
+
+ l, err := m.Lock()
+ if err != nil {
+ t.Fatal("storage lock failed(1): ", err)
+ }
+ _, err = m.Lock()
+ if err == nil {
+ t.Fatal("expect error for second storage lock attempt")
+ } else {
+ t.Logf("storage lock got error: %s (expected)", err)
+ }
+ l.Release()
+ _, err = m.Lock()
+ if err != nil {
+ t.Fatal("storage lock failed(2): ", err)
+ }
+
+ f := m.GetFile(1, TypeTable)
+ if f.Num() != 1 && f.Type() != TypeTable {
+ t.Fatal("invalid file number and type")
+ }
+ w, _ := f.Create()
+ w.Write([]byte("abc"))
+ w.Close()
+ if ff, _ := m.GetFiles(TypeAll); len(ff) != 1 {
+ t.Fatal("invalid GetFiles len")
+ }
+ buf := new(bytes.Buffer)
+ r, err := f.Open()
+ if err != nil {
+ t.Fatal("Open: got error: ", err)
+ }
+ buf.ReadFrom(r)
+ r.Close()
+ if got := buf.String(); got != "abc" {
+ t.Fatalf("Read: invalid value, want=abc got=%s", got)
+ }
+ if _, err := f.Open(); err != nil {
+ t.Fatal("Open: got error: ", err)
+ }
+ if _, err := m.GetFile(1, TypeTable).Open(); err == nil {
+ t.Fatal("expecting error")
+ }
+ f.Remove()
+ if ff, _ := m.GetFiles(TypeAll); len(ff) != 0 {
+ t.Fatal("invalid GetFiles len", len(ff))
+ }
+ if _, err := f.Open(); err == nil {
+ t.Fatal("expecting error")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/storage.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/storage.go
new file mode 100644
index 0000000000000000000000000000000000000000..bdda8c447e241d497b6dfc41fa6812b26ae157e2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/storage.go
@@ -0,0 +1,157 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package storage provides storage abstraction for LevelDB.
+package storage
+
+import (
+ "errors"
+ "fmt"
+ "io"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type FileType uint32
+
+const (
+ TypeManifest FileType = 1 << iota
+ TypeJournal
+ TypeTable
+ TypeTemp
+
+ TypeAll = TypeManifest | TypeJournal | TypeTable | TypeTemp
+)
+
+func (t FileType) String() string {
+ switch t {
+ case TypeManifest:
+ return "manifest"
+ case TypeJournal:
+ return "journal"
+ case TypeTable:
+ return "table"
+ case TypeTemp:
+ return "temp"
+ }
+ return fmt.Sprintf("<unknown:%d>", t)
+}
+
+var (
+ ErrInvalidFile = errors.New("leveldb/storage: invalid file for argument")
+ ErrLocked = errors.New("leveldb/storage: already locked")
+ ErrClosed = errors.New("leveldb/storage: closed")
+)
+
+// Syncer is the interface that wraps basic Sync method.
+type Syncer interface {
+ // Sync commits the current contents of the file to stable storage.
+ Sync() error
+}
+
+// Reader is the interface that groups the basic Read, Seek, ReadAt and Close
+// methods.
+type Reader interface {
+ io.ReadSeeker
+ io.ReaderAt
+ io.Closer
+}
+
+// Writer is the interface that groups the basic Write, Sync and Close
+// methods.
+type Writer interface {
+ io.WriteCloser
+ Syncer
+}
+
+// File is the file. A file instance must be goroutine-safe.
+type File interface {
+ // Open opens the file for read. Returns os.ErrNotExist error
+ // if the file does not exist.
+ // Returns ErrClosed if the underlying storage is closed.
+ Open() (r Reader, err error)
+
+ // Create creates the file for writting. Truncate the file if
+ // already exist.
+ // Returns ErrClosed if the underlying storage is closed.
+ Create() (w Writer, err error)
+
+ // Replace replaces file with newfile.
+ // Returns ErrClosed if the underlying storage is closed.
+ Replace(newfile File) error
+
+ // Type returns the file type
+ Type() FileType
+
+ // Num returns the file number.
+ Num() uint64
+
+ // Remove removes the file.
+ // Returns ErrClosed if the underlying storage is closed.
+ Remove() error
+}
+
+// Storage is the storage. A storage instance must be goroutine-safe.
+type Storage interface {
+ // Lock locks the storage. Any subsequent attempt to call Lock will fail
+ // until the last lock released.
+ // After use the caller should call the Release method.
+ Lock() (l util.Releaser, err error)
+
+ // Log logs a string. This is used for logging. An implementation
+ // may write to a file, stdout or simply do nothing.
+ Log(str string)
+
+ // GetFile returns a file for the given number and type. GetFile will never
+ // returns nil, even if the underlying storage is closed.
+ GetFile(num uint64, t FileType) File
+
+ // GetFiles returns a slice of files that match the given file types.
+ // The file types may be OR'ed together.
+ GetFiles(t FileType) ([]File, error)
+
+ // GetManifest returns a manifest file. Returns os.ErrNotExist if manifest
+ // file does not exist.
+ GetManifest() (File, error)
+
+ // SetManifest sets the given file as manifest file. The given file should
+ // be a manifest file type or error will be returned.
+ SetManifest(f File) error
+
+ // Close closes the storage. It is valid to call Close multiple times.
+ // Other methods should not be called after the storage has been closed.
+ Close() error
+}
+
+// FileInfo wraps basic file info.
+type FileInfo struct {
+ Type FileType
+ Num uint64
+}
+
+func (fi FileInfo) String() string {
+ switch fi.Type {
+ case TypeManifest:
+ return fmt.Sprintf("MANIFEST-%06d", fi.Num)
+ case TypeJournal:
+ return fmt.Sprintf("%06d.log", fi.Num)
+ case TypeTable:
+ return fmt.Sprintf("%06d.ldb", fi.Num)
+ case TypeTemp:
+ return fmt.Sprintf("%06d.tmp", fi.Num)
+ default:
+ return fmt.Sprintf("%#x-%d", fi.Type, fi.Num)
+ }
+}
+
+// NewFileInfo creates new FileInfo from the given File. It will returns nil
+// if File is nil.
+func NewFileInfo(f File) *FileInfo {
+ if f == nil {
+ return nil
+ }
+ return &FileInfo{f.Type(), f.Num()}
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..a068113fd81ffef9cd6177a8468253f2bd3f9810
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage_test.go
@@ -0,0 +1,549 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENE file.
+
+package leveldb
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "math/rand"
+ "os"
+ "path/filepath"
+ "sync"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+const typeShift = 4
+
+var (
+ tsErrInvalidFile = errors.New("leveldb.testStorage: invalid file for argument")
+ tsErrFileOpen = errors.New("leveldb.testStorage: file still open")
+)
+
+var (
+ tsFSEnv = os.Getenv("GOLEVELDB_USEFS")
+ tsTempdir = os.Getenv("GOLEVELDB_TEMPDIR")
+ tsKeepFS = tsFSEnv == "2"
+ tsFS = tsKeepFS || tsFSEnv == "" || tsFSEnv == "1"
+ tsMU = &sync.Mutex{}
+ tsNum = 0
+)
+
+type tsOp uint
+
+const (
+ tsOpOpen tsOp = iota
+ tsOpCreate
+ tsOpReplace
+ tsOpRemove
+ tsOpRead
+ tsOpReadAt
+ tsOpWrite
+ tsOpSync
+
+ tsOpNum
+)
+
+type tsLock struct {
+ ts *testStorage
+ r util.Releaser
+}
+
+func (l tsLock) Release() {
+ l.r.Release()
+ l.ts.t.Log("I: storage lock released")
+}
+
+type tsReader struct {
+ tf tsFile
+ storage.Reader
+}
+
+func (tr tsReader) Read(b []byte) (n int, err error) {
+ ts := tr.tf.ts
+ ts.countRead(tr.tf.Type())
+ if tr.tf.shouldErrLocked(tsOpRead) {
+ return 0, errors.New("leveldb.testStorage: emulated read error")
+ }
+ n, err = tr.Reader.Read(b)
+ if err != nil && err != io.EOF {
+ ts.t.Errorf("E: read error, num=%d type=%v n=%d: %v", tr.tf.Num(), tr.tf.Type(), n, err)
+ }
+ return
+}
+
+func (tr tsReader) ReadAt(b []byte, off int64) (n int, err error) {
+ ts := tr.tf.ts
+ ts.countRead(tr.tf.Type())
+ if tr.tf.shouldErrLocked(tsOpReadAt) {
+ return 0, errors.New("leveldb.testStorage: emulated readAt error")
+ }
+ n, err = tr.Reader.ReadAt(b, off)
+ if err != nil && err != io.EOF {
+ ts.t.Errorf("E: readAt error, num=%d type=%v off=%d n=%d: %v", tr.tf.Num(), tr.tf.Type(), off, n, err)
+ }
+ return
+}
+
+func (tr tsReader) Close() (err error) {
+ err = tr.Reader.Close()
+ tr.tf.close("reader", err)
+ return
+}
+
+type tsWriter struct {
+ tf tsFile
+ storage.Writer
+}
+
+func (tw tsWriter) Write(b []byte) (n int, err error) {
+ if tw.tf.shouldErrLocked(tsOpWrite) {
+ return 0, errors.New("leveldb.testStorage: emulated write error")
+ }
+ n, err = tw.Writer.Write(b)
+ if err != nil {
+ tw.tf.ts.t.Errorf("E: write error, num=%d type=%v n=%d: %v", tw.tf.Num(), tw.tf.Type(), n, err)
+ }
+ return
+}
+
+func (tw tsWriter) Sync() (err error) {
+ ts := tw.tf.ts
+ ts.mu.Lock()
+ for ts.emuDelaySync&tw.tf.Type() != 0 {
+ ts.cond.Wait()
+ }
+ ts.mu.Unlock()
+ if tw.tf.shouldErrLocked(tsOpSync) {
+ return errors.New("leveldb.testStorage: emulated sync error")
+ }
+ err = tw.Writer.Sync()
+ if err != nil {
+ tw.tf.ts.t.Errorf("E: sync error, num=%d type=%v: %v", tw.tf.Num(), tw.tf.Type(), err)
+ }
+ return
+}
+
+func (tw tsWriter) Close() (err error) {
+ err = tw.Writer.Close()
+ tw.tf.close("writer", err)
+ return
+}
+
+type tsFile struct {
+ ts *testStorage
+ storage.File
+}
+
+func (tf tsFile) x() uint64 {
+ return tf.Num()<<typeShift | uint64(tf.Type())
+}
+
+func (tf tsFile) shouldErr(op tsOp) bool {
+ return tf.ts.shouldErr(tf, op)
+}
+
+func (tf tsFile) shouldErrLocked(op tsOp) bool {
+ tf.ts.mu.Lock()
+ defer tf.ts.mu.Unlock()
+ return tf.shouldErr(op)
+}
+
+func (tf tsFile) checkOpen(m string) error {
+ ts := tf.ts
+ if writer, ok := ts.opens[tf.x()]; ok {
+ if writer {
+ ts.t.Errorf("E: cannot %s file, num=%d type=%v: a writer still open", m, tf.Num(), tf.Type())
+ } else {
+ ts.t.Errorf("E: cannot %s file, num=%d type=%v: a reader still open", m, tf.Num(), tf.Type())
+ }
+ return tsErrFileOpen
+ }
+ return nil
+}
+
+func (tf tsFile) close(m string, err error) {
+ ts := tf.ts
+ ts.mu.Lock()
+ defer ts.mu.Unlock()
+ if _, ok := ts.opens[tf.x()]; !ok {
+ ts.t.Errorf("E: %s: redudant file closing, num=%d type=%v", m, tf.Num(), tf.Type())
+ } else if err == nil {
+ ts.t.Logf("I: %s: file closed, num=%d type=%v", m, tf.Num(), tf.Type())
+ }
+ delete(ts.opens, tf.x())
+ if err != nil {
+ ts.t.Errorf("E: %s: cannot close file, num=%d type=%v: %v", m, tf.Num(), tf.Type(), err)
+ }
+}
+
+func (tf tsFile) Open() (r storage.Reader, err error) {
+ ts := tf.ts
+ ts.mu.Lock()
+ defer ts.mu.Unlock()
+ err = tf.checkOpen("open")
+ if err != nil {
+ return
+ }
+ if tf.shouldErr(tsOpOpen) {
+ err = errors.New("leveldb.testStorage: emulated open error")
+ return
+ }
+ r, err = tf.File.Open()
+ if err != nil {
+ if ts.ignoreOpenErr&tf.Type() != 0 {
+ ts.t.Logf("I: cannot open file, num=%d type=%v: %v (ignored)", tf.Num(), tf.Type(), err)
+ } else {
+ ts.t.Errorf("E: cannot open file, num=%d type=%v: %v", tf.Num(), tf.Type(), err)
+ }
+ } else {
+ ts.t.Logf("I: file opened, num=%d type=%v", tf.Num(), tf.Type())
+ ts.opens[tf.x()] = false
+ r = tsReader{tf, r}
+ }
+ return
+}
+
+func (tf tsFile) Create() (w storage.Writer, err error) {
+ ts := tf.ts
+ ts.mu.Lock()
+ defer ts.mu.Unlock()
+ err = tf.checkOpen("create")
+ if err != nil {
+ return
+ }
+ if tf.shouldErr(tsOpCreate) {
+ err = errors.New("leveldb.testStorage: emulated create error")
+ return
+ }
+ w, err = tf.File.Create()
+ if err != nil {
+ ts.t.Errorf("E: cannot create file, num=%d type=%v: %v", tf.Num(), tf.Type(), err)
+ } else {
+ ts.t.Logf("I: file created, num=%d type=%v", tf.Num(), tf.Type())
+ ts.opens[tf.x()] = true
+ w = tsWriter{tf, w}
+ }
+ return
+}
+
+func (tf tsFile) Replace(newfile storage.File) (err error) {
+ ts := tf.ts
+ ts.mu.Lock()
+ defer ts.mu.Unlock()
+ err = tf.checkOpen("replace")
+ if err != nil {
+ return
+ }
+ if tf.shouldErr(tsOpReplace) {
+ err = errors.New("leveldb.testStorage: emulated create error")
+ return
+ }
+ err = tf.File.Replace(newfile.(tsFile).File)
+ if err != nil {
+ ts.t.Errorf("E: cannot replace file, num=%d type=%v: %v", tf.Num(), tf.Type(), err)
+ } else {
+ ts.t.Logf("I: file replace, num=%d type=%v", tf.Num(), tf.Type())
+ }
+ return
+}
+
+func (tf tsFile) Remove() (err error) {
+ ts := tf.ts
+ ts.mu.Lock()
+ defer ts.mu.Unlock()
+ err = tf.checkOpen("remove")
+ if err != nil {
+ return
+ }
+ if tf.shouldErr(tsOpRemove) {
+ err = errors.New("leveldb.testStorage: emulated create error")
+ return
+ }
+ err = tf.File.Remove()
+ if err != nil {
+ ts.t.Errorf("E: cannot remove file, num=%d type=%v: %v", tf.Num(), tf.Type(), err)
+ } else {
+ ts.t.Logf("I: file removed, num=%d type=%v", tf.Num(), tf.Type())
+ }
+ return
+}
+
+type testStorage struct {
+ t *testing.T
+ storage.Storage
+ closeFn func() error
+
+ mu sync.Mutex
+ cond sync.Cond
+ // Open files, true=writer, false=reader
+ opens map[uint64]bool
+ emuDelaySync storage.FileType
+ ignoreOpenErr storage.FileType
+ readCnt uint64
+ readCntEn storage.FileType
+
+ emuErr [tsOpNum]storage.FileType
+ emuErrOnce [tsOpNum]storage.FileType
+ emuRandErr [tsOpNum]storage.FileType
+ emuRandErrProb int
+ emuErrOnceMap map[uint64]uint
+ emuRandRand *rand.Rand
+}
+
+func (ts *testStorage) shouldErr(tf tsFile, op tsOp) bool {
+ if ts.emuErr[op]&tf.Type() != 0 {
+ return true
+ } else if ts.emuRandErr[op]&tf.Type() != 0 || ts.emuErrOnce[op]&tf.Type() != 0 {
+ sop := uint(1) << op
+ eop := ts.emuErrOnceMap[tf.x()]
+ if eop&sop == 0 && (ts.emuRandRand.Int()%ts.emuRandErrProb == 0 || ts.emuErrOnce[op]&tf.Type() != 0) {
+ ts.emuErrOnceMap[tf.x()] = eop | sop
+ ts.t.Logf("I: emulated error: file=%d type=%v op=%v", tf.Num(), tf.Type(), op)
+ return true
+ }
+ }
+ return false
+}
+
+func (ts *testStorage) SetEmuErr(t storage.FileType, ops ...tsOp) {
+ ts.mu.Lock()
+ for _, op := range ops {
+ ts.emuErr[op] = t
+ }
+ ts.mu.Unlock()
+}
+
+func (ts *testStorage) SetEmuErrOnce(t storage.FileType, ops ...tsOp) {
+ ts.mu.Lock()
+ for _, op := range ops {
+ ts.emuErrOnce[op] = t
+ }
+ ts.mu.Unlock()
+}
+
+func (ts *testStorage) SetEmuRandErr(t storage.FileType, ops ...tsOp) {
+ ts.mu.Lock()
+ for _, op := range ops {
+ ts.emuRandErr[op] = t
+ }
+ ts.mu.Unlock()
+}
+
+func (ts *testStorage) SetEmuRandErrProb(prob int) {
+ ts.mu.Lock()
+ ts.emuRandErrProb = prob
+ ts.mu.Unlock()
+}
+
+func (ts *testStorage) DelaySync(t storage.FileType) {
+ ts.mu.Lock()
+ ts.emuDelaySync |= t
+ ts.cond.Broadcast()
+ ts.mu.Unlock()
+}
+
+func (ts *testStorage) ReleaseSync(t storage.FileType) {
+ ts.mu.Lock()
+ ts.emuDelaySync &= ^t
+ ts.cond.Broadcast()
+ ts.mu.Unlock()
+}
+
+func (ts *testStorage) ReadCounter() uint64 {
+ ts.mu.Lock()
+ defer ts.mu.Unlock()
+ return ts.readCnt
+}
+
+func (ts *testStorage) ResetReadCounter() {
+ ts.mu.Lock()
+ ts.readCnt = 0
+ ts.mu.Unlock()
+}
+
+func (ts *testStorage) SetReadCounter(t storage.FileType) {
+ ts.mu.Lock()
+ ts.readCntEn = t
+ ts.mu.Unlock()
+}
+
+func (ts *testStorage) countRead(t storage.FileType) {
+ ts.mu.Lock()
+ if ts.readCntEn&t != 0 {
+ ts.readCnt++
+ }
+ ts.mu.Unlock()
+}
+
+func (ts *testStorage) SetIgnoreOpenErr(t storage.FileType) {
+ ts.ignoreOpenErr = t
+}
+
+func (ts *testStorage) Lock() (r util.Releaser, err error) {
+ r, err = ts.Storage.Lock()
+ if err != nil {
+ ts.t.Logf("W: storage locking failed: %v", err)
+ } else {
+ ts.t.Log("I: storage locked")
+ r = tsLock{ts, r}
+ }
+ return
+}
+
+func (ts *testStorage) Log(str string) {
+ ts.t.Log("L: " + str)
+ ts.Storage.Log(str)
+}
+
+func (ts *testStorage) GetFile(num uint64, t storage.FileType) storage.File {
+ return tsFile{ts, ts.Storage.GetFile(num, t)}
+}
+
+func (ts *testStorage) GetFiles(t storage.FileType) (ff []storage.File, err error) {
+ ff0, err := ts.Storage.GetFiles(t)
+ if err != nil {
+ ts.t.Errorf("E: get files failed: %v", err)
+ return
+ }
+ ff = make([]storage.File, len(ff0))
+ for i, f := range ff0 {
+ ff[i] = tsFile{ts, f}
+ }
+ ts.t.Logf("I: get files, type=0x%x count=%d", int(t), len(ff))
+ return
+}
+
+func (ts *testStorage) GetManifest() (f storage.File, err error) {
+ f0, err := ts.Storage.GetManifest()
+ if err != nil {
+ if !os.IsNotExist(err) {
+ ts.t.Errorf("E: get manifest failed: %v", err)
+ }
+ return
+ }
+ f = tsFile{ts, f0}
+ ts.t.Logf("I: get manifest, num=%d", f.Num())
+ return
+}
+
+func (ts *testStorage) SetManifest(f storage.File) error {
+ tf, ok := f.(tsFile)
+ if !ok {
+ ts.t.Error("E: set manifest failed: type assertion failed")
+ return tsErrInvalidFile
+ } else if tf.Type() != storage.TypeManifest {
+ ts.t.Errorf("E: set manifest failed: invalid file type: %s", tf.Type())
+ return tsErrInvalidFile
+ }
+ err := ts.Storage.SetManifest(tf.File)
+ if err != nil {
+ ts.t.Errorf("E: set manifest failed: %v", err)
+ } else {
+ ts.t.Logf("I: set manifest, num=%d", tf.Num())
+ }
+ return err
+}
+
+func (ts *testStorage) Close() error {
+ ts.CloseCheck()
+ err := ts.Storage.Close()
+ if err != nil {
+ ts.t.Errorf("E: closing storage failed: %v", err)
+ } else {
+ ts.t.Log("I: storage closed")
+ }
+ if ts.closeFn != nil {
+ if err := ts.closeFn(); err != nil {
+ ts.t.Errorf("E: close function: %v", err)
+ }
+ }
+ return err
+}
+
+func (ts *testStorage) CloseCheck() {
+ ts.mu.Lock()
+ if len(ts.opens) == 0 {
+ ts.t.Log("I: all files are closed")
+ } else {
+ ts.t.Errorf("E: %d files still open", len(ts.opens))
+ for x, writer := range ts.opens {
+ num, tt := x>>typeShift, storage.FileType(x)&storage.TypeAll
+ ts.t.Errorf("E: * num=%d type=%v writer=%v", num, tt, writer)
+ }
+ }
+ ts.mu.Unlock()
+}
+
+func newTestStorage(t *testing.T) *testStorage {
+ var stor storage.Storage
+ var closeFn func() error
+ if tsFS {
+ for {
+ tsMU.Lock()
+ num := tsNum
+ tsNum++
+ tsMU.Unlock()
+ tempdir := tsTempdir
+ if tempdir == "" {
+ tempdir = os.TempDir()
+ }
+ path := filepath.Join(tempdir, fmt.Sprintf("goleveldb-test%d0%d0%d", os.Getuid(), os.Getpid(), num))
+ if _, err := os.Stat(path); err != nil {
+ stor, err = storage.OpenFile(path)
+ if err != nil {
+ t.Fatalf("F: cannot create storage: %v", err)
+ }
+ t.Logf("I: storage created: %s", path)
+ closeFn = func() error {
+ for _, name := range []string{"LOG.old", "LOG"} {
+ f, err := os.Open(filepath.Join(path, name))
+ if err != nil {
+ continue
+ }
+ if log, err := ioutil.ReadAll(f); err != nil {
+ t.Logf("---------------------- %s ----------------------", name)
+ t.Logf("cannot read log: %v", err)
+ t.Logf("---------------------- %s ----------------------", name)
+ } else if len(log) > 0 {
+ t.Logf("---------------------- %s ----------------------\n%s", name, string(log))
+ t.Logf("---------------------- %s ----------------------", name)
+ }
+ f.Close()
+ }
+ if t.Failed() {
+ t.Logf("testing failed, test DB preserved at %s", path)
+ return nil
+ }
+ if tsKeepFS {
+ return nil
+ }
+ return os.RemoveAll(path)
+ }
+
+ break
+ }
+ }
+ } else {
+ stor = storage.NewMemStorage()
+ }
+ ts := &testStorage{
+ t: t,
+ Storage: stor,
+ closeFn: closeFn,
+ opens: make(map[uint64]bool),
+ emuErrOnceMap: make(map[uint64]uint),
+ emuRandErrProb: 0x999,
+ emuRandRand: rand.New(rand.NewSource(0xfacedead)),
+ }
+ ts.cond.L = &ts.mu
+ return ts
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table.go
new file mode 100644
index 0000000000000000000000000000000000000000..57fce1314b202eea9e06bcc473c385ad3aa2489d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table.go
@@ -0,0 +1,525 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "fmt"
+ "sort"
+ "sync/atomic"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+// tFile holds basic information about a table.
+type tFile struct {
+ file storage.File
+ seekLeft int32
+ size uint64
+ imin, imax iKey
+}
+
+// Returns true if given key is after largest key of this table.
+func (t *tFile) after(icmp *iComparer, ukey []byte) bool {
+ return ukey != nil && icmp.uCompare(ukey, t.imax.ukey()) > 0
+}
+
+// Returns true if given key is before smallest key of this table.
+func (t *tFile) before(icmp *iComparer, ukey []byte) bool {
+ return ukey != nil && icmp.uCompare(ukey, t.imin.ukey()) < 0
+}
+
+// Returns true if given key range overlaps with this table key range.
+func (t *tFile) overlaps(icmp *iComparer, umin, umax []byte) bool {
+ return !t.after(icmp, umin) && !t.before(icmp, umax)
+}
+
+// Cosumes one seek and return current seeks left.
+func (t *tFile) consumeSeek() int32 {
+ return atomic.AddInt32(&t.seekLeft, -1)
+}
+
+// Creates new tFile.
+func newTableFile(file storage.File, size uint64, imin, imax iKey) *tFile {
+ f := &tFile{
+ file: file,
+ size: size,
+ imin: imin,
+ imax: imax,
+ }
+
+ // We arrange to automatically compact this file after
+ // a certain number of seeks. Let's assume:
+ // (1) One seek costs 10ms
+ // (2) Writing or reading 1MB costs 10ms (100MB/s)
+ // (3) A compaction of 1MB does 25MB of IO:
+ // 1MB read from this level
+ // 10-12MB read from next level (boundaries may be misaligned)
+ // 10-12MB written to next level
+ // This implies that 25 seeks cost the same as the compaction
+ // of 1MB of data. I.e., one seek costs approximately the
+ // same as the compaction of 40KB of data. We are a little
+ // conservative and allow approximately one seek for every 16KB
+ // of data before triggering a compaction.
+ f.seekLeft = int32(size / 16384)
+ if f.seekLeft < 100 {
+ f.seekLeft = 100
+ }
+
+ return f
+}
+
+// tFiles hold multiple tFile.
+type tFiles []*tFile
+
+func (tf tFiles) Len() int { return len(tf) }
+func (tf tFiles) Swap(i, j int) { tf[i], tf[j] = tf[j], tf[i] }
+
+func (tf tFiles) nums() string {
+ x := "[ "
+ for i, f := range tf {
+ if i != 0 {
+ x += ", "
+ }
+ x += fmt.Sprint(f.file.Num())
+ }
+ x += " ]"
+ return x
+}
+
+// Returns true if i smallest key is less than j.
+// This used for sort by key in ascending order.
+func (tf tFiles) lessByKey(icmp *iComparer, i, j int) bool {
+ a, b := tf[i], tf[j]
+ n := icmp.Compare(a.imin, b.imin)
+ if n == 0 {
+ return a.file.Num() < b.file.Num()
+ }
+ return n < 0
+}
+
+// Returns true if i file number is greater than j.
+// This used for sort by file number in descending order.
+func (tf tFiles) lessByNum(i, j int) bool {
+ return tf[i].file.Num() > tf[j].file.Num()
+}
+
+// Sorts tables by key in ascending order.
+func (tf tFiles) sortByKey(icmp *iComparer) {
+ sort.Sort(&tFilesSortByKey{tFiles: tf, icmp: icmp})
+}
+
+// Sorts tables by file number in descending order.
+func (tf tFiles) sortByNum() {
+ sort.Sort(&tFilesSortByNum{tFiles: tf})
+}
+
+// Returns sum of all tables size.
+func (tf tFiles) size() (sum uint64) {
+ for _, t := range tf {
+ sum += t.size
+ }
+ return sum
+}
+
+// Searches smallest index of tables whose its smallest
+// key is after or equal with given key.
+func (tf tFiles) searchMin(icmp *iComparer, ikey iKey) int {
+ return sort.Search(len(tf), func(i int) bool {
+ return icmp.Compare(tf[i].imin, ikey) >= 0
+ })
+}
+
+// Searches smallest index of tables whose its largest
+// key is after or equal with given key.
+func (tf tFiles) searchMax(icmp *iComparer, ikey iKey) int {
+ return sort.Search(len(tf), func(i int) bool {
+ return icmp.Compare(tf[i].imax, ikey) >= 0
+ })
+}
+
+// Returns true if given key range overlaps with one or more
+// tables key range. If unsorted is true then binary search will not be used.
+func (tf tFiles) overlaps(icmp *iComparer, umin, umax []byte, unsorted bool) bool {
+ if unsorted {
+ // Check against all files.
+ for _, t := range tf {
+ if t.overlaps(icmp, umin, umax) {
+ return true
+ }
+ }
+ return false
+ }
+
+ i := 0
+ if len(umin) > 0 {
+ // Find the earliest possible internal key for min.
+ i = tf.searchMax(icmp, newIkey(umin, kMaxSeq, ktSeek))
+ }
+ if i >= len(tf) {
+ // Beginning of range is after all files, so no overlap.
+ return false
+ }
+ return !tf[i].before(icmp, umax)
+}
+
+// Returns tables whose its key range overlaps with given key range.
+// Range will be expanded if ukey found hop across tables.
+// If overlapped is true then the search will be restarted if umax
+// expanded.
+// The dst content will be overwritten.
+func (tf tFiles) getOverlaps(dst tFiles, icmp *iComparer, umin, umax []byte, overlapped bool) tFiles {
+ dst = dst[:0]
+ for i := 0; i < len(tf); {
+ t := tf[i]
+ if t.overlaps(icmp, umin, umax) {
+ if umin != nil && icmp.uCompare(t.imin.ukey(), umin) < 0 {
+ umin = t.imin.ukey()
+ dst = dst[:0]
+ i = 0
+ continue
+ } else if umax != nil && icmp.uCompare(t.imax.ukey(), umax) > 0 {
+ umax = t.imax.ukey()
+ // Restart search if it is overlapped.
+ if overlapped {
+ dst = dst[:0]
+ i = 0
+ continue
+ }
+ }
+
+ dst = append(dst, t)
+ }
+ i++
+ }
+
+ return dst
+}
+
+// Returns tables key range.
+func (tf tFiles) getRange(icmp *iComparer) (imin, imax iKey) {
+ for i, t := range tf {
+ if i == 0 {
+ imin, imax = t.imin, t.imax
+ continue
+ }
+ if icmp.Compare(t.imin, imin) < 0 {
+ imin = t.imin
+ }
+ if icmp.Compare(t.imax, imax) > 0 {
+ imax = t.imax
+ }
+ }
+
+ return
+}
+
+// Creates iterator index from tables.
+func (tf tFiles) newIndexIterator(tops *tOps, icmp *iComparer, slice *util.Range, ro *opt.ReadOptions) iterator.IteratorIndexer {
+ if slice != nil {
+ var start, limit int
+ if slice.Start != nil {
+ start = tf.searchMax(icmp, iKey(slice.Start))
+ }
+ if slice.Limit != nil {
+ limit = tf.searchMin(icmp, iKey(slice.Limit))
+ } else {
+ limit = tf.Len()
+ }
+ tf = tf[start:limit]
+ }
+ return iterator.NewArrayIndexer(&tFilesArrayIndexer{
+ tFiles: tf,
+ tops: tops,
+ icmp: icmp,
+ slice: slice,
+ ro: ro,
+ })
+}
+
+// Tables iterator index.
+type tFilesArrayIndexer struct {
+ tFiles
+ tops *tOps
+ icmp *iComparer
+ slice *util.Range
+ ro *opt.ReadOptions
+}
+
+func (a *tFilesArrayIndexer) Search(key []byte) int {
+ return a.searchMax(a.icmp, iKey(key))
+}
+
+func (a *tFilesArrayIndexer) Get(i int) iterator.Iterator {
+ if i == 0 || i == a.Len()-1 {
+ return a.tops.newIterator(a.tFiles[i], a.slice, a.ro)
+ }
+ return a.tops.newIterator(a.tFiles[i], nil, a.ro)
+}
+
+// Helper type for sortByKey.
+type tFilesSortByKey struct {
+ tFiles
+ icmp *iComparer
+}
+
+func (x *tFilesSortByKey) Less(i, j int) bool {
+ return x.lessByKey(x.icmp, i, j)
+}
+
+// Helper type for sortByNum.
+type tFilesSortByNum struct {
+ tFiles
+}
+
+func (x *tFilesSortByNum) Less(i, j int) bool {
+ return x.lessByNum(i, j)
+}
+
+// Table operations.
+type tOps struct {
+ s *session
+ cache *cache.Cache
+ bcache *cache.Cache
+ bpool *util.BufferPool
+}
+
+// Creates an empty table and returns table writer.
+func (t *tOps) create() (*tWriter, error) {
+ file := t.s.getTableFile(t.s.allocFileNum())
+ fw, err := file.Create()
+ if err != nil {
+ return nil, err
+ }
+ return &tWriter{
+ t: t,
+ file: file,
+ w: fw,
+ tw: table.NewWriter(fw, t.s.o.Options),
+ }, nil
+}
+
+// Builds table from src iterator.
+func (t *tOps) createFrom(src iterator.Iterator) (f *tFile, n int, err error) {
+ w, err := t.create()
+ if err != nil {
+ return
+ }
+
+ defer func() {
+ if err != nil {
+ w.drop()
+ }
+ }()
+
+ for src.Next() {
+ err = w.append(src.Key(), src.Value())
+ if err != nil {
+ return
+ }
+ }
+ err = src.Error()
+ if err != nil {
+ return
+ }
+
+ n = w.tw.EntriesLen()
+ f, err = w.finish()
+ return
+}
+
+// Opens table. It returns a cache handle, which should
+// be released after use.
+func (t *tOps) open(f *tFile) (ch *cache.Handle, err error) {
+ num := f.file.Num()
+ ch = t.cache.Get(0, num, func() (size int, value cache.Value) {
+ var r storage.Reader
+ r, err = f.file.Open()
+ if err != nil {
+ return 0, nil
+ }
+
+ var bcache *cache.CacheGetter
+ if t.bcache != nil {
+ bcache = &cache.CacheGetter{Cache: t.bcache, NS: num}
+ }
+
+ var tr *table.Reader
+ tr, err = table.NewReader(r, int64(f.size), storage.NewFileInfo(f.file), bcache, t.bpool, t.s.o.Options)
+ if err != nil {
+ r.Close()
+ return 0, nil
+ }
+ return 1, tr
+
+ })
+ if ch == nil && err == nil {
+ err = ErrClosed
+ }
+ return
+}
+
+// Finds key/value pair whose key is greater than or equal to the
+// given key.
+func (t *tOps) find(f *tFile, key []byte, ro *opt.ReadOptions) (rkey, rvalue []byte, err error) {
+ ch, err := t.open(f)
+ if err != nil {
+ return nil, nil, err
+ }
+ defer ch.Release()
+ return ch.Value().(*table.Reader).Find(key, true, ro)
+}
+
+// Finds key that is greater than or equal to the given key.
+func (t *tOps) findKey(f *tFile, key []byte, ro *opt.ReadOptions) (rkey []byte, err error) {
+ ch, err := t.open(f)
+ if err != nil {
+ return nil, err
+ }
+ defer ch.Release()
+ return ch.Value().(*table.Reader).FindKey(key, true, ro)
+}
+
+// Returns approximate offset of the given key.
+func (t *tOps) offsetOf(f *tFile, key []byte) (offset uint64, err error) {
+ ch, err := t.open(f)
+ if err != nil {
+ return
+ }
+ defer ch.Release()
+ offset_, err := ch.Value().(*table.Reader).OffsetOf(key)
+ return uint64(offset_), err
+}
+
+// Creates an iterator from the given table.
+func (t *tOps) newIterator(f *tFile, slice *util.Range, ro *opt.ReadOptions) iterator.Iterator {
+ ch, err := t.open(f)
+ if err != nil {
+ return iterator.NewEmptyIterator(err)
+ }
+ iter := ch.Value().(*table.Reader).NewIterator(slice, ro)
+ iter.SetReleaser(ch)
+ return iter
+}
+
+// Removes table from persistent storage. It waits until
+// no one use the the table.
+func (t *tOps) remove(f *tFile) {
+ num := f.file.Num()
+ t.cache.Delete(0, num, func() {
+ if err := f.file.Remove(); err != nil {
+ t.s.logf("table@remove removing @%d %q", num, err)
+ } else {
+ t.s.logf("table@remove removed @%d", num)
+ }
+ if t.bcache != nil {
+ t.bcache.EvictNS(num)
+ }
+ })
+}
+
+// Closes the table ops instance. It will close all tables,
+// regadless still used or not.
+func (t *tOps) close() {
+ t.bpool.Close()
+ t.cache.Close()
+ if t.bcache != nil {
+ t.bcache.Close()
+ }
+}
+
+// Creates new initialized table ops instance.
+func newTableOps(s *session) *tOps {
+ var (
+ cacher cache.Cacher
+ bcache *cache.Cache
+ bpool *util.BufferPool
+ )
+ if s.o.GetOpenFilesCacheCapacity() > 0 {
+ cacher = cache.NewLRU(s.o.GetOpenFilesCacheCapacity())
+ }
+ if !s.o.GetDisableBlockCache() {
+ var bcacher cache.Cacher
+ if s.o.GetBlockCacheCapacity() > 0 {
+ bcacher = cache.NewLRU(s.o.GetBlockCacheCapacity())
+ }
+ bcache = cache.NewCache(bcacher)
+ }
+ if !s.o.GetDisableBufferPool() {
+ bpool = util.NewBufferPool(s.o.GetBlockSize() + 5)
+ }
+ return &tOps{
+ s: s,
+ cache: cache.NewCache(cacher),
+ bcache: bcache,
+ bpool: bpool,
+ }
+}
+
+// tWriter wraps the table writer. It keep track of file descriptor
+// and added key range.
+type tWriter struct {
+ t *tOps
+
+ file storage.File
+ w storage.Writer
+ tw *table.Writer
+
+ first, last []byte
+}
+
+// Append key/value pair to the table.
+func (w *tWriter) append(key, value []byte) error {
+ if w.first == nil {
+ w.first = append([]byte{}, key...)
+ }
+ w.last = append(w.last[:0], key...)
+ return w.tw.Append(key, value)
+}
+
+// Returns true if the table is empty.
+func (w *tWriter) empty() bool {
+ return w.first == nil
+}
+
+// Closes the storage.Writer.
+func (w *tWriter) close() {
+ if w.w != nil {
+ w.w.Close()
+ w.w = nil
+ }
+}
+
+// Finalizes the table and returns table file.
+func (w *tWriter) finish() (f *tFile, err error) {
+ defer w.close()
+ err = w.tw.Close()
+ if err != nil {
+ return
+ }
+ err = w.w.Sync()
+ if err != nil {
+ return
+ }
+ f = newTableFile(w.file, uint64(w.tw.BytesLen()), iKey(w.first), iKey(w.last))
+ return
+}
+
+// Drops the table.
+func (w *tWriter) drop() {
+ w.close()
+ w.file.Remove()
+ w.t.s.reuseFileNum(w.file.Num())
+ w.file = nil
+ w.tw = nil
+ w.first = nil
+ w.last = nil
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/block_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/block_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..a8580cf324784e3d1122680de1e26477db26a4f2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/block_test.go
@@ -0,0 +1,139 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package table
+
+import (
+ "encoding/binary"
+ "fmt"
+
+ . "github.com/onsi/ginkgo"
+ . "github.com/onsi/gomega"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type blockTesting struct {
+ tr *Reader
+ b *block
+}
+
+func (t *blockTesting) TestNewIterator(slice *util.Range) iterator.Iterator {
+ return t.tr.newBlockIter(t.b, nil, slice, false)
+}
+
+var _ = testutil.Defer(func() {
+ Describe("Block", func() {
+ Build := func(kv *testutil.KeyValue, restartInterval int) *blockTesting {
+ // Building the block.
+ bw := &blockWriter{
+ restartInterval: restartInterval,
+ scratch: make([]byte, 30),
+ }
+ kv.Iterate(func(i int, key, value []byte) {
+ bw.append(key, value)
+ })
+ bw.finish()
+
+ // Opening the block.
+ data := bw.buf.Bytes()
+ restartsLen := int(binary.LittleEndian.Uint32(data[len(data)-4:]))
+ return &blockTesting{
+ tr: &Reader{cmp: comparer.DefaultComparer},
+ b: &block{
+ data: data,
+ restartsLen: restartsLen,
+ restartsOffset: len(data) - (restartsLen+1)*4,
+ },
+ }
+ }
+
+ Describe("read test", func() {
+ for restartInterval := 1; restartInterval <= 5; restartInterval++ {
+ Describe(fmt.Sprintf("with restart interval of %d", restartInterval), func() {
+ kv := &testutil.KeyValue{}
+ Text := func() string {
+ return fmt.Sprintf("and %d keys", kv.Len())
+ }
+
+ Test := func() {
+ // Make block.
+ br := Build(kv, restartInterval)
+ // Do testing.
+ testutil.KeyValueTesting(nil, kv.Clone(), br, nil, nil)
+ }
+
+ Describe(Text(), Test)
+
+ kv.PutString("", "empty")
+ Describe(Text(), Test)
+
+ kv.PutString("a1", "foo")
+ Describe(Text(), Test)
+
+ kv.PutString("a2", "v")
+ Describe(Text(), Test)
+
+ kv.PutString("a3qqwrkks", "hello")
+ Describe(Text(), Test)
+
+ kv.PutString("a4", "bar")
+ Describe(Text(), Test)
+
+ kv.PutString("a5111111", "v5")
+ kv.PutString("a6", "")
+ kv.PutString("a7", "v7")
+ kv.PutString("a8", "vvvvvvvvvvvvvvvvvvvvvv8")
+ kv.PutString("b", "v9")
+ kv.PutString("c9", "v9")
+ kv.PutString("c91", "v9")
+ kv.PutString("d0", "v9")
+ Describe(Text(), Test)
+ })
+ }
+ })
+
+ Describe("out-of-bound slice test", func() {
+ kv := &testutil.KeyValue{}
+ kv.PutString("k1", "v1")
+ kv.PutString("k2", "v2")
+ kv.PutString("k3abcdefgg", "v3")
+ kv.PutString("k4", "v4")
+ kv.PutString("k5", "v5")
+ for restartInterval := 1; restartInterval <= 5; restartInterval++ {
+ Describe(fmt.Sprintf("with restart interval of %d", restartInterval), func() {
+ // Make block.
+ bt := Build(kv, restartInterval)
+
+ Test := func(r *util.Range) func(done Done) {
+ return func(done Done) {
+ iter := bt.TestNewIterator(r)
+ Expect(iter.Error()).ShouldNot(HaveOccurred())
+
+ t := testutil.IteratorTesting{
+ KeyValue: kv.Clone(),
+ Iter: iter,
+ }
+
+ testutil.DoIteratorTesting(&t)
+ iter.Release()
+ done <- true
+ }
+ }
+
+ It("Should do iterations and seeks correctly #0",
+ Test(&util.Range{Start: []byte("k0"), Limit: []byte("k6")}), 2.0)
+
+ It("Should do iterations and seeks correctly #1",
+ Test(&util.Range{Start: []byte(""), Limit: []byte("zzzzzzz")}), 2.0)
+ })
+ }
+ })
+ })
+})
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/reader.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/reader.go
new file mode 100644
index 0000000000000000000000000000000000000000..1bfc3978768c2126690c6aa9f707532539e1a8f0
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/reader.go
@@ -0,0 +1,1107 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package table
+
+import (
+ "encoding/binary"
+ "fmt"
+ "io"
+ "sort"
+ "strings"
+ "sync"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+var (
+ ErrNotFound = errors.ErrNotFound
+ ErrReaderReleased = errors.New("leveldb/table: reader released")
+ ErrIterReleased = errors.New("leveldb/table: iterator released")
+)
+
+type ErrCorrupted struct {
+ Pos int64
+ Size int64
+ Kind string
+ Reason string
+}
+
+func (e *ErrCorrupted) Error() string {
+ return fmt.Sprintf("leveldb/table: corruption on %s (pos=%d): %s", e.Kind, e.Pos, e.Reason)
+}
+
+func max(x, y int) int {
+ if x > y {
+ return x
+ }
+ return y
+}
+
+type block struct {
+ bpool *util.BufferPool
+ bh blockHandle
+ data []byte
+ restartsLen int
+ restartsOffset int
+}
+
+func (b *block) seek(cmp comparer.Comparer, rstart, rlimit int, key []byte) (index, offset int, err error) {
+ index = sort.Search(b.restartsLen-rstart-(b.restartsLen-rlimit), func(i int) bool {
+ offset := int(binary.LittleEndian.Uint32(b.data[b.restartsOffset+4*(rstart+i):]))
+ offset += 1 // shared always zero, since this is a restart point
+ v1, n1 := binary.Uvarint(b.data[offset:]) // key length
+ _, n2 := binary.Uvarint(b.data[offset+n1:]) // value length
+ m := offset + n1 + n2
+ return cmp.Compare(b.data[m:m+int(v1)], key) > 0
+ }) + rstart - 1
+ if index < rstart {
+ // The smallest key is greater-than key sought.
+ index = rstart
+ }
+ offset = int(binary.LittleEndian.Uint32(b.data[b.restartsOffset+4*index:]))
+ return
+}
+
+func (b *block) restartIndex(rstart, rlimit, offset int) int {
+ return sort.Search(b.restartsLen-rstart-(b.restartsLen-rlimit), func(i int) bool {
+ return int(binary.LittleEndian.Uint32(b.data[b.restartsOffset+4*(rstart+i):])) > offset
+ }) + rstart - 1
+}
+
+func (b *block) restartOffset(index int) int {
+ return int(binary.LittleEndian.Uint32(b.data[b.restartsOffset+4*index:]))
+}
+
+func (b *block) entry(offset int) (key, value []byte, nShared, n int, err error) {
+ if offset >= b.restartsOffset {
+ if offset != b.restartsOffset {
+ err = &ErrCorrupted{Reason: "entries offset not aligned"}
+ }
+ return
+ }
+ v0, n0 := binary.Uvarint(b.data[offset:]) // Shared prefix length
+ v1, n1 := binary.Uvarint(b.data[offset+n0:]) // Key length
+ v2, n2 := binary.Uvarint(b.data[offset+n0+n1:]) // Value length
+ m := n0 + n1 + n2
+ n = m + int(v1) + int(v2)
+ if n0 <= 0 || n1 <= 0 || n2 <= 0 || offset+n > b.restartsOffset {
+ err = &ErrCorrupted{Reason: "entries corrupted"}
+ return
+ }
+ key = b.data[offset+m : offset+m+int(v1)]
+ value = b.data[offset+m+int(v1) : offset+n]
+ nShared = int(v0)
+ return
+}
+
+func (b *block) Release() {
+ b.bpool.Put(b.data)
+ b.bpool = nil
+ b.data = nil
+}
+
+type dir int
+
+const (
+ dirReleased dir = iota - 1
+ dirSOI
+ dirEOI
+ dirBackward
+ dirForward
+)
+
+type blockIter struct {
+ tr *Reader
+ block *block
+ blockReleaser util.Releaser
+ releaser util.Releaser
+ key, value []byte
+ offset int
+ // Previous offset, only filled by Next.
+ prevOffset int
+ prevNode []int
+ prevKeys []byte
+ restartIndex int
+ // Iterator direction.
+ dir dir
+ // Restart index slice range.
+ riStart int
+ riLimit int
+ // Offset slice range.
+ offsetStart int
+ offsetRealStart int
+ offsetLimit int
+ // Error.
+ err error
+}
+
+func (i *blockIter) sErr(err error) {
+ i.err = err
+ i.key = nil
+ i.value = nil
+ i.prevNode = nil
+ i.prevKeys = nil
+}
+
+func (i *blockIter) reset() {
+ if i.dir == dirBackward {
+ i.prevNode = i.prevNode[:0]
+ i.prevKeys = i.prevKeys[:0]
+ }
+ i.restartIndex = i.riStart
+ i.offset = i.offsetStart
+ i.dir = dirSOI
+ i.key = i.key[:0]
+ i.value = nil
+}
+
+func (i *blockIter) isFirst() bool {
+ switch i.dir {
+ case dirForward:
+ return i.prevOffset == i.offsetRealStart
+ case dirBackward:
+ return len(i.prevNode) == 1 && i.restartIndex == i.riStart
+ }
+ return false
+}
+
+func (i *blockIter) isLast() bool {
+ switch i.dir {
+ case dirForward, dirBackward:
+ return i.offset == i.offsetLimit
+ }
+ return false
+}
+
+func (i *blockIter) First() bool {
+ if i.err != nil {
+ return false
+ } else if i.dir == dirReleased {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ if i.dir == dirBackward {
+ i.prevNode = i.prevNode[:0]
+ i.prevKeys = i.prevKeys[:0]
+ }
+ i.dir = dirSOI
+ return i.Next()
+}
+
+func (i *blockIter) Last() bool {
+ if i.err != nil {
+ return false
+ } else if i.dir == dirReleased {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ if i.dir == dirBackward {
+ i.prevNode = i.prevNode[:0]
+ i.prevKeys = i.prevKeys[:0]
+ }
+ i.dir = dirEOI
+ return i.Prev()
+}
+
+func (i *blockIter) Seek(key []byte) bool {
+ if i.err != nil {
+ return false
+ } else if i.dir == dirReleased {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ ri, offset, err := i.block.seek(i.tr.cmp, i.riStart, i.riLimit, key)
+ if err != nil {
+ i.sErr(err)
+ return false
+ }
+ i.restartIndex = ri
+ i.offset = max(i.offsetStart, offset)
+ if i.dir == dirSOI || i.dir == dirEOI {
+ i.dir = dirForward
+ }
+ for i.Next() {
+ if i.tr.cmp.Compare(i.key, key) >= 0 {
+ return true
+ }
+ }
+ return false
+}
+
+func (i *blockIter) Next() bool {
+ if i.dir == dirEOI || i.err != nil {
+ return false
+ } else if i.dir == dirReleased {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ if i.dir == dirSOI {
+ i.restartIndex = i.riStart
+ i.offset = i.offsetStart
+ } else if i.dir == dirBackward {
+ i.prevNode = i.prevNode[:0]
+ i.prevKeys = i.prevKeys[:0]
+ }
+ for i.offset < i.offsetRealStart {
+ key, value, nShared, n, err := i.block.entry(i.offset)
+ if err != nil {
+ i.sErr(i.tr.fixErrCorruptedBH(i.block.bh, err))
+ return false
+ }
+ if n == 0 {
+ i.dir = dirEOI
+ return false
+ }
+ i.key = append(i.key[:nShared], key...)
+ i.value = value
+ i.offset += n
+ }
+ if i.offset >= i.offsetLimit {
+ i.dir = dirEOI
+ if i.offset != i.offsetLimit {
+ i.sErr(i.tr.newErrCorruptedBH(i.block.bh, "entries offset not aligned"))
+ }
+ return false
+ }
+ key, value, nShared, n, err := i.block.entry(i.offset)
+ if err != nil {
+ i.sErr(i.tr.fixErrCorruptedBH(i.block.bh, err))
+ return false
+ }
+ if n == 0 {
+ i.dir = dirEOI
+ return false
+ }
+ i.key = append(i.key[:nShared], key...)
+ i.value = value
+ i.prevOffset = i.offset
+ i.offset += n
+ i.dir = dirForward
+ return true
+}
+
+func (i *blockIter) Prev() bool {
+ if i.dir == dirSOI || i.err != nil {
+ return false
+ } else if i.dir == dirReleased {
+ i.err = ErrIterReleased
+ return false
+ }
+
+ var ri int
+ if i.dir == dirForward {
+ // Change direction.
+ i.offset = i.prevOffset
+ if i.offset == i.offsetRealStart {
+ i.dir = dirSOI
+ return false
+ }
+ ri = i.block.restartIndex(i.restartIndex, i.riLimit, i.offset)
+ i.dir = dirBackward
+ } else if i.dir == dirEOI {
+ // At the end of iterator.
+ i.restartIndex = i.riLimit
+ i.offset = i.offsetLimit
+ if i.offset == i.offsetRealStart {
+ i.dir = dirSOI
+ return false
+ }
+ ri = i.riLimit - 1
+ i.dir = dirBackward
+ } else if len(i.prevNode) == 1 {
+ // This is the end of a restart range.
+ i.offset = i.prevNode[0]
+ i.prevNode = i.prevNode[:0]
+ if i.restartIndex == i.riStart {
+ i.dir = dirSOI
+ return false
+ }
+ i.restartIndex--
+ ri = i.restartIndex
+ } else {
+ // In the middle of restart range, get from cache.
+ n := len(i.prevNode) - 3
+ node := i.prevNode[n:]
+ i.prevNode = i.prevNode[:n]
+ // Get the key.
+ ko := node[0]
+ i.key = append(i.key[:0], i.prevKeys[ko:]...)
+ i.prevKeys = i.prevKeys[:ko]
+ // Get the value.
+ vo := node[1]
+ vl := vo + node[2]
+ i.value = i.block.data[vo:vl]
+ i.offset = vl
+ return true
+ }
+ // Build entries cache.
+ i.key = i.key[:0]
+ i.value = nil
+ offset := i.block.restartOffset(ri)
+ if offset == i.offset {
+ ri -= 1
+ if ri < 0 {
+ i.dir = dirSOI
+ return false
+ }
+ offset = i.block.restartOffset(ri)
+ }
+ i.prevNode = append(i.prevNode, offset)
+ for {
+ key, value, nShared, n, err := i.block.entry(offset)
+ if err != nil {
+ i.sErr(i.tr.fixErrCorruptedBH(i.block.bh, err))
+ return false
+ }
+ if offset >= i.offsetRealStart {
+ if i.value != nil {
+ // Appends 3 variables:
+ // 1. Previous keys offset
+ // 2. Value offset in the data block
+ // 3. Value length
+ i.prevNode = append(i.prevNode, len(i.prevKeys), offset-len(i.value), len(i.value))
+ i.prevKeys = append(i.prevKeys, i.key...)
+ }
+ i.value = value
+ }
+ i.key = append(i.key[:nShared], key...)
+ offset += n
+ // Stop if target offset reached.
+ if offset >= i.offset {
+ if offset != i.offset {
+ i.sErr(i.tr.newErrCorruptedBH(i.block.bh, "entries offset not aligned"))
+ return false
+ }
+
+ break
+ }
+ }
+ i.restartIndex = ri
+ i.offset = offset
+ return true
+}
+
+func (i *blockIter) Key() []byte {
+ if i.err != nil || i.dir <= dirEOI {
+ return nil
+ }
+ return i.key
+}
+
+func (i *blockIter) Value() []byte {
+ if i.err != nil || i.dir <= dirEOI {
+ return nil
+ }
+ return i.value
+}
+
+func (i *blockIter) Release() {
+ if i.dir != dirReleased {
+ i.tr = nil
+ i.block = nil
+ i.prevNode = nil
+ i.prevKeys = nil
+ i.key = nil
+ i.value = nil
+ i.dir = dirReleased
+ if i.blockReleaser != nil {
+ i.blockReleaser.Release()
+ i.blockReleaser = nil
+ }
+ if i.releaser != nil {
+ i.releaser.Release()
+ i.releaser = nil
+ }
+ }
+}
+
+func (i *blockIter) SetReleaser(releaser util.Releaser) {
+ if i.dir == dirReleased {
+ panic(util.ErrReleased)
+ }
+ if i.releaser != nil && releaser != nil {
+ panic(util.ErrHasReleaser)
+ }
+ i.releaser = releaser
+}
+
+func (i *blockIter) Valid() bool {
+ return i.err == nil && (i.dir == dirBackward || i.dir == dirForward)
+}
+
+func (i *blockIter) Error() error {
+ return i.err
+}
+
+type filterBlock struct {
+ bpool *util.BufferPool
+ data []byte
+ oOffset int
+ baseLg uint
+ filtersNum int
+}
+
+func (b *filterBlock) contains(filter filter.Filter, offset uint64, key []byte) bool {
+ i := int(offset >> b.baseLg)
+ if i < b.filtersNum {
+ o := b.data[b.oOffset+i*4:]
+ n := int(binary.LittleEndian.Uint32(o))
+ m := int(binary.LittleEndian.Uint32(o[4:]))
+ if n < m && m <= b.oOffset {
+ return filter.Contains(b.data[n:m], key)
+ } else if n == m {
+ return false
+ }
+ }
+ return true
+}
+
+func (b *filterBlock) Release() {
+ b.bpool.Put(b.data)
+ b.bpool = nil
+ b.data = nil
+}
+
+type indexIter struct {
+ *blockIter
+ tr *Reader
+ slice *util.Range
+ // Options
+ fillCache bool
+}
+
+func (i *indexIter) Get() iterator.Iterator {
+ value := i.Value()
+ if value == nil {
+ return nil
+ }
+ dataBH, n := decodeBlockHandle(value)
+ if n == 0 {
+ return iterator.NewEmptyIterator(i.tr.newErrCorruptedBH(i.tr.indexBH, "bad data block handle"))
+ }
+
+ var slice *util.Range
+ if i.slice != nil && (i.blockIter.isFirst() || i.blockIter.isLast()) {
+ slice = i.slice
+ }
+ return i.tr.getDataIterErr(dataBH, slice, i.tr.verifyChecksum, i.fillCache)
+}
+
+// Reader is a table reader.
+type Reader struct {
+ mu sync.RWMutex
+ fi *storage.FileInfo
+ reader io.ReaderAt
+ cache *cache.CacheGetter
+ err error
+ bpool *util.BufferPool
+ // Options
+ o *opt.Options
+ cmp comparer.Comparer
+ filter filter.Filter
+ verifyChecksum bool
+
+ dataEnd int64
+ metaBH, indexBH, filterBH blockHandle
+ indexBlock *block
+ filterBlock *filterBlock
+}
+
+func (r *Reader) blockKind(bh blockHandle) string {
+ switch bh.offset {
+ case r.metaBH.offset:
+ return "meta-block"
+ case r.indexBH.offset:
+ return "index-block"
+ case r.filterBH.offset:
+ if r.filterBH.length > 0 {
+ return "filter-block"
+ }
+ }
+ return "data-block"
+}
+
+func (r *Reader) newErrCorrupted(pos, size int64, kind, reason string) error {
+ return &errors.ErrCorrupted{File: r.fi, Err: &ErrCorrupted{Pos: pos, Size: size, Kind: kind, Reason: reason}}
+}
+
+func (r *Reader) newErrCorruptedBH(bh blockHandle, reason string) error {
+ return r.newErrCorrupted(int64(bh.offset), int64(bh.length), r.blockKind(bh), reason)
+}
+
+func (r *Reader) fixErrCorruptedBH(bh blockHandle, err error) error {
+ if cerr, ok := err.(*ErrCorrupted); ok {
+ cerr.Pos = int64(bh.offset)
+ cerr.Size = int64(bh.length)
+ cerr.Kind = r.blockKind(bh)
+ return &errors.ErrCorrupted{File: r.fi, Err: cerr}
+ }
+ return err
+}
+
+func (r *Reader) readRawBlock(bh blockHandle, verifyChecksum bool) ([]byte, error) {
+ data := r.bpool.Get(int(bh.length + blockTrailerLen))
+ if _, err := r.reader.ReadAt(data, int64(bh.offset)); err != nil && err != io.EOF {
+ return nil, err
+ }
+
+ if verifyChecksum {
+ n := bh.length + 1
+ checksum0 := binary.LittleEndian.Uint32(data[n:])
+ checksum1 := util.NewCRC(data[:n]).Value()
+ if checksum0 != checksum1 {
+ r.bpool.Put(data)
+ return nil, r.newErrCorruptedBH(bh, fmt.Sprintf("checksum mismatch, want=%#x got=%#x", checksum0, checksum1))
+ }
+ }
+
+ switch data[bh.length] {
+ case blockTypeNoCompression:
+ data = data[:bh.length]
+ case blockTypeSnappyCompression:
+ decLen, err := snappy.DecodedLen(data[:bh.length])
+ if err != nil {
+ return nil, r.newErrCorruptedBH(bh, err.Error())
+ }
+ decData := r.bpool.Get(decLen)
+ decData, err = snappy.Decode(decData, data[:bh.length])
+ r.bpool.Put(data)
+ if err != nil {
+ r.bpool.Put(decData)
+ return nil, r.newErrCorruptedBH(bh, err.Error())
+ }
+ data = decData
+ default:
+ r.bpool.Put(data)
+ return nil, r.newErrCorruptedBH(bh, fmt.Sprintf("unknown compression type %#x", data[bh.length]))
+ }
+ return data, nil
+}
+
+func (r *Reader) readBlock(bh blockHandle, verifyChecksum bool) (*block, error) {
+ data, err := r.readRawBlock(bh, verifyChecksum)
+ if err != nil {
+ return nil, err
+ }
+ restartsLen := int(binary.LittleEndian.Uint32(data[len(data)-4:]))
+ b := &block{
+ bpool: r.bpool,
+ bh: bh,
+ data: data,
+ restartsLen: restartsLen,
+ restartsOffset: len(data) - (restartsLen+1)*4,
+ }
+ return b, nil
+}
+
+func (r *Reader) readBlockCached(bh blockHandle, verifyChecksum, fillCache bool) (*block, util.Releaser, error) {
+ if r.cache != nil {
+ var (
+ err error
+ ch *cache.Handle
+ )
+ if fillCache {
+ ch = r.cache.Get(bh.offset, func() (size int, value cache.Value) {
+ var b *block
+ b, err = r.readBlock(bh, verifyChecksum)
+ if err != nil {
+ return 0, nil
+ }
+ return cap(b.data), b
+ })
+ } else {
+ ch = r.cache.Get(bh.offset, nil)
+ }
+ if ch != nil {
+ b, ok := ch.Value().(*block)
+ if !ok {
+ ch.Release()
+ return nil, nil, errors.New("leveldb/table: inconsistent block type")
+ }
+ return b, ch, err
+ } else if err != nil {
+ return nil, nil, err
+ }
+ }
+
+ b, err := r.readBlock(bh, verifyChecksum)
+ return b, b, err
+}
+
+func (r *Reader) readFilterBlock(bh blockHandle) (*filterBlock, error) {
+ data, err := r.readRawBlock(bh, true)
+ if err != nil {
+ return nil, err
+ }
+ n := len(data)
+ if n < 5 {
+ return nil, r.newErrCorruptedBH(bh, "too short")
+ }
+ m := n - 5
+ oOffset := int(binary.LittleEndian.Uint32(data[m:]))
+ if oOffset > m {
+ return nil, r.newErrCorruptedBH(bh, "invalid data-offsets offset")
+ }
+ b := &filterBlock{
+ bpool: r.bpool,
+ data: data,
+ oOffset: oOffset,
+ baseLg: uint(data[n-1]),
+ filtersNum: (m - oOffset) / 4,
+ }
+ return b, nil
+}
+
+func (r *Reader) readFilterBlockCached(bh blockHandle, fillCache bool) (*filterBlock, util.Releaser, error) {
+ if r.cache != nil {
+ var (
+ err error
+ ch *cache.Handle
+ )
+ if fillCache {
+ ch = r.cache.Get(bh.offset, func() (size int, value cache.Value) {
+ var b *filterBlock
+ b, err = r.readFilterBlock(bh)
+ if err != nil {
+ return 0, nil
+ }
+ return cap(b.data), b
+ })
+ } else {
+ ch = r.cache.Get(bh.offset, nil)
+ }
+ if ch != nil {
+ b, ok := ch.Value().(*filterBlock)
+ if !ok {
+ ch.Release()
+ return nil, nil, errors.New("leveldb/table: inconsistent block type")
+ }
+ return b, ch, err
+ } else if err != nil {
+ return nil, nil, err
+ }
+ }
+
+ b, err := r.readFilterBlock(bh)
+ return b, b, err
+}
+
+func (r *Reader) getIndexBlock(fillCache bool) (b *block, rel util.Releaser, err error) {
+ if r.indexBlock == nil {
+ return r.readBlockCached(r.indexBH, true, fillCache)
+ }
+ return r.indexBlock, util.NoopReleaser{}, nil
+}
+
+func (r *Reader) getFilterBlock(fillCache bool) (*filterBlock, util.Releaser, error) {
+ if r.filterBlock == nil {
+ return r.readFilterBlockCached(r.filterBH, fillCache)
+ }
+ return r.filterBlock, util.NoopReleaser{}, nil
+}
+
+func (r *Reader) newBlockIter(b *block, bReleaser util.Releaser, slice *util.Range, inclLimit bool) *blockIter {
+ bi := &blockIter{
+ tr: r,
+ block: b,
+ blockReleaser: bReleaser,
+ // Valid key should never be nil.
+ key: make([]byte, 0),
+ dir: dirSOI,
+ riStart: 0,
+ riLimit: b.restartsLen,
+ offsetStart: 0,
+ offsetRealStart: 0,
+ offsetLimit: b.restartsOffset,
+ }
+ if slice != nil {
+ if slice.Start != nil {
+ if bi.Seek(slice.Start) {
+ bi.riStart = b.restartIndex(bi.restartIndex, b.restartsLen, bi.prevOffset)
+ bi.offsetStart = b.restartOffset(bi.riStart)
+ bi.offsetRealStart = bi.prevOffset
+ } else {
+ bi.riStart = b.restartsLen
+ bi.offsetStart = b.restartsOffset
+ bi.offsetRealStart = b.restartsOffset
+ }
+ }
+ if slice.Limit != nil {
+ if bi.Seek(slice.Limit) && (!inclLimit || bi.Next()) {
+ bi.offsetLimit = bi.prevOffset
+ bi.riLimit = bi.restartIndex + 1
+ }
+ }
+ bi.reset()
+ if bi.offsetStart > bi.offsetLimit {
+ bi.sErr(errors.New("leveldb/table: invalid slice range"))
+ }
+ }
+ return bi
+}
+
+func (r *Reader) getDataIter(dataBH blockHandle, slice *util.Range, verifyChecksum, fillCache bool) iterator.Iterator {
+ b, rel, err := r.readBlockCached(dataBH, verifyChecksum, fillCache)
+ if err != nil {
+ return iterator.NewEmptyIterator(err)
+ }
+ return r.newBlockIter(b, rel, slice, false)
+}
+
+func (r *Reader) getDataIterErr(dataBH blockHandle, slice *util.Range, verifyChecksum, fillCache bool) iterator.Iterator {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+
+ if r.err != nil {
+ return iterator.NewEmptyIterator(r.err)
+ }
+
+ return r.getDataIter(dataBH, slice, verifyChecksum, fillCache)
+}
+
+// NewIterator creates an iterator from the table.
+//
+// Slice allows slicing the iterator to only contains keys in the given
+// range. A nil Range.Start is treated as a key before all keys in the
+// table. And a nil Range.Limit is treated as a key after all keys in
+// the table.
+//
+// The returned iterator is not goroutine-safe and should be released
+// when not used.
+//
+// Also read Iterator documentation of the leveldb/iterator package.
+func (r *Reader) NewIterator(slice *util.Range, ro *opt.ReadOptions) iterator.Iterator {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+
+ if r.err != nil {
+ return iterator.NewEmptyIterator(r.err)
+ }
+
+ fillCache := !ro.GetDontFillCache()
+ indexBlock, rel, err := r.getIndexBlock(fillCache)
+ if err != nil {
+ return iterator.NewEmptyIterator(err)
+ }
+ index := &indexIter{
+ blockIter: r.newBlockIter(indexBlock, rel, slice, true),
+ tr: r,
+ slice: slice,
+ fillCache: !ro.GetDontFillCache(),
+ }
+ return iterator.NewIndexedIterator(index, opt.GetStrict(r.o, ro, opt.StrictReader))
+}
+
+func (r *Reader) find(key []byte, filtered bool, ro *opt.ReadOptions, noValue bool) (rkey, value []byte, err error) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+
+ if r.err != nil {
+ err = r.err
+ return
+ }
+
+ indexBlock, rel, err := r.getIndexBlock(true)
+ if err != nil {
+ return
+ }
+ defer rel.Release()
+
+ index := r.newBlockIter(indexBlock, nil, nil, true)
+ defer index.Release()
+ if !index.Seek(key) {
+ err = index.Error()
+ if err == nil {
+ err = ErrNotFound
+ }
+ return
+ }
+ dataBH, n := decodeBlockHandle(index.Value())
+ if n == 0 {
+ r.err = r.newErrCorruptedBH(r.indexBH, "bad data block handle")
+ return
+ }
+ if filtered && r.filter != nil {
+ filterBlock, frel, ferr := r.getFilterBlock(true)
+ if ferr == nil {
+ if !filterBlock.contains(r.filter, dataBH.offset, key) {
+ frel.Release()
+ return nil, nil, ErrNotFound
+ }
+ frel.Release()
+ } else if !errors.IsCorrupted(ferr) {
+ err = ferr
+ return
+ }
+ }
+ data := r.getDataIter(dataBH, nil, r.verifyChecksum, !ro.GetDontFillCache())
+ defer data.Release()
+ if !data.Seek(key) {
+ err = data.Error()
+ if err == nil {
+ err = ErrNotFound
+ }
+ return
+ }
+ // Don't use block buffer, no need to copy the buffer.
+ rkey = data.Key()
+ if !noValue {
+ if r.bpool == nil {
+ value = data.Value()
+ } else {
+ // Use block buffer, and since the buffer will be recycled, the buffer
+ // need to be copied.
+ value = append([]byte{}, data.Value()...)
+ }
+ }
+ return
+}
+
+// Find finds key/value pair whose key is greater than or equal to the
+// given key. It returns ErrNotFound if the table doesn't contain
+// such pair.
+// If filtered is true then the nearest 'block' will be checked against
+// 'filter data' (if present) and will immediately return ErrNotFound if
+// 'filter data' indicates that such pair doesn't exist.
+//
+// The caller may modify the contents of the returned slice as it is its
+// own copy.
+// It is safe to modify the contents of the argument after Find returns.
+func (r *Reader) Find(key []byte, filtered bool, ro *opt.ReadOptions) (rkey, value []byte, err error) {
+ return r.find(key, filtered, ro, false)
+}
+
+// Find finds key that is greater than or equal to the given key.
+// It returns ErrNotFound if the table doesn't contain such key.
+// If filtered is true then the nearest 'block' will be checked against
+// 'filter data' (if present) and will immediately return ErrNotFound if
+// 'filter data' indicates that such key doesn't exist.
+//
+// The caller may modify the contents of the returned slice as it is its
+// own copy.
+// It is safe to modify the contents of the argument after Find returns.
+func (r *Reader) FindKey(key []byte, filtered bool, ro *opt.ReadOptions) (rkey []byte, err error) {
+ rkey, _, err = r.find(key, filtered, ro, true)
+ return
+}
+
+// Get gets the value for the given key. It returns errors.ErrNotFound
+// if the table does not contain the key.
+//
+// The caller may modify the contents of the returned slice as it is its
+// own copy.
+// It is safe to modify the contents of the argument after Find returns.
+func (r *Reader) Get(key []byte, ro *opt.ReadOptions) (value []byte, err error) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+
+ if r.err != nil {
+ err = r.err
+ return
+ }
+
+ rkey, value, err := r.find(key, false, ro, false)
+ if err == nil && r.cmp.Compare(rkey, key) != 0 {
+ value = nil
+ err = ErrNotFound
+ }
+ return
+}
+
+// OffsetOf returns approximate offset for the given key.
+//
+// It is safe to modify the contents of the argument after Get returns.
+func (r *Reader) OffsetOf(key []byte) (offset int64, err error) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+
+ if r.err != nil {
+ err = r.err
+ return
+ }
+
+ indexBlock, rel, err := r.readBlockCached(r.indexBH, true, true)
+ if err != nil {
+ return
+ }
+ defer rel.Release()
+
+ index := r.newBlockIter(indexBlock, nil, nil, true)
+ defer index.Release()
+ if index.Seek(key) {
+ dataBH, n := decodeBlockHandle(index.Value())
+ if n == 0 {
+ r.err = r.newErrCorruptedBH(r.indexBH, "bad data block handle")
+ return
+ }
+ offset = int64(dataBH.offset)
+ return
+ }
+ err = index.Error()
+ if err == nil {
+ offset = r.dataEnd
+ }
+ return
+}
+
+// Release implements util.Releaser.
+// It also close the file if it is an io.Closer.
+func (r *Reader) Release() {
+ r.mu.Lock()
+ defer r.mu.Unlock()
+
+ if closer, ok := r.reader.(io.Closer); ok {
+ closer.Close()
+ }
+ if r.indexBlock != nil {
+ r.indexBlock.Release()
+ r.indexBlock = nil
+ }
+ if r.filterBlock != nil {
+ r.filterBlock.Release()
+ r.filterBlock = nil
+ }
+ r.reader = nil
+ r.cache = nil
+ r.bpool = nil
+ r.err = ErrReaderReleased
+}
+
+// NewReader creates a new initialized table reader for the file.
+// The fi, cache and bpool is optional and can be nil.
+//
+// The returned table reader instance is goroutine-safe.
+func NewReader(f io.ReaderAt, size int64, fi *storage.FileInfo, cache *cache.CacheGetter, bpool *util.BufferPool, o *opt.Options) (*Reader, error) {
+ if f == nil {
+ return nil, errors.New("leveldb/table: nil file")
+ }
+
+ r := &Reader{
+ fi: fi,
+ reader: f,
+ cache: cache,
+ bpool: bpool,
+ o: o,
+ cmp: o.GetComparer(),
+ verifyChecksum: o.GetStrict(opt.StrictBlockChecksum),
+ }
+
+ if size < footerLen {
+ r.err = r.newErrCorrupted(0, size, "table", "too small")
+ return r, nil
+ }
+
+ footerPos := size - footerLen
+ var footer [footerLen]byte
+ if _, err := r.reader.ReadAt(footer[:], footerPos); err != nil && err != io.EOF {
+ return nil, err
+ }
+ if string(footer[footerLen-len(magic):footerLen]) != magic {
+ r.err = r.newErrCorrupted(footerPos, footerLen, "table-footer", "bad magic number")
+ return r, nil
+ }
+
+ var n int
+ // Decode the metaindex block handle.
+ r.metaBH, n = decodeBlockHandle(footer[:])
+ if n == 0 {
+ r.err = r.newErrCorrupted(footerPos, footerLen, "table-footer", "bad metaindex block handle")
+ return r, nil
+ }
+
+ // Decode the index block handle.
+ r.indexBH, n = decodeBlockHandle(footer[n:])
+ if n == 0 {
+ r.err = r.newErrCorrupted(footerPos, footerLen, "table-footer", "bad index block handle")
+ return r, nil
+ }
+
+ // Read metaindex block.
+ metaBlock, err := r.readBlock(r.metaBH, true)
+ if err != nil {
+ if errors.IsCorrupted(err) {
+ r.err = err
+ return r, nil
+ } else {
+ return nil, err
+ }
+ }
+
+ // Set data end.
+ r.dataEnd = int64(r.metaBH.offset)
+
+ // Read metaindex.
+ metaIter := r.newBlockIter(metaBlock, nil, nil, true)
+ for metaIter.Next() {
+ key := string(metaIter.Key())
+ if !strings.HasPrefix(key, "filter.") {
+ continue
+ }
+ fn := key[7:]
+ if f0 := o.GetFilter(); f0 != nil && f0.Name() == fn {
+ r.filter = f0
+ } else {
+ for _, f0 := range o.GetAltFilters() {
+ if f0.Name() == fn {
+ r.filter = f0
+ break
+ }
+ }
+ }
+ if r.filter != nil {
+ filterBH, n := decodeBlockHandle(metaIter.Value())
+ if n == 0 {
+ continue
+ }
+ r.filterBH = filterBH
+ // Update data end.
+ r.dataEnd = int64(filterBH.offset)
+ break
+ }
+ }
+ metaIter.Release()
+ metaBlock.Release()
+
+ // Cache index and filter block locally, since we don't have global cache.
+ if cache == nil {
+ r.indexBlock, err = r.readBlock(r.indexBH, true)
+ if err != nil {
+ if errors.IsCorrupted(err) {
+ r.err = err
+ return r, nil
+ } else {
+ return nil, err
+ }
+ }
+ if r.filter != nil {
+ r.filterBlock, err = r.readFilterBlock(r.filterBH)
+ if err != nil {
+ if !errors.IsCorrupted(err) {
+ return nil, err
+ }
+
+ // Don't use filter then.
+ r.filter = nil
+ }
+ }
+ }
+
+ return r, nil
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/table.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/table.go
new file mode 100644
index 0000000000000000000000000000000000000000..beacdc1f024a47e4921a721c8225850a2bd3e68b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/table.go
@@ -0,0 +1,177 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package table allows read and write sorted key/value.
+package table
+
+import (
+ "encoding/binary"
+)
+
+/*
+Table:
+
+Table is consist of one or more data blocks, an optional filter block
+a metaindex block, an index block and a table footer. Metaindex block
+is a special block used to keep parameters of the table, such as filter
+block name and its block handle. Index block is a special block used to
+keep record of data blocks offset and length, index block use one as
+restart interval. The key used by index block are the last key of preceding
+block, shorter separator of adjacent blocks or shorter successor of the
+last key of the last block. Filter block is an optional block contains
+sequence of filter data generated by a filter generator.
+
+Table data structure:
+ + optional
+ /
+ +--------------+--------------+--------------+------+-------+-----------------+-------------+--------+
+ | data block 1 | ... | data block n | filter block | metaindex block | index block | footer |
+ +--------------+--------------+--------------+--------------+-----------------+-------------+--------+
+
+ Each block followed by a 5-bytes trailer contains compression type and checksum.
+
+Table block trailer:
+
+ +---------------------------+-------------------+
+ | compression type (1-byte) | checksum (4-byte) |
+ +---------------------------+-------------------+
+
+ The checksum is a CRC-32 computed using Castagnoli's polynomial. Compression
+ type also included in the checksum.
+
+Table footer:
+
+ +------------------- 40-bytes -------------------+
+ / \
+ +------------------------+--------------------+------+-----------------+
+ | metaindex block handle / index block handle / ---- | magic (8-bytes) |
+ +------------------------+--------------------+------+-----------------+
+
+ The magic are first 64-bit of SHA-1 sum of "http://code.google.com/p/leveldb/".
+
+NOTE: All fixed-length integer are little-endian.
+*/
+
+/*
+Block:
+
+Block is consist of one or more key/value entries and a block trailer.
+Block entry shares key prefix with its preceding key until a restart
+point reached. A block should contains at least one restart point.
+First restart point are always zero.
+
+Block data structure:
+
+ + restart point + restart point (depends on restart interval)
+ / /
+ +---------------+---------------+---------------+---------------+---------+
+ | block entry 1 | block entry 2 | ... | block entry n | trailer |
+ +---------------+---------------+---------------+---------------+---------+
+
+Key/value entry:
+
+ +---- key len ----+
+ / \
+ +-------+---------+-----------+---------+--------------------+--------------+----------------+
+ | shared (varint) | not shared (varint) | value len (varint) | key (varlen) | value (varlen) |
+ +-----------------+---------------------+--------------------+--------------+----------------+
+
+ Block entry shares key prefix with its preceding key:
+ Conditions:
+ restart_interval=2
+ entry one : key=deck,value=v1
+ entry two : key=dock,value=v2
+ entry three: key=duck,value=v3
+ The entries will be encoded as follow:
+
+ + restart point (offset=0) + restart point (offset=16)
+ / /
+ +-----+-----+-----+----------+--------+-----+-----+-----+---------+--------+-----+-----+-----+----------+--------+
+ | 0 | 4 | 2 | "deck" | "v1" | 1 | 3 | 2 | "ock" | "v2" | 0 | 4 | 2 | "duck" | "v3" |
+ +-----+-----+-----+----------+--------+-----+-----+-----+---------+--------+-----+-----+-----+----------+--------+
+ \ / \ / \ /
+ +----------- entry one -----------+ +----------- entry two ----------+ +---------- entry three ----------+
+
+ The block trailer will contains two restart points:
+
+ +------------+-----------+--------+
+ | 0 | 16 | 2 |
+ +------------+-----------+---+----+
+ \ / \
+ +-- restart points --+ + restart points length
+
+Block trailer:
+
+ +-- 4-bytes --+
+ / \
+ +-----------------+-----------------+-----------------+------------------------------+
+ | restart point 1 | .... | restart point n | restart points len (4-bytes) |
+ +-----------------+-----------------+-----------------+------------------------------+
+
+
+NOTE: All fixed-length integer are little-endian.
+*/
+
+/*
+Filter block:
+
+Filter block consist of one or more filter data and a filter block trailer.
+The trailer contains filter data offsets, a trailer offset and a 1-byte base Lg.
+
+Filter block data structure:
+
+ + offset 1 + offset 2 + offset n + trailer offset
+ / / / /
+ +---------------+---------------+---------------+---------+
+ | filter data 1 | ... | filter data n | trailer |
+ +---------------+---------------+---------------+---------+
+
+Filter block trailer:
+
+ +- 4-bytes -+
+ / \
+ +---------------+---------------+---------------+-------------------------------+------------------+
+ | data 1 offset | .... | data n offset | data-offsets offset (4-bytes) | base Lg (1-byte) |
+ +-------------- +---------------+---------------+-------------------------------+------------------+
+
+
+NOTE: All fixed-length integer are little-endian.
+*/
+
+const (
+ blockTrailerLen = 5
+ footerLen = 48
+
+ magic = "\x57\xfb\x80\x8b\x24\x75\x47\xdb"
+
+ // The block type gives the per-block compression format.
+ // These constants are part of the file format and should not be changed.
+ blockTypeNoCompression = 0
+ blockTypeSnappyCompression = 1
+
+ // Generate new filter every 2KB of data
+ filterBaseLg = 11
+ filterBase = 1 << filterBaseLg
+)
+
+type blockHandle struct {
+ offset, length uint64
+}
+
+func decodeBlockHandle(src []byte) (blockHandle, int) {
+ offset, n := binary.Uvarint(src)
+ length, m := binary.Uvarint(src[n:])
+ if n == 0 || m == 0 {
+ return blockHandle{}, 0
+ }
+ return blockHandle{offset, length}, n + m
+}
+
+func encodeBlockHandle(dst []byte, b blockHandle) int {
+ n := binary.PutUvarint(dst, b.offset)
+ m := binary.PutUvarint(dst[n:], b.length)
+ return n + m
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/table_suite_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/table_suite_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..d35a13051497c79133aa293560897c9b63276e67
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/table_suite_test.go
@@ -0,0 +1,11 @@
+package table
+
+import (
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil"
+)
+
+func TestTable(t *testing.T) {
+ testutil.RunSuite(t, "Table Suite")
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/table_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/table_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..5429c465b6938b75d1f7e39662b66f1d4a507797
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/table_test.go
@@ -0,0 +1,122 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package table
+
+import (
+ "bytes"
+
+ . "github.com/onsi/ginkgo"
+ . "github.com/onsi/gomega"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type tableWrapper struct {
+ *Reader
+}
+
+func (t tableWrapper) TestFind(key []byte) (rkey, rvalue []byte, err error) {
+ return t.Reader.Find(key, false, nil)
+}
+
+func (t tableWrapper) TestGet(key []byte) (value []byte, err error) {
+ return t.Reader.Get(key, nil)
+}
+
+func (t tableWrapper) TestNewIterator(slice *util.Range) iterator.Iterator {
+ return t.Reader.NewIterator(slice, nil)
+}
+
+var _ = testutil.Defer(func() {
+ Describe("Table", func() {
+ Describe("approximate offset test", func() {
+ var (
+ buf = &bytes.Buffer{}
+ o = &opt.Options{
+ BlockSize: 1024,
+ Compression: opt.NoCompression,
+ }
+ )
+
+ // Building the table.
+ tw := NewWriter(buf, o)
+ tw.Append([]byte("k01"), []byte("hello"))
+ tw.Append([]byte("k02"), []byte("hello2"))
+ tw.Append([]byte("k03"), bytes.Repeat([]byte{'x'}, 10000))
+ tw.Append([]byte("k04"), bytes.Repeat([]byte{'x'}, 200000))
+ tw.Append([]byte("k05"), bytes.Repeat([]byte{'x'}, 300000))
+ tw.Append([]byte("k06"), []byte("hello3"))
+ tw.Append([]byte("k07"), bytes.Repeat([]byte{'x'}, 100000))
+ err := tw.Close()
+
+ It("Should be able to approximate offset of a key correctly", func() {
+ Expect(err).ShouldNot(HaveOccurred())
+
+ tr, err := NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()), nil, nil, nil, o)
+ Expect(err).ShouldNot(HaveOccurred())
+ CheckOffset := func(key string, expect, threshold int) {
+ offset, err := tr.OffsetOf([]byte(key))
+ Expect(err).ShouldNot(HaveOccurred())
+ Expect(offset).Should(BeNumerically("~", expect, threshold), "Offset of key %q", key)
+ }
+
+ CheckOffset("k0", 0, 0)
+ CheckOffset("k01a", 0, 0)
+ CheckOffset("k02", 0, 0)
+ CheckOffset("k03", 0, 0)
+ CheckOffset("k04", 10000, 1000)
+ CheckOffset("k04a", 210000, 1000)
+ CheckOffset("k05", 210000, 1000)
+ CheckOffset("k06", 510000, 1000)
+ CheckOffset("k07", 510000, 1000)
+ CheckOffset("xyz", 610000, 2000)
+ })
+ })
+
+ Describe("read test", func() {
+ Build := func(kv testutil.KeyValue) testutil.DB {
+ o := &opt.Options{
+ BlockSize: 512,
+ BlockRestartInterval: 3,
+ }
+ buf := &bytes.Buffer{}
+
+ // Building the table.
+ tw := NewWriter(buf, o)
+ kv.Iterate(func(i int, key, value []byte) {
+ tw.Append(key, value)
+ })
+ tw.Close()
+
+ // Opening the table.
+ tr, _ := NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()), nil, nil, nil, o)
+ return tableWrapper{tr}
+ }
+ Test := func(kv *testutil.KeyValue, body func(r *Reader)) func() {
+ return func() {
+ db := Build(*kv)
+ if body != nil {
+ body(db.(tableWrapper).Reader)
+ }
+ testutil.KeyValueTesting(nil, *kv, db, nil, nil)
+ }
+ }
+
+ testutil.AllKeyValueTesting(nil, Build, nil, nil)
+ Describe("with one key per block", Test(testutil.KeyValue_Generate(nil, 9, 1, 10, 512, 512), func(r *Reader) {
+ It("should have correct blocks number", func() {
+ indexBlock, err := r.readBlock(r.indexBH, true)
+ Expect(err).To(BeNil())
+ Expect(indexBlock.restartsLen).Should(Equal(9))
+ })
+ }))
+ })
+ })
+})
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/writer.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/writer.go
new file mode 100644
index 0000000000000000000000000000000000000000..51f9fc7173978511abb9ab83a1e91bfd5b60197e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/writer.go
@@ -0,0 +1,379 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package table
+
+import (
+ "encoding/binary"
+ "errors"
+ "fmt"
+ "io"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/filter"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+func sharedPrefixLen(a, b []byte) int {
+ i, n := 0, len(a)
+ if n > len(b) {
+ n = len(b)
+ }
+ for i < n && a[i] == b[i] {
+ i++
+ }
+ return i
+}
+
+type blockWriter struct {
+ restartInterval int
+ buf util.Buffer
+ nEntries int
+ prevKey []byte
+ restarts []uint32
+ scratch []byte
+}
+
+func (w *blockWriter) append(key, value []byte) {
+ nShared := 0
+ if w.nEntries%w.restartInterval == 0 {
+ w.restarts = append(w.restarts, uint32(w.buf.Len()))
+ } else {
+ nShared = sharedPrefixLen(w.prevKey, key)
+ }
+ n := binary.PutUvarint(w.scratch[0:], uint64(nShared))
+ n += binary.PutUvarint(w.scratch[n:], uint64(len(key)-nShared))
+ n += binary.PutUvarint(w.scratch[n:], uint64(len(value)))
+ w.buf.Write(w.scratch[:n])
+ w.buf.Write(key[nShared:])
+ w.buf.Write(value)
+ w.prevKey = append(w.prevKey[:0], key...)
+ w.nEntries++
+}
+
+func (w *blockWriter) finish() {
+ // Write restarts entry.
+ if w.nEntries == 0 {
+ // Must have at least one restart entry.
+ w.restarts = append(w.restarts, 0)
+ }
+ w.restarts = append(w.restarts, uint32(len(w.restarts)))
+ for _, x := range w.restarts {
+ buf4 := w.buf.Alloc(4)
+ binary.LittleEndian.PutUint32(buf4, x)
+ }
+}
+
+func (w *blockWriter) reset() {
+ w.buf.Reset()
+ w.nEntries = 0
+ w.restarts = w.restarts[:0]
+}
+
+func (w *blockWriter) bytesLen() int {
+ restartsLen := len(w.restarts)
+ if restartsLen == 0 {
+ restartsLen = 1
+ }
+ return w.buf.Len() + 4*restartsLen + 4
+}
+
+type filterWriter struct {
+ generator filter.FilterGenerator
+ buf util.Buffer
+ nKeys int
+ offsets []uint32
+}
+
+func (w *filterWriter) add(key []byte) {
+ if w.generator == nil {
+ return
+ }
+ w.generator.Add(key)
+ w.nKeys++
+}
+
+func (w *filterWriter) flush(offset uint64) {
+ if w.generator == nil {
+ return
+ }
+ for x := int(offset / filterBase); x > len(w.offsets); {
+ w.generate()
+ }
+}
+
+func (w *filterWriter) finish() {
+ if w.generator == nil {
+ return
+ }
+ // Generate last keys.
+
+ if w.nKeys > 0 {
+ w.generate()
+ }
+ w.offsets = append(w.offsets, uint32(w.buf.Len()))
+ for _, x := range w.offsets {
+ buf4 := w.buf.Alloc(4)
+ binary.LittleEndian.PutUint32(buf4, x)
+ }
+ w.buf.WriteByte(filterBaseLg)
+}
+
+func (w *filterWriter) generate() {
+ // Record offset.
+ w.offsets = append(w.offsets, uint32(w.buf.Len()))
+ // Generate filters.
+ if w.nKeys > 0 {
+ w.generator.Generate(&w.buf)
+ w.nKeys = 0
+ }
+}
+
+// Writer is a table writer.
+type Writer struct {
+ writer io.Writer
+ err error
+ // Options
+ cmp comparer.Comparer
+ filter filter.Filter
+ compression opt.Compression
+ blockSize int
+
+ dataBlock blockWriter
+ indexBlock blockWriter
+ filterBlock filterWriter
+ pendingBH blockHandle
+ offset uint64
+ nEntries int
+ // Scratch allocated enough for 5 uvarint. Block writer should not use
+ // first 20-bytes since it will be used to encode block handle, which
+ // then passed to the block writer itself.
+ scratch [50]byte
+ comparerScratch []byte
+ compressionScratch []byte
+}
+
+func (w *Writer) writeBlock(buf *util.Buffer, compression opt.Compression) (bh blockHandle, err error) {
+ // Compress the buffer if necessary.
+ var b []byte
+ if compression == opt.SnappyCompression {
+ // Allocate scratch enough for compression and block trailer.
+ if n := snappy.MaxEncodedLen(buf.Len()) + blockTrailerLen; len(w.compressionScratch) < n {
+ w.compressionScratch = make([]byte, n)
+ }
+ var compressed []byte
+ compressed, err = snappy.Encode(w.compressionScratch, buf.Bytes())
+ if err != nil {
+ return
+ }
+ n := len(compressed)
+ b = compressed[:n+blockTrailerLen]
+ b[n] = blockTypeSnappyCompression
+ } else {
+ tmp := buf.Alloc(blockTrailerLen)
+ tmp[0] = blockTypeNoCompression
+ b = buf.Bytes()
+ }
+
+ // Calculate the checksum.
+ n := len(b) - 4
+ checksum := util.NewCRC(b[:n]).Value()
+ binary.LittleEndian.PutUint32(b[n:], checksum)
+
+ // Write the buffer to the file.
+ _, err = w.writer.Write(b)
+ if err != nil {
+ return
+ }
+ bh = blockHandle{w.offset, uint64(len(b) - blockTrailerLen)}
+ w.offset += uint64(len(b))
+ return
+}
+
+func (w *Writer) flushPendingBH(key []byte) {
+ if w.pendingBH.length == 0 {
+ return
+ }
+ var separator []byte
+ if len(key) == 0 {
+ separator = w.cmp.Successor(w.comparerScratch[:0], w.dataBlock.prevKey)
+ } else {
+ separator = w.cmp.Separator(w.comparerScratch[:0], w.dataBlock.prevKey, key)
+ }
+ if separator == nil {
+ separator = w.dataBlock.prevKey
+ } else {
+ w.comparerScratch = separator
+ }
+ n := encodeBlockHandle(w.scratch[:20], w.pendingBH)
+ // Append the block handle to the index block.
+ w.indexBlock.append(separator, w.scratch[:n])
+ // Reset prev key of the data block.
+ w.dataBlock.prevKey = w.dataBlock.prevKey[:0]
+ // Clear pending block handle.
+ w.pendingBH = blockHandle{}
+}
+
+func (w *Writer) finishBlock() error {
+ w.dataBlock.finish()
+ bh, err := w.writeBlock(&w.dataBlock.buf, w.compression)
+ if err != nil {
+ return err
+ }
+ w.pendingBH = bh
+ // Reset the data block.
+ w.dataBlock.reset()
+ // Flush the filter block.
+ w.filterBlock.flush(w.offset)
+ return nil
+}
+
+// Append appends key/value pair to the table. The keys passed must
+// be in increasing order.
+//
+// It is safe to modify the contents of the arguments after Append returns.
+func (w *Writer) Append(key, value []byte) error {
+ if w.err != nil {
+ return w.err
+ }
+ if w.nEntries > 0 && w.cmp.Compare(w.dataBlock.prevKey, key) >= 0 {
+ w.err = fmt.Errorf("leveldb/table: Writer: keys are not in increasing order: %q, %q", w.dataBlock.prevKey, key)
+ return w.err
+ }
+
+ w.flushPendingBH(key)
+ // Append key/value pair to the data block.
+ w.dataBlock.append(key, value)
+ // Add key to the filter block.
+ w.filterBlock.add(key)
+
+ // Finish the data block if block size target reached.
+ if w.dataBlock.bytesLen() >= w.blockSize {
+ if err := w.finishBlock(); err != nil {
+ w.err = err
+ return w.err
+ }
+ }
+ w.nEntries++
+ return nil
+}
+
+// BlocksLen returns number of blocks written so far.
+func (w *Writer) BlocksLen() int {
+ n := w.indexBlock.nEntries
+ if w.pendingBH.length > 0 {
+ // Includes the pending block.
+ n++
+ }
+ return n
+}
+
+// EntriesLen returns number of entries added so far.
+func (w *Writer) EntriesLen() int {
+ return w.nEntries
+}
+
+// BytesLen returns number of bytes written so far.
+func (w *Writer) BytesLen() int {
+ return int(w.offset)
+}
+
+// Close will finalize the table. Calling Append is not possible
+// after Close, but calling BlocksLen, EntriesLen and BytesLen
+// is still possible.
+func (w *Writer) Close() error {
+ if w.err != nil {
+ return w.err
+ }
+
+ // Write the last data block. Or empty data block if there
+ // aren't any data blocks at all.
+ if w.dataBlock.nEntries > 0 || w.nEntries == 0 {
+ if err := w.finishBlock(); err != nil {
+ w.err = err
+ return w.err
+ }
+ }
+ w.flushPendingBH(nil)
+
+ // Write the filter block.
+ var filterBH blockHandle
+ w.filterBlock.finish()
+ if buf := &w.filterBlock.buf; buf.Len() > 0 {
+ filterBH, w.err = w.writeBlock(buf, opt.NoCompression)
+ if w.err != nil {
+ return w.err
+ }
+ }
+
+ // Write the metaindex block.
+ if filterBH.length > 0 {
+ key := []byte("filter." + w.filter.Name())
+ n := encodeBlockHandle(w.scratch[:20], filterBH)
+ w.dataBlock.append(key, w.scratch[:n])
+ }
+ w.dataBlock.finish()
+ metaindexBH, err := w.writeBlock(&w.dataBlock.buf, w.compression)
+ if err != nil {
+ w.err = err
+ return w.err
+ }
+
+ // Write the index block.
+ w.indexBlock.finish()
+ indexBH, err := w.writeBlock(&w.indexBlock.buf, w.compression)
+ if err != nil {
+ w.err = err
+ return w.err
+ }
+
+ // Write the table footer.
+ footer := w.scratch[:footerLen]
+ for i := range footer {
+ footer[i] = 0
+ }
+ n := encodeBlockHandle(footer, metaindexBH)
+ encodeBlockHandle(footer[n:], indexBH)
+ copy(footer[footerLen-len(magic):], magic)
+ if _, err := w.writer.Write(footer); err != nil {
+ w.err = err
+ return w.err
+ }
+ w.offset += footerLen
+
+ w.err = errors.New("leveldb/table: writer is closed")
+ return nil
+}
+
+// NewWriter creates a new initialized table writer for the file.
+//
+// Table writer is not goroutine-safe.
+func NewWriter(f io.Writer, o *opt.Options) *Writer {
+ w := &Writer{
+ writer: f,
+ cmp: o.GetComparer(),
+ filter: o.GetFilter(),
+ compression: o.GetCompression(),
+ blockSize: o.GetBlockSize(),
+ comparerScratch: make([]byte, 0),
+ }
+ // data block
+ w.dataBlock.restartInterval = o.GetBlockRestartInterval()
+ // The first 20-bytes are used for encoding block handle.
+ w.dataBlock.scratch = w.scratch[20:]
+ // index block
+ w.indexBlock.restartInterval = 1
+ w.indexBlock.scratch = w.scratch[20:]
+ // filter block
+ if w.filter != nil {
+ w.filterBlock.generator = w.filter.NewGenerator()
+ w.filterBlock.flush(0)
+ }
+ return w
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/db.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/db.go
new file mode 100644
index 0000000000000000000000000000000000000000..a0995a4b7b7c83efb955bb97f46b319b35b69d3b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/db.go
@@ -0,0 +1,222 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package testutil
+
+import (
+ "fmt"
+ "math/rand"
+
+ . "github.com/onsi/gomega"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type DB interface{}
+
+type Put interface {
+ TestPut(key []byte, value []byte) error
+}
+
+type Delete interface {
+ TestDelete(key []byte) error
+}
+
+type Find interface {
+ TestFind(key []byte) (rkey, rvalue []byte, err error)
+}
+
+type Get interface {
+ TestGet(key []byte) (value []byte, err error)
+}
+
+type Has interface {
+ TestHas(key []byte) (ret bool, err error)
+}
+
+type NewIterator interface {
+ TestNewIterator(slice *util.Range) iterator.Iterator
+}
+
+type DBAct int
+
+func (a DBAct) String() string {
+ switch a {
+ case DBNone:
+ return "none"
+ case DBPut:
+ return "put"
+ case DBOverwrite:
+ return "overwrite"
+ case DBDelete:
+ return "delete"
+ case DBDeleteNA:
+ return "delete_na"
+ }
+ return "unknown"
+}
+
+const (
+ DBNone DBAct = iota
+ DBPut
+ DBOverwrite
+ DBDelete
+ DBDeleteNA
+)
+
+type DBTesting struct {
+ Rand *rand.Rand
+ DB interface {
+ Get
+ Put
+ Delete
+ }
+ PostFn func(t *DBTesting)
+ Deleted, Present KeyValue
+ Act, LastAct DBAct
+ ActKey, LastActKey []byte
+}
+
+func (t *DBTesting) post() {
+ if t.PostFn != nil {
+ t.PostFn(t)
+ }
+}
+
+func (t *DBTesting) setAct(act DBAct, key []byte) {
+ t.LastAct, t.Act = t.Act, act
+ t.LastActKey, t.ActKey = t.ActKey, key
+}
+
+func (t *DBTesting) text() string {
+ return fmt.Sprintf("last action was <%v> %q, <%v> %q", t.LastAct, t.LastActKey, t.Act, t.ActKey)
+}
+
+func (t *DBTesting) Text() string {
+ return "DBTesting " + t.text()
+}
+
+func (t *DBTesting) TestPresentKV(key, value []byte) {
+ rvalue, err := t.DB.TestGet(key)
+ Expect(err).ShouldNot(HaveOccurred(), "Get on key %q, %s", key, t.text())
+ Expect(rvalue).Should(Equal(value), "Value for key %q, %s", key, t.text())
+}
+
+func (t *DBTesting) TestAllPresent() {
+ t.Present.IterateShuffled(t.Rand, func(i int, key, value []byte) {
+ t.TestPresentKV(key, value)
+ })
+}
+
+func (t *DBTesting) TestDeletedKey(key []byte) {
+ _, err := t.DB.TestGet(key)
+ Expect(err).Should(Equal(errors.ErrNotFound), "Get on deleted key %q, %s", key, t.text())
+}
+
+func (t *DBTesting) TestAllDeleted() {
+ t.Deleted.IterateShuffled(t.Rand, func(i int, key, value []byte) {
+ t.TestDeletedKey(key)
+ })
+}
+
+func (t *DBTesting) TestAll() {
+ dn := t.Deleted.Len()
+ pn := t.Present.Len()
+ ShuffledIndex(t.Rand, dn+pn, 1, func(i int) {
+ if i >= dn {
+ key, value := t.Present.Index(i - dn)
+ t.TestPresentKV(key, value)
+ } else {
+ t.TestDeletedKey(t.Deleted.KeyAt(i))
+ }
+ })
+}
+
+func (t *DBTesting) Put(key, value []byte) {
+ if new := t.Present.PutU(key, value); new {
+ t.setAct(DBPut, key)
+ } else {
+ t.setAct(DBOverwrite, key)
+ }
+ t.Deleted.Delete(key)
+ err := t.DB.TestPut(key, value)
+ Expect(err).ShouldNot(HaveOccurred(), t.Text())
+ t.TestPresentKV(key, value)
+ t.post()
+}
+
+func (t *DBTesting) PutRandom() bool {
+ if t.Deleted.Len() > 0 {
+ i := t.Rand.Intn(t.Deleted.Len())
+ key, value := t.Deleted.Index(i)
+ t.Put(key, value)
+ return true
+ }
+ return false
+}
+
+func (t *DBTesting) Delete(key []byte) {
+ if exist, value := t.Present.Delete(key); exist {
+ t.setAct(DBDelete, key)
+ t.Deleted.PutU(key, value)
+ } else {
+ t.setAct(DBDeleteNA, key)
+ }
+ err := t.DB.TestDelete(key)
+ Expect(err).ShouldNot(HaveOccurred(), t.Text())
+ t.TestDeletedKey(key)
+ t.post()
+}
+
+func (t *DBTesting) DeleteRandom() bool {
+ if t.Present.Len() > 0 {
+ i := t.Rand.Intn(t.Present.Len())
+ t.Delete(t.Present.KeyAt(i))
+ return true
+ }
+ return false
+}
+
+func (t *DBTesting) RandomAct(round int) {
+ for i := 0; i < round; i++ {
+ if t.Rand.Int()%2 == 0 {
+ t.PutRandom()
+ } else {
+ t.DeleteRandom()
+ }
+ }
+}
+
+func DoDBTesting(t *DBTesting) {
+ if t.Rand == nil {
+ t.Rand = NewRand()
+ }
+
+ t.DeleteRandom()
+ t.PutRandom()
+ t.DeleteRandom()
+ t.DeleteRandom()
+ for i := t.Deleted.Len() / 2; i >= 0; i-- {
+ t.PutRandom()
+ }
+ t.RandomAct((t.Deleted.Len() + t.Present.Len()) * 10)
+
+ // Additional iterator testing
+ if db, ok := t.DB.(NewIterator); ok {
+ iter := db.TestNewIterator(nil)
+ Expect(iter.Error()).NotTo(HaveOccurred())
+
+ it := IteratorTesting{
+ KeyValue: t.Present,
+ Iter: iter,
+ }
+
+ DoIteratorTesting(&it)
+ iter.Release()
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/ginkgo.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/ginkgo.go
new file mode 100644
index 0000000000000000000000000000000000000000..82f3d0e81113b7e85bc0f3b07d338333473882cc
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/ginkgo.go
@@ -0,0 +1,21 @@
+package testutil
+
+import (
+ . "github.com/onsi/ginkgo"
+ . "github.com/onsi/gomega"
+)
+
+func RunSuite(t GinkgoTestingT, name string) {
+ RunDefer()
+
+ SynchronizedBeforeSuite(func() []byte {
+ RunDefer("setup")
+ return nil
+ }, func(data []byte) {})
+ SynchronizedAfterSuite(func() {
+ RunDefer("teardown")
+ }, func() {})
+
+ RegisterFailHandler(Fail)
+ RunSpecs(t, name)
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/iter.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/iter.go
new file mode 100644
index 0000000000000000000000000000000000000000..5e3cbb160d543800a09960a01c63b1c60e6ed4fd
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/iter.go
@@ -0,0 +1,327 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package testutil
+
+import (
+ "fmt"
+ "math/rand"
+
+ . "github.com/onsi/gomega"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+)
+
+type IterAct int
+
+func (a IterAct) String() string {
+ switch a {
+ case IterNone:
+ return "none"
+ case IterFirst:
+ return "first"
+ case IterLast:
+ return "last"
+ case IterPrev:
+ return "prev"
+ case IterNext:
+ return "next"
+ case IterSeek:
+ return "seek"
+ case IterSOI:
+ return "soi"
+ case IterEOI:
+ return "eoi"
+ }
+ return "unknown"
+}
+
+const (
+ IterNone IterAct = iota
+ IterFirst
+ IterLast
+ IterPrev
+ IterNext
+ IterSeek
+ IterSOI
+ IterEOI
+)
+
+type IteratorTesting struct {
+ KeyValue
+ Iter iterator.Iterator
+ Rand *rand.Rand
+ PostFn func(t *IteratorTesting)
+ Pos int
+ Act, LastAct IterAct
+
+ once bool
+}
+
+func (t *IteratorTesting) init() {
+ if !t.once {
+ t.Pos = -1
+ t.once = true
+ }
+}
+
+func (t *IteratorTesting) post() {
+ if t.PostFn != nil {
+ t.PostFn(t)
+ }
+}
+
+func (t *IteratorTesting) setAct(act IterAct) {
+ t.LastAct, t.Act = t.Act, act
+}
+
+func (t *IteratorTesting) text() string {
+ return fmt.Sprintf("at pos %d and last action was <%v> -> <%v>", t.Pos, t.LastAct, t.Act)
+}
+
+func (t *IteratorTesting) Text() string {
+ return "IteratorTesting is " + t.text()
+}
+
+func (t *IteratorTesting) IsFirst() bool {
+ t.init()
+ return t.Len() > 0 && t.Pos == 0
+}
+
+func (t *IteratorTesting) IsLast() bool {
+ t.init()
+ return t.Len() > 0 && t.Pos == t.Len()-1
+}
+
+func (t *IteratorTesting) TestKV() {
+ t.init()
+ key, value := t.Index(t.Pos)
+ Expect(t.Iter.Key()).NotTo(BeNil())
+ Expect(t.Iter.Key()).Should(Equal(key), "Key is invalid, %s", t.text())
+ Expect(t.Iter.Value()).Should(Equal(value), "Value for key %q, %s", key, t.text())
+}
+
+func (t *IteratorTesting) First() {
+ t.init()
+ t.setAct(IterFirst)
+
+ ok := t.Iter.First()
+ Expect(t.Iter.Error()).ShouldNot(HaveOccurred())
+ if t.Len() > 0 {
+ t.Pos = 0
+ Expect(ok).Should(BeTrue(), t.Text())
+ t.TestKV()
+ } else {
+ t.Pos = -1
+ Expect(ok).ShouldNot(BeTrue(), t.Text())
+ }
+ t.post()
+}
+
+func (t *IteratorTesting) Last() {
+ t.init()
+ t.setAct(IterLast)
+
+ ok := t.Iter.Last()
+ Expect(t.Iter.Error()).ShouldNot(HaveOccurred())
+ if t.Len() > 0 {
+ t.Pos = t.Len() - 1
+ Expect(ok).Should(BeTrue(), t.Text())
+ t.TestKV()
+ } else {
+ t.Pos = 0
+ Expect(ok).ShouldNot(BeTrue(), t.Text())
+ }
+ t.post()
+}
+
+func (t *IteratorTesting) Next() {
+ t.init()
+ t.setAct(IterNext)
+
+ ok := t.Iter.Next()
+ Expect(t.Iter.Error()).ShouldNot(HaveOccurred())
+ if t.Pos < t.Len()-1 {
+ t.Pos++
+ Expect(ok).Should(BeTrue(), t.Text())
+ t.TestKV()
+ } else {
+ t.Pos = t.Len()
+ Expect(ok).ShouldNot(BeTrue(), t.Text())
+ }
+ t.post()
+}
+
+func (t *IteratorTesting) Prev() {
+ t.init()
+ t.setAct(IterPrev)
+
+ ok := t.Iter.Prev()
+ Expect(t.Iter.Error()).ShouldNot(HaveOccurred())
+ if t.Pos > 0 {
+ t.Pos--
+ Expect(ok).Should(BeTrue(), t.Text())
+ t.TestKV()
+ } else {
+ t.Pos = -1
+ Expect(ok).ShouldNot(BeTrue(), t.Text())
+ }
+ t.post()
+}
+
+func (t *IteratorTesting) Seek(i int) {
+ t.init()
+ t.setAct(IterSeek)
+
+ key, _ := t.Index(i)
+ oldKey, _ := t.IndexOrNil(t.Pos)
+
+ ok := t.Iter.Seek(key)
+ Expect(t.Iter.Error()).ShouldNot(HaveOccurred())
+ Expect(ok).Should(BeTrue(), fmt.Sprintf("Seek from key %q to %q, to pos %d, %s", oldKey, key, i, t.text()))
+
+ t.Pos = i
+ t.TestKV()
+ t.post()
+}
+
+func (t *IteratorTesting) SeekInexact(i int) {
+ t.init()
+ t.setAct(IterSeek)
+ var key0 []byte
+ key1, _ := t.Index(i)
+ if i > 0 {
+ key0, _ = t.Index(i - 1)
+ }
+ key := BytesSeparator(key0, key1)
+ oldKey, _ := t.IndexOrNil(t.Pos)
+
+ ok := t.Iter.Seek(key)
+ Expect(t.Iter.Error()).ShouldNot(HaveOccurred())
+ Expect(ok).Should(BeTrue(), fmt.Sprintf("Seek from key %q to %q (%q), to pos %d, %s", oldKey, key, key1, i, t.text()))
+
+ t.Pos = i
+ t.TestKV()
+ t.post()
+}
+
+func (t *IteratorTesting) SeekKey(key []byte) {
+ t.init()
+ t.setAct(IterSeek)
+ oldKey, _ := t.IndexOrNil(t.Pos)
+ i := t.Search(key)
+
+ ok := t.Iter.Seek(key)
+ Expect(t.Iter.Error()).ShouldNot(HaveOccurred())
+ if i < t.Len() {
+ key_, _ := t.Index(i)
+ Expect(ok).Should(BeTrue(), fmt.Sprintf("Seek from key %q to %q (%q), to pos %d, %s", oldKey, key, key_, i, t.text()))
+ t.Pos = i
+ t.TestKV()
+ } else {
+ Expect(ok).ShouldNot(BeTrue(), fmt.Sprintf("Seek from key %q to %q, %s", oldKey, key, t.text()))
+ }
+
+ t.Pos = i
+ t.post()
+}
+
+func (t *IteratorTesting) SOI() {
+ t.init()
+ t.setAct(IterSOI)
+ Expect(t.Pos).Should(BeNumerically("<=", 0), t.Text())
+ for i := 0; i < 3; i++ {
+ t.Prev()
+ }
+ t.post()
+}
+
+func (t *IteratorTesting) EOI() {
+ t.init()
+ t.setAct(IterEOI)
+ Expect(t.Pos).Should(BeNumerically(">=", t.Len()-1), t.Text())
+ for i := 0; i < 3; i++ {
+ t.Next()
+ }
+ t.post()
+}
+
+func (t *IteratorTesting) WalkPrev(fn func(t *IteratorTesting)) {
+ t.init()
+ for old := t.Pos; t.Pos > 0; old = t.Pos {
+ fn(t)
+ Expect(t.Pos).Should(BeNumerically("<", old), t.Text())
+ }
+}
+
+func (t *IteratorTesting) WalkNext(fn func(t *IteratorTesting)) {
+ t.init()
+ for old := t.Pos; t.Pos < t.Len()-1; old = t.Pos {
+ fn(t)
+ Expect(t.Pos).Should(BeNumerically(">", old), t.Text())
+ }
+}
+
+func (t *IteratorTesting) PrevAll() {
+ t.WalkPrev(func(t *IteratorTesting) {
+ t.Prev()
+ })
+}
+
+func (t *IteratorTesting) NextAll() {
+ t.WalkNext(func(t *IteratorTesting) {
+ t.Next()
+ })
+}
+
+func DoIteratorTesting(t *IteratorTesting) {
+ if t.Rand == nil {
+ t.Rand = NewRand()
+ }
+ t.SOI()
+ t.NextAll()
+ t.First()
+ t.SOI()
+ t.NextAll()
+ t.EOI()
+ t.PrevAll()
+ t.Last()
+ t.EOI()
+ t.PrevAll()
+ t.SOI()
+
+ t.NextAll()
+ t.PrevAll()
+ t.NextAll()
+ t.Last()
+ t.PrevAll()
+ t.First()
+ t.NextAll()
+ t.EOI()
+
+ ShuffledIndex(t.Rand, t.Len(), 1, func(i int) {
+ t.Seek(i)
+ })
+
+ ShuffledIndex(t.Rand, t.Len(), 1, func(i int) {
+ t.SeekInexact(i)
+ })
+
+ ShuffledIndex(t.Rand, t.Len(), 1, func(i int) {
+ t.Seek(i)
+ if i%2 != 0 {
+ t.PrevAll()
+ t.SOI()
+ } else {
+ t.NextAll()
+ t.EOI()
+ }
+ })
+
+ for _, key := range []string{"", "foo", "bar", "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"} {
+ t.SeekKey([]byte(key))
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/kv.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/kv.go
new file mode 100644
index 0000000000000000000000000000000000000000..83a01a4719b84ab5da4aa0e23258fa9e057089bb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/kv.go
@@ -0,0 +1,352 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package testutil
+
+import (
+ "fmt"
+ "math/rand"
+ "sort"
+ "strings"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type KeyValueEntry struct {
+ key, value []byte
+}
+
+type KeyValue struct {
+ entries []KeyValueEntry
+ nbytes int
+}
+
+func (kv *KeyValue) Put(key, value []byte) {
+ if n := len(kv.entries); n > 0 && cmp.Compare(kv.entries[n-1].key, key) >= 0 {
+ panic(fmt.Sprintf("Put: keys are not in increasing order: %q, %q", kv.entries[n-1].key, key))
+ }
+ kv.entries = append(kv.entries, KeyValueEntry{key, value})
+ kv.nbytes += len(key) + len(value)
+}
+
+func (kv *KeyValue) PutString(key, value string) {
+ kv.Put([]byte(key), []byte(value))
+}
+
+func (kv *KeyValue) PutU(key, value []byte) bool {
+ if i, exist := kv.Get(key); !exist {
+ if i < kv.Len() {
+ kv.entries = append(kv.entries[:i+1], kv.entries[i:]...)
+ kv.entries[i] = KeyValueEntry{key, value}
+ } else {
+ kv.entries = append(kv.entries, KeyValueEntry{key, value})
+ }
+ kv.nbytes += len(key) + len(value)
+ return true
+ } else {
+ kv.nbytes += len(value) - len(kv.ValueAt(i))
+ kv.entries[i].value = value
+ }
+ return false
+}
+
+func (kv *KeyValue) PutUString(key, value string) bool {
+ return kv.PutU([]byte(key), []byte(value))
+}
+
+func (kv *KeyValue) Delete(key []byte) (exist bool, value []byte) {
+ i, exist := kv.Get(key)
+ if exist {
+ value = kv.entries[i].value
+ kv.DeleteIndex(i)
+ }
+ return
+}
+
+func (kv *KeyValue) DeleteIndex(i int) bool {
+ if i < kv.Len() {
+ kv.nbytes -= len(kv.KeyAt(i)) + len(kv.ValueAt(i))
+ kv.entries = append(kv.entries[:i], kv.entries[i+1:]...)
+ return true
+ }
+ return false
+}
+
+func (kv KeyValue) Len() int {
+ return len(kv.entries)
+}
+
+func (kv *KeyValue) Size() int {
+ return kv.nbytes
+}
+
+func (kv KeyValue) KeyAt(i int) []byte {
+ return kv.entries[i].key
+}
+
+func (kv KeyValue) ValueAt(i int) []byte {
+ return kv.entries[i].value
+}
+
+func (kv KeyValue) Index(i int) (key, value []byte) {
+ if i < 0 || i >= len(kv.entries) {
+ panic(fmt.Sprintf("Index #%d: out of range", i))
+ }
+ return kv.entries[i].key, kv.entries[i].value
+}
+
+func (kv KeyValue) IndexInexact(i int) (key_, key, value []byte) {
+ key, value = kv.Index(i)
+ var key0 []byte
+ var key1 = kv.KeyAt(i)
+ if i > 0 {
+ key0 = kv.KeyAt(i - 1)
+ }
+ key_ = BytesSeparator(key0, key1)
+ return
+}
+
+func (kv KeyValue) IndexOrNil(i int) (key, value []byte) {
+ if i >= 0 && i < len(kv.entries) {
+ return kv.entries[i].key, kv.entries[i].value
+ }
+ return nil, nil
+}
+
+func (kv KeyValue) IndexString(i int) (key, value string) {
+ key_, _value := kv.Index(i)
+ return string(key_), string(_value)
+}
+
+func (kv KeyValue) Search(key []byte) int {
+ return sort.Search(kv.Len(), func(i int) bool {
+ return cmp.Compare(kv.KeyAt(i), key) >= 0
+ })
+}
+
+func (kv KeyValue) SearchString(key string) int {
+ return kv.Search([]byte(key))
+}
+
+func (kv KeyValue) Get(key []byte) (i int, exist bool) {
+ i = kv.Search(key)
+ if i < kv.Len() && cmp.Compare(kv.KeyAt(i), key) == 0 {
+ exist = true
+ }
+ return
+}
+
+func (kv KeyValue) GetString(key string) (i int, exist bool) {
+ return kv.Get([]byte(key))
+}
+
+func (kv KeyValue) Iterate(fn func(i int, key, value []byte)) {
+ for i, x := range kv.entries {
+ fn(i, x.key, x.value)
+ }
+}
+
+func (kv KeyValue) IterateString(fn func(i int, key, value string)) {
+ kv.Iterate(func(i int, key, value []byte) {
+ fn(i, string(key), string(value))
+ })
+}
+
+func (kv KeyValue) IterateShuffled(rnd *rand.Rand, fn func(i int, key, value []byte)) {
+ ShuffledIndex(rnd, kv.Len(), 1, func(i int) {
+ fn(i, kv.entries[i].key, kv.entries[i].value)
+ })
+}
+
+func (kv KeyValue) IterateShuffledString(rnd *rand.Rand, fn func(i int, key, value string)) {
+ kv.IterateShuffled(rnd, func(i int, key, value []byte) {
+ fn(i, string(key), string(value))
+ })
+}
+
+func (kv KeyValue) IterateInexact(fn func(i int, key_, key, value []byte)) {
+ for i := range kv.entries {
+ key_, key, value := kv.IndexInexact(i)
+ fn(i, key_, key, value)
+ }
+}
+
+func (kv KeyValue) IterateInexactString(fn func(i int, key_, key, value string)) {
+ kv.IterateInexact(func(i int, key_, key, value []byte) {
+ fn(i, string(key_), string(key), string(value))
+ })
+}
+
+func (kv KeyValue) Clone() KeyValue {
+ return KeyValue{append([]KeyValueEntry{}, kv.entries...), kv.nbytes}
+}
+
+func (kv KeyValue) Slice(start, limit int) KeyValue {
+ if start < 0 || limit > kv.Len() {
+ panic(fmt.Sprintf("Slice %d .. %d: out of range", start, limit))
+ } else if limit < start {
+ panic(fmt.Sprintf("Slice %d .. %d: invalid range", start, limit))
+ }
+ return KeyValue{append([]KeyValueEntry{}, kv.entries[start:limit]...), kv.nbytes}
+}
+
+func (kv KeyValue) SliceKey(start, limit []byte) KeyValue {
+ start_ := 0
+ limit_ := kv.Len()
+ if start != nil {
+ start_ = kv.Search(start)
+ }
+ if limit != nil {
+ limit_ = kv.Search(limit)
+ }
+ return kv.Slice(start_, limit_)
+}
+
+func (kv KeyValue) SliceKeyString(start, limit string) KeyValue {
+ return kv.SliceKey([]byte(start), []byte(limit))
+}
+
+func (kv KeyValue) SliceRange(r *util.Range) KeyValue {
+ if r != nil {
+ return kv.SliceKey(r.Start, r.Limit)
+ }
+ return kv.Clone()
+}
+
+func (kv KeyValue) Range(start, limit int) (r util.Range) {
+ if kv.Len() > 0 {
+ if start == kv.Len() {
+ r.Start = BytesAfter(kv.KeyAt(start - 1))
+ } else {
+ r.Start = kv.KeyAt(start)
+ }
+ }
+ if limit < kv.Len() {
+ r.Limit = kv.KeyAt(limit)
+ }
+ return
+}
+
+func KeyValue_EmptyKey() *KeyValue {
+ kv := &KeyValue{}
+ kv.PutString("", "v")
+ return kv
+}
+
+func KeyValue_EmptyValue() *KeyValue {
+ kv := &KeyValue{}
+ kv.PutString("abc", "")
+ kv.PutString("abcd", "")
+ return kv
+}
+
+func KeyValue_OneKeyValue() *KeyValue {
+ kv := &KeyValue{}
+ kv.PutString("abc", "v")
+ return kv
+}
+
+func KeyValue_BigValue() *KeyValue {
+ kv := &KeyValue{}
+ kv.PutString("big1", strings.Repeat("1", 200000))
+ return kv
+}
+
+func KeyValue_SpecialKey() *KeyValue {
+ kv := &KeyValue{}
+ kv.PutString("\xff\xff", "v3")
+ return kv
+}
+
+func KeyValue_MultipleKeyValue() *KeyValue {
+ kv := &KeyValue{}
+ kv.PutString("a", "v")
+ kv.PutString("aa", "v1")
+ kv.PutString("aaa", "v2")
+ kv.PutString("aaacccccccccc", "v2")
+ kv.PutString("aaaccccccccccd", "v3")
+ kv.PutString("aaaccccccccccf", "v4")
+ kv.PutString("aaaccccccccccfg", "v5")
+ kv.PutString("ab", "v6")
+ kv.PutString("abc", "v7")
+ kv.PutString("abcd", "v8")
+ kv.PutString("accccccccccccccc", "v9")
+ kv.PutString("b", "v10")
+ kv.PutString("bb", "v11")
+ kv.PutString("bc", "v12")
+ kv.PutString("c", "v13")
+ kv.PutString("c1", "v13")
+ kv.PutString("czzzzzzzzzzzzzz", "v14")
+ kv.PutString("fffffffffffffff", "v15")
+ kv.PutString("g11", "v15")
+ kv.PutString("g111", "v15")
+ kv.PutString("g111\xff", "v15")
+ kv.PutString("zz", "v16")
+ kv.PutString("zzzzzzz", "v16")
+ kv.PutString("zzzzzzzzzzzzzzzz", "v16")
+ return kv
+}
+
+var keymap = []byte("012345678ABCDEFGHIJKLMNOPQRSTUVWXYabcdefghijklmnopqrstuvwxy")
+
+func KeyValue_Generate(rnd *rand.Rand, n, minlen, maxlen, vminlen, vmaxlen int) *KeyValue {
+ if rnd == nil {
+ rnd = NewRand()
+ }
+ if maxlen < minlen {
+ panic("max len should >= min len")
+ }
+
+ rrand := func(min, max int) int {
+ if min == max {
+ return max
+ }
+ return rnd.Intn(max-min) + min
+ }
+
+ kv := &KeyValue{}
+ endC := byte(len(keymap) - 1)
+ gen := make([]byte, 0, maxlen)
+ for i := 0; i < n; i++ {
+ m := rrand(minlen, maxlen)
+ last := gen
+ retry:
+ gen = last[:m]
+ if k := len(last); m > k {
+ for j := k; j < m; j++ {
+ gen[j] = 0
+ }
+ } else {
+ for j := m - 1; j >= 0; j-- {
+ c := last[j]
+ if c == endC {
+ continue
+ }
+ gen[j] = c + 1
+ for j += 1; j < m; j++ {
+ gen[j] = 0
+ }
+ goto ok
+ }
+ if m < maxlen {
+ m++
+ goto retry
+ }
+ panic(fmt.Sprintf("only able to generate %d keys out of %d keys, try increasing max len", kv.Len(), n))
+ ok:
+ }
+ key := make([]byte, m)
+ for j := 0; j < m; j++ {
+ key[j] = keymap[gen[j]]
+ }
+ value := make([]byte, rrand(vminlen, vmaxlen))
+ for n := copy(value, []byte(fmt.Sprintf("v%d", i))); n < len(value); n++ {
+ value[n] = 'x'
+ }
+ kv.Put(key, value)
+ }
+ return kv
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/kvtest.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/kvtest.go
new file mode 100644
index 0000000000000000000000000000000000000000..78d981c7dcd38fc198fa4c70fd3b46a9c134d83a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/kvtest.go
@@ -0,0 +1,187 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package testutil
+
+import (
+ "fmt"
+ "math/rand"
+
+ . "github.com/onsi/ginkgo"
+ . "github.com/onsi/gomega"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+func KeyValueTesting(rnd *rand.Rand, kv KeyValue, p DB, setup func(KeyValue) DB, teardown func(DB)) {
+ if rnd == nil {
+ rnd = NewRand()
+ }
+
+ if p == nil {
+ BeforeEach(func() {
+ p = setup(kv)
+ })
+ if teardown != nil {
+ AfterEach(func() {
+ teardown(p)
+ })
+ }
+ }
+
+ It("Should find all keys with Find", func() {
+ if db, ok := p.(Find); ok {
+ ShuffledIndex(nil, kv.Len(), 1, func(i int) {
+ key_, key, value := kv.IndexInexact(i)
+
+ // Using exact key.
+ rkey, rvalue, err := db.TestFind(key)
+ Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key)
+ Expect(rkey).Should(Equal(key), "Key")
+ Expect(rvalue).Should(Equal(value), "Value for key %q", key)
+
+ // Using inexact key.
+ rkey, rvalue, err = db.TestFind(key_)
+ Expect(err).ShouldNot(HaveOccurred(), "Error for key %q (%q)", key_, key)
+ Expect(rkey).Should(Equal(key))
+ Expect(rvalue).Should(Equal(value), "Value for key %q (%q)", key_, key)
+ })
+ }
+ })
+
+ It("Should return error if the key is not present", func() {
+ if db, ok := p.(Find); ok {
+ var key []byte
+ if kv.Len() > 0 {
+ key_, _ := kv.Index(kv.Len() - 1)
+ key = BytesAfter(key_)
+ }
+ rkey, _, err := db.TestFind(key)
+ Expect(err).Should(HaveOccurred(), "Find for key %q yield key %q", key, rkey)
+ Expect(err).Should(Equal(errors.ErrNotFound))
+ }
+ })
+
+ It("Should only find exact key with Get", func() {
+ if db, ok := p.(Get); ok {
+ ShuffledIndex(nil, kv.Len(), 1, func(i int) {
+ key_, key, value := kv.IndexInexact(i)
+
+ // Using exact key.
+ rvalue, err := db.TestGet(key)
+ Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key)
+ Expect(rvalue).Should(Equal(value), "Value for key %q", key)
+
+ // Using inexact key.
+ if len(key_) > 0 {
+ _, err = db.TestGet(key_)
+ Expect(err).Should(HaveOccurred(), "Error for key %q", key_)
+ Expect(err).Should(Equal(errors.ErrNotFound))
+ }
+ })
+ }
+ })
+
+ It("Should only find present key with Has", func() {
+ if db, ok := p.(Has); ok {
+ ShuffledIndex(nil, kv.Len(), 1, func(i int) {
+ key_, key, _ := kv.IndexInexact(i)
+
+ // Using exact key.
+ ret, err := db.TestHas(key)
+ Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key)
+ Expect(ret).Should(BeTrue(), "False for key %q", key)
+
+ // Using inexact key.
+ if len(key_) > 0 {
+ ret, err = db.TestHas(key_)
+ Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key_)
+ Expect(ret).ShouldNot(BeTrue(), "True for key %q", key)
+ }
+ })
+ }
+ })
+
+ TestIter := func(r *util.Range, _kv KeyValue) {
+ if db, ok := p.(NewIterator); ok {
+ iter := db.TestNewIterator(r)
+ Expect(iter.Error()).ShouldNot(HaveOccurred())
+
+ t := IteratorTesting{
+ KeyValue: _kv,
+ Iter: iter,
+ }
+
+ DoIteratorTesting(&t)
+ iter.Release()
+ }
+ }
+
+ It("Should iterates and seeks correctly", func(done Done) {
+ TestIter(nil, kv.Clone())
+ done <- true
+ }, 3.0)
+
+ RandomIndex(rnd, kv.Len(), Min(kv.Len(), 50), func(i int) {
+ type slice struct {
+ r *util.Range
+ start, limit int
+ }
+
+ key_, _, _ := kv.IndexInexact(i)
+ for _, x := range []slice{
+ {&util.Range{Start: key_, Limit: nil}, i, kv.Len()},
+ {&util.Range{Start: nil, Limit: key_}, 0, i},
+ } {
+ It(fmt.Sprintf("Should iterates and seeks correctly of a slice %d .. %d", x.start, x.limit), func(done Done) {
+ TestIter(x.r, kv.Slice(x.start, x.limit))
+ done <- true
+ }, 3.0)
+ }
+ })
+
+ RandomRange(rnd, kv.Len(), Min(kv.Len(), 50), func(start, limit int) {
+ It(fmt.Sprintf("Should iterates and seeks correctly of a slice %d .. %d", start, limit), func(done Done) {
+ r := kv.Range(start, limit)
+ TestIter(&r, kv.Slice(start, limit))
+ done <- true
+ }, 3.0)
+ })
+}
+
+func AllKeyValueTesting(rnd *rand.Rand, body, setup func(KeyValue) DB, teardown func(DB)) {
+ Test := func(kv *KeyValue) func() {
+ return func() {
+ var p DB
+ if setup != nil {
+ Defer("setup", func() {
+ p = setup(*kv)
+ })
+ }
+ if teardown != nil {
+ Defer("teardown", func() {
+ teardown(p)
+ })
+ }
+ if body != nil {
+ p = body(*kv)
+ }
+ KeyValueTesting(rnd, *kv, p, func(KeyValue) DB {
+ return p
+ }, nil)
+ }
+ }
+
+ Describe("with no key/value (empty)", Test(&KeyValue{}))
+ Describe("with empty key", Test(KeyValue_EmptyKey()))
+ Describe("with empty value", Test(KeyValue_EmptyValue()))
+ Describe("with one key/value", Test(KeyValue_OneKeyValue()))
+ Describe("with big value", Test(KeyValue_BigValue()))
+ Describe("with special key", Test(KeyValue_SpecialKey()))
+ Describe("with multiple key/value", Test(KeyValue_MultipleKeyValue()))
+ Describe("with generated key/value", Test(KeyValue_Generate(nil, 120, 1, 50, 10, 120)))
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/storage.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/storage.go
new file mode 100644
index 0000000000000000000000000000000000000000..d515438b175e1ae785a6ae3ee500808dc7c62cdb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/storage.go
@@ -0,0 +1,586 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package testutil
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "os"
+ "path/filepath"
+ "runtime"
+ "strings"
+ "sync"
+
+ . "github.com/onsi/gomega"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+var (
+ storageMu sync.Mutex
+ storageUseFS bool = true
+ storageKeepFS bool = false
+ storageNum int
+)
+
+type StorageMode int
+
+const (
+ ModeOpen StorageMode = 1 << iota
+ ModeCreate
+ ModeRemove
+ ModeRead
+ ModeWrite
+ ModeSync
+ ModeClose
+)
+
+const (
+ modeOpen = iota
+ modeCreate
+ modeRemove
+ modeRead
+ modeWrite
+ modeSync
+ modeClose
+
+ modeCount
+)
+
+const (
+ typeManifest = iota
+ typeJournal
+ typeTable
+ typeTemp
+
+ typeCount
+)
+
+const flattenCount = modeCount * typeCount
+
+func flattenType(m StorageMode, t storage.FileType) int {
+ var x int
+ switch m {
+ case ModeOpen:
+ x = modeOpen
+ case ModeCreate:
+ x = modeCreate
+ case ModeRemove:
+ x = modeRemove
+ case ModeRead:
+ x = modeRead
+ case ModeWrite:
+ x = modeWrite
+ case ModeSync:
+ x = modeSync
+ case ModeClose:
+ x = modeClose
+ default:
+ panic("invalid storage mode")
+ }
+ x *= typeCount
+ switch t {
+ case storage.TypeManifest:
+ return x + typeManifest
+ case storage.TypeJournal:
+ return x + typeJournal
+ case storage.TypeTable:
+ return x + typeTable
+ case storage.TypeTemp:
+ return x + typeTemp
+ default:
+ panic("invalid file type")
+ }
+}
+
+func listFlattenType(m StorageMode, t storage.FileType) []int {
+ ret := make([]int, 0, flattenCount)
+ add := func(x int) {
+ x *= typeCount
+ switch {
+ case t&storage.TypeManifest != 0:
+ ret = append(ret, x+typeManifest)
+ case t&storage.TypeJournal != 0:
+ ret = append(ret, x+typeJournal)
+ case t&storage.TypeTable != 0:
+ ret = append(ret, x+typeTable)
+ case t&storage.TypeTemp != 0:
+ ret = append(ret, x+typeTemp)
+ }
+ }
+ switch {
+ case m&ModeOpen != 0:
+ add(modeOpen)
+ case m&ModeCreate != 0:
+ add(modeCreate)
+ case m&ModeRemove != 0:
+ add(modeRemove)
+ case m&ModeRead != 0:
+ add(modeRead)
+ case m&ModeWrite != 0:
+ add(modeWrite)
+ case m&ModeSync != 0:
+ add(modeSync)
+ case m&ModeClose != 0:
+ add(modeClose)
+ }
+ return ret
+}
+
+func packFile(num uint64, t storage.FileType) uint64 {
+ if num>>(64-typeCount) != 0 {
+ panic("overflow")
+ }
+ return num<<typeCount | uint64(t)
+}
+
+func unpackFile(x uint64) (uint64, storage.FileType) {
+ return x >> typeCount, storage.FileType(x) & storage.TypeAll
+}
+
+type emulatedError struct {
+ err error
+}
+
+func (err emulatedError) Error() string {
+ return fmt.Sprintf("emulated storage error: %v", err.err)
+}
+
+type storageLock struct {
+ s *Storage
+ r util.Releaser
+}
+
+func (l storageLock) Release() {
+ l.r.Release()
+ l.s.logI("storage lock released")
+}
+
+type reader struct {
+ f *file
+ storage.Reader
+}
+
+func (r *reader) Read(p []byte) (n int, err error) {
+ err = r.f.s.emulateError(ModeRead, r.f.Type())
+ if err == nil {
+ r.f.s.stall(ModeRead, r.f.Type())
+ n, err = r.Reader.Read(p)
+ }
+ r.f.s.count(ModeRead, r.f.Type(), n)
+ if err != nil && err != io.EOF {
+ r.f.s.logI("read error, num=%d type=%v n=%d err=%v", r.f.Num(), r.f.Type(), n, err)
+ }
+ return
+}
+
+func (r *reader) ReadAt(p []byte, off int64) (n int, err error) {
+ err = r.f.s.emulateError(ModeRead, r.f.Type())
+ if err == nil {
+ r.f.s.stall(ModeRead, r.f.Type())
+ n, err = r.Reader.ReadAt(p, off)
+ }
+ r.f.s.count(ModeRead, r.f.Type(), n)
+ if err != nil && err != io.EOF {
+ r.f.s.logI("readAt error, num=%d type=%v offset=%d n=%d err=%v", r.f.Num(), r.f.Type(), off, n, err)
+ }
+ return
+}
+
+func (r *reader) Close() (err error) {
+ return r.f.doClose(r.Reader)
+}
+
+type writer struct {
+ f *file
+ storage.Writer
+}
+
+func (w *writer) Write(p []byte) (n int, err error) {
+ err = w.f.s.emulateError(ModeWrite, w.f.Type())
+ if err == nil {
+ w.f.s.stall(ModeWrite, w.f.Type())
+ n, err = w.Writer.Write(p)
+ }
+ w.f.s.count(ModeWrite, w.f.Type(), n)
+ if err != nil && err != io.EOF {
+ w.f.s.logI("write error, num=%d type=%v n=%d err=%v", w.f.Num(), w.f.Type(), n, err)
+ }
+ return
+}
+
+func (w *writer) Sync() (err error) {
+ err = w.f.s.emulateError(ModeSync, w.f.Type())
+ if err == nil {
+ w.f.s.stall(ModeSync, w.f.Type())
+ err = w.Writer.Sync()
+ }
+ w.f.s.count(ModeSync, w.f.Type(), 0)
+ if err != nil {
+ w.f.s.logI("sync error, num=%d type=%v err=%v", w.f.Num(), w.f.Type(), err)
+ }
+ return
+}
+
+func (w *writer) Close() (err error) {
+ return w.f.doClose(w.Writer)
+}
+
+type file struct {
+ s *Storage
+ storage.File
+}
+
+func (f *file) pack() uint64 {
+ return packFile(f.Num(), f.Type())
+}
+
+func (f *file) assertOpen() {
+ ExpectWithOffset(2, f.s.opens).NotTo(HaveKey(f.pack()), "File open, num=%d type=%v writer=%v", f.Num(), f.Type(), f.s.opens[f.pack()])
+}
+
+func (f *file) doClose(closer io.Closer) (err error) {
+ err = f.s.emulateError(ModeClose, f.Type())
+ if err == nil {
+ f.s.stall(ModeClose, f.Type())
+ }
+ f.s.mu.Lock()
+ defer f.s.mu.Unlock()
+ if err == nil {
+ ExpectWithOffset(2, f.s.opens).To(HaveKey(f.pack()), "File closed, num=%d type=%v", f.Num(), f.Type())
+ err = closer.Close()
+ }
+ f.s.countNB(ModeClose, f.Type(), 0)
+ writer := f.s.opens[f.pack()]
+ if err != nil {
+ f.s.logISkip(1, "file close failed, num=%d type=%v writer=%v err=%v", f.Num(), f.Type(), writer, err)
+ } else {
+ f.s.logISkip(1, "file closed, num=%d type=%v writer=%v", f.Num(), f.Type(), writer)
+ delete(f.s.opens, f.pack())
+ }
+ return
+}
+
+func (f *file) Open() (r storage.Reader, err error) {
+ err = f.s.emulateError(ModeOpen, f.Type())
+ if err == nil {
+ f.s.stall(ModeOpen, f.Type())
+ }
+ f.s.mu.Lock()
+ defer f.s.mu.Unlock()
+ if err == nil {
+ f.assertOpen()
+ f.s.countNB(ModeOpen, f.Type(), 0)
+ r, err = f.File.Open()
+ }
+ if err != nil {
+ f.s.logI("file open failed, num=%d type=%v err=%v", f.Num(), f.Type(), err)
+ } else {
+ f.s.logI("file opened, num=%d type=%v", f.Num(), f.Type())
+ f.s.opens[f.pack()] = false
+ r = &reader{f, r}
+ }
+ return
+}
+
+func (f *file) Create() (w storage.Writer, err error) {
+ err = f.s.emulateError(ModeCreate, f.Type())
+ if err == nil {
+ f.s.stall(ModeCreate, f.Type())
+ }
+ f.s.mu.Lock()
+ defer f.s.mu.Unlock()
+ if err == nil {
+ f.assertOpen()
+ f.s.countNB(ModeCreate, f.Type(), 0)
+ w, err = f.File.Create()
+ }
+ if err != nil {
+ f.s.logI("file create failed, num=%d type=%v err=%v", f.Num(), f.Type(), err)
+ } else {
+ f.s.logI("file created, num=%d type=%v", f.Num(), f.Type())
+ f.s.opens[f.pack()] = true
+ w = &writer{f, w}
+ }
+ return
+}
+
+func (f *file) Remove() (err error) {
+ err = f.s.emulateError(ModeRemove, f.Type())
+ if err == nil {
+ f.s.stall(ModeRemove, f.Type())
+ }
+ f.s.mu.Lock()
+ defer f.s.mu.Unlock()
+ if err == nil {
+ f.assertOpen()
+ f.s.countNB(ModeRemove, f.Type(), 0)
+ err = f.File.Remove()
+ }
+ if err != nil {
+ f.s.logI("file remove failed, num=%d type=%v err=%v", f.Num(), f.Type(), err)
+ } else {
+ f.s.logI("file removed, num=%d type=%v", f.Num(), f.Type())
+ }
+ return
+}
+
+type Storage struct {
+ storage.Storage
+ closeFn func() error
+
+ lmu sync.Mutex
+ lb bytes.Buffer
+
+ mu sync.Mutex
+ // Open files, true=writer, false=reader
+ opens map[uint64]bool
+ counters [flattenCount]int
+ bytesCounter [flattenCount]int64
+ emulatedError [flattenCount]error
+ stallCond sync.Cond
+ stalled [flattenCount]bool
+}
+
+func (s *Storage) log(skip int, str string) {
+ s.lmu.Lock()
+ defer s.lmu.Unlock()
+ _, file, line, ok := runtime.Caller(skip + 2)
+ if ok {
+ // Truncate file name at last file name separator.
+ if index := strings.LastIndex(file, "/"); index >= 0 {
+ file = file[index+1:]
+ } else if index = strings.LastIndex(file, "\\"); index >= 0 {
+ file = file[index+1:]
+ }
+ } else {
+ file = "???"
+ line = 1
+ }
+ fmt.Fprintf(&s.lb, "%s:%d: ", file, line)
+ lines := strings.Split(str, "\n")
+ if l := len(lines); l > 1 && lines[l-1] == "" {
+ lines = lines[:l-1]
+ }
+ for i, line := range lines {
+ if i > 0 {
+ s.lb.WriteString("\n\t")
+ }
+ s.lb.WriteString(line)
+ }
+ s.lb.WriteByte('\n')
+}
+
+func (s *Storage) logISkip(skip int, format string, args ...interface{}) {
+ pc, _, _, ok := runtime.Caller(skip + 1)
+ if ok {
+ if f := runtime.FuncForPC(pc); f != nil {
+ fname := f.Name()
+ if index := strings.LastIndex(fname, "."); index >= 0 {
+ fname = fname[index+1:]
+ }
+ format = fname + ": " + format
+ }
+ }
+ s.log(skip+1, fmt.Sprintf(format, args...))
+}
+
+func (s *Storage) logI(format string, args ...interface{}) {
+ s.logISkip(1, format, args...)
+}
+
+func (s *Storage) Log(str string) {
+ s.log(1, "Log: "+str)
+ s.Storage.Log(str)
+}
+
+func (s *Storage) Lock() (r util.Releaser, err error) {
+ r, err = s.Storage.Lock()
+ if err != nil {
+ s.logI("storage locking failed, err=%v", err)
+ } else {
+ s.logI("storage locked")
+ r = storageLock{s, r}
+ }
+ return
+}
+
+func (s *Storage) GetFile(num uint64, t storage.FileType) storage.File {
+ return &file{s, s.Storage.GetFile(num, t)}
+}
+
+func (s *Storage) GetFiles(t storage.FileType) (files []storage.File, err error) {
+ rfiles, err := s.Storage.GetFiles(t)
+ if err != nil {
+ s.logI("get files failed, err=%v", err)
+ return
+ }
+ files = make([]storage.File, len(rfiles))
+ for i, f := range rfiles {
+ files[i] = &file{s, f}
+ }
+ s.logI("get files, type=0x%x count=%d", int(t), len(files))
+ return
+}
+
+func (s *Storage) GetManifest() (f storage.File, err error) {
+ manifest, err := s.Storage.GetManifest()
+ if err != nil {
+ if !os.IsNotExist(err) {
+ s.logI("get manifest failed, err=%v", err)
+ }
+ return
+ }
+ s.logI("get manifest, num=%d", manifest.Num())
+ return &file{s, manifest}, nil
+}
+
+func (s *Storage) SetManifest(f storage.File) error {
+ f_, ok := f.(*file)
+ ExpectWithOffset(1, ok).To(BeTrue())
+ ExpectWithOffset(1, f_.Type()).To(Equal(storage.TypeManifest))
+ err := s.Storage.SetManifest(f_.File)
+ if err != nil {
+ s.logI("set manifest failed, err=%v", err)
+ } else {
+ s.logI("set manifest, num=%d", f_.Num())
+ }
+ return err
+}
+
+func (s *Storage) openFiles() string {
+ out := "Open files:"
+ for x, writer := range s.opens {
+ num, t := unpackFile(x)
+ out += fmt.Sprintf("\n · num=%d type=%v writer=%v", num, t, writer)
+ }
+ return out
+}
+
+func (s *Storage) Close() error {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ ExpectWithOffset(1, s.opens).To(BeEmpty(), s.openFiles())
+ err := s.Storage.Close()
+ if err != nil {
+ s.logI("storage closing failed, err=%v", err)
+ } else {
+ s.logI("storage closed")
+ }
+ if s.closeFn != nil {
+ if err1 := s.closeFn(); err1 != nil {
+ s.logI("close func error, err=%v", err1)
+ }
+ }
+ return err
+}
+
+func (s *Storage) countNB(m StorageMode, t storage.FileType, n int) {
+ s.counters[flattenType(m, t)]++
+ s.bytesCounter[flattenType(m, t)] += int64(n)
+}
+
+func (s *Storage) count(m StorageMode, t storage.FileType, n int) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ s.countNB(m, t, n)
+}
+
+func (s *Storage) ResetCounter(m StorageMode, t storage.FileType) {
+ for _, x := range listFlattenType(m, t) {
+ s.counters[x] = 0
+ s.bytesCounter[x] = 0
+ }
+}
+
+func (s *Storage) Counter(m StorageMode, t storage.FileType) (count int, bytes int64) {
+ for _, x := range listFlattenType(m, t) {
+ count += s.counters[x]
+ bytes += s.bytesCounter[x]
+ }
+ return
+}
+
+func (s *Storage) emulateError(m StorageMode, t storage.FileType) error {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ err := s.emulatedError[flattenType(m, t)]
+ if err != nil {
+ return emulatedError{err}
+ }
+ return nil
+}
+
+func (s *Storage) EmulateError(m StorageMode, t storage.FileType, err error) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ for _, x := range listFlattenType(m, t) {
+ s.emulatedError[x] = err
+ }
+}
+
+func (s *Storage) stall(m StorageMode, t storage.FileType) {
+ x := flattenType(m, t)
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ for s.stalled[x] {
+ s.stallCond.Wait()
+ }
+}
+
+func (s *Storage) Stall(m StorageMode, t storage.FileType) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ for _, x := range listFlattenType(m, t) {
+ s.stalled[x] = true
+ }
+}
+
+func (s *Storage) Release(m StorageMode, t storage.FileType) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ for _, x := range listFlattenType(m, t) {
+ s.stalled[x] = false
+ }
+ s.stallCond.Broadcast()
+}
+
+func NewStorage() *Storage {
+ var stor storage.Storage
+ var closeFn func() error
+ if storageUseFS {
+ for {
+ storageMu.Lock()
+ num := storageNum
+ storageNum++
+ storageMu.Unlock()
+ path := filepath.Join(os.TempDir(), fmt.Sprintf("goleveldb-test%d0%d0%d", os.Getuid(), os.Getpid(), num))
+ if _, err := os.Stat(path); os.IsNotExist(err) {
+ stor, err = storage.OpenFile(path)
+ ExpectWithOffset(1, err).NotTo(HaveOccurred(), "creating storage at %s", path)
+ closeFn = func() error {
+ if storageKeepFS {
+ return nil
+ }
+ return os.RemoveAll(path)
+ }
+ break
+ }
+ }
+ } else {
+ stor = storage.NewMemStorage()
+ }
+ s := &Storage{
+ Storage: stor,
+ closeFn: closeFn,
+ opens: make(map[uint64]bool),
+ }
+ s.stallCond.L = &s.mu
+ return s
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/util.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..7ac261ddba2bd4c5056f737f2af07dd0cdca1f61
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/util.go
@@ -0,0 +1,171 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package testutil
+
+import (
+ "bytes"
+ "flag"
+ "math/rand"
+ "reflect"
+ "sync"
+
+ "github.com/onsi/ginkgo/config"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer"
+)
+
+var (
+ runfn = make(map[string][]func())
+ runmu sync.Mutex
+)
+
+func Defer(args ...interface{}) bool {
+ var (
+ group string
+ fn func()
+ )
+ for _, arg := range args {
+ v := reflect.ValueOf(arg)
+ switch v.Kind() {
+ case reflect.String:
+ group = v.String()
+ case reflect.Func:
+ r := reflect.ValueOf(&fn).Elem()
+ r.Set(v)
+ }
+ }
+ if fn != nil {
+ runmu.Lock()
+ runfn[group] = append(runfn[group], fn)
+ runmu.Unlock()
+ }
+ return true
+}
+
+func RunDefer(groups ...string) bool {
+ if len(groups) == 0 {
+ groups = append(groups, "")
+ }
+ runmu.Lock()
+ var runfn_ []func()
+ for _, group := range groups {
+ runfn_ = append(runfn_, runfn[group]...)
+ delete(runfn, group)
+ }
+ runmu.Unlock()
+ for _, fn := range runfn_ {
+ fn()
+ }
+ return runfn_ != nil
+}
+
+func RandomSeed() int64 {
+ if !flag.Parsed() {
+ panic("random seed not initialized")
+ }
+ return config.GinkgoConfig.RandomSeed
+}
+
+func NewRand() *rand.Rand {
+ return rand.New(rand.NewSource(RandomSeed()))
+}
+
+var cmp = comparer.DefaultComparer
+
+func BytesSeparator(a, b []byte) []byte {
+ if bytes.Equal(a, b) {
+ return b
+ }
+ i, n := 0, len(a)
+ if n > len(b) {
+ n = len(b)
+ }
+ for ; i < n && (a[i] == b[i]); i++ {
+ }
+ x := append([]byte{}, a[:i]...)
+ if i < n {
+ if c := a[i] + 1; c < b[i] {
+ return append(x, c)
+ }
+ x = append(x, a[i])
+ i++
+ }
+ for ; i < len(a); i++ {
+ if c := a[i]; c < 0xff {
+ return append(x, c+1)
+ } else {
+ x = append(x, c)
+ }
+ }
+ if len(b) > i && b[i] > 0 {
+ return append(x, b[i]-1)
+ }
+ return append(x, 'x')
+}
+
+func BytesAfter(b []byte) []byte {
+ var x []byte
+ for _, c := range b {
+ if c < 0xff {
+ return append(x, c+1)
+ } else {
+ x = append(x, c)
+ }
+ }
+ return append(x, 'x')
+}
+
+func RandomIndex(rnd *rand.Rand, n, round int, fn func(i int)) {
+ if rnd == nil {
+ rnd = NewRand()
+ }
+ for x := 0; x < round; x++ {
+ fn(rnd.Intn(n))
+ }
+ return
+}
+
+func ShuffledIndex(rnd *rand.Rand, n, round int, fn func(i int)) {
+ if rnd == nil {
+ rnd = NewRand()
+ }
+ for x := 0; x < round; x++ {
+ for _, i := range rnd.Perm(n) {
+ fn(i)
+ }
+ }
+ return
+}
+
+func RandomRange(rnd *rand.Rand, n, round int, fn func(start, limit int)) {
+ if rnd == nil {
+ rnd = NewRand()
+ }
+ for x := 0; x < round; x++ {
+ start := rnd.Intn(n)
+ length := 0
+ if j := n - start; j > 0 {
+ length = rnd.Intn(j)
+ }
+ fn(start, start+length)
+ }
+ return
+}
+
+func Max(x, y int) int {
+ if x > y {
+ return x
+ }
+ return y
+}
+
+func Min(x, y int) int {
+ if x < y {
+ return x
+ }
+ return y
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..868f7ffab3e0df8ba7c583e05b1960529148e8ad
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil_test.go
@@ -0,0 +1,63 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ . "github.com/onsi/gomega"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type testingDB struct {
+ *DB
+ ro *opt.ReadOptions
+ wo *opt.WriteOptions
+ stor *testutil.Storage
+}
+
+func (t *testingDB) TestPut(key []byte, value []byte) error {
+ return t.Put(key, value, t.wo)
+}
+
+func (t *testingDB) TestDelete(key []byte) error {
+ return t.Delete(key, t.wo)
+}
+
+func (t *testingDB) TestGet(key []byte) (value []byte, err error) {
+ return t.Get(key, t.ro)
+}
+
+func (t *testingDB) TestHas(key []byte) (ret bool, err error) {
+ return t.Has(key, t.ro)
+}
+
+func (t *testingDB) TestNewIterator(slice *util.Range) iterator.Iterator {
+ return t.NewIterator(slice, t.ro)
+}
+
+func (t *testingDB) TestClose() {
+ err := t.Close()
+ ExpectWithOffset(1, err).NotTo(HaveOccurred())
+ err = t.stor.Close()
+ ExpectWithOffset(1, err).NotTo(HaveOccurred())
+}
+
+func newTestingDB(o *opt.Options, ro *opt.ReadOptions, wo *opt.WriteOptions) *testingDB {
+ stor := testutil.NewStorage()
+ db, err := Open(stor, o)
+ // FIXME: This may be called from outside It, which may cause panic.
+ Expect(err).NotTo(HaveOccurred())
+ return &testingDB{
+ DB: db,
+ ro: ro,
+ wo: wo,
+ stor: stor,
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..7de9260d0d38eb3b21e5e2c5d2841695bda8a4ad
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util.go
@@ -0,0 +1,91 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "fmt"
+ "sort"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage"
+)
+
+func shorten(str string) string {
+ if len(str) <= 8 {
+ return str
+ }
+ return str[:3] + ".." + str[len(str)-3:]
+}
+
+var bunits = [...]string{"", "Ki", "Mi", "Gi"}
+
+func shortenb(bytes int) string {
+ i := 0
+ for ; bytes > 1024 && i < 4; i++ {
+ bytes /= 1024
+ }
+ return fmt.Sprintf("%d%sB", bytes, bunits[i])
+}
+
+func sshortenb(bytes int) string {
+ if bytes == 0 {
+ return "~"
+ }
+ sign := "+"
+ if bytes < 0 {
+ sign = "-"
+ bytes *= -1
+ }
+ i := 0
+ for ; bytes > 1024 && i < 4; i++ {
+ bytes /= 1024
+ }
+ return fmt.Sprintf("%s%d%sB", sign, bytes, bunits[i])
+}
+
+func sint(x int) string {
+ if x == 0 {
+ return "~"
+ }
+ sign := "+"
+ if x < 0 {
+ sign = "-"
+ x *= -1
+ }
+ return fmt.Sprintf("%s%d", sign, x)
+}
+
+func minInt(a, b int) int {
+ if a < b {
+ return a
+ }
+ return b
+}
+
+func maxInt(a, b int) int {
+ if a > b {
+ return a
+ }
+ return b
+}
+
+type files []storage.File
+
+func (p files) Len() int {
+ return len(p)
+}
+
+func (p files) Less(i, j int) bool {
+ return p[i].Num() < p[j].Num()
+}
+
+func (p files) Swap(i, j int) {
+ p[i], p[j] = p[j], p[i]
+}
+
+func (p files) sort() {
+ sort.Sort(p)
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/buffer.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/buffer.go
new file mode 100644
index 0000000000000000000000000000000000000000..21de242552d20fac45c3e38a2c581f367f7a7988
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/buffer.go
@@ -0,0 +1,293 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package util
+
+// This a copy of Go std bytes.Buffer with some modification
+// and some features stripped.
+
+import (
+ "bytes"
+ "io"
+)
+
+// A Buffer is a variable-sized buffer of bytes with Read and Write methods.
+// The zero value for Buffer is an empty buffer ready to use.
+type Buffer struct {
+ buf []byte // contents are the bytes buf[off : len(buf)]
+ off int // read at &buf[off], write at &buf[len(buf)]
+ bootstrap [64]byte // memory to hold first slice; helps small buffers (Printf) avoid allocation.
+}
+
+// Bytes returns a slice of the contents of the unread portion of the buffer;
+// len(b.Bytes()) == b.Len(). If the caller changes the contents of the
+// returned slice, the contents of the buffer will change provided there
+// are no intervening method calls on the Buffer.
+func (b *Buffer) Bytes() []byte { return b.buf[b.off:] }
+
+// String returns the contents of the unread portion of the buffer
+// as a string. If the Buffer is a nil pointer, it returns "<nil>".
+func (b *Buffer) String() string {
+ if b == nil {
+ // Special case, useful in debugging.
+ return "<nil>"
+ }
+ return string(b.buf[b.off:])
+}
+
+// Len returns the number of bytes of the unread portion of the buffer;
+// b.Len() == len(b.Bytes()).
+func (b *Buffer) Len() int { return len(b.buf) - b.off }
+
+// Truncate discards all but the first n unread bytes from the buffer.
+// It panics if n is negative or greater than the length of the buffer.
+func (b *Buffer) Truncate(n int) {
+ switch {
+ case n < 0 || n > b.Len():
+ panic("leveldb/util.Buffer: truncation out of range")
+ case n == 0:
+ // Reuse buffer space.
+ b.off = 0
+ }
+ b.buf = b.buf[0 : b.off+n]
+}
+
+// Reset resets the buffer so it has no content.
+// b.Reset() is the same as b.Truncate(0).
+func (b *Buffer) Reset() { b.Truncate(0) }
+
+// grow grows the buffer to guarantee space for n more bytes.
+// It returns the index where bytes should be written.
+// If the buffer can't grow it will panic with bytes.ErrTooLarge.
+func (b *Buffer) grow(n int) int {
+ m := b.Len()
+ // If buffer is empty, reset to recover space.
+ if m == 0 && b.off != 0 {
+ b.Truncate(0)
+ }
+ if len(b.buf)+n > cap(b.buf) {
+ var buf []byte
+ if b.buf == nil && n <= len(b.bootstrap) {
+ buf = b.bootstrap[0:]
+ } else if m+n <= cap(b.buf)/2 {
+ // We can slide things down instead of allocating a new
+ // slice. We only need m+n <= cap(b.buf) to slide, but
+ // we instead let capacity get twice as large so we
+ // don't spend all our time copying.
+ copy(b.buf[:], b.buf[b.off:])
+ buf = b.buf[:m]
+ } else {
+ // not enough space anywhere
+ buf = makeSlice(2*cap(b.buf) + n)
+ copy(buf, b.buf[b.off:])
+ }
+ b.buf = buf
+ b.off = 0
+ }
+ b.buf = b.buf[0 : b.off+m+n]
+ return b.off + m
+}
+
+// Alloc allocs n bytes of slice from the buffer, growing the buffer as
+// needed. If n is negative, Alloc will panic.
+// If the buffer can't grow it will panic with bytes.ErrTooLarge.
+func (b *Buffer) Alloc(n int) []byte {
+ if n < 0 {
+ panic("leveldb/util.Buffer.Alloc: negative count")
+ }
+ m := b.grow(n)
+ return b.buf[m:]
+}
+
+// Grow grows the buffer's capacity, if necessary, to guarantee space for
+// another n bytes. After Grow(n), at least n bytes can be written to the
+// buffer without another allocation.
+// If n is negative, Grow will panic.
+// If the buffer can't grow it will panic with bytes.ErrTooLarge.
+func (b *Buffer) Grow(n int) {
+ if n < 0 {
+ panic("leveldb/util.Buffer.Grow: negative count")
+ }
+ m := b.grow(n)
+ b.buf = b.buf[0:m]
+}
+
+// Write appends the contents of p to the buffer, growing the buffer as
+// needed. The return value n is the length of p; err is always nil. If the
+// buffer becomes too large, Write will panic with bytes.ErrTooLarge.
+func (b *Buffer) Write(p []byte) (n int, err error) {
+ m := b.grow(len(p))
+ return copy(b.buf[m:], p), nil
+}
+
+// MinRead is the minimum slice size passed to a Read call by
+// Buffer.ReadFrom. As long as the Buffer has at least MinRead bytes beyond
+// what is required to hold the contents of r, ReadFrom will not grow the
+// underlying buffer.
+const MinRead = 512
+
+// ReadFrom reads data from r until EOF and appends it to the buffer, growing
+// the buffer as needed. The return value n is the number of bytes read. Any
+// error except io.EOF encountered during the read is also returned. If the
+// buffer becomes too large, ReadFrom will panic with bytes.ErrTooLarge.
+func (b *Buffer) ReadFrom(r io.Reader) (n int64, err error) {
+ // If buffer is empty, reset to recover space.
+ if b.off >= len(b.buf) {
+ b.Truncate(0)
+ }
+ for {
+ if free := cap(b.buf) - len(b.buf); free < MinRead {
+ // not enough space at end
+ newBuf := b.buf
+ if b.off+free < MinRead {
+ // not enough space using beginning of buffer;
+ // double buffer capacity
+ newBuf = makeSlice(2*cap(b.buf) + MinRead)
+ }
+ copy(newBuf, b.buf[b.off:])
+ b.buf = newBuf[:len(b.buf)-b.off]
+ b.off = 0
+ }
+ m, e := r.Read(b.buf[len(b.buf):cap(b.buf)])
+ b.buf = b.buf[0 : len(b.buf)+m]
+ n += int64(m)
+ if e == io.EOF {
+ break
+ }
+ if e != nil {
+ return n, e
+ }
+ }
+ return n, nil // err is EOF, so return nil explicitly
+}
+
+// makeSlice allocates a slice of size n. If the allocation fails, it panics
+// with bytes.ErrTooLarge.
+func makeSlice(n int) []byte {
+ // If the make fails, give a known error.
+ defer func() {
+ if recover() != nil {
+ panic(bytes.ErrTooLarge)
+ }
+ }()
+ return make([]byte, n)
+}
+
+// WriteTo writes data to w until the buffer is drained or an error occurs.
+// The return value n is the number of bytes written; it always fits into an
+// int, but it is int64 to match the io.WriterTo interface. Any error
+// encountered during the write is also returned.
+func (b *Buffer) WriteTo(w io.Writer) (n int64, err error) {
+ if b.off < len(b.buf) {
+ nBytes := b.Len()
+ m, e := w.Write(b.buf[b.off:])
+ if m > nBytes {
+ panic("leveldb/util.Buffer.WriteTo: invalid Write count")
+ }
+ b.off += m
+ n = int64(m)
+ if e != nil {
+ return n, e
+ }
+ // all bytes should have been written, by definition of
+ // Write method in io.Writer
+ if m != nBytes {
+ return n, io.ErrShortWrite
+ }
+ }
+ // Buffer is now empty; reset.
+ b.Truncate(0)
+ return
+}
+
+// WriteByte appends the byte c to the buffer, growing the buffer as needed.
+// The returned error is always nil, but is included to match bufio.Writer's
+// WriteByte. If the buffer becomes too large, WriteByte will panic with
+// bytes.ErrTooLarge.
+func (b *Buffer) WriteByte(c byte) error {
+ m := b.grow(1)
+ b.buf[m] = c
+ return nil
+}
+
+// Read reads the next len(p) bytes from the buffer or until the buffer
+// is drained. The return value n is the number of bytes read. If the
+// buffer has no data to return, err is io.EOF (unless len(p) is zero);
+// otherwise it is nil.
+func (b *Buffer) Read(p []byte) (n int, err error) {
+ if b.off >= len(b.buf) {
+ // Buffer is empty, reset to recover space.
+ b.Truncate(0)
+ if len(p) == 0 {
+ return
+ }
+ return 0, io.EOF
+ }
+ n = copy(p, b.buf[b.off:])
+ b.off += n
+ return
+}
+
+// Next returns a slice containing the next n bytes from the buffer,
+// advancing the buffer as if the bytes had been returned by Read.
+// If there are fewer than n bytes in the buffer, Next returns the entire buffer.
+// The slice is only valid until the next call to a read or write method.
+func (b *Buffer) Next(n int) []byte {
+ m := b.Len()
+ if n > m {
+ n = m
+ }
+ data := b.buf[b.off : b.off+n]
+ b.off += n
+ return data
+}
+
+// ReadByte reads and returns the next byte from the buffer.
+// If no byte is available, it returns error io.EOF.
+func (b *Buffer) ReadByte() (c byte, err error) {
+ if b.off >= len(b.buf) {
+ // Buffer is empty, reset to recover space.
+ b.Truncate(0)
+ return 0, io.EOF
+ }
+ c = b.buf[b.off]
+ b.off++
+ return c, nil
+}
+
+// ReadBytes reads until the first occurrence of delim in the input,
+// returning a slice containing the data up to and including the delimiter.
+// If ReadBytes encounters an error before finding a delimiter,
+// it returns the data read before the error and the error itself (often io.EOF).
+// ReadBytes returns err != nil if and only if the returned data does not end in
+// delim.
+func (b *Buffer) ReadBytes(delim byte) (line []byte, err error) {
+ slice, err := b.readSlice(delim)
+ // return a copy of slice. The buffer's backing array may
+ // be overwritten by later calls.
+ line = append(line, slice...)
+ return
+}
+
+// readSlice is like ReadBytes but returns a reference to internal buffer data.
+func (b *Buffer) readSlice(delim byte) (line []byte, err error) {
+ i := bytes.IndexByte(b.buf[b.off:], delim)
+ end := b.off + i + 1
+ if i < 0 {
+ end = len(b.buf)
+ err = io.EOF
+ }
+ line = b.buf[b.off:end]
+ b.off = end
+ return line, err
+}
+
+// NewBuffer creates and initializes a new Buffer using buf as its initial
+// contents. It is intended to prepare a Buffer to read existing data. It
+// can also be used to size the internal buffer for writing. To do that,
+// buf should have the desired capacity but a length of zero.
+//
+// In most cases, new(Buffer) (or just declaring a Buffer variable) is
+// sufficient to initialize a Buffer.
+func NewBuffer(buf []byte) *Buffer { return &Buffer{buf: buf} }
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/buffer_pool.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/buffer_pool.go
new file mode 100644
index 0000000000000000000000000000000000000000..2b8453d759817fe01e9e87a91c93499b2e6d4ee8
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/buffer_pool.go
@@ -0,0 +1,238 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package util
+
+import (
+ "fmt"
+ "sync"
+ "sync/atomic"
+ "time"
+)
+
+type buffer struct {
+ b []byte
+ miss int
+}
+
+// BufferPool is a 'buffer pool'.
+type BufferPool struct {
+ pool [6]chan []byte
+ size [5]uint32
+ sizeMiss [5]uint32
+ sizeHalf [5]uint32
+ baseline [4]int
+ baseline0 int
+
+ mu sync.RWMutex
+ closed bool
+ closeC chan struct{}
+
+ get uint32
+ put uint32
+ half uint32
+ less uint32
+ equal uint32
+ greater uint32
+ miss uint32
+}
+
+func (p *BufferPool) poolNum(n int) int {
+ if n <= p.baseline0 && n > p.baseline0/2 {
+ return 0
+ }
+ for i, x := range p.baseline {
+ if n <= x {
+ return i + 1
+ }
+ }
+ return len(p.baseline) + 1
+}
+
+// Get returns buffer with length of n.
+func (p *BufferPool) Get(n int) []byte {
+ if p == nil {
+ return make([]byte, n)
+ }
+
+ p.mu.RLock()
+ defer p.mu.RUnlock()
+
+ if p.closed {
+ return make([]byte, n)
+ }
+
+ atomic.AddUint32(&p.get, 1)
+
+ poolNum := p.poolNum(n)
+ pool := p.pool[poolNum]
+ if poolNum == 0 {
+ // Fast path.
+ select {
+ case b := <-pool:
+ switch {
+ case cap(b) > n:
+ if cap(b)-n >= n {
+ atomic.AddUint32(&p.half, 1)
+ select {
+ case pool <- b:
+ default:
+ }
+ return make([]byte, n)
+ } else {
+ atomic.AddUint32(&p.less, 1)
+ return b[:n]
+ }
+ case cap(b) == n:
+ atomic.AddUint32(&p.equal, 1)
+ return b[:n]
+ default:
+ atomic.AddUint32(&p.greater, 1)
+ }
+ default:
+ atomic.AddUint32(&p.miss, 1)
+ }
+
+ return make([]byte, n, p.baseline0)
+ } else {
+ sizePtr := &p.size[poolNum-1]
+
+ select {
+ case b := <-pool:
+ switch {
+ case cap(b) > n:
+ if cap(b)-n >= n {
+ atomic.AddUint32(&p.half, 1)
+ sizeHalfPtr := &p.sizeHalf[poolNum-1]
+ if atomic.AddUint32(sizeHalfPtr, 1) == 20 {
+ atomic.StoreUint32(sizePtr, uint32(cap(b)/2))
+ atomic.StoreUint32(sizeHalfPtr, 0)
+ } else {
+ select {
+ case pool <- b:
+ default:
+ }
+ }
+ return make([]byte, n)
+ } else {
+ atomic.AddUint32(&p.less, 1)
+ return b[:n]
+ }
+ case cap(b) == n:
+ atomic.AddUint32(&p.equal, 1)
+ return b[:n]
+ default:
+ atomic.AddUint32(&p.greater, 1)
+ if uint32(cap(b)) >= atomic.LoadUint32(sizePtr) {
+ select {
+ case pool <- b:
+ default:
+ }
+ }
+ }
+ default:
+ atomic.AddUint32(&p.miss, 1)
+ }
+
+ if size := atomic.LoadUint32(sizePtr); uint32(n) > size {
+ if size == 0 {
+ atomic.CompareAndSwapUint32(sizePtr, 0, uint32(n))
+ } else {
+ sizeMissPtr := &p.sizeMiss[poolNum-1]
+ if atomic.AddUint32(sizeMissPtr, 1) == 20 {
+ atomic.StoreUint32(sizePtr, uint32(n))
+ atomic.StoreUint32(sizeMissPtr, 0)
+ }
+ }
+ return make([]byte, n)
+ } else {
+ return make([]byte, n, size)
+ }
+ }
+}
+
+// Put adds given buffer to the pool.
+func (p *BufferPool) Put(b []byte) {
+ if p == nil {
+ return
+ }
+
+ p.mu.RLock()
+ defer p.mu.RUnlock()
+
+ if p.closed {
+ return
+ }
+
+ atomic.AddUint32(&p.put, 1)
+
+ pool := p.pool[p.poolNum(cap(b))]
+ select {
+ case pool <- b:
+ default:
+ }
+
+}
+
+func (p *BufferPool) Close() {
+ if p == nil {
+ return
+ }
+
+ p.mu.Lock()
+ if !p.closed {
+ p.closed = true
+ p.closeC <- struct{}{}
+ }
+ p.mu.Unlock()
+}
+
+func (p *BufferPool) String() string {
+ if p == nil {
+ return "<nil>"
+ }
+
+ return fmt.Sprintf("BufferPool{B·%d Z·%v Zm·%v Zh·%v G·%d P·%d H·%d <·%d =·%d >·%d M·%d}",
+ p.baseline0, p.size, p.sizeMiss, p.sizeHalf, p.get, p.put, p.half, p.less, p.equal, p.greater, p.miss)
+}
+
+func (p *BufferPool) drain() {
+ ticker := time.NewTicker(2 * time.Second)
+ for {
+ select {
+ case <-ticker.C:
+ for _, ch := range p.pool {
+ select {
+ case <-ch:
+ default:
+ }
+ }
+ case <-p.closeC:
+ close(p.closeC)
+ for _, ch := range p.pool {
+ close(ch)
+ }
+ return
+ }
+ }
+}
+
+// NewBufferPool creates a new initialized 'buffer pool'.
+func NewBufferPool(baseline int) *BufferPool {
+ if baseline <= 0 {
+ panic("baseline can't be <= 0")
+ }
+ p := &BufferPool{
+ baseline0: baseline,
+ baseline: [...]int{baseline / 4, baseline / 2, baseline * 2, baseline * 4},
+ closeC: make(chan struct{}, 1),
+ }
+ for i, cap := range []int{2, 2, 4, 4, 2, 1} {
+ p.pool[i] = make(chan []byte, cap)
+ }
+ go p.drain()
+ return p
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/buffer_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/buffer_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..87d96739c43d08dffc75fb31e547bb44aee2c42e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/buffer_test.go
@@ -0,0 +1,369 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package util
+
+import (
+ "bytes"
+ "io"
+ "math/rand"
+ "runtime"
+ "testing"
+)
+
+const N = 10000 // make this bigger for a larger (and slower) test
+var data string // test data for write tests
+var testBytes []byte // test data; same as data but as a slice.
+
+func init() {
+ testBytes = make([]byte, N)
+ for i := 0; i < N; i++ {
+ testBytes[i] = 'a' + byte(i%26)
+ }
+ data = string(testBytes)
+}
+
+// Verify that contents of buf match the string s.
+func check(t *testing.T, testname string, buf *Buffer, s string) {
+ bytes := buf.Bytes()
+ str := buf.String()
+ if buf.Len() != len(bytes) {
+ t.Errorf("%s: buf.Len() == %d, len(buf.Bytes()) == %d", testname, buf.Len(), len(bytes))
+ }
+
+ if buf.Len() != len(str) {
+ t.Errorf("%s: buf.Len() == %d, len(buf.String()) == %d", testname, buf.Len(), len(str))
+ }
+
+ if buf.Len() != len(s) {
+ t.Errorf("%s: buf.Len() == %d, len(s) == %d", testname, buf.Len(), len(s))
+ }
+
+ if string(bytes) != s {
+ t.Errorf("%s: string(buf.Bytes()) == %q, s == %q", testname, string(bytes), s)
+ }
+}
+
+// Fill buf through n writes of byte slice fub.
+// The initial contents of buf corresponds to the string s;
+// the result is the final contents of buf returned as a string.
+func fillBytes(t *testing.T, testname string, buf *Buffer, s string, n int, fub []byte) string {
+ check(t, testname+" (fill 1)", buf, s)
+ for ; n > 0; n-- {
+ m, err := buf.Write(fub)
+ if m != len(fub) {
+ t.Errorf(testname+" (fill 2): m == %d, expected %d", m, len(fub))
+ }
+ if err != nil {
+ t.Errorf(testname+" (fill 3): err should always be nil, found err == %s", err)
+ }
+ s += string(fub)
+ check(t, testname+" (fill 4)", buf, s)
+ }
+ return s
+}
+
+func TestNewBuffer(t *testing.T) {
+ buf := NewBuffer(testBytes)
+ check(t, "NewBuffer", buf, data)
+}
+
+// Empty buf through repeated reads into fub.
+// The initial contents of buf corresponds to the string s.
+func empty(t *testing.T, testname string, buf *Buffer, s string, fub []byte) {
+ check(t, testname+" (empty 1)", buf, s)
+
+ for {
+ n, err := buf.Read(fub)
+ if n == 0 {
+ break
+ }
+ if err != nil {
+ t.Errorf(testname+" (empty 2): err should always be nil, found err == %s", err)
+ }
+ s = s[n:]
+ check(t, testname+" (empty 3)", buf, s)
+ }
+
+ check(t, testname+" (empty 4)", buf, "")
+}
+
+func TestBasicOperations(t *testing.T) {
+ var buf Buffer
+
+ for i := 0; i < 5; i++ {
+ check(t, "TestBasicOperations (1)", &buf, "")
+
+ buf.Reset()
+ check(t, "TestBasicOperations (2)", &buf, "")
+
+ buf.Truncate(0)
+ check(t, "TestBasicOperations (3)", &buf, "")
+
+ n, err := buf.Write([]byte(data[0:1]))
+ if n != 1 {
+ t.Errorf("wrote 1 byte, but n == %d", n)
+ }
+ if err != nil {
+ t.Errorf("err should always be nil, but err == %s", err)
+ }
+ check(t, "TestBasicOperations (4)", &buf, "a")
+
+ buf.WriteByte(data[1])
+ check(t, "TestBasicOperations (5)", &buf, "ab")
+
+ n, err = buf.Write([]byte(data[2:26]))
+ if n != 24 {
+ t.Errorf("wrote 25 bytes, but n == %d", n)
+ }
+ check(t, "TestBasicOperations (6)", &buf, string(data[0:26]))
+
+ buf.Truncate(26)
+ check(t, "TestBasicOperations (7)", &buf, string(data[0:26]))
+
+ buf.Truncate(20)
+ check(t, "TestBasicOperations (8)", &buf, string(data[0:20]))
+
+ empty(t, "TestBasicOperations (9)", &buf, string(data[0:20]), make([]byte, 5))
+ empty(t, "TestBasicOperations (10)", &buf, "", make([]byte, 100))
+
+ buf.WriteByte(data[1])
+ c, err := buf.ReadByte()
+ if err != nil {
+ t.Error("ReadByte unexpected eof")
+ }
+ if c != data[1] {
+ t.Errorf("ReadByte wrong value c=%v", c)
+ }
+ c, err = buf.ReadByte()
+ if err == nil {
+ t.Error("ReadByte unexpected not eof")
+ }
+ }
+}
+
+func TestLargeByteWrites(t *testing.T) {
+ var buf Buffer
+ limit := 30
+ if testing.Short() {
+ limit = 9
+ }
+ for i := 3; i < limit; i += 3 {
+ s := fillBytes(t, "TestLargeWrites (1)", &buf, "", 5, testBytes)
+ empty(t, "TestLargeByteWrites (2)", &buf, s, make([]byte, len(data)/i))
+ }
+ check(t, "TestLargeByteWrites (3)", &buf, "")
+}
+
+func TestLargeByteReads(t *testing.T) {
+ var buf Buffer
+ for i := 3; i < 30; i += 3 {
+ s := fillBytes(t, "TestLargeReads (1)", &buf, "", 5, testBytes[0:len(testBytes)/i])
+ empty(t, "TestLargeReads (2)", &buf, s, make([]byte, len(data)))
+ }
+ check(t, "TestLargeByteReads (3)", &buf, "")
+}
+
+func TestMixedReadsAndWrites(t *testing.T) {
+ var buf Buffer
+ s := ""
+ for i := 0; i < 50; i++ {
+ wlen := rand.Intn(len(data))
+ s = fillBytes(t, "TestMixedReadsAndWrites (1)", &buf, s, 1, testBytes[0:wlen])
+ rlen := rand.Intn(len(data))
+ fub := make([]byte, rlen)
+ n, _ := buf.Read(fub)
+ s = s[n:]
+ }
+ empty(t, "TestMixedReadsAndWrites (2)", &buf, s, make([]byte, buf.Len()))
+}
+
+func TestNil(t *testing.T) {
+ var b *Buffer
+ if b.String() != "<nil>" {
+ t.Errorf("expected <nil>; got %q", b.String())
+ }
+}
+
+func TestReadFrom(t *testing.T) {
+ var buf Buffer
+ for i := 3; i < 30; i += 3 {
+ s := fillBytes(t, "TestReadFrom (1)", &buf, "", 5, testBytes[0:len(testBytes)/i])
+ var b Buffer
+ b.ReadFrom(&buf)
+ empty(t, "TestReadFrom (2)", &b, s, make([]byte, len(data)))
+ }
+}
+
+func TestWriteTo(t *testing.T) {
+ var buf Buffer
+ for i := 3; i < 30; i += 3 {
+ s := fillBytes(t, "TestWriteTo (1)", &buf, "", 5, testBytes[0:len(testBytes)/i])
+ var b Buffer
+ buf.WriteTo(&b)
+ empty(t, "TestWriteTo (2)", &b, s, make([]byte, len(data)))
+ }
+}
+
+func TestNext(t *testing.T) {
+ b := []byte{0, 1, 2, 3, 4}
+ tmp := make([]byte, 5)
+ for i := 0; i <= 5; i++ {
+ for j := i; j <= 5; j++ {
+ for k := 0; k <= 6; k++ {
+ // 0 <= i <= j <= 5; 0 <= k <= 6
+ // Check that if we start with a buffer
+ // of length j at offset i and ask for
+ // Next(k), we get the right bytes.
+ buf := NewBuffer(b[0:j])
+ n, _ := buf.Read(tmp[0:i])
+ if n != i {
+ t.Fatalf("Read %d returned %d", i, n)
+ }
+ bb := buf.Next(k)
+ want := k
+ if want > j-i {
+ want = j - i
+ }
+ if len(bb) != want {
+ t.Fatalf("in %d,%d: len(Next(%d)) == %d", i, j, k, len(bb))
+ }
+ for l, v := range bb {
+ if v != byte(l+i) {
+ t.Fatalf("in %d,%d: Next(%d)[%d] = %d, want %d", i, j, k, l, v, l+i)
+ }
+ }
+ }
+ }
+ }
+}
+
+var readBytesTests = []struct {
+ buffer string
+ delim byte
+ expected []string
+ err error
+}{
+ {"", 0, []string{""}, io.EOF},
+ {"a\x00", 0, []string{"a\x00"}, nil},
+ {"abbbaaaba", 'b', []string{"ab", "b", "b", "aaab"}, nil},
+ {"hello\x01world", 1, []string{"hello\x01"}, nil},
+ {"foo\nbar", 0, []string{"foo\nbar"}, io.EOF},
+ {"alpha\nbeta\ngamma\n", '\n', []string{"alpha\n", "beta\n", "gamma\n"}, nil},
+ {"alpha\nbeta\ngamma", '\n', []string{"alpha\n", "beta\n", "gamma"}, io.EOF},
+}
+
+func TestReadBytes(t *testing.T) {
+ for _, test := range readBytesTests {
+ buf := NewBuffer([]byte(test.buffer))
+ var err error
+ for _, expected := range test.expected {
+ var bytes []byte
+ bytes, err = buf.ReadBytes(test.delim)
+ if string(bytes) != expected {
+ t.Errorf("expected %q, got %q", expected, bytes)
+ }
+ if err != nil {
+ break
+ }
+ }
+ if err != test.err {
+ t.Errorf("expected error %v, got %v", test.err, err)
+ }
+ }
+}
+
+func TestGrow(t *testing.T) {
+ x := []byte{'x'}
+ y := []byte{'y'}
+ tmp := make([]byte, 72)
+ for _, startLen := range []int{0, 100, 1000, 10000, 100000} {
+ xBytes := bytes.Repeat(x, startLen)
+ for _, growLen := range []int{0, 100, 1000, 10000, 100000} {
+ buf := NewBuffer(xBytes)
+ // If we read, this affects buf.off, which is good to test.
+ readBytes, _ := buf.Read(tmp)
+ buf.Grow(growLen)
+ yBytes := bytes.Repeat(y, growLen)
+ // Check no allocation occurs in write, as long as we're single-threaded.
+ var m1, m2 runtime.MemStats
+ runtime.ReadMemStats(&m1)
+ buf.Write(yBytes)
+ runtime.ReadMemStats(&m2)
+ if runtime.GOMAXPROCS(-1) == 1 && m1.Mallocs != m2.Mallocs {
+ t.Errorf("allocation occurred during write")
+ }
+ // Check that buffer has correct data.
+ if !bytes.Equal(buf.Bytes()[0:startLen-readBytes], xBytes[readBytes:]) {
+ t.Errorf("bad initial data at %d %d", startLen, growLen)
+ }
+ if !bytes.Equal(buf.Bytes()[startLen-readBytes:startLen-readBytes+growLen], yBytes) {
+ t.Errorf("bad written data at %d %d", startLen, growLen)
+ }
+ }
+ }
+}
+
+// Was a bug: used to give EOF reading empty slice at EOF.
+func TestReadEmptyAtEOF(t *testing.T) {
+ b := new(Buffer)
+ slice := make([]byte, 0)
+ n, err := b.Read(slice)
+ if err != nil {
+ t.Errorf("read error: %v", err)
+ }
+ if n != 0 {
+ t.Errorf("wrong count; got %d want 0", n)
+ }
+}
+
+// Tests that we occasionally compact. Issue 5154.
+func TestBufferGrowth(t *testing.T) {
+ var b Buffer
+ buf := make([]byte, 1024)
+ b.Write(buf[0:1])
+ var cap0 int
+ for i := 0; i < 5<<10; i++ {
+ b.Write(buf)
+ b.Read(buf)
+ if i == 0 {
+ cap0 = cap(b.buf)
+ }
+ }
+ cap1 := cap(b.buf)
+ // (*Buffer).grow allows for 2x capacity slop before sliding,
+ // so set our error threshold at 3x.
+ if cap1 > cap0*3 {
+ t.Errorf("buffer cap = %d; too big (grew from %d)", cap1, cap0)
+ }
+}
+
+// From Issue 5154.
+func BenchmarkBufferNotEmptyWriteRead(b *testing.B) {
+ buf := make([]byte, 1024)
+ for i := 0; i < b.N; i++ {
+ var b Buffer
+ b.Write(buf[0:1])
+ for i := 0; i < 5<<10; i++ {
+ b.Write(buf)
+ b.Read(buf)
+ }
+ }
+}
+
+// Check that we don't compact too often. From Issue 5154.
+func BenchmarkBufferFullSmallReads(b *testing.B) {
+ buf := make([]byte, 1024)
+ for i := 0; i < b.N; i++ {
+ var b Buffer
+ b.Write(buf)
+ for b.Len()+20 < cap(b.buf) {
+ b.Write(buf[:10])
+ }
+ for i := 0; i < 5<<10; i++ {
+ b.Read(buf[:1])
+ b.Write(buf[:1])
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/crc32.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/crc32.go
new file mode 100644
index 0000000000000000000000000000000000000000..631c9d6109c95760e55d58c13b9572970923f105
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/crc32.go
@@ -0,0 +1,30 @@
+// Copyright 2011 The LevelDB-Go Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package util
+
+import (
+ "hash/crc32"
+)
+
+var table = crc32.MakeTable(crc32.Castagnoli)
+
+// CRC is a CRC-32 checksum computed using Castagnoli's polynomial.
+type CRC uint32
+
+// NewCRC creates a new crc based on the given bytes.
+func NewCRC(b []byte) CRC {
+ return CRC(0).Update(b)
+}
+
+// Update updates the crc with the given bytes.
+func (c CRC) Update(b []byte) CRC {
+ return CRC(crc32.Update(uint32(c), table, b))
+}
+
+// Value returns a masked crc.
+func (c CRC) Value() uint32 {
+ return uint32(c>>15|c<<17) + 0xa282ead8
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/hash.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/hash.go
new file mode 100644
index 0000000000000000000000000000000000000000..54903660ffa713ce0bf867efec3c775d6eb7f315
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/hash.go
@@ -0,0 +1,48 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package util
+
+import (
+ "bytes"
+ "encoding/binary"
+)
+
+// Hash return hash of the given data.
+func Hash(data []byte, seed uint32) uint32 {
+ // Similar to murmur hash
+ var m uint32 = 0xc6a4a793
+ var r uint32 = 24
+ h := seed ^ (uint32(len(data)) * m)
+
+ buf := bytes.NewBuffer(data)
+ for buf.Len() >= 4 {
+ var w uint32
+ binary.Read(buf, binary.LittleEndian, &w)
+ h += w
+ h *= m
+ h ^= (h >> 16)
+ }
+
+ rest := buf.Bytes()
+ switch len(rest) {
+ default:
+ panic("not reached")
+ case 3:
+ h += uint32(rest[2]) << 16
+ fallthrough
+ case 2:
+ h += uint32(rest[1]) << 8
+ fallthrough
+ case 1:
+ h += uint32(rest[0])
+ h *= m
+ h ^= (h >> r)
+ case 0:
+ }
+
+ return h
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/pool.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/pool.go
new file mode 100644
index 0000000000000000000000000000000000000000..1f7fdd41fe4edda0c6083fac96fa16d71ab80d59
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/pool.go
@@ -0,0 +1,21 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// +build go1.3
+
+package util
+
+import (
+ "sync"
+)
+
+type Pool struct {
+ sync.Pool
+}
+
+func NewPool(cap int) *Pool {
+ return &Pool{}
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/pool_legacy.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/pool_legacy.go
new file mode 100644
index 0000000000000000000000000000000000000000..27b8d03be9477703757e0043fe70c28a05c27756
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/pool_legacy.go
@@ -0,0 +1,33 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// +build !go1.3
+
+package util
+
+type Pool struct {
+ pool chan interface{}
+}
+
+func (p *Pool) Get() interface{} {
+ select {
+ case x := <-p.pool:
+ return x
+ default:
+ return nil
+ }
+}
+
+func (p *Pool) Put(x interface{}) {
+ select {
+ case p.pool <- x:
+ default:
+ }
+}
+
+func NewPool(cap int) *Pool {
+ return &Pool{pool: make(chan interface{}, cap)}
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/range.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/range.go
new file mode 100644
index 0000000000000000000000000000000000000000..85159583d2c36581bb6967e7ee610467b2154e30
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/range.go
@@ -0,0 +1,32 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package util
+
+// Range is a key range.
+type Range struct {
+ // Start of the key range, include in the range.
+ Start []byte
+
+ // Limit of the key range, not include in the range.
+ Limit []byte
+}
+
+// BytesPrefix returns key range that satisfy the given prefix.
+// This only applicable for the standard 'bytes comparer'.
+func BytesPrefix(prefix []byte) *Range {
+ var limit []byte
+ for i := len(prefix) - 1; i >= 0; i-- {
+ c := prefix[i]
+ if c < 0xff {
+ limit = make([]byte, i+1)
+ copy(limit, prefix)
+ limit[i] = c + 1
+ break
+ }
+ }
+ return &Range{prefix, limit}
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/util.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..f35976865bff172970e4cafc293814d40542e859
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util/util.go
@@ -0,0 +1,73 @@
+// Copyright (c) 2013, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package util provides utilities used throughout leveldb.
+package util
+
+import (
+ "errors"
+)
+
+var (
+ ErrReleased = errors.New("leveldb: resource already relesed")
+ ErrHasReleaser = errors.New("leveldb: releaser already defined")
+)
+
+// Releaser is the interface that wraps the basic Release method.
+type Releaser interface {
+ // Release releases associated resources. Release should always success
+ // and can be called multipe times without causing error.
+ Release()
+}
+
+// ReleaseSetter is the interface that wraps the basic SetReleaser method.
+type ReleaseSetter interface {
+ // SetReleaser associates the given releaser to the resources. The
+ // releaser will be called once coresponding resources released.
+ // Calling SetReleaser with nil will clear the releaser.
+ //
+ // This will panic if a releaser already present or coresponding
+ // resource is already released. Releaser should be cleared first
+ // before assigned a new one.
+ SetReleaser(releaser Releaser)
+}
+
+// BasicReleaser provides basic implementation of Releaser and ReleaseSetter.
+type BasicReleaser struct {
+ releaser Releaser
+ released bool
+}
+
+// Released returns whether Release method already called.
+func (r *BasicReleaser) Released() bool {
+ return r.released
+}
+
+// Release implements Releaser.Release.
+func (r *BasicReleaser) Release() {
+ if !r.released {
+ if r.releaser != nil {
+ r.releaser.Release()
+ r.releaser = nil
+ }
+ r.released = true
+ }
+}
+
+// SetReleaser implements ReleaseSetter.SetReleaser.
+func (r *BasicReleaser) SetReleaser(releaser Releaser) {
+ if r.released {
+ panic(ErrReleased)
+ }
+ if r.releaser != nil && releaser != nil {
+ panic(ErrHasReleaser)
+ }
+ r.releaser = releaser
+}
+
+type NoopReleaser struct{}
+
+func (NoopReleaser) Release() {}
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/version.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/version.go
new file mode 100644
index 0000000000000000000000000000000000000000..25ae21da97e390fb12f92a32ae44053cf247e2ba
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/version.go
@@ -0,0 +1,457 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+ "sync/atomic"
+ "unsafe"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type tSet struct {
+ level int
+ table *tFile
+}
+
+type version struct {
+ s *session
+
+ tables []tFiles
+
+ // Level that should be compacted next and its compaction score.
+ // Score < 1 means compaction is not strictly needed. These fields
+ // are initialized by computeCompaction()
+ cLevel int
+ cScore float64
+
+ cSeek unsafe.Pointer
+
+ ref int
+ // Succeeding version.
+ next *version
+}
+
+func newVersion(s *session) *version {
+ return &version{s: s, tables: make([]tFiles, s.o.GetNumLevel())}
+}
+
+func (v *version) releaseNB() {
+ v.ref--
+ if v.ref > 0 {
+ return
+ }
+ if v.ref < 0 {
+ panic("negative version ref")
+ }
+
+ tables := make(map[uint64]bool)
+ for _, tt := range v.next.tables {
+ for _, t := range tt {
+ num := t.file.Num()
+ tables[num] = true
+ }
+ }
+
+ for _, tt := range v.tables {
+ for _, t := range tt {
+ num := t.file.Num()
+ if _, ok := tables[num]; !ok {
+ v.s.tops.remove(t)
+ }
+ }
+ }
+
+ v.next.releaseNB()
+ v.next = nil
+}
+
+func (v *version) release() {
+ v.s.vmu.Lock()
+ v.releaseNB()
+ v.s.vmu.Unlock()
+}
+
+func (v *version) walkOverlapping(ikey iKey, f func(level int, t *tFile) bool, lf func(level int) bool) {
+ ukey := ikey.ukey()
+
+ // Walk tables level-by-level.
+ for level, tables := range v.tables {
+ if len(tables) == 0 {
+ continue
+ }
+
+ if level == 0 {
+ // Level-0 files may overlap each other. Find all files that
+ // overlap ukey.
+ for _, t := range tables {
+ if t.overlaps(v.s.icmp, ukey, ukey) {
+ if !f(level, t) {
+ return
+ }
+ }
+ }
+ } else {
+ if i := tables.searchMax(v.s.icmp, ikey); i < len(tables) {
+ t := tables[i]
+ if v.s.icmp.uCompare(ukey, t.imin.ukey()) >= 0 {
+ if !f(level, t) {
+ return
+ }
+ }
+ }
+ }
+
+ if lf != nil && !lf(level) {
+ return
+ }
+ }
+}
+
+func (v *version) get(ikey iKey, ro *opt.ReadOptions, noValue bool) (value []byte, tcomp bool, err error) {
+ ukey := ikey.ukey()
+
+ var (
+ tset *tSet
+ tseek bool
+
+ // Level-0.
+ zfound bool
+ zseq uint64
+ zkt kType
+ zval []byte
+ )
+
+ err = ErrNotFound
+
+ // Since entries never hope across level, finding key/value
+ // in smaller level make later levels irrelevant.
+ v.walkOverlapping(ikey, func(level int, t *tFile) bool {
+ if !tseek {
+ if tset == nil {
+ tset = &tSet{level, t}
+ } else {
+ tseek = true
+ }
+ }
+
+ var (
+ fikey, fval []byte
+ ferr error
+ )
+ if noValue {
+ fikey, ferr = v.s.tops.findKey(t, ikey, ro)
+ } else {
+ fikey, fval, ferr = v.s.tops.find(t, ikey, ro)
+ }
+ switch ferr {
+ case nil:
+ case ErrNotFound:
+ return true
+ default:
+ err = ferr
+ return false
+ }
+
+ if fukey, fseq, fkt, fkerr := parseIkey(fikey); fkerr == nil {
+ if v.s.icmp.uCompare(ukey, fukey) == 0 {
+ if level == 0 {
+ if fseq >= zseq {
+ zfound = true
+ zseq = fseq
+ zkt = fkt
+ zval = fval
+ }
+ } else {
+ switch fkt {
+ case ktVal:
+ value = fval
+ err = nil
+ case ktDel:
+ default:
+ panic("leveldb: invalid iKey type")
+ }
+ return false
+ }
+ }
+ } else {
+ err = fkerr
+ return false
+ }
+
+ return true
+ }, func(level int) bool {
+ if zfound {
+ switch zkt {
+ case ktVal:
+ value = zval
+ err = nil
+ case ktDel:
+ default:
+ panic("leveldb: invalid iKey type")
+ }
+ return false
+ }
+
+ return true
+ })
+
+ if tseek && tset.table.consumeSeek() <= 0 {
+ tcomp = atomic.CompareAndSwapPointer(&v.cSeek, nil, unsafe.Pointer(tset))
+ }
+
+ return
+}
+
+func (v *version) sampleSeek(ikey iKey) (tcomp bool) {
+ var tset *tSet
+
+ v.walkOverlapping(ikey, func(level int, t *tFile) bool {
+ if tset == nil {
+ tset = &tSet{level, t}
+ return true
+ } else {
+ if tset.table.consumeSeek() <= 0 {
+ tcomp = atomic.CompareAndSwapPointer(&v.cSeek, nil, unsafe.Pointer(tset))
+ }
+ return false
+ }
+ }, nil)
+
+ return
+}
+
+func (v *version) getIterators(slice *util.Range, ro *opt.ReadOptions) (its []iterator.Iterator) {
+ // Merge all level zero files together since they may overlap
+ for _, t := range v.tables[0] {
+ it := v.s.tops.newIterator(t, slice, ro)
+ its = append(its, it)
+ }
+
+ strict := opt.GetStrict(v.s.o.Options, ro, opt.StrictReader)
+ for _, tables := range v.tables[1:] {
+ if len(tables) == 0 {
+ continue
+ }
+
+ it := iterator.NewIndexedIterator(tables.newIndexIterator(v.s.tops, v.s.icmp, slice, ro), strict)
+ its = append(its, it)
+ }
+
+ return
+}
+
+func (v *version) newStaging() *versionStaging {
+ return &versionStaging{base: v, tables: make([]tablesScratch, v.s.o.GetNumLevel())}
+}
+
+// Spawn a new version based on this version.
+func (v *version) spawn(r *sessionRecord) *version {
+ staging := v.newStaging()
+ staging.commit(r)
+ return staging.finish()
+}
+
+func (v *version) fillRecord(r *sessionRecord) {
+ for level, ts := range v.tables {
+ for _, t := range ts {
+ r.addTableFile(level, t)
+ }
+ }
+}
+
+func (v *version) tLen(level int) int {
+ return len(v.tables[level])
+}
+
+func (v *version) offsetOf(ikey iKey) (n uint64, err error) {
+ for level, tables := range v.tables {
+ for _, t := range tables {
+ if v.s.icmp.Compare(t.imax, ikey) <= 0 {
+ // Entire file is before "ikey", so just add the file size
+ n += t.size
+ } else if v.s.icmp.Compare(t.imin, ikey) > 0 {
+ // Entire file is after "ikey", so ignore
+ if level > 0 {
+ // Files other than level 0 are sorted by meta->min, so
+ // no further files in this level will contain data for
+ // "ikey".
+ break
+ }
+ } else {
+ // "ikey" falls in the range for this table. Add the
+ // approximate offset of "ikey" within the table.
+ var nn uint64
+ nn, err = v.s.tops.offsetOf(t, ikey)
+ if err != nil {
+ return 0, err
+ }
+ n += nn
+ }
+ }
+ }
+
+ return
+}
+
+func (v *version) pickMemdbLevel(umin, umax []byte) (level int) {
+ if !v.tables[0].overlaps(v.s.icmp, umin, umax, true) {
+ var overlaps tFiles
+ maxLevel := v.s.o.GetMaxMemCompationLevel()
+ for ; level < maxLevel; level++ {
+ if v.tables[level+1].overlaps(v.s.icmp, umin, umax, false) {
+ break
+ }
+ overlaps = v.tables[level+2].getOverlaps(overlaps, v.s.icmp, umin, umax, false)
+ if overlaps.size() > uint64(v.s.o.GetCompactionGPOverlaps(level)) {
+ break
+ }
+ }
+ }
+
+ return
+}
+
+func (v *version) computeCompaction() {
+ // Precomputed best level for next compaction
+ var bestLevel int = -1
+ var bestScore float64 = -1
+
+ for level, tables := range v.tables {
+ var score float64
+ if level == 0 {
+ // We treat level-0 specially by bounding the number of files
+ // instead of number of bytes for two reasons:
+ //
+ // (1) With larger write-buffer sizes, it is nice not to do too
+ // many level-0 compactions.
+ //
+ // (2) The files in level-0 are merged on every read and
+ // therefore we wish to avoid too many files when the individual
+ // file size is small (perhaps because of a small write-buffer
+ // setting, or very high compression ratios, or lots of
+ // overwrites/deletions).
+ score = float64(len(tables)) / float64(v.s.o.GetCompactionL0Trigger())
+ } else {
+ score = float64(tables.size()) / float64(v.s.o.GetCompactionTotalSize(level))
+ }
+
+ if score > bestScore {
+ bestLevel = level
+ bestScore = score
+ }
+ }
+
+ v.cLevel = bestLevel
+ v.cScore = bestScore
+}
+
+func (v *version) needCompaction() bool {
+ return v.cScore >= 1 || atomic.LoadPointer(&v.cSeek) != nil
+}
+
+type tablesScratch struct {
+ added map[uint64]atRecord
+ deleted map[uint64]struct{}
+}
+
+type versionStaging struct {
+ base *version
+ tables []tablesScratch
+}
+
+func (p *versionStaging) commit(r *sessionRecord) {
+ // Deleted tables.
+ for _, r := range r.deletedTables {
+ tm := &(p.tables[r.level])
+
+ if len(p.base.tables[r.level]) > 0 {
+ if tm.deleted == nil {
+ tm.deleted = make(map[uint64]struct{})
+ }
+ tm.deleted[r.num] = struct{}{}
+ }
+
+ if tm.added != nil {
+ delete(tm.added, r.num)
+ }
+ }
+
+ // New tables.
+ for _, r := range r.addedTables {
+ tm := &(p.tables[r.level])
+
+ if tm.added == nil {
+ tm.added = make(map[uint64]atRecord)
+ }
+ tm.added[r.num] = r
+
+ if tm.deleted != nil {
+ delete(tm.deleted, r.num)
+ }
+ }
+}
+
+func (p *versionStaging) finish() *version {
+ // Build new version.
+ nv := newVersion(p.base.s)
+ for level, tm := range p.tables {
+ btables := p.base.tables[level]
+
+ n := len(btables) + len(tm.added) - len(tm.deleted)
+ if n < 0 {
+ n = 0
+ }
+ nt := make(tFiles, 0, n)
+
+ // Base tables.
+ for _, t := range btables {
+ if _, ok := tm.deleted[t.file.Num()]; ok {
+ continue
+ }
+ if _, ok := tm.added[t.file.Num()]; ok {
+ continue
+ }
+ nt = append(nt, t)
+ }
+
+ // New tables.
+ for _, r := range tm.added {
+ nt = append(nt, p.base.s.tableFileFromRecord(r))
+ }
+
+ // Sort tables.
+ if level == 0 {
+ nt.sortByNum()
+ } else {
+ nt.sortByKey(p.base.s.icmp)
+ }
+ nv.tables[level] = nt
+ }
+
+ // Compute compaction score for new version.
+ nv.computeCompaction()
+
+ return nv
+}
+
+type versionReleaser struct {
+ v *version
+ once bool
+}
+
+func (vr *versionReleaser) Release() {
+ v := vr.v
+ v.s.vmu.Lock()
+ if !vr.once {
+ v.releaseNB()
+ vr.once = true
+ }
+ v.s.vmu.Unlock()
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/decode.go b/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/decode.go
new file mode 100644
index 0000000000000000000000000000000000000000..552a17bfb0500fe0617753c9ca7df0263ec363db
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/decode.go
@@ -0,0 +1,292 @@
+// Copyright 2011 The Snappy-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package snappy
+
+import (
+ "encoding/binary"
+ "errors"
+ "io"
+)
+
+var (
+ // ErrCorrupt reports that the input is invalid.
+ ErrCorrupt = errors.New("snappy: corrupt input")
+ // ErrUnsupported reports that the input isn't supported.
+ ErrUnsupported = errors.New("snappy: unsupported input")
+)
+
+// DecodedLen returns the length of the decoded block.
+func DecodedLen(src []byte) (int, error) {
+ v, _, err := decodedLen(src)
+ return v, err
+}
+
+// decodedLen returns the length of the decoded block and the number of bytes
+// that the length header occupied.
+func decodedLen(src []byte) (blockLen, headerLen int, err error) {
+ v, n := binary.Uvarint(src)
+ if n == 0 {
+ return 0, 0, ErrCorrupt
+ }
+ if uint64(int(v)) != v {
+ return 0, 0, errors.New("snappy: decoded block is too large")
+ }
+ return int(v), n, nil
+}
+
+// Decode returns the decoded form of src. The returned slice may be a sub-
+// slice of dst if dst was large enough to hold the entire decoded block.
+// Otherwise, a newly allocated slice will be returned.
+// It is valid to pass a nil dst.
+func Decode(dst, src []byte) ([]byte, error) {
+ dLen, s, err := decodedLen(src)
+ if err != nil {
+ return nil, err
+ }
+ if len(dst) < dLen {
+ dst = make([]byte, dLen)
+ }
+
+ var d, offset, length int
+ for s < len(src) {
+ switch src[s] & 0x03 {
+ case tagLiteral:
+ x := uint(src[s] >> 2)
+ switch {
+ case x < 60:
+ s += 1
+ case x == 60:
+ s += 2
+ if s > len(src) {
+ return nil, ErrCorrupt
+ }
+ x = uint(src[s-1])
+ case x == 61:
+ s += 3
+ if s > len(src) {
+ return nil, ErrCorrupt
+ }
+ x = uint(src[s-2]) | uint(src[s-1])<<8
+ case x == 62:
+ s += 4
+ if s > len(src) {
+ return nil, ErrCorrupt
+ }
+ x = uint(src[s-3]) | uint(src[s-2])<<8 | uint(src[s-1])<<16
+ case x == 63:
+ s += 5
+ if s > len(src) {
+ return nil, ErrCorrupt
+ }
+ x = uint(src[s-4]) | uint(src[s-3])<<8 | uint(src[s-2])<<16 | uint(src[s-1])<<24
+ }
+ length = int(x + 1)
+ if length <= 0 {
+ return nil, errors.New("snappy: unsupported literal length")
+ }
+ if length > len(dst)-d || length > len(src)-s {
+ return nil, ErrCorrupt
+ }
+ copy(dst[d:], src[s:s+length])
+ d += length
+ s += length
+ continue
+
+ case tagCopy1:
+ s += 2
+ if s > len(src) {
+ return nil, ErrCorrupt
+ }
+ length = 4 + int(src[s-2])>>2&0x7
+ offset = int(src[s-2])&0xe0<<3 | int(src[s-1])
+
+ case tagCopy2:
+ s += 3
+ if s > len(src) {
+ return nil, ErrCorrupt
+ }
+ length = 1 + int(src[s-3])>>2
+ offset = int(src[s-2]) | int(src[s-1])<<8
+
+ case tagCopy4:
+ return nil, errors.New("snappy: unsupported COPY_4 tag")
+ }
+
+ end := d + length
+ if offset > d || end > len(dst) {
+ return nil, ErrCorrupt
+ }
+ for ; d < end; d++ {
+ dst[d] = dst[d-offset]
+ }
+ }
+ if d != dLen {
+ return nil, ErrCorrupt
+ }
+ return dst[:d], nil
+}
+
+// NewReader returns a new Reader that decompresses from r, using the framing
+// format described at
+// https://code.google.com/p/snappy/source/browse/trunk/framing_format.txt
+func NewReader(r io.Reader) *Reader {
+ return &Reader{
+ r: r,
+ decoded: make([]byte, maxUncompressedChunkLen),
+ buf: make([]byte, MaxEncodedLen(maxUncompressedChunkLen)+checksumSize),
+ }
+}
+
+// Reader is an io.Reader than can read Snappy-compressed bytes.
+type Reader struct {
+ r io.Reader
+ err error
+ decoded []byte
+ buf []byte
+ // decoded[i:j] contains decoded bytes that have not yet been passed on.
+ i, j int
+ readHeader bool
+}
+
+// Reset discards any buffered data, resets all state, and switches the Snappy
+// reader to read from r. This permits reusing a Reader rather than allocating
+// a new one.
+func (r *Reader) Reset(reader io.Reader) {
+ r.r = reader
+ r.err = nil
+ r.i = 0
+ r.j = 0
+ r.readHeader = false
+}
+
+func (r *Reader) readFull(p []byte) (ok bool) {
+ if _, r.err = io.ReadFull(r.r, p); r.err != nil {
+ if r.err == io.ErrUnexpectedEOF {
+ r.err = ErrCorrupt
+ }
+ return false
+ }
+ return true
+}
+
+// Read satisfies the io.Reader interface.
+func (r *Reader) Read(p []byte) (int, error) {
+ if r.err != nil {
+ return 0, r.err
+ }
+ for {
+ if r.i < r.j {
+ n := copy(p, r.decoded[r.i:r.j])
+ r.i += n
+ return n, nil
+ }
+ if !r.readFull(r.buf[:4]) {
+ return 0, r.err
+ }
+ chunkType := r.buf[0]
+ if !r.readHeader {
+ if chunkType != chunkTypeStreamIdentifier {
+ r.err = ErrCorrupt
+ return 0, r.err
+ }
+ r.readHeader = true
+ }
+ chunkLen := int(r.buf[1]) | int(r.buf[2])<<8 | int(r.buf[3])<<16
+ if chunkLen > len(r.buf) {
+ r.err = ErrUnsupported
+ return 0, r.err
+ }
+
+ // The chunk types are specified at
+ // https://code.google.com/p/snappy/source/browse/trunk/framing_format.txt
+ switch chunkType {
+ case chunkTypeCompressedData:
+ // Section 4.2. Compressed data (chunk type 0x00).
+ if chunkLen < checksumSize {
+ r.err = ErrCorrupt
+ return 0, r.err
+ }
+ buf := r.buf[:chunkLen]
+ if !r.readFull(buf) {
+ return 0, r.err
+ }
+ checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
+ buf = buf[checksumSize:]
+
+ n, err := DecodedLen(buf)
+ if err != nil {
+ r.err = err
+ return 0, r.err
+ }
+ if n > len(r.decoded) {
+ r.err = ErrCorrupt
+ return 0, r.err
+ }
+ if _, err := Decode(r.decoded, buf); err != nil {
+ r.err = err
+ return 0, r.err
+ }
+ if crc(r.decoded[:n]) != checksum {
+ r.err = ErrCorrupt
+ return 0, r.err
+ }
+ r.i, r.j = 0, n
+ continue
+
+ case chunkTypeUncompressedData:
+ // Section 4.3. Uncompressed data (chunk type 0x01).
+ if chunkLen < checksumSize {
+ r.err = ErrCorrupt
+ return 0, r.err
+ }
+ buf := r.buf[:checksumSize]
+ if !r.readFull(buf) {
+ return 0, r.err
+ }
+ checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
+ // Read directly into r.decoded instead of via r.buf.
+ n := chunkLen - checksumSize
+ if !r.readFull(r.decoded[:n]) {
+ return 0, r.err
+ }
+ if crc(r.decoded[:n]) != checksum {
+ r.err = ErrCorrupt
+ return 0, r.err
+ }
+ r.i, r.j = 0, n
+ continue
+
+ case chunkTypeStreamIdentifier:
+ // Section 4.1. Stream identifier (chunk type 0xff).
+ if chunkLen != len(magicBody) {
+ r.err = ErrCorrupt
+ return 0, r.err
+ }
+ if !r.readFull(r.buf[:len(magicBody)]) {
+ return 0, r.err
+ }
+ for i := 0; i < len(magicBody); i++ {
+ if r.buf[i] != magicBody[i] {
+ r.err = ErrCorrupt
+ return 0, r.err
+ }
+ }
+ continue
+ }
+
+ if chunkType <= 0x7f {
+ // Section 4.5. Reserved unskippable chunks (chunk types 0x02-0x7f).
+ r.err = ErrUnsupported
+ return 0, r.err
+
+ } else {
+ // Section 4.4 Padding (chunk type 0xfe).
+ // Section 4.6. Reserved skippable chunks (chunk types 0x80-0xfd).
+ if !r.readFull(r.buf[:chunkLen]) {
+ return 0, r.err
+ }
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/encode.go b/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/encode.go
new file mode 100644
index 0000000000000000000000000000000000000000..dda372422d437441e1932607737295eae4bd30fd
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/encode.go
@@ -0,0 +1,258 @@
+// Copyright 2011 The Snappy-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package snappy
+
+import (
+ "encoding/binary"
+ "io"
+)
+
+// We limit how far copy back-references can go, the same as the C++ code.
+const maxOffset = 1 << 15
+
+// emitLiteral writes a literal chunk and returns the number of bytes written.
+func emitLiteral(dst, lit []byte) int {
+ i, n := 0, uint(len(lit)-1)
+ switch {
+ case n < 60:
+ dst[0] = uint8(n)<<2 | tagLiteral
+ i = 1
+ case n < 1<<8:
+ dst[0] = 60<<2 | tagLiteral
+ dst[1] = uint8(n)
+ i = 2
+ case n < 1<<16:
+ dst[0] = 61<<2 | tagLiteral
+ dst[1] = uint8(n)
+ dst[2] = uint8(n >> 8)
+ i = 3
+ case n < 1<<24:
+ dst[0] = 62<<2 | tagLiteral
+ dst[1] = uint8(n)
+ dst[2] = uint8(n >> 8)
+ dst[3] = uint8(n >> 16)
+ i = 4
+ case int64(n) < 1<<32:
+ dst[0] = 63<<2 | tagLiteral
+ dst[1] = uint8(n)
+ dst[2] = uint8(n >> 8)
+ dst[3] = uint8(n >> 16)
+ dst[4] = uint8(n >> 24)
+ i = 5
+ default:
+ panic("snappy: source buffer is too long")
+ }
+ if copy(dst[i:], lit) != len(lit) {
+ panic("snappy: destination buffer is too short")
+ }
+ return i + len(lit)
+}
+
+// emitCopy writes a copy chunk and returns the number of bytes written.
+func emitCopy(dst []byte, offset, length int) int {
+ i := 0
+ for length > 0 {
+ x := length - 4
+ if 0 <= x && x < 1<<3 && offset < 1<<11 {
+ dst[i+0] = uint8(offset>>8)&0x07<<5 | uint8(x)<<2 | tagCopy1
+ dst[i+1] = uint8(offset)
+ i += 2
+ break
+ }
+
+ x = length
+ if x > 1<<6 {
+ x = 1 << 6
+ }
+ dst[i+0] = uint8(x-1)<<2 | tagCopy2
+ dst[i+1] = uint8(offset)
+ dst[i+2] = uint8(offset >> 8)
+ i += 3
+ length -= x
+ }
+ return i
+}
+
+// Encode returns the encoded form of src. The returned slice may be a sub-
+// slice of dst if dst was large enough to hold the entire encoded block.
+// Otherwise, a newly allocated slice will be returned.
+// It is valid to pass a nil dst.
+func Encode(dst, src []byte) ([]byte, error) {
+ if n := MaxEncodedLen(len(src)); len(dst) < n {
+ dst = make([]byte, n)
+ }
+
+ // The block starts with the varint-encoded length of the decompressed bytes.
+ d := binary.PutUvarint(dst, uint64(len(src)))
+
+ // Return early if src is short.
+ if len(src) <= 4 {
+ if len(src) != 0 {
+ d += emitLiteral(dst[d:], src)
+ }
+ return dst[:d], nil
+ }
+
+ // Initialize the hash table. Its size ranges from 1<<8 to 1<<14 inclusive.
+ const maxTableSize = 1 << 14
+ shift, tableSize := uint(32-8), 1<<8
+ for tableSize < maxTableSize && tableSize < len(src) {
+ shift--
+ tableSize *= 2
+ }
+ var table [maxTableSize]int
+
+ // Iterate over the source bytes.
+ var (
+ s int // The iterator position.
+ t int // The last position with the same hash as s.
+ lit int // The start position of any pending literal bytes.
+ )
+ for s+3 < len(src) {
+ // Update the hash table.
+ b0, b1, b2, b3 := src[s], src[s+1], src[s+2], src[s+3]
+ h := uint32(b0) | uint32(b1)<<8 | uint32(b2)<<16 | uint32(b3)<<24
+ p := &table[(h*0x1e35a7bd)>>shift]
+ // We need to to store values in [-1, inf) in table. To save
+ // some initialization time, (re)use the table's zero value
+ // and shift the values against this zero: add 1 on writes,
+ // subtract 1 on reads.
+ t, *p = *p-1, s+1
+ // If t is invalid or src[s:s+4] differs from src[t:t+4], accumulate a literal byte.
+ if t < 0 || s-t >= maxOffset || b0 != src[t] || b1 != src[t+1] || b2 != src[t+2] || b3 != src[t+3] {
+ s++
+ continue
+ }
+ // Otherwise, we have a match. First, emit any pending literal bytes.
+ if lit != s {
+ d += emitLiteral(dst[d:], src[lit:s])
+ }
+ // Extend the match to be as long as possible.
+ s0 := s
+ s, t = s+4, t+4
+ for s < len(src) && src[s] == src[t] {
+ s++
+ t++
+ }
+ // Emit the copied bytes.
+ d += emitCopy(dst[d:], s-t, s-s0)
+ lit = s
+ }
+
+ // Emit any final pending literal bytes and return.
+ if lit != len(src) {
+ d += emitLiteral(dst[d:], src[lit:])
+ }
+ return dst[:d], nil
+}
+
+// MaxEncodedLen returns the maximum length of a snappy block, given its
+// uncompressed length.
+func MaxEncodedLen(srcLen int) int {
+ // Compressed data can be defined as:
+ // compressed := item* literal*
+ // item := literal* copy
+ //
+ // The trailing literal sequence has a space blowup of at most 62/60
+ // since a literal of length 60 needs one tag byte + one extra byte
+ // for length information.
+ //
+ // Item blowup is trickier to measure. Suppose the "copy" op copies
+ // 4 bytes of data. Because of a special check in the encoding code,
+ // we produce a 4-byte copy only if the offset is < 65536. Therefore
+ // the copy op takes 3 bytes to encode, and this type of item leads
+ // to at most the 62/60 blowup for representing literals.
+ //
+ // Suppose the "copy" op copies 5 bytes of data. If the offset is big
+ // enough, it will take 5 bytes to encode the copy op. Therefore the
+ // worst case here is a one-byte literal followed by a five-byte copy.
+ // That is, 6 bytes of input turn into 7 bytes of "compressed" data.
+ //
+ // This last factor dominates the blowup, so the final estimate is:
+ return 32 + srcLen + srcLen/6
+}
+
+// NewWriter returns a new Writer that compresses to w, using the framing
+// format described at
+// https://code.google.com/p/snappy/source/browse/trunk/framing_format.txt
+func NewWriter(w io.Writer) *Writer {
+ return &Writer{
+ w: w,
+ enc: make([]byte, MaxEncodedLen(maxUncompressedChunkLen)),
+ }
+}
+
+// Writer is an io.Writer than can write Snappy-compressed bytes.
+type Writer struct {
+ w io.Writer
+ err error
+ enc []byte
+ buf [checksumSize + chunkHeaderSize]byte
+ wroteHeader bool
+}
+
+// Reset discards the writer's state and switches the Snappy writer to write to
+// w. This permits reusing a Writer rather than allocating a new one.
+func (w *Writer) Reset(writer io.Writer) {
+ w.w = writer
+ w.err = nil
+ w.wroteHeader = false
+}
+
+// Write satisfies the io.Writer interface.
+func (w *Writer) Write(p []byte) (n int, errRet error) {
+ if w.err != nil {
+ return 0, w.err
+ }
+ if !w.wroteHeader {
+ copy(w.enc, magicChunk)
+ if _, err := w.w.Write(w.enc[:len(magicChunk)]); err != nil {
+ w.err = err
+ return n, err
+ }
+ w.wroteHeader = true
+ }
+ for len(p) > 0 {
+ var uncompressed []byte
+ if len(p) > maxUncompressedChunkLen {
+ uncompressed, p = p[:maxUncompressedChunkLen], p[maxUncompressedChunkLen:]
+ } else {
+ uncompressed, p = p, nil
+ }
+ checksum := crc(uncompressed)
+
+ // Compress the buffer, discarding the result if the improvement
+ // isn't at least 12.5%.
+ chunkType := uint8(chunkTypeCompressedData)
+ chunkBody, err := Encode(w.enc, uncompressed)
+ if err != nil {
+ w.err = err
+ return n, err
+ }
+ if len(chunkBody) >= len(uncompressed)-len(uncompressed)/8 {
+ chunkType, chunkBody = chunkTypeUncompressedData, uncompressed
+ }
+
+ chunkLen := 4 + len(chunkBody)
+ w.buf[0] = chunkType
+ w.buf[1] = uint8(chunkLen >> 0)
+ w.buf[2] = uint8(chunkLen >> 8)
+ w.buf[3] = uint8(chunkLen >> 16)
+ w.buf[4] = uint8(checksum >> 0)
+ w.buf[5] = uint8(checksum >> 8)
+ w.buf[6] = uint8(checksum >> 16)
+ w.buf[7] = uint8(checksum >> 24)
+ if _, err = w.w.Write(w.buf[:]); err != nil {
+ w.err = err
+ return n, err
+ }
+ if _, err = w.w.Write(chunkBody); err != nil {
+ w.err = err
+ return n, err
+ }
+ n += len(uncompressed)
+ }
+ return n, nil
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/snappy.go b/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/snappy.go
new file mode 100644
index 0000000000000000000000000000000000000000..043bf3d81a949af84bafdf12a7b1e06f93e75bb9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/snappy.go
@@ -0,0 +1,68 @@
+// Copyright 2011 The Snappy-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package snappy implements the snappy block-based compression format.
+// It aims for very high speeds and reasonable compression.
+//
+// The C++ snappy implementation is at http://code.google.com/p/snappy/
+package snappy
+
+import (
+ "hash/crc32"
+)
+
+/*
+Each encoded block begins with the varint-encoded length of the decoded data,
+followed by a sequence of chunks. Chunks begin and end on byte boundaries. The
+first byte of each chunk is broken into its 2 least and 6 most significant bits
+called l and m: l ranges in [0, 4) and m ranges in [0, 64). l is the chunk tag.
+Zero means a literal tag. All other values mean a copy tag.
+
+For literal tags:
+ - If m < 60, the next 1 + m bytes are literal bytes.
+ - Otherwise, let n be the little-endian unsigned integer denoted by the next
+ m - 59 bytes. The next 1 + n bytes after that are literal bytes.
+
+For copy tags, length bytes are copied from offset bytes ago, in the style of
+Lempel-Ziv compression algorithms. In particular:
+ - For l == 1, the offset ranges in [0, 1<<11) and the length in [4, 12).
+ The length is 4 + the low 3 bits of m. The high 3 bits of m form bits 8-10
+ of the offset. The next byte is bits 0-7 of the offset.
+ - For l == 2, the offset ranges in [0, 1<<16) and the length in [1, 65).
+ The length is 1 + m. The offset is the little-endian unsigned integer
+ denoted by the next 2 bytes.
+ - For l == 3, this tag is a legacy format that is no longer supported.
+*/
+const (
+ tagLiteral = 0x00
+ tagCopy1 = 0x01
+ tagCopy2 = 0x02
+ tagCopy4 = 0x03
+)
+
+const (
+ checksumSize = 4
+ chunkHeaderSize = 4
+ magicChunk = "\xff\x06\x00\x00" + magicBody
+ magicBody = "sNaPpY"
+ // https://code.google.com/p/snappy/source/browse/trunk/framing_format.txt says
+ // that "the uncompressed data in a chunk must be no longer than 65536 bytes".
+ maxUncompressedChunkLen = 65536
+)
+
+const (
+ chunkTypeCompressedData = 0x00
+ chunkTypeUncompressedData = 0x01
+ chunkTypePadding = 0xfe
+ chunkTypeStreamIdentifier = 0xff
+)
+
+var crcTable = crc32.MakeTable(crc32.Castagnoli)
+
+// crc implements the checksum specified in section 3 of
+// https://code.google.com/p/snappy/source/browse/trunk/framing_format.txt
+func crc(b []byte) uint32 {
+ c := crc32.Update(0, crcTable, b)
+ return uint32(c>>15|c<<17) + 0xa282ead8
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/snappy_test.go b/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/snappy_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..0623385b71d22ebe18ae8b5aae94e64d0825580d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/snappy_test.go
@@ -0,0 +1,364 @@
+// Copyright 2011 The Snappy-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package snappy
+
+import (
+ "bytes"
+ "flag"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "math/rand"
+ "net/http"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+)
+
+var (
+ download = flag.Bool("download", false, "If true, download any missing files before running benchmarks")
+ testdata = flag.String("testdata", "testdata", "Directory containing the test data")
+)
+
+func roundtrip(b, ebuf, dbuf []byte) error {
+ e, err := Encode(ebuf, b)
+ if err != nil {
+ return fmt.Errorf("encoding error: %v", err)
+ }
+ d, err := Decode(dbuf, e)
+ if err != nil {
+ return fmt.Errorf("decoding error: %v", err)
+ }
+ if !bytes.Equal(b, d) {
+ return fmt.Errorf("roundtrip mismatch:\n\twant %v\n\tgot %v", b, d)
+ }
+ return nil
+}
+
+func TestEmpty(t *testing.T) {
+ if err := roundtrip(nil, nil, nil); err != nil {
+ t.Fatal(err)
+ }
+}
+
+func TestSmallCopy(t *testing.T) {
+ for _, ebuf := range [][]byte{nil, make([]byte, 20), make([]byte, 64)} {
+ for _, dbuf := range [][]byte{nil, make([]byte, 20), make([]byte, 64)} {
+ for i := 0; i < 32; i++ {
+ s := "aaaa" + strings.Repeat("b", i) + "aaaabbbb"
+ if err := roundtrip([]byte(s), ebuf, dbuf); err != nil {
+ t.Errorf("len(ebuf)=%d, len(dbuf)=%d, i=%d: %v", len(ebuf), len(dbuf), i, err)
+ }
+ }
+ }
+ }
+}
+
+func TestSmallRand(t *testing.T) {
+ rng := rand.New(rand.NewSource(27354294))
+ for n := 1; n < 20000; n += 23 {
+ b := make([]byte, n)
+ for i := range b {
+ b[i] = uint8(rng.Uint32())
+ }
+ if err := roundtrip(b, nil, nil); err != nil {
+ t.Fatal(err)
+ }
+ }
+}
+
+func TestSmallRegular(t *testing.T) {
+ for n := 1; n < 20000; n += 23 {
+ b := make([]byte, n)
+ for i := range b {
+ b[i] = uint8(i%10 + 'a')
+ }
+ if err := roundtrip(b, nil, nil); err != nil {
+ t.Fatal(err)
+ }
+ }
+}
+
+func cmp(a, b []byte) error {
+ if len(a) != len(b) {
+ return fmt.Errorf("got %d bytes, want %d", len(a), len(b))
+ }
+ for i := range a {
+ if a[i] != b[i] {
+ return fmt.Errorf("byte #%d: got 0x%02x, want 0x%02x", i, a[i], b[i])
+ }
+ }
+ return nil
+}
+
+func TestFramingFormat(t *testing.T) {
+ // src is comprised of alternating 1e5-sized sequences of random
+ // (incompressible) bytes and repeated (compressible) bytes. 1e5 was chosen
+ // because it is larger than maxUncompressedChunkLen (64k).
+ src := make([]byte, 1e6)
+ rng := rand.New(rand.NewSource(1))
+ for i := 0; i < 10; i++ {
+ if i%2 == 0 {
+ for j := 0; j < 1e5; j++ {
+ src[1e5*i+j] = uint8(rng.Intn(256))
+ }
+ } else {
+ for j := 0; j < 1e5; j++ {
+ src[1e5*i+j] = uint8(i)
+ }
+ }
+ }
+
+ buf := new(bytes.Buffer)
+ if _, err := NewWriter(buf).Write(src); err != nil {
+ t.Fatalf("Write: encoding: %v", err)
+ }
+ dst, err := ioutil.ReadAll(NewReader(buf))
+ if err != nil {
+ t.Fatalf("ReadAll: decoding: %v", err)
+ }
+ if err := cmp(dst, src); err != nil {
+ t.Fatal(err)
+ }
+}
+
+func TestReaderReset(t *testing.T) {
+ gold := bytes.Repeat([]byte("All that is gold does not glitter,\n"), 10000)
+ buf := new(bytes.Buffer)
+ if _, err := NewWriter(buf).Write(gold); err != nil {
+ t.Fatalf("Write: %v", err)
+ }
+ encoded, invalid, partial := buf.String(), "invalid", "partial"
+ r := NewReader(nil)
+ for i, s := range []string{encoded, invalid, partial, encoded, partial, invalid, encoded, encoded} {
+ if s == partial {
+ r.Reset(strings.NewReader(encoded))
+ if _, err := r.Read(make([]byte, 101)); err != nil {
+ t.Errorf("#%d: %v", i, err)
+ continue
+ }
+ continue
+ }
+ r.Reset(strings.NewReader(s))
+ got, err := ioutil.ReadAll(r)
+ switch s {
+ case encoded:
+ if err != nil {
+ t.Errorf("#%d: %v", i, err)
+ continue
+ }
+ if err := cmp(got, gold); err != nil {
+ t.Errorf("#%d: %v", i, err)
+ continue
+ }
+ case invalid:
+ if err == nil {
+ t.Errorf("#%d: got nil error, want non-nil", i)
+ continue
+ }
+ }
+ }
+}
+
+func TestWriterReset(t *testing.T) {
+ gold := bytes.Repeat([]byte("Not all those who wander are lost;\n"), 10000)
+ var gots, wants [][]byte
+ const n = 20
+ w, failed := NewWriter(nil), false
+ for i := 0; i <= n; i++ {
+ buf := new(bytes.Buffer)
+ w.Reset(buf)
+ want := gold[:len(gold)*i/n]
+ if _, err := w.Write(want); err != nil {
+ t.Errorf("#%d: Write: %v", i, err)
+ failed = true
+ continue
+ }
+ got, err := ioutil.ReadAll(NewReader(buf))
+ if err != nil {
+ t.Errorf("#%d: ReadAll: %v", i, err)
+ failed = true
+ continue
+ }
+ gots = append(gots, got)
+ wants = append(wants, want)
+ }
+ if failed {
+ return
+ }
+ for i := range gots {
+ if err := cmp(gots[i], wants[i]); err != nil {
+ t.Errorf("#%d: %v", i, err)
+ }
+ }
+}
+
+func benchDecode(b *testing.B, src []byte) {
+ encoded, err := Encode(nil, src)
+ if err != nil {
+ b.Fatal(err)
+ }
+ // Bandwidth is in amount of uncompressed data.
+ b.SetBytes(int64(len(src)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ Decode(src, encoded)
+ }
+}
+
+func benchEncode(b *testing.B, src []byte) {
+ // Bandwidth is in amount of uncompressed data.
+ b.SetBytes(int64(len(src)))
+ dst := make([]byte, MaxEncodedLen(len(src)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ Encode(dst, src)
+ }
+}
+
+func readFile(b testing.TB, filename string) []byte {
+ src, err := ioutil.ReadFile(filename)
+ if err != nil {
+ b.Fatalf("failed reading %s: %s", filename, err)
+ }
+ if len(src) == 0 {
+ b.Fatalf("%s has zero length", filename)
+ }
+ return src
+}
+
+// expand returns a slice of length n containing repeated copies of src.
+func expand(src []byte, n int) []byte {
+ dst := make([]byte, n)
+ for x := dst; len(x) > 0; {
+ i := copy(x, src)
+ x = x[i:]
+ }
+ return dst
+}
+
+func benchWords(b *testing.B, n int, decode bool) {
+ // Note: the file is OS-language dependent so the resulting values are not
+ // directly comparable for non-US-English OS installations.
+ data := expand(readFile(b, "/usr/share/dict/words"), n)
+ if decode {
+ benchDecode(b, data)
+ } else {
+ benchEncode(b, data)
+ }
+}
+
+func BenchmarkWordsDecode1e3(b *testing.B) { benchWords(b, 1e3, true) }
+func BenchmarkWordsDecode1e4(b *testing.B) { benchWords(b, 1e4, true) }
+func BenchmarkWordsDecode1e5(b *testing.B) { benchWords(b, 1e5, true) }
+func BenchmarkWordsDecode1e6(b *testing.B) { benchWords(b, 1e6, true) }
+func BenchmarkWordsEncode1e3(b *testing.B) { benchWords(b, 1e3, false) }
+func BenchmarkWordsEncode1e4(b *testing.B) { benchWords(b, 1e4, false) }
+func BenchmarkWordsEncode1e5(b *testing.B) { benchWords(b, 1e5, false) }
+func BenchmarkWordsEncode1e6(b *testing.B) { benchWords(b, 1e6, false) }
+
+// testFiles' values are copied directly from
+// https://raw.githubusercontent.com/google/snappy/master/snappy_unittest.cc
+// The label field is unused in snappy-go.
+var testFiles = []struct {
+ label string
+ filename string
+}{
+ {"html", "html"},
+ {"urls", "urls.10K"},
+ {"jpg", "fireworks.jpeg"},
+ {"jpg_200", "fireworks.jpeg"},
+ {"pdf", "paper-100k.pdf"},
+ {"html4", "html_x_4"},
+ {"txt1", "alice29.txt"},
+ {"txt2", "asyoulik.txt"},
+ {"txt3", "lcet10.txt"},
+ {"txt4", "plrabn12.txt"},
+ {"pb", "geo.protodata"},
+ {"gaviota", "kppkn.gtb"},
+}
+
+// The test data files are present at this canonical URL.
+const baseURL = "https://raw.githubusercontent.com/google/snappy/master/testdata/"
+
+func downloadTestdata(basename string) (errRet error) {
+ filename := filepath.Join(*testdata, basename)
+ if stat, err := os.Stat(filename); err == nil && stat.Size() != 0 {
+ return nil
+ }
+
+ if !*download {
+ return fmt.Errorf("test data not found; skipping benchmark without the -download flag")
+ }
+ // Download the official snappy C++ implementation reference test data
+ // files for benchmarking.
+ if err := os.Mkdir(*testdata, 0777); err != nil && !os.IsExist(err) {
+ return fmt.Errorf("failed to create testdata: %s", err)
+ }
+
+ f, err := os.Create(filename)
+ if err != nil {
+ return fmt.Errorf("failed to create %s: %s", filename, err)
+ }
+ defer f.Close()
+ defer func() {
+ if errRet != nil {
+ os.Remove(filename)
+ }
+ }()
+ url := baseURL + basename
+ resp, err := http.Get(url)
+ if err != nil {
+ return fmt.Errorf("failed to download %s: %s", url, err)
+ }
+ defer resp.Body.Close()
+ if s := resp.StatusCode; s != http.StatusOK {
+ return fmt.Errorf("downloading %s: HTTP status code %d (%s)", url, s, http.StatusText(s))
+ }
+ _, err = io.Copy(f, resp.Body)
+ if err != nil {
+ return fmt.Errorf("failed to download %s to %s: %s", url, filename, err)
+ }
+ return nil
+}
+
+func benchFile(b *testing.B, n int, decode bool) {
+ if err := downloadTestdata(testFiles[n].filename); err != nil {
+ b.Fatalf("failed to download testdata: %s", err)
+ }
+ data := readFile(b, filepath.Join(*testdata, testFiles[n].filename))
+ if decode {
+ benchDecode(b, data)
+ } else {
+ benchEncode(b, data)
+ }
+}
+
+// Naming convention is kept similar to what snappy's C++ implementation uses.
+func Benchmark_UFlat0(b *testing.B) { benchFile(b, 0, true) }
+func Benchmark_UFlat1(b *testing.B) { benchFile(b, 1, true) }
+func Benchmark_UFlat2(b *testing.B) { benchFile(b, 2, true) }
+func Benchmark_UFlat3(b *testing.B) { benchFile(b, 3, true) }
+func Benchmark_UFlat4(b *testing.B) { benchFile(b, 4, true) }
+func Benchmark_UFlat5(b *testing.B) { benchFile(b, 5, true) }
+func Benchmark_UFlat6(b *testing.B) { benchFile(b, 6, true) }
+func Benchmark_UFlat7(b *testing.B) { benchFile(b, 7, true) }
+func Benchmark_UFlat8(b *testing.B) { benchFile(b, 8, true) }
+func Benchmark_UFlat9(b *testing.B) { benchFile(b, 9, true) }
+func Benchmark_UFlat10(b *testing.B) { benchFile(b, 10, true) }
+func Benchmark_UFlat11(b *testing.B) { benchFile(b, 11, true) }
+func Benchmark_ZFlat0(b *testing.B) { benchFile(b, 0, false) }
+func Benchmark_ZFlat1(b *testing.B) { benchFile(b, 1, false) }
+func Benchmark_ZFlat2(b *testing.B) { benchFile(b, 2, false) }
+func Benchmark_ZFlat3(b *testing.B) { benchFile(b, 3, false) }
+func Benchmark_ZFlat4(b *testing.B) { benchFile(b, 4, false) }
+func Benchmark_ZFlat5(b *testing.B) { benchFile(b, 5, false) }
+func Benchmark_ZFlat6(b *testing.B) { benchFile(b, 6, false) }
+func Benchmark_ZFlat7(b *testing.B) { benchFile(b, 7, false) }
+func Benchmark_ZFlat8(b *testing.B) { benchFile(b, 8, false) }
+func Benchmark_ZFlat9(b *testing.B) { benchFile(b, 9, false) }
+func Benchmark_ZFlat10(b *testing.B) { benchFile(b, 10, false) }
+func Benchmark_ZFlat11(b *testing.B) { benchFile(b, 11, false) }
diff --git a/Godeps/_workspace/src/github.com/tendermint/ed25519/LICENSE b/Godeps/_workspace/src/github.com/tendermint/ed25519/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..74487567632c8f137ef3971b0f5912ca50bebcda
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/ed25519/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2012 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+ * 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.
+ * Neither the name of Google Inc. 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 COPYRIGHT HOLDERS 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 COPYRIGHT
+OWNER 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.
diff --git a/Godeps/_workspace/src/github.com/tendermint/ed25519/ed25519.go b/Godeps/_workspace/src/github.com/tendermint/ed25519/ed25519.go
new file mode 100644
index 0000000000000000000000000000000000000000..6c7e5cbc4109740ed3d2ecb517d02d63e89b84cd
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/ed25519/ed25519.go
@@ -0,0 +1,132 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package ed25519 implements the Ed25519 signature algorithm. See
+// http://ed25519.cr.yp.to/.
+package ed25519
+
+// This code is a port of the public domain, "ref10" implementation of ed25519
+// from SUPERCOP.
+
+import (
+ "crypto/sha512"
+ "crypto/subtle"
+ "io"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/agl/ed25519/edwards25519"
+)
+
+const (
+ PublicKeySize = 32
+ PrivateKeySize = 64
+ SignatureSize = 64
+)
+
+// GenerateKey generates a public/private key pair using randomness from rand.
+func GenerateKey(rand io.Reader) (publicKey *[PublicKeySize]byte, privateKey *[PrivateKeySize]byte, err error) {
+ privateKey = new([64]byte)
+ _, err = io.ReadFull(rand, privateKey[:32])
+ if err != nil {
+ return nil, nil, err
+ }
+
+ publicKey = MakePublicKey(privateKey)
+ return
+}
+
+// MakePublicKey makes a publicKey from the first half of privateKey.
+func MakePublicKey(privateKey *[PrivateKeySize]byte) (publicKey *[PublicKeySize]byte) {
+ publicKey = new([32]byte)
+
+ h := sha512.New()
+ h.Write(privateKey[:32])
+ digest := h.Sum(nil)
+
+ digest[0] &= 248
+ digest[31] &= 127
+ digest[31] |= 64
+
+ var A edwards25519.ExtendedGroupElement
+ var hBytes [32]byte
+ copy(hBytes[:], digest)
+ edwards25519.GeScalarMultBase(&A, &hBytes)
+ A.ToBytes(publicKey)
+
+ copy(privateKey[32:], publicKey[:])
+ return
+}
+
+// Sign signs the message with privateKey and returns a signature.
+func Sign(privateKey *[PrivateKeySize]byte, message []byte) *[SignatureSize]byte {
+ h := sha512.New()
+ h.Write(privateKey[:32])
+
+ var digest1, messageDigest, hramDigest [64]byte
+ var expandedSecretKey [32]byte
+ h.Sum(digest1[:0])
+ copy(expandedSecretKey[:], digest1[:])
+ expandedSecretKey[0] &= 248
+ expandedSecretKey[31] &= 63
+ expandedSecretKey[31] |= 64
+
+ h.Reset()
+ h.Write(digest1[32:])
+ h.Write(message)
+ h.Sum(messageDigest[:0])
+
+ var messageDigestReduced [32]byte
+ edwards25519.ScReduce(&messageDigestReduced, &messageDigest)
+ var R edwards25519.ExtendedGroupElement
+ edwards25519.GeScalarMultBase(&R, &messageDigestReduced)
+
+ var encodedR [32]byte
+ R.ToBytes(&encodedR)
+
+ h.Reset()
+ h.Write(encodedR[:])
+ h.Write(privateKey[32:])
+ h.Write(message)
+ h.Sum(hramDigest[:0])
+ var hramDigestReduced [32]byte
+ edwards25519.ScReduce(&hramDigestReduced, &hramDigest)
+
+ var s [32]byte
+ edwards25519.ScMulAdd(&s, &hramDigestReduced, &expandedSecretKey, &messageDigestReduced)
+
+ signature := new([64]byte)
+ copy(signature[:], encodedR[:])
+ copy(signature[32:], s[:])
+ return signature
+}
+
+// Verify returns true iff sig is a valid signature of message by publicKey.
+func Verify(publicKey *[PublicKeySize]byte, message []byte, sig *[SignatureSize]byte) bool {
+ if sig[63]&224 != 0 {
+ return false
+ }
+
+ var A edwards25519.ExtendedGroupElement
+ if !A.FromBytes(publicKey) {
+ return false
+ }
+
+ h := sha512.New()
+ h.Write(sig[:32])
+ h.Write(publicKey[:])
+ h.Write(message)
+ var digest [64]byte
+ h.Sum(digest[:0])
+
+ var hReduced [32]byte
+ edwards25519.ScReduce(&hReduced, &digest)
+
+ var R edwards25519.ProjectiveGroupElement
+ var b [32]byte
+ copy(b[:], sig[32:])
+ edwards25519.GeDoubleScalarMultVartime(&R, &hReduced, &A, &b)
+
+ var checkR [32]byte
+ R.ToBytes(&checkR)
+ return subtle.ConstantTimeCompare(sig[:32], checkR[:]) == 1
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/ed25519/ed25519_test.go b/Godeps/_workspace/src/github.com/tendermint/ed25519/ed25519_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..0dc2b13b9dda743ed99b5d78423f7f103964ec81
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/ed25519/ed25519_test.go
@@ -0,0 +1,105 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ed25519
+
+import (
+ "bufio"
+ "bytes"
+ "compress/gzip"
+ "encoding/hex"
+ "io"
+ "os"
+ "strings"
+ "testing"
+)
+
+type zeroReader struct{}
+
+func (zeroReader) Read(buf []byte) (int, error) {
+ for i := range buf {
+ buf[i] = 0
+ }
+ return len(buf), nil
+}
+
+func TestSignVerify(t *testing.T) {
+ var zero zeroReader
+ public, private, _ := GenerateKey(zero)
+
+ message := []byte("test message")
+ sig := Sign(private, message)
+ if !Verify(public, message, sig) {
+ t.Errorf("valid signature rejected")
+ }
+
+ wrongMessage := []byte("wrong message")
+ if Verify(public, wrongMessage, sig) {
+ t.Errorf("signature of different message accepted")
+ }
+}
+
+func TestGolden(t *testing.T) {
+ // sign.input.gz is a selection of test cases from
+ // http://ed25519.cr.yp.to/python/sign.input
+ testDataZ, err := os.Open("testdata/sign.input.gz")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer testDataZ.Close()
+ testData, err := gzip.NewReader(testDataZ)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer testData.Close()
+
+ in := bufio.NewReaderSize(testData, 1<<12)
+ lineNo := 0
+ for {
+ lineNo++
+ lineBytes, isPrefix, err := in.ReadLine()
+ if isPrefix {
+ t.Fatal("bufio buffer too small")
+ }
+ if err != nil {
+ if err == io.EOF {
+ break
+ }
+ t.Fatalf("error reading test data: %s", err)
+ }
+
+ line := string(lineBytes)
+ parts := strings.Split(line, ":")
+ if len(parts) != 5 {
+ t.Fatalf("bad number of parts on line %d", lineNo)
+ }
+
+ privBytes, _ := hex.DecodeString(parts[0])
+ pubKeyBytes, _ := hex.DecodeString(parts[1])
+ msg, _ := hex.DecodeString(parts[2])
+ sig, _ := hex.DecodeString(parts[3])
+ // The signatures in the test vectors also include the message
+ // at the end, but we just want R and S.
+ sig = sig[:SignatureSize]
+
+ if l := len(pubKeyBytes); l != PublicKeySize {
+ t.Fatalf("bad public key length on line %d: got %d bytes", lineNo, l)
+ }
+
+ var priv [PrivateKeySize]byte
+ copy(priv[:], privBytes)
+ copy(priv[32:], pubKeyBytes)
+
+ sig2 := Sign(&priv, msg)
+ if !bytes.Equal(sig, sig2[:]) {
+ t.Errorf("different signature result on line %d: %x vs %x", lineNo, sig, sig2)
+ }
+
+ var pubKey [PublicKeySize]byte
+ copy(pubKey[:], pubKeyBytes)
+ if !Verify(&pubKey, msg, sig2) {
+ t.Errorf("signature failed to verify on line %d", lineNo)
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/ed25519/edwards25519/const.go b/Godeps/_workspace/src/github.com/tendermint/ed25519/edwards25519/const.go
new file mode 100644
index 0000000000000000000000000000000000000000..ea5b77a710e73c79c168762567a547b80c9912ed
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/ed25519/edwards25519/const.go
@@ -0,0 +1,1411 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package edwards25519
+
+var d = FieldElement{
+ -10913610, 13857413, -15372611, 6949391, 114729, -8787816, -6275908, -3247719, -18696448, -12055116,
+}
+
+var d2 = FieldElement{
+ -21827239, -5839606, -30745221, 13898782, 229458, 15978800, -12551817, -6495438, 29715968, 9444199,
+}
+
+var SqrtM1 = FieldElement{
+ -32595792, -7943725, 9377950, 3500415, 12389472, -272473, -25146209, -2005654, 326686, 11406482,
+}
+
+var A = FieldElement{
+ 486662, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+}
+
+var bi = [8]PreComputedGroupElement{
+ {
+ FieldElement{25967493, -14356035, 29566456, 3660896, -12694345, 4014787, 27544626, -11754271, -6079156, 2047605},
+ FieldElement{-12545711, 934262, -2722910, 3049990, -727428, 9406986, 12720692, 5043384, 19500929, -15469378},
+ FieldElement{-8738181, 4489570, 9688441, -14785194, 10184609, -12363380, 29287919, 11864899, -24514362, -4438546},
+ },
+ {
+ FieldElement{15636291, -9688557, 24204773, -7912398, 616977, -16685262, 27787600, -14772189, 28944400, -1550024},
+ FieldElement{16568933, 4717097, -11556148, -1102322, 15682896, -11807043, 16354577, -11775962, 7689662, 11199574},
+ FieldElement{30464156, -5976125, -11779434, -15670865, 23220365, 15915852, 7512774, 10017326, -17749093, -9920357},
+ },
+ {
+ FieldElement{10861363, 11473154, 27284546, 1981175, -30064349, 12577861, 32867885, 14515107, -15438304, 10819380},
+ FieldElement{4708026, 6336745, 20377586, 9066809, -11272109, 6594696, -25653668, 12483688, -12668491, 5581306},
+ FieldElement{19563160, 16186464, -29386857, 4097519, 10237984, -4348115, 28542350, 13850243, -23678021, -15815942},
+ },
+ {
+ FieldElement{5153746, 9909285, 1723747, -2777874, 30523605, 5516873, 19480852, 5230134, -23952439, -15175766},
+ FieldElement{-30269007, -3463509, 7665486, 10083793, 28475525, 1649722, 20654025, 16520125, 30598449, 7715701},
+ FieldElement{28881845, 14381568, 9657904, 3680757, -20181635, 7843316, -31400660, 1370708, 29794553, -1409300},
+ },
+ {
+ FieldElement{-22518993, -6692182, 14201702, -8745502, -23510406, 8844726, 18474211, -1361450, -13062696, 13821877},
+ FieldElement{-6455177, -7839871, 3374702, -4740862, -27098617, -10571707, 31655028, -7212327, 18853322, -14220951},
+ FieldElement{4566830, -12963868, -28974889, -12240689, -7602672, -2830569, -8514358, -10431137, 2207753, -3209784},
+ },
+ {
+ FieldElement{-25154831, -4185821, 29681144, 7868801, -6854661, -9423865, -12437364, -663000, -31111463, -16132436},
+ FieldElement{25576264, -2703214, 7349804, -11814844, 16472782, 9300885, 3844789, 15725684, 171356, 6466918},
+ FieldElement{23103977, 13316479, 9739013, -16149481, 817875, -15038942, 8965339, -14088058, -30714912, 16193877},
+ },
+ {
+ FieldElement{-33521811, 3180713, -2394130, 14003687, -16903474, -16270840, 17238398, 4729455, -18074513, 9256800},
+ FieldElement{-25182317, -4174131, 32336398, 5036987, -21236817, 11360617, 22616405, 9761698, -19827198, 630305},
+ FieldElement{-13720693, 2639453, -24237460, -7406481, 9494427, -5774029, -6554551, -15960994, -2449256, -14291300},
+ },
+ {
+ FieldElement{-3151181, -5046075, 9282714, 6866145, -31907062, -863023, -18940575, 15033784, 25105118, -7894876},
+ FieldElement{-24326370, 15950226, -31801215, -14592823, -11662737, -5090925, 1573892, -2625887, 2198790, -15804619},
+ FieldElement{-3099351, 10324967, -2241613, 7453183, -5446979, -2735503, -13812022, -16236442, -32461234, -12290683},
+ },
+}
+
+var base = [32][8]PreComputedGroupElement{
+ {
+ {
+ FieldElement{25967493, -14356035, 29566456, 3660896, -12694345, 4014787, 27544626, -11754271, -6079156, 2047605},
+ FieldElement{-12545711, 934262, -2722910, 3049990, -727428, 9406986, 12720692, 5043384, 19500929, -15469378},
+ FieldElement{-8738181, 4489570, 9688441, -14785194, 10184609, -12363380, 29287919, 11864899, -24514362, -4438546},
+ },
+ {
+ FieldElement{-12815894, -12976347, -21581243, 11784320, -25355658, -2750717, -11717903, -3814571, -358445, -10211303},
+ FieldElement{-21703237, 6903825, 27185491, 6451973, -29577724, -9554005, -15616551, 11189268, -26829678, -5319081},
+ FieldElement{26966642, 11152617, 32442495, 15396054, 14353839, -12752335, -3128826, -9541118, -15472047, -4166697},
+ },
+ {
+ FieldElement{15636291, -9688557, 24204773, -7912398, 616977, -16685262, 27787600, -14772189, 28944400, -1550024},
+ FieldElement{16568933, 4717097, -11556148, -1102322, 15682896, -11807043, 16354577, -11775962, 7689662, 11199574},
+ FieldElement{30464156, -5976125, -11779434, -15670865, 23220365, 15915852, 7512774, 10017326, -17749093, -9920357},
+ },
+ {
+ FieldElement{-17036878, 13921892, 10945806, -6033431, 27105052, -16084379, -28926210, 15006023, 3284568, -6276540},
+ FieldElement{23599295, -8306047, -11193664, -7687416, 13236774, 10506355, 7464579, 9656445, 13059162, 10374397},
+ FieldElement{7798556, 16710257, 3033922, 2874086, 28997861, 2835604, 32406664, -3839045, -641708, -101325},
+ },
+ {
+ FieldElement{10861363, 11473154, 27284546, 1981175, -30064349, 12577861, 32867885, 14515107, -15438304, 10819380},
+ FieldElement{4708026, 6336745, 20377586, 9066809, -11272109, 6594696, -25653668, 12483688, -12668491, 5581306},
+ FieldElement{19563160, 16186464, -29386857, 4097519, 10237984, -4348115, 28542350, 13850243, -23678021, -15815942},
+ },
+ {
+ FieldElement{-15371964, -12862754, 32573250, 4720197, -26436522, 5875511, -19188627, -15224819, -9818940, -12085777},
+ FieldElement{-8549212, 109983, 15149363, 2178705, 22900618, 4543417, 3044240, -15689887, 1762328, 14866737},
+ FieldElement{-18199695, -15951423, -10473290, 1707278, -17185920, 3916101, -28236412, 3959421, 27914454, 4383652},
+ },
+ {
+ FieldElement{5153746, 9909285, 1723747, -2777874, 30523605, 5516873, 19480852, 5230134, -23952439, -15175766},
+ FieldElement{-30269007, -3463509, 7665486, 10083793, 28475525, 1649722, 20654025, 16520125, 30598449, 7715701},
+ FieldElement{28881845, 14381568, 9657904, 3680757, -20181635, 7843316, -31400660, 1370708, 29794553, -1409300},
+ },
+ {
+ FieldElement{14499471, -2729599, -33191113, -4254652, 28494862, 14271267, 30290735, 10876454, -33154098, 2381726},
+ FieldElement{-7195431, -2655363, -14730155, 462251, -27724326, 3941372, -6236617, 3696005, -32300832, 15351955},
+ FieldElement{27431194, 8222322, 16448760, -3907995, -18707002, 11938355, -32961401, -2970515, 29551813, 10109425},
+ },
+ },
+ {
+ {
+ FieldElement{-13657040, -13155431, -31283750, 11777098, 21447386, 6519384, -2378284, -1627556, 10092783, -4764171},
+ FieldElement{27939166, 14210322, 4677035, 16277044, -22964462, -12398139, -32508754, 12005538, -17810127, 12803510},
+ FieldElement{17228999, -15661624, -1233527, 300140, -1224870, -11714777, 30364213, -9038194, 18016357, 4397660},
+ },
+ {
+ FieldElement{-10958843, -7690207, 4776341, -14954238, 27850028, -15602212, -26619106, 14544525, -17477504, 982639},
+ FieldElement{29253598, 15796703, -2863982, -9908884, 10057023, 3163536, 7332899, -4120128, -21047696, 9934963},
+ FieldElement{5793303, 16271923, -24131614, -10116404, 29188560, 1206517, -14747930, 4559895, -30123922, -10897950},
+ },
+ {
+ FieldElement{-27643952, -11493006, 16282657, -11036493, 28414021, -15012264, 24191034, 4541697, -13338309, 5500568},
+ FieldElement{12650548, -1497113, 9052871, 11355358, -17680037, -8400164, -17430592, 12264343, 10874051, 13524335},
+ FieldElement{25556948, -3045990, 714651, 2510400, 23394682, -10415330, 33119038, 5080568, -22528059, 5376628},
+ },
+ {
+ FieldElement{-26088264, -4011052, -17013699, -3537628, -6726793, 1920897, -22321305, -9447443, 4535768, 1569007},
+ FieldElement{-2255422, 14606630, -21692440, -8039818, 28430649, 8775819, -30494562, 3044290, 31848280, 12543772},
+ FieldElement{-22028579, 2943893, -31857513, 6777306, 13784462, -4292203, -27377195, -2062731, 7718482, 14474653},
+ },
+ {
+ FieldElement{2385315, 2454213, -22631320, 46603, -4437935, -15680415, 656965, -7236665, 24316168, -5253567},
+ FieldElement{13741529, 10911568, -33233417, -8603737, -20177830, -1033297, 33040651, -13424532, -20729456, 8321686},
+ FieldElement{21060490, -2212744, 15712757, -4336099, 1639040, 10656336, 23845965, -11874838, -9984458, 608372},
+ },
+ {
+ FieldElement{-13672732, -15087586, -10889693, -7557059, -6036909, 11305547, 1123968, -6780577, 27229399, 23887},
+ FieldElement{-23244140, -294205, -11744728, 14712571, -29465699, -2029617, 12797024, -6440308, -1633405, 16678954},
+ FieldElement{-29500620, 4770662, -16054387, 14001338, 7830047, 9564805, -1508144, -4795045, -17169265, 4904953},
+ },
+ {
+ FieldElement{24059557, 14617003, 19037157, -15039908, 19766093, -14906429, 5169211, 16191880, 2128236, -4326833},
+ FieldElement{-16981152, 4124966, -8540610, -10653797, 30336522, -14105247, -29806336, 916033, -6882542, -2986532},
+ FieldElement{-22630907, 12419372, -7134229, -7473371, -16478904, 16739175, 285431, 2763829, 15736322, 4143876},
+ },
+ {
+ FieldElement{2379352, 11839345, -4110402, -5988665, 11274298, 794957, 212801, -14594663, 23527084, -16458268},
+ FieldElement{33431127, -11130478, -17838966, -15626900, 8909499, 8376530, -32625340, 4087881, -15188911, -14416214},
+ FieldElement{1767683, 7197987, -13205226, -2022635, -13091350, 448826, 5799055, 4357868, -4774191, -16323038},
+ },
+ },
+ {
+ {
+ FieldElement{6721966, 13833823, -23523388, -1551314, 26354293, -11863321, 23365147, -3949732, 7390890, 2759800},
+ FieldElement{4409041, 2052381, 23373853, 10530217, 7676779, -12885954, 21302353, -4264057, 1244380, -12919645},
+ FieldElement{-4421239, 7169619, 4982368, -2957590, 30256825, -2777540, 14086413, 9208236, 15886429, 16489664},
+ },
+ {
+ FieldElement{1996075, 10375649, 14346367, 13311202, -6874135, -16438411, -13693198, 398369, -30606455, -712933},
+ FieldElement{-25307465, 9795880, -2777414, 14878809, -33531835, 14780363, 13348553, 12076947, -30836462, 5113182},
+ FieldElement{-17770784, 11797796, 31950843, 13929123, -25888302, 12288344, -30341101, -7336386, 13847711, 5387222},
+ },
+ {
+ FieldElement{-18582163, -3416217, 17824843, -2340966, 22744343, -10442611, 8763061, 3617786, -19600662, 10370991},
+ FieldElement{20246567, -14369378, 22358229, -543712, 18507283, -10413996, 14554437, -8746092, 32232924, 16763880},
+ FieldElement{9648505, 10094563, 26416693, 14745928, -30374318, -6472621, 11094161, 15689506, 3140038, -16510092},
+ },
+ {
+ FieldElement{-16160072, 5472695, 31895588, 4744994, 8823515, 10365685, -27224800, 9448613, -28774454, 366295},
+ FieldElement{19153450, 11523972, -11096490, -6503142, -24647631, 5420647, 28344573, 8041113, 719605, 11671788},
+ FieldElement{8678025, 2694440, -6808014, 2517372, 4964326, 11152271, -15432916, -15266516, 27000813, -10195553},
+ },
+ {
+ FieldElement{-15157904, 7134312, 8639287, -2814877, -7235688, 10421742, 564065, 5336097, 6750977, -14521026},
+ FieldElement{11836410, -3979488, 26297894, 16080799, 23455045, 15735944, 1695823, -8819122, 8169720, 16220347},
+ FieldElement{-18115838, 8653647, 17578566, -6092619, -8025777, -16012763, -11144307, -2627664, -5990708, -14166033},
+ },
+ {
+ FieldElement{-23308498, -10968312, 15213228, -10081214, -30853605, -11050004, 27884329, 2847284, 2655861, 1738395},
+ FieldElement{-27537433, -14253021, -25336301, -8002780, -9370762, 8129821, 21651608, -3239336, -19087449, -11005278},
+ FieldElement{1533110, 3437855, 23735889, 459276, 29970501, 11335377, 26030092, 5821408, 10478196, 8544890},
+ },
+ {
+ FieldElement{32173121, -16129311, 24896207, 3921497, 22579056, -3410854, 19270449, 12217473, 17789017, -3395995},
+ FieldElement{-30552961, -2228401, -15578829, -10147201, 13243889, 517024, 15479401, -3853233, 30460520, 1052596},
+ FieldElement{-11614875, 13323618, 32618793, 8175907, -15230173, 12596687, 27491595, -4612359, 3179268, -9478891},
+ },
+ {
+ FieldElement{31947069, -14366651, -4640583, -15339921, -15125977, -6039709, -14756777, -16411740, 19072640, -9511060},
+ FieldElement{11685058, 11822410, 3158003, -13952594, 33402194, -4165066, 5977896, -5215017, 473099, 5040608},
+ FieldElement{-20290863, 8198642, -27410132, 11602123, 1290375, -2799760, 28326862, 1721092, -19558642, -3131606},
+ },
+ },
+ {
+ {
+ FieldElement{7881532, 10687937, 7578723, 7738378, -18951012, -2553952, 21820786, 8076149, -27868496, 11538389},
+ FieldElement{-19935666, 3899861, 18283497, -6801568, -15728660, -11249211, 8754525, 7446702, -5676054, 5797016},
+ FieldElement{-11295600, -3793569, -15782110, -7964573, 12708869, -8456199, 2014099, -9050574, -2369172, -5877341},
+ },
+ {
+ FieldElement{-22472376, -11568741, -27682020, 1146375, 18956691, 16640559, 1192730, -3714199, 15123619, 10811505},
+ FieldElement{14352098, -3419715, -18942044, 10822655, 32750596, 4699007, -70363, 15776356, -28886779, -11974553},
+ FieldElement{-28241164, -8072475, -4978962, -5315317, 29416931, 1847569, -20654173, -16484855, 4714547, -9600655},
+ },
+ {
+ FieldElement{15200332, 8368572, 19679101, 15970074, -31872674, 1959451, 24611599, -4543832, -11745876, 12340220},
+ FieldElement{12876937, -10480056, 33134381, 6590940, -6307776, 14872440, 9613953, 8241152, 15370987, 9608631},
+ FieldElement{-4143277, -12014408, 8446281, -391603, 4407738, 13629032, -7724868, 15866074, -28210621, -8814099},
+ },
+ {
+ FieldElement{26660628, -15677655, 8393734, 358047, -7401291, 992988, -23904233, 858697, 20571223, 8420556},
+ FieldElement{14620715, 13067227, -15447274, 8264467, 14106269, 15080814, 33531827, 12516406, -21574435, -12476749},
+ FieldElement{236881, 10476226, 57258, -14677024, 6472998, 2466984, 17258519, 7256740, 8791136, 15069930},
+ },
+ {
+ FieldElement{1276410, -9371918, 22949635, -16322807, -23493039, -5702186, 14711875, 4874229, -30663140, -2331391},
+ FieldElement{5855666, 4990204, -13711848, 7294284, -7804282, 1924647, -1423175, -7912378, -33069337, 9234253},
+ FieldElement{20590503, -9018988, 31529744, -7352666, -2706834, 10650548, 31559055, -11609587, 18979186, 13396066},
+ },
+ {
+ FieldElement{24474287, 4968103, 22267082, 4407354, 24063882, -8325180, -18816887, 13594782, 33514650, 7021958},
+ FieldElement{-11566906, -6565505, -21365085, 15928892, -26158305, 4315421, -25948728, -3916677, -21480480, 12868082},
+ FieldElement{-28635013, 13504661, 19988037, -2132761, 21078225, 6443208, -21446107, 2244500, -12455797, -8089383},
+ },
+ {
+ FieldElement{-30595528, 13793479, -5852820, 319136, -25723172, -6263899, 33086546, 8957937, -15233648, 5540521},
+ FieldElement{-11630176, -11503902, -8119500, -7643073, 2620056, 1022908, -23710744, -1568984, -16128528, -14962807},
+ FieldElement{23152971, 775386, 27395463, 14006635, -9701118, 4649512, 1689819, 892185, -11513277, -15205948},
+ },
+ {
+ FieldElement{9770129, 9586738, 26496094, 4324120, 1556511, -3550024, 27453819, 4763127, -19179614, 5867134},
+ FieldElement{-32765025, 1927590, 31726409, -4753295, 23962434, -16019500, 27846559, 5931263, -29749703, -16108455},
+ FieldElement{27461885, -2977536, 22380810, 1815854, -23033753, -3031938, 7283490, -15148073, -19526700, 7734629},
+ },
+ },
+ {
+ {
+ FieldElement{-8010264, -9590817, -11120403, 6196038, 29344158, -13430885, 7585295, -3176626, 18549497, 15302069},
+ FieldElement{-32658337, -6171222, -7672793, -11051681, 6258878, 13504381, 10458790, -6418461, -8872242, 8424746},
+ FieldElement{24687205, 8613276, -30667046, -3233545, 1863892, -1830544, 19206234, 7134917, -11284482, -828919},
+ },
+ {
+ FieldElement{11334899, -9218022, 8025293, 12707519, 17523892, -10476071, 10243738, -14685461, -5066034, 16498837},
+ FieldElement{8911542, 6887158, -9584260, -6958590, 11145641, -9543680, 17303925, -14124238, 6536641, 10543906},
+ FieldElement{-28946384, 15479763, -17466835, 568876, -1497683, 11223454, -2669190, -16625574, -27235709, 8876771},
+ },
+ {
+ FieldElement{-25742899, -12566864, -15649966, -846607, -33026686, -796288, -33481822, 15824474, -604426, -9039817},
+ FieldElement{10330056, 70051, 7957388, -9002667, 9764902, 15609756, 27698697, -4890037, 1657394, 3084098},
+ FieldElement{10477963, -7470260, 12119566, -13250805, 29016247, -5365589, 31280319, 14396151, -30233575, 15272409},
+ },
+ {
+ FieldElement{-12288309, 3169463, 28813183, 16658753, 25116432, -5630466, -25173957, -12636138, -25014757, 1950504},
+ FieldElement{-26180358, 9489187, 11053416, -14746161, -31053720, 5825630, -8384306, -8767532, 15341279, 8373727},
+ FieldElement{28685821, 7759505, -14378516, -12002860, -31971820, 4079242, 298136, -10232602, -2878207, 15190420},
+ },
+ {
+ FieldElement{-32932876, 13806336, -14337485, -15794431, -24004620, 10940928, 8669718, 2742393, -26033313, -6875003},
+ FieldElement{-1580388, -11729417, -25979658, -11445023, -17411874, -10912854, 9291594, -16247779, -12154742, 6048605},
+ FieldElement{-30305315, 14843444, 1539301, 11864366, 20201677, 1900163, 13934231, 5128323, 11213262, 9168384},
+ },
+ {
+ FieldElement{-26280513, 11007847, 19408960, -940758, -18592965, -4328580, -5088060, -11105150, 20470157, -16398701},
+ FieldElement{-23136053, 9282192, 14855179, -15390078, -7362815, -14408560, -22783952, 14461608, 14042978, 5230683},
+ FieldElement{29969567, -2741594, -16711867, -8552442, 9175486, -2468974, 21556951, 3506042, -5933891, -12449708},
+ },
+ {
+ FieldElement{-3144746, 8744661, 19704003, 4581278, -20430686, 6830683, -21284170, 8971513, -28539189, 15326563},
+ FieldElement{-19464629, 10110288, -17262528, -3503892, -23500387, 1355669, -15523050, 15300988, -20514118, 9168260},
+ FieldElement{-5353335, 4488613, -23803248, 16314347, 7780487, -15638939, -28948358, 9601605, 33087103, -9011387},
+ },
+ {
+ FieldElement{-19443170, -15512900, -20797467, -12445323, -29824447, 10229461, -27444329, -15000531, -5996870, 15664672},
+ FieldElement{23294591, -16632613, -22650781, -8470978, 27844204, 11461195, 13099750, -2460356, 18151676, 13417686},
+ FieldElement{-24722913, -4176517, -31150679, 5988919, -26858785, 6685065, 1661597, -12551441, 15271676, -15452665},
+ },
+ },
+ {
+ {
+ FieldElement{11433042, -13228665, 8239631, -5279517, -1985436, -725718, -18698764, 2167544, -6921301, -13440182},
+ FieldElement{-31436171, 15575146, 30436815, 12192228, -22463353, 9395379, -9917708, -8638997, 12215110, 12028277},
+ FieldElement{14098400, 6555944, 23007258, 5757252, -15427832, -12950502, 30123440, 4617780, -16900089, -655628},
+ },
+ {
+ FieldElement{-4026201, -15240835, 11893168, 13718664, -14809462, 1847385, -15819999, 10154009, 23973261, -12684474},
+ FieldElement{-26531820, -3695990, -1908898, 2534301, -31870557, -16550355, 18341390, -11419951, 32013174, -10103539},
+ FieldElement{-25479301, 10876443, -11771086, -14625140, -12369567, 1838104, 21911214, 6354752, 4425632, -837822},
+ },
+ {
+ FieldElement{-10433389, -14612966, 22229858, -3091047, -13191166, 776729, -17415375, -12020462, 4725005, 14044970},
+ FieldElement{19268650, -7304421, 1555349, 8692754, -21474059, -9910664, 6347390, -1411784, -19522291, -16109756},
+ FieldElement{-24864089, 12986008, -10898878, -5558584, -11312371, -148526, 19541418, 8180106, 9282262, 10282508},
+ },
+ {
+ FieldElement{-26205082, 4428547, -8661196, -13194263, 4098402, -14165257, 15522535, 8372215, 5542595, -10702683},
+ FieldElement{-10562541, 14895633, 26814552, -16673850, -17480754, -2489360, -2781891, 6993761, -18093885, 10114655},
+ FieldElement{-20107055, -929418, 31422704, 10427861, -7110749, 6150669, -29091755, -11529146, 25953725, -106158},
+ },
+ {
+ FieldElement{-4234397, -8039292, -9119125, 3046000, 2101609, -12607294, 19390020, 6094296, -3315279, 12831125},
+ FieldElement{-15998678, 7578152, 5310217, 14408357, -33548620, -224739, 31575954, 6326196, 7381791, -2421839},
+ FieldElement{-20902779, 3296811, 24736065, -16328389, 18374254, 7318640, 6295303, 8082724, -15362489, 12339664},
+ },
+ {
+ FieldElement{27724736, 2291157, 6088201, -14184798, 1792727, 5857634, 13848414, 15768922, 25091167, 14856294},
+ FieldElement{-18866652, 8331043, 24373479, 8541013, -701998, -9269457, 12927300, -12695493, -22182473, -9012899},
+ FieldElement{-11423429, -5421590, 11632845, 3405020, 30536730, -11674039, -27260765, 13866390, 30146206, 9142070},
+ },
+ {
+ FieldElement{3924129, -15307516, -13817122, -10054960, 12291820, -668366, -27702774, 9326384, -8237858, 4171294},
+ FieldElement{-15921940, 16037937, 6713787, 16606682, -21612135, 2790944, 26396185, 3731949, 345228, -5462949},
+ FieldElement{-21327538, 13448259, 25284571, 1143661, 20614966, -8849387, 2031539, -12391231, -16253183, -13582083},
+ },
+ {
+ FieldElement{31016211, -16722429, 26371392, -14451233, -5027349, 14854137, 17477601, 3842657, 28012650, -16405420},
+ FieldElement{-5075835, 9368966, -8562079, -4600902, -15249953, 6970560, -9189873, 16292057, -8867157, 3507940},
+ FieldElement{29439664, 3537914, 23333589, 6997794, -17555561, -11018068, -15209202, -15051267, -9164929, 6580396},
+ },
+ },
+ {
+ {
+ FieldElement{-12185861, -7679788, 16438269, 10826160, -8696817, -6235611, 17860444, -9273846, -2095802, 9304567},
+ FieldElement{20714564, -4336911, 29088195, 7406487, 11426967, -5095705, 14792667, -14608617, 5289421, -477127},
+ FieldElement{-16665533, -10650790, -6160345, -13305760, 9192020, -1802462, 17271490, 12349094, 26939669, -3752294},
+ },
+ {
+ FieldElement{-12889898, 9373458, 31595848, 16374215, 21471720, 13221525, -27283495, -12348559, -3698806, 117887},
+ FieldElement{22263325, -6560050, 3984570, -11174646, -15114008, -566785, 28311253, 5358056, -23319780, 541964},
+ FieldElement{16259219, 3261970, 2309254, -15534474, -16885711, -4581916, 24134070, -16705829, -13337066, -13552195},
+ },
+ {
+ FieldElement{9378160, -13140186, -22845982, -12745264, 28198281, -7244098, -2399684, -717351, 690426, 14876244},
+ FieldElement{24977353, -314384, -8223969, -13465086, 28432343, -1176353, -13068804, -12297348, -22380984, 6618999},
+ FieldElement{-1538174, 11685646, 12944378, 13682314, -24389511, -14413193, 8044829, -13817328, 32239829, -5652762},
+ },
+ {
+ FieldElement{-18603066, 4762990, -926250, 8885304, -28412480, -3187315, 9781647, -10350059, 32779359, 5095274},
+ FieldElement{-33008130, -5214506, -32264887, -3685216, 9460461, -9327423, -24601656, 14506724, 21639561, -2630236},
+ FieldElement{-16400943, -13112215, 25239338, 15531969, 3987758, -4499318, -1289502, -6863535, 17874574, 558605},
+ },
+ {
+ FieldElement{-13600129, 10240081, 9171883, 16131053, -20869254, 9599700, 33499487, 5080151, 2085892, 5119761},
+ FieldElement{-22205145, -2519528, -16381601, 414691, -25019550, 2170430, 30634760, -8363614, -31999993, -5759884},
+ FieldElement{-6845704, 15791202, 8550074, -1312654, 29928809, -12092256, 27534430, -7192145, -22351378, 12961482},
+ },
+ {
+ FieldElement{-24492060, -9570771, 10368194, 11582341, -23397293, -2245287, 16533930, 8206996, -30194652, -5159638},
+ FieldElement{-11121496, -3382234, 2307366, 6362031, -135455, 8868177, -16835630, 7031275, 7589640, 8945490},
+ FieldElement{-32152748, 8917967, 6661220, -11677616, -1192060, -15793393, 7251489, -11182180, 24099109, -14456170},
+ },
+ {
+ FieldElement{5019558, -7907470, 4244127, -14714356, -26933272, 6453165, -19118182, -13289025, -6231896, -10280736},
+ FieldElement{10853594, 10721687, 26480089, 5861829, -22995819, 1972175, -1866647, -10557898, -3363451, -6441124},
+ FieldElement{-17002408, 5906790, 221599, -6563147, 7828208, -13248918, 24362661, -2008168, -13866408, 7421392},
+ },
+ {
+ FieldElement{8139927, -6546497, 32257646, -5890546, 30375719, 1886181, -21175108, 15441252, 28826358, -4123029},
+ FieldElement{6267086, 9695052, 7709135, -16603597, -32869068, -1886135, 14795160, -7840124, 13746021, -1742048},
+ FieldElement{28584902, 7787108, -6732942, -15050729, 22846041, -7571236, -3181936, -363524, 4771362, -8419958},
+ },
+ },
+ {
+ {
+ FieldElement{24949256, 6376279, -27466481, -8174608, -18646154, -9930606, 33543569, -12141695, 3569627, 11342593},
+ FieldElement{26514989, 4740088, 27912651, 3697550, 19331575, -11472339, 6809886, 4608608, 7325975, -14801071},
+ FieldElement{-11618399, -14554430, -24321212, 7655128, -1369274, 5214312, -27400540, 10258390, -17646694, -8186692},
+ },
+ {
+ FieldElement{11431204, 15823007, 26570245, 14329124, 18029990, 4796082, -31446179, 15580664, 9280358, -3973687},
+ FieldElement{-160783, -10326257, -22855316, -4304997, -20861367, -13621002, -32810901, -11181622, -15545091, 4387441},
+ FieldElement{-20799378, 12194512, 3937617, -5805892, -27154820, 9340370, -24513992, 8548137, 20617071, -7482001},
+ },
+ {
+ FieldElement{-938825, -3930586, -8714311, 16124718, 24603125, -6225393, -13775352, -11875822, 24345683, 10325460},
+ FieldElement{-19855277, -1568885, -22202708, 8714034, 14007766, 6928528, 16318175, -1010689, 4766743, 3552007},
+ FieldElement{-21751364, -16730916, 1351763, -803421, -4009670, 3950935, 3217514, 14481909, 10988822, -3994762},
+ },
+ {
+ FieldElement{15564307, -14311570, 3101243, 5684148, 30446780, -8051356, 12677127, -6505343, -8295852, 13296005},
+ FieldElement{-9442290, 6624296, -30298964, -11913677, -4670981, -2057379, 31521204, 9614054, -30000824, 12074674},
+ FieldElement{4771191, -135239, 14290749, -13089852, 27992298, 14998318, -1413936, -1556716, 29832613, -16391035},
+ },
+ {
+ FieldElement{7064884, -7541174, -19161962, -5067537, -18891269, -2912736, 25825242, 5293297, -27122660, 13101590},
+ FieldElement{-2298563, 2439670, -7466610, 1719965, -27267541, -16328445, 32512469, -5317593, -30356070, -4190957},
+ FieldElement{-30006540, 10162316, -33180176, 3981723, -16482138, -13070044, 14413974, 9515896, 19568978, 9628812},
+ },
+ {
+ FieldElement{33053803, 199357, 15894591, 1583059, 27380243, -4580435, -17838894, -6106839, -6291786, 3437740},
+ FieldElement{-18978877, 3884493, 19469877, 12726490, 15913552, 13614290, -22961733, 70104, 7463304, 4176122},
+ FieldElement{-27124001, 10659917, 11482427, -16070381, 12771467, -6635117, -32719404, -5322751, 24216882, 5944158},
+ },
+ {
+ FieldElement{8894125, 7450974, -2664149, -9765752, -28080517, -12389115, 19345746, 14680796, 11632993, 5847885},
+ FieldElement{26942781, -2315317, 9129564, -4906607, 26024105, 11769399, -11518837, 6367194, -9727230, 4782140},
+ FieldElement{19916461, -4828410, -22910704, -11414391, 25606324, -5972441, 33253853, 8220911, 6358847, -1873857},
+ },
+ {
+ FieldElement{801428, -2081702, 16569428, 11065167, 29875704, 96627, 7908388, -4480480, -13538503, 1387155},
+ FieldElement{19646058, 5720633, -11416706, 12814209, 11607948, 12749789, 14147075, 15156355, -21866831, 11835260},
+ FieldElement{19299512, 1155910, 28703737, 14890794, 2925026, 7269399, 26121523, 15467869, -26560550, 5052483},
+ },
+ },
+ {
+ {
+ FieldElement{-3017432, 10058206, 1980837, 3964243, 22160966, 12322533, -6431123, -12618185, 12228557, -7003677},
+ FieldElement{32944382, 14922211, -22844894, 5188528, 21913450, -8719943, 4001465, 13238564, -6114803, 8653815},
+ FieldElement{22865569, -4652735, 27603668, -12545395, 14348958, 8234005, 24808405, 5719875, 28483275, 2841751},
+ },
+ {
+ FieldElement{-16420968, -1113305, -327719, -12107856, 21886282, -15552774, -1887966, -315658, 19932058, -12739203},
+ FieldElement{-11656086, 10087521, -8864888, -5536143, -19278573, -3055912, 3999228, 13239134, -4777469, -13910208},
+ FieldElement{1382174, -11694719, 17266790, 9194690, -13324356, 9720081, 20403944, 11284705, -14013818, 3093230},
+ },
+ {
+ FieldElement{16650921, -11037932, -1064178, 1570629, -8329746, 7352753, -302424, 16271225, -24049421, -6691850},
+ FieldElement{-21911077, -5927941, -4611316, -5560156, -31744103, -10785293, 24123614, 15193618, -21652117, -16739389},
+ FieldElement{-9935934, -4289447, -25279823, 4372842, 2087473, 10399484, 31870908, 14690798, 17361620, 11864968},
+ },
+ {
+ FieldElement{-11307610, 6210372, 13206574, 5806320, -29017692, -13967200, -12331205, -7486601, -25578460, -16240689},
+ FieldElement{14668462, -12270235, 26039039, 15305210, 25515617, 4542480, 10453892, 6577524, 9145645, -6443880},
+ FieldElement{5974874, 3053895, -9433049, -10385191, -31865124, 3225009, -7972642, 3936128, -5652273, -3050304},
+ },
+ {
+ FieldElement{30625386, -4729400, -25555961, -12792866, -20484575, 7695099, 17097188, -16303496, -27999779, 1803632},
+ FieldElement{-3553091, 9865099, -5228566, 4272701, -5673832, -16689700, 14911344, 12196514, -21405489, 7047412},
+ FieldElement{20093277, 9920966, -11138194, -5343857, 13161587, 12044805, -32856851, 4124601, -32343828, -10257566},
+ },
+ {
+ FieldElement{-20788824, 14084654, -13531713, 7842147, 19119038, -13822605, 4752377, -8714640, -21679658, 2288038},
+ FieldElement{-26819236, -3283715, 29965059, 3039786, -14473765, 2540457, 29457502, 14625692, -24819617, 12570232},
+ FieldElement{-1063558, -11551823, 16920318, 12494842, 1278292, -5869109, -21159943, -3498680, -11974704, 4724943},
+ },
+ {
+ FieldElement{17960970, -11775534, -4140968, -9702530, -8876562, -1410617, -12907383, -8659932, -29576300, 1903856},
+ FieldElement{23134274, -14279132, -10681997, -1611936, 20684485, 15770816, -12989750, 3190296, 26955097, 14109738},
+ FieldElement{15308788, 5320727, -30113809, -14318877, 22902008, 7767164, 29425325, -11277562, 31960942, 11934971},
+ },
+ {
+ FieldElement{-27395711, 8435796, 4109644, 12222639, -24627868, 14818669, 20638173, 4875028, 10491392, 1379718},
+ FieldElement{-13159415, 9197841, 3875503, -8936108, -1383712, -5879801, 33518459, 16176658, 21432314, 12180697},
+ FieldElement{-11787308, 11500838, 13787581, -13832590, -22430679, 10140205, 1465425, 12689540, -10301319, -13872883},
+ },
+ },
+ {
+ {
+ FieldElement{5414091, -15386041, -21007664, 9643570, 12834970, 1186149, -2622916, -1342231, 26128231, 6032912},
+ FieldElement{-26337395, -13766162, 32496025, -13653919, 17847801, -12669156, 3604025, 8316894, -25875034, -10437358},
+ FieldElement{3296484, 6223048, 24680646, -12246460, -23052020, 5903205, -8862297, -4639164, 12376617, 3188849},
+ },
+ {
+ FieldElement{29190488, -14659046, 27549113, -1183516, 3520066, -10697301, 32049515, -7309113, -16109234, -9852307},
+ FieldElement{-14744486, -9309156, 735818, -598978, -20407687, -5057904, 25246078, -15795669, 18640741, -960977},
+ FieldElement{-6928835, -16430795, 10361374, 5642961, 4910474, 12345252, -31638386, -494430, 10530747, 1053335},
+ },
+ {
+ FieldElement{-29265967, -14186805, -13538216, -12117373, -19457059, -10655384, -31462369, -2948985, 24018831, 15026644},
+ FieldElement{-22592535, -3145277, -2289276, 5953843, -13440189, 9425631, 25310643, 13003497, -2314791, -15145616},
+ FieldElement{-27419985, -603321, -8043984, -1669117, -26092265, 13987819, -27297622, 187899, -23166419, -2531735},
+ },
+ {
+ FieldElement{-21744398, -13810475, 1844840, 5021428, -10434399, -15911473, 9716667, 16266922, -5070217, 726099},
+ FieldElement{29370922, -6053998, 7334071, -15342259, 9385287, 2247707, -13661962, -4839461, 30007388, -15823341},
+ FieldElement{-936379, 16086691, 23751945, -543318, -1167538, -5189036, 9137109, 730663, 9835848, 4555336},
+ },
+ {
+ FieldElement{-23376435, 1410446, -22253753, -12899614, 30867635, 15826977, 17693930, 544696, -11985298, 12422646},
+ FieldElement{31117226, -12215734, -13502838, 6561947, -9876867, -12757670, -5118685, -4096706, 29120153, 13924425},
+ FieldElement{-17400879, -14233209, 19675799, -2734756, -11006962, -5858820, -9383939, -11317700, 7240931, -237388},
+ },
+ {
+ FieldElement{-31361739, -11346780, -15007447, -5856218, -22453340, -12152771, 1222336, 4389483, 3293637, -15551743},
+ FieldElement{-16684801, -14444245, 11038544, 11054958, -13801175, -3338533, -24319580, 7733547, 12796905, -6335822},
+ FieldElement{-8759414, -10817836, -25418864, 10783769, -30615557, -9746811, -28253339, 3647836, 3222231, -11160462},
+ },
+ {
+ FieldElement{18606113, 1693100, -25448386, -15170272, 4112353, 10045021, 23603893, -2048234, -7550776, 2484985},
+ FieldElement{9255317, -3131197, -12156162, -1004256, 13098013, -9214866, 16377220, -2102812, -19802075, -3034702},
+ FieldElement{-22729289, 7496160, -5742199, 11329249, 19991973, -3347502, -31718148, 9936966, -30097688, -10618797},
+ },
+ {
+ FieldElement{21878590, -5001297, 4338336, 13643897, -3036865, 13160960, 19708896, 5415497, -7360503, -4109293},
+ FieldElement{27736861, 10103576, 12500508, 8502413, -3413016, -9633558, 10436918, -1550276, -23659143, -8132100},
+ FieldElement{19492550, -12104365, -29681976, -852630, -3208171, 12403437, 30066266, 8367329, 13243957, 8709688},
+ },
+ },
+ {
+ {
+ FieldElement{12015105, 2801261, 28198131, 10151021, 24818120, -4743133, -11194191, -5645734, 5150968, 7274186},
+ FieldElement{2831366, -12492146, 1478975, 6122054, 23825128, -12733586, 31097299, 6083058, 31021603, -9793610},
+ FieldElement{-2529932, -2229646, 445613, 10720828, -13849527, -11505937, -23507731, 16354465, 15067285, -14147707},
+ },
+ {
+ FieldElement{7840942, 14037873, -33364863, 15934016, -728213, -3642706, 21403988, 1057586, -19379462, -12403220},
+ FieldElement{915865, -16469274, 15608285, -8789130, -24357026, 6060030, -17371319, 8410997, -7220461, 16527025},
+ FieldElement{32922597, -556987, 20336074, -16184568, 10903705, -5384487, 16957574, 52992, 23834301, 6588044},
+ },
+ {
+ FieldElement{32752030, 11232950, 3381995, -8714866, 22652988, -10744103, 17159699, 16689107, -20314580, -1305992},
+ FieldElement{-4689649, 9166776, -25710296, -10847306, 11576752, 12733943, 7924251, -2752281, 1976123, -7249027},
+ FieldElement{21251222, 16309901, -2983015, -6783122, 30810597, 12967303, 156041, -3371252, 12331345, -8237197},
+ },
+ {
+ FieldElement{8651614, -4477032, -16085636, -4996994, 13002507, 2950805, 29054427, -5106970, 10008136, -4667901},
+ FieldElement{31486080, 15114593, -14261250, 12951354, 14369431, -7387845, 16347321, -13662089, 8684155, -10532952},
+ FieldElement{19443825, 11385320, 24468943, -9659068, -23919258, 2187569, -26263207, -6086921, 31316348, 14219878},
+ },
+ {
+ FieldElement{-28594490, 1193785, 32245219, 11392485, 31092169, 15722801, 27146014, 6992409, 29126555, 9207390},
+ FieldElement{32382935, 1110093, 18477781, 11028262, -27411763, -7548111, -4980517, 10843782, -7957600, -14435730},
+ FieldElement{2814918, 7836403, 27519878, -7868156, -20894015, -11553689, -21494559, 8550130, 28346258, 1994730},
+ },
+ {
+ FieldElement{-19578299, 8085545, -14000519, -3948622, 2785838, -16231307, -19516951, 7174894, 22628102, 8115180},
+ FieldElement{-30405132, 955511, -11133838, -15078069, -32447087, -13278079, -25651578, 3317160, -9943017, 930272},
+ FieldElement{-15303681, -6833769, 28856490, 1357446, 23421993, 1057177, 24091212, -1388970, -22765376, -10650715},
+ },
+ {
+ FieldElement{-22751231, -5303997, -12907607, -12768866, -15811511, -7797053, -14839018, -16554220, -1867018, 8398970},
+ FieldElement{-31969310, 2106403, -4736360, 1362501, 12813763, 16200670, 22981545, -6291273, 18009408, -15772772},
+ FieldElement{-17220923, -9545221, -27784654, 14166835, 29815394, 7444469, 29551787, -3727419, 19288549, 1325865},
+ },
+ {
+ FieldElement{15100157, -15835752, -23923978, -1005098, -26450192, 15509408, 12376730, -3479146, 33166107, -8042750},
+ FieldElement{20909231, 13023121, -9209752, 16251778, -5778415, -8094914, 12412151, 10018715, 2213263, -13878373},
+ FieldElement{32529814, -11074689, 30361439, -16689753, -9135940, 1513226, 22922121, 6382134, -5766928, 8371348},
+ },
+ },
+ {
+ {
+ FieldElement{9923462, 11271500, 12616794, 3544722, -29998368, -1721626, 12891687, -8193132, -26442943, 10486144},
+ FieldElement{-22597207, -7012665, 8587003, -8257861, 4084309, -12970062, 361726, 2610596, -23921530, -11455195},
+ FieldElement{5408411, -1136691, -4969122, 10561668, 24145918, 14240566, 31319731, -4235541, 19985175, -3436086},
+ },
+ {
+ FieldElement{-13994457, 16616821, 14549246, 3341099, 32155958, 13648976, -17577068, 8849297, 65030, 8370684},
+ FieldElement{-8320926, -12049626, 31204563, 5839400, -20627288, -1057277, -19442942, 6922164, 12743482, -9800518},
+ FieldElement{-2361371, 12678785, 28815050, 4759974, -23893047, 4884717, 23783145, 11038569, 18800704, 255233},
+ },
+ {
+ FieldElement{-5269658, -1773886, 13957886, 7990715, 23132995, 728773, 13393847, 9066957, 19258688, -14753793},
+ FieldElement{-2936654, -10827535, -10432089, 14516793, -3640786, 4372541, -31934921, 2209390, -1524053, 2055794},
+ FieldElement{580882, 16705327, 5468415, -2683018, -30926419, -14696000, -7203346, -8994389, -30021019, 7394435},
+ },
+ {
+ FieldElement{23838809, 1822728, -15738443, 15242727, 8318092, -3733104, -21672180, -3492205, -4821741, 14799921},
+ FieldElement{13345610, 9759151, 3371034, -16137791, 16353039, 8577942, 31129804, 13496856, -9056018, 7402518},
+ FieldElement{2286874, -4435931, -20042458, -2008336, -13696227, 5038122, 11006906, -15760352, 8205061, 1607563},
+ },
+ {
+ FieldElement{14414086, -8002132, 3331830, -3208217, 22249151, -5594188, 18364661, -2906958, 30019587, -9029278},
+ FieldElement{-27688051, 1585953, -10775053, 931069, -29120221, -11002319, -14410829, 12029093, 9944378, 8024},
+ FieldElement{4368715, -3709630, 29874200, -15022983, -20230386, -11410704, -16114594, -999085, -8142388, 5640030},
+ },
+ {
+ FieldElement{10299610, 13746483, 11661824, 16234854, 7630238, 5998374, 9809887, -16694564, 15219798, -14327783},
+ FieldElement{27425505, -5719081, 3055006, 10660664, 23458024, 595578, -15398605, -1173195, -18342183, 9742717},
+ FieldElement{6744077, 2427284, 26042789, 2720740, -847906, 1118974, 32324614, 7406442, 12420155, 1994844},
+ },
+ {
+ FieldElement{14012521, -5024720, -18384453, -9578469, -26485342, -3936439, -13033478, -10909803, 24319929, -6446333},
+ FieldElement{16412690, -4507367, 10772641, 15929391, -17068788, -4658621, 10555945, -10484049, -30102368, -4739048},
+ FieldElement{22397382, -7767684, -9293161, -12792868, 17166287, -9755136, -27333065, 6199366, 21880021, -12250760},
+ },
+ {
+ FieldElement{-4283307, 5368523, -31117018, 8163389, -30323063, 3209128, 16557151, 8890729, 8840445, 4957760},
+ FieldElement{-15447727, 709327, -6919446, -10870178, -29777922, 6522332, -21720181, 12130072, -14796503, 5005757},
+ FieldElement{-2114751, -14308128, 23019042, 15765735, -25269683, 6002752, 10183197, -13239326, -16395286, -2176112},
+ },
+ },
+ {
+ {
+ FieldElement{-19025756, 1632005, 13466291, -7995100, -23640451, 16573537, -32013908, -3057104, 22208662, 2000468},
+ FieldElement{3065073, -1412761, -25598674, -361432, -17683065, -5703415, -8164212, 11248527, -3691214, -7414184},
+ FieldElement{10379208, -6045554, 8877319, 1473647, -29291284, -12507580, 16690915, 2553332, -3132688, 16400289},
+ },
+ {
+ FieldElement{15716668, 1254266, -18472690, 7446274, -8448918, 6344164, -22097271, -7285580, 26894937, 9132066},
+ FieldElement{24158887, 12938817, 11085297, -8177598, -28063478, -4457083, -30576463, 64452, -6817084, -2692882},
+ FieldElement{13488534, 7794716, 22236231, 5989356, 25426474, -12578208, 2350710, -3418511, -4688006, 2364226},
+ },
+ {
+ FieldElement{16335052, 9132434, 25640582, 6678888, 1725628, 8517937, -11807024, -11697457, 15445875, -7798101},
+ FieldElement{29004207, -7867081, 28661402, -640412, -12794003, -7943086, 31863255, -4135540, -278050, -15759279},
+ FieldElement{-6122061, -14866665, -28614905, 14569919, -10857999, -3591829, 10343412, -6976290, -29828287, -10815811},
+ },
+ {
+ FieldElement{27081650, 3463984, 14099042, -4517604, 1616303, -6205604, 29542636, 15372179, 17293797, 960709},
+ FieldElement{20263915, 11434237, -5765435, 11236810, 13505955, -10857102, -16111345, 6493122, -19384511, 7639714},
+ FieldElement{-2830798, -14839232, 25403038, -8215196, -8317012, -16173699, 18006287, -16043750, 29994677, -15808121},
+ },
+ {
+ FieldElement{9769828, 5202651, -24157398, -13631392, -28051003, -11561624, -24613141, -13860782, -31184575, 709464},
+ FieldElement{12286395, 13076066, -21775189, -1176622, -25003198, 4057652, -32018128, -8890874, 16102007, 13205847},
+ FieldElement{13733362, 5599946, 10557076, 3195751, -5557991, 8536970, -25540170, 8525972, 10151379, 10394400},
+ },
+ {
+ FieldElement{4024660, -16137551, 22436262, 12276534, -9099015, -2686099, 19698229, 11743039, -33302334, 8934414},
+ FieldElement{-15879800, -4525240, -8580747, -2934061, 14634845, -698278, -9449077, 3137094, -11536886, 11721158},
+ FieldElement{17555939, -5013938, 8268606, 2331751, -22738815, 9761013, 9319229, 8835153, -9205489, -1280045},
+ },
+ {
+ FieldElement{-461409, -7830014, 20614118, 16688288, -7514766, -4807119, 22300304, 505429, 6108462, -6183415},
+ FieldElement{-5070281, 12367917, -30663534, 3234473, 32617080, -8422642, 29880583, -13483331, -26898490, -7867459},
+ FieldElement{-31975283, 5726539, 26934134, 10237677, -3173717, -605053, 24199304, 3795095, 7592688, -14992079},
+ },
+ {
+ FieldElement{21594432, -14964228, 17466408, -4077222, 32537084, 2739898, 6407723, 12018833, -28256052, 4298412},
+ FieldElement{-20650503, -11961496, -27236275, 570498, 3767144, -1717540, 13891942, -1569194, 13717174, 10805743},
+ FieldElement{-14676630, -15644296, 15287174, 11927123, 24177847, -8175568, -796431, 14860609, -26938930, -5863836},
+ },
+ },
+ {
+ {
+ FieldElement{12962541, 5311799, -10060768, 11658280, 18855286, -7954201, 13286263, -12808704, -4381056, 9882022},
+ FieldElement{18512079, 11319350, -20123124, 15090309, 18818594, 5271736, -22727904, 3666879, -23967430, -3299429},
+ FieldElement{-6789020, -3146043, 16192429, 13241070, 15898607, -14206114, -10084880, -6661110, -2403099, 5276065},
+ },
+ {
+ FieldElement{30169808, -5317648, 26306206, -11750859, 27814964, 7069267, 7152851, 3684982, 1449224, 13082861},
+ FieldElement{10342826, 3098505, 2119311, 193222, 25702612, 12233820, 23697382, 15056736, -21016438, -8202000},
+ FieldElement{-33150110, 3261608, 22745853, 7948688, 19370557, -15177665, -26171976, 6482814, -10300080, -11060101},
+ },
+ {
+ FieldElement{32869458, -5408545, 25609743, 15678670, -10687769, -15471071, 26112421, 2521008, -22664288, 6904815},
+ FieldElement{29506923, 4457497, 3377935, -9796444, -30510046, 12935080, 1561737, 3841096, -29003639, -6657642},
+ FieldElement{10340844, -6630377, -18656632, -2278430, 12621151, -13339055, 30878497, -11824370, -25584551, 5181966},
+ },
+ {
+ FieldElement{25940115, -12658025, 17324188, -10307374, -8671468, 15029094, 24396252, -16450922, -2322852, -12388574},
+ FieldElement{-21765684, 9916823, -1300409, 4079498, -1028346, 11909559, 1782390, 12641087, 20603771, -6561742},
+ FieldElement{-18882287, -11673380, 24849422, 11501709, 13161720, -4768874, 1925523, 11914390, 4662781, 7820689},
+ },
+ {
+ FieldElement{12241050, -425982, 8132691, 9393934, 32846760, -1599620, 29749456, 12172924, 16136752, 15264020},
+ FieldElement{-10349955, -14680563, -8211979, 2330220, -17662549, -14545780, 10658213, 6671822, 19012087, 3772772},
+ FieldElement{3753511, -3421066, 10617074, 2028709, 14841030, -6721664, 28718732, -15762884, 20527771, 12988982},
+ },
+ {
+ FieldElement{-14822485, -5797269, -3707987, 12689773, -898983, -10914866, -24183046, -10564943, 3299665, -12424953},
+ FieldElement{-16777703, -15253301, -9642417, 4978983, 3308785, 8755439, 6943197, 6461331, -25583147, 8991218},
+ FieldElement{-17226263, 1816362, -1673288, -6086439, 31783888, -8175991, -32948145, 7417950, -30242287, 1507265},
+ },
+ {
+ FieldElement{29692663, 6829891, -10498800, 4334896, 20945975, -11906496, -28887608, 8209391, 14606362, -10647073},
+ FieldElement{-3481570, 8707081, 32188102, 5672294, 22096700, 1711240, -33020695, 9761487, 4170404, -2085325},
+ FieldElement{-11587470, 14855945, -4127778, -1531857, -26649089, 15084046, 22186522, 16002000, -14276837, -8400798},
+ },
+ {
+ FieldElement{-4811456, 13761029, -31703877, -2483919, -3312471, 7869047, -7113572, -9620092, 13240845, 10965870},
+ FieldElement{-7742563, -8256762, -14768334, -13656260, -23232383, 12387166, 4498947, 14147411, 29514390, 4302863},
+ FieldElement{-13413405, -12407859, 20757302, -13801832, 14785143, 8976368, -5061276, -2144373, 17846988, -13971927},
+ },
+ },
+ {
+ {
+ FieldElement{-2244452, -754728, -4597030, -1066309, -6247172, 1455299, -21647728, -9214789, -5222701, 12650267},
+ FieldElement{-9906797, -16070310, 21134160, 12198166, -27064575, 708126, 387813, 13770293, -19134326, 10958663},
+ FieldElement{22470984, 12369526, 23446014, -5441109, -21520802, -9698723, -11772496, -11574455, -25083830, 4271862},
+ },
+ {
+ FieldElement{-25169565, -10053642, -19909332, 15361595, -5984358, 2159192, 75375, -4278529, -32526221, 8469673},
+ FieldElement{15854970, 4148314, -8893890, 7259002, 11666551, 13824734, -30531198, 2697372, 24154791, -9460943},
+ FieldElement{15446137, -15806644, 29759747, 14019369, 30811221, -9610191, -31582008, 12840104, 24913809, 9815020},
+ },
+ {
+ FieldElement{-4709286, -5614269, -31841498, -12288893, -14443537, 10799414, -9103676, 13438769, 18735128, 9466238},
+ FieldElement{11933045, 9281483, 5081055, -5183824, -2628162, -4905629, -7727821, -10896103, -22728655, 16199064},
+ FieldElement{14576810, 379472, -26786533, -8317236, -29426508, -10812974, -102766, 1876699, 30801119, 2164795},
+ },
+ {
+ FieldElement{15995086, 3199873, 13672555, 13712240, -19378835, -4647646, -13081610, -15496269, -13492807, 1268052},
+ FieldElement{-10290614, -3659039, -3286592, 10948818, 23037027, 3794475, -3470338, -12600221, -17055369, 3565904},
+ FieldElement{29210088, -9419337, -5919792, -4952785, 10834811, -13327726, -16512102, -10820713, -27162222, -14030531},
+ },
+ {
+ FieldElement{-13161890, 15508588, 16663704, -8156150, -28349942, 9019123, -29183421, -3769423, 2244111, -14001979},
+ FieldElement{-5152875, -3800936, -9306475, -6071583, 16243069, 14684434, -25673088, -16180800, 13491506, 4641841},
+ FieldElement{10813417, 643330, -19188515, -728916, 30292062, -16600078, 27548447, -7721242, 14476989, -12767431},
+ },
+ {
+ FieldElement{10292079, 9984945, 6481436, 8279905, -7251514, 7032743, 27282937, -1644259, -27912810, 12651324},
+ FieldElement{-31185513, -813383, 22271204, 11835308, 10201545, 15351028, 17099662, 3988035, 21721536, -3148940},
+ FieldElement{10202177, -6545839, -31373232, -9574638, -32150642, -8119683, -12906320, 3852694, 13216206, 14842320},
+ },
+ {
+ FieldElement{-15815640, -10601066, -6538952, -7258995, -6984659, -6581778, -31500847, 13765824, -27434397, 9900184},
+ FieldElement{14465505, -13833331, -32133984, -14738873, -27443187, 12990492, 33046193, 15796406, -7051866, -8040114},
+ FieldElement{30924417, -8279620, 6359016, -12816335, 16508377, 9071735, -25488601, 15413635, 9524356, -7018878},
+ },
+ {
+ FieldElement{12274201, -13175547, 32627641, -1785326, 6736625, 13267305, 5237659, -5109483, 15663516, 4035784},
+ FieldElement{-2951309, 8903985, 17349946, 601635, -16432815, -4612556, -13732739, -15889334, -22258478, 4659091},
+ FieldElement{-16916263, -4952973, -30393711, -15158821, 20774812, 15897498, 5736189, 15026997, -2178256, -13455585},
+ },
+ },
+ {
+ {
+ FieldElement{-8858980, -2219056, 28571666, -10155518, -474467, -10105698, -3801496, 278095, 23440562, -290208},
+ FieldElement{10226241, -5928702, 15139956, 120818, -14867693, 5218603, 32937275, 11551483, -16571960, -7442864},
+ FieldElement{17932739, -12437276, -24039557, 10749060, 11316803, 7535897, 22503767, 5561594, -3646624, 3898661},
+ },
+ {
+ FieldElement{7749907, -969567, -16339731, -16464, -25018111, 15122143, -1573531, 7152530, 21831162, 1245233},
+ FieldElement{26958459, -14658026, 4314586, 8346991, -5677764, 11960072, -32589295, -620035, -30402091, -16716212},
+ FieldElement{-12165896, 9166947, 33491384, 13673479, 29787085, 13096535, 6280834, 14587357, -22338025, 13987525},
+ },
+ {
+ FieldElement{-24349909, 7778775, 21116000, 15572597, -4833266, -5357778, -4300898, -5124639, -7469781, -2858068},
+ FieldElement{9681908, -6737123, -31951644, 13591838, -6883821, 386950, 31622781, 6439245, -14581012, 4091397},
+ FieldElement{-8426427, 1470727, -28109679, -1596990, 3978627, -5123623, -19622683, 12092163, 29077877, -14741988},
+ },
+ {
+ FieldElement{5269168, -6859726, -13230211, -8020715, 25932563, 1763552, -5606110, -5505881, -20017847, 2357889},
+ FieldElement{32264008, -15407652, -5387735, -1160093, -2091322, -3946900, 23104804, -12869908, 5727338, 189038},
+ FieldElement{14609123, -8954470, -6000566, -16622781, -14577387, -7743898, -26745169, 10942115, -25888931, -14884697},
+ },
+ {
+ FieldElement{20513500, 5557931, -15604613, 7829531, 26413943, -2019404, -21378968, 7471781, 13913677, -5137875},
+ FieldElement{-25574376, 11967826, 29233242, 12948236, -6754465, 4713227, -8940970, 14059180, 12878652, 8511905},
+ FieldElement{-25656801, 3393631, -2955415, -7075526, -2250709, 9366908, -30223418, 6812974, 5568676, -3127656},
+ },
+ {
+ FieldElement{11630004, 12144454, 2116339, 13606037, 27378885, 15676917, -17408753, -13504373, -14395196, 8070818},
+ FieldElement{27117696, -10007378, -31282771, -5570088, 1127282, 12772488, -29845906, 10483306, -11552749, -1028714},
+ FieldElement{10637467, -5688064, 5674781, 1072708, -26343588, -6982302, -1683975, 9177853, -27493162, 15431203},
+ },
+ {
+ FieldElement{20525145, 10892566, -12742472, 12779443, -29493034, 16150075, -28240519, 14943142, -15056790, -7935931},
+ FieldElement{-30024462, 5626926, -551567, -9981087, 753598, 11981191, 25244767, -3239766, -3356550, 9594024},
+ FieldElement{-23752644, 2636870, -5163910, -10103818, 585134, 7877383, 11345683, -6492290, 13352335, -10977084},
+ },
+ {
+ FieldElement{-1931799, -5407458, 3304649, -12884869, 17015806, -4877091, -29783850, -7752482, -13215537, -319204},
+ FieldElement{20239939, 6607058, 6203985, 3483793, -18386976, -779229, -20723742, 15077870, -22750759, 14523817},
+ FieldElement{27406042, -6041657, 27423596, -4497394, 4996214, 10002360, -28842031, -4545494, -30172742, -4805667},
+ },
+ },
+ {
+ {
+ FieldElement{11374242, 12660715, 17861383, -12540833, 10935568, 1099227, -13886076, -9091740, -27727044, 11358504},
+ FieldElement{-12730809, 10311867, 1510375, 10778093, -2119455, -9145702, 32676003, 11149336, -26123651, 4985768},
+ FieldElement{-19096303, 341147, -6197485, -239033, 15756973, -8796662, -983043, 13794114, -19414307, -15621255},
+ },
+ {
+ FieldElement{6490081, 11940286, 25495923, -7726360, 8668373, -8751316, 3367603, 6970005, -1691065, -9004790},
+ FieldElement{1656497, 13457317, 15370807, 6364910, 13605745, 8362338, -19174622, -5475723, -16796596, -5031438},
+ FieldElement{-22273315, -13524424, -64685, -4334223, -18605636, -10921968, -20571065, -7007978, -99853, -10237333},
+ },
+ {
+ FieldElement{17747465, 10039260, 19368299, -4050591, -20630635, -16041286, 31992683, -15857976, -29260363, -5511971},
+ FieldElement{31932027, -4986141, -19612382, 16366580, 22023614, 88450, 11371999, -3744247, 4882242, -10626905},
+ FieldElement{29796507, 37186, 19818052, 10115756, -11829032, 3352736, 18551198, 3272828, -5190932, -4162409},
+ },
+ {
+ FieldElement{12501286, 4044383, -8612957, -13392385, -32430052, 5136599, -19230378, -3529697, 330070, -3659409},
+ FieldElement{6384877, 2899513, 17807477, 7663917, -2358888, 12363165, 25366522, -8573892, -271295, 12071499},
+ FieldElement{-8365515, -4042521, 25133448, -4517355, -6211027, 2265927, -32769618, 1936675, -5159697, 3829363},
+ },
+ {
+ FieldElement{28425966, -5835433, -577090, -4697198, -14217555, 6870930, 7921550, -6567787, 26333140, 14267664},
+ FieldElement{-11067219, 11871231, 27385719, -10559544, -4585914, -11189312, 10004786, -8709488, -21761224, 8930324},
+ FieldElement{-21197785, -16396035, 25654216, -1725397, 12282012, 11008919, 1541940, 4757911, -26491501, -16408940},
+ },
+ {
+ FieldElement{13537262, -7759490, -20604840, 10961927, -5922820, -13218065, -13156584, 6217254, -15943699, 13814990},
+ FieldElement{-17422573, 15157790, 18705543, 29619, 24409717, -260476, 27361681, 9257833, -1956526, -1776914},
+ FieldElement{-25045300, -10191966, 15366585, 15166509, -13105086, 8423556, -29171540, 12361135, -18685978, 4578290},
+ },
+ {
+ FieldElement{24579768, 3711570, 1342322, -11180126, -27005135, 14124956, -22544529, 14074919, 21964432, 8235257},
+ FieldElement{-6528613, -2411497, 9442966, -5925588, 12025640, -1487420, -2981514, -1669206, 13006806, 2355433},
+ FieldElement{-16304899, -13605259, -6632427, -5142349, 16974359, -10911083, 27202044, 1719366, 1141648, -12796236},
+ },
+ {
+ FieldElement{-12863944, -13219986, -8318266, -11018091, -6810145, -4843894, 13475066, -3133972, 32674895, 13715045},
+ FieldElement{11423335, -5468059, 32344216, 8962751, 24989809, 9241752, -13265253, 16086212, -28740881, -15642093},
+ FieldElement{-1409668, 12530728, -6368726, 10847387, 19531186, -14132160, -11709148, 7791794, -27245943, 4383347},
+ },
+ },
+ {
+ {
+ FieldElement{-28970898, 5271447, -1266009, -9736989, -12455236, 16732599, -4862407, -4906449, 27193557, 6245191},
+ FieldElement{-15193956, 5362278, -1783893, 2695834, 4960227, 12840725, 23061898, 3260492, 22510453, 8577507},
+ FieldElement{-12632451, 11257346, -32692994, 13548177, -721004, 10879011, 31168030, 13952092, -29571492, -3635906},
+ },
+ {
+ FieldElement{3877321, -9572739, 32416692, 5405324, -11004407, -13656635, 3759769, 11935320, 5611860, 8164018},
+ FieldElement{-16275802, 14667797, 15906460, 12155291, -22111149, -9039718, 32003002, -8832289, 5773085, -8422109},
+ FieldElement{-23788118, -8254300, 1950875, 8937633, 18686727, 16459170, -905725, 12376320, 31632953, 190926},
+ },
+ {
+ FieldElement{-24593607, -16138885, -8423991, 13378746, 14162407, 6901328, -8288749, 4508564, -25341555, -3627528},
+ FieldElement{8884438, -5884009, 6023974, 10104341, -6881569, -4941533, 18722941, -14786005, -1672488, 827625},
+ FieldElement{-32720583, -16289296, -32503547, 7101210, 13354605, 2659080, -1800575, -14108036, -24878478, 1541286},
+ },
+ {
+ FieldElement{2901347, -1117687, 3880376, -10059388, -17620940, -3612781, -21802117, -3567481, 20456845, -1885033},
+ FieldElement{27019610, 12299467, -13658288, -1603234, -12861660, -4861471, -19540150, -5016058, 29439641, 15138866},
+ FieldElement{21536104, -6626420, -32447818, -10690208, -22408077, 5175814, -5420040, -16361163, 7779328, 109896},
+ },
+ {
+ FieldElement{30279744, 14648750, -8044871, 6425558, 13639621, -743509, 28698390, 12180118, 23177719, -554075},
+ FieldElement{26572847, 3405927, -31701700, 12890905, -19265668, 5335866, -6493768, 2378492, 4439158, -13279347},
+ FieldElement{-22716706, 3489070, -9225266, -332753, 18875722, -1140095, 14819434, -12731527, -17717757, -5461437},
+ },
+ {
+ FieldElement{-5056483, 16566551, 15953661, 3767752, -10436499, 15627060, -820954, 2177225, 8550082, -15114165},
+ FieldElement{-18473302, 16596775, -381660, 15663611, 22860960, 15585581, -27844109, -3582739, -23260460, -8428588},
+ FieldElement{-32480551, 15707275, -8205912, -5652081, 29464558, 2713815, -22725137, 15860482, -21902570, 1494193},
+ },
+ {
+ FieldElement{-19562091, -14087393, -25583872, -9299552, 13127842, 759709, 21923482, 16529112, 8742704, 12967017},
+ FieldElement{-28464899, 1553205, 32536856, -10473729, -24691605, -406174, -8914625, -2933896, -29903758, 15553883},
+ FieldElement{21877909, 3230008, 9881174, 10539357, -4797115, 2841332, 11543572, 14513274, 19375923, -12647961},
+ },
+ {
+ FieldElement{8832269, -14495485, 13253511, 5137575, 5037871, 4078777, 24880818, -6222716, 2862653, 9455043},
+ FieldElement{29306751, 5123106, 20245049, -14149889, 9592566, 8447059, -2077124, -2990080, 15511449, 4789663},
+ FieldElement{-20679756, 7004547, 8824831, -9434977, -4045704, -3750736, -5754762, 108893, 23513200, 16652362},
+ },
+ },
+ {
+ {
+ FieldElement{-33256173, 4144782, -4476029, -6579123, 10770039, -7155542, -6650416, -12936300, -18319198, 10212860},
+ FieldElement{2756081, 8598110, 7383731, -6859892, 22312759, -1105012, 21179801, 2600940, -9988298, -12506466},
+ FieldElement{-24645692, 13317462, -30449259, -15653928, 21365574, -10869657, 11344424, 864440, -2499677, -16710063},
+ },
+ {
+ FieldElement{-26432803, 6148329, -17184412, -14474154, 18782929, -275997, -22561534, 211300, 2719757, 4940997},
+ FieldElement{-1323882, 3911313, -6948744, 14759765, -30027150, 7851207, 21690126, 8518463, 26699843, 5276295},
+ FieldElement{-13149873, -6429067, 9396249, 365013, 24703301, -10488939, 1321586, 149635, -15452774, 7159369},
+ },
+ {
+ FieldElement{9987780, -3404759, 17507962, 9505530, 9731535, -2165514, 22356009, 8312176, 22477218, -8403385},
+ FieldElement{18155857, -16504990, 19744716, 9006923, 15154154, -10538976, 24256460, -4864995, -22548173, 9334109},
+ FieldElement{2986088, -4911893, 10776628, -3473844, 10620590, -7083203, -21413845, 14253545, -22587149, 536906},
+ },
+ {
+ FieldElement{4377756, 8115836, 24567078, 15495314, 11625074, 13064599, 7390551, 10589625, 10838060, -15420424},
+ FieldElement{-19342404, 867880, 9277171, -3218459, -14431572, -1986443, 19295826, -15796950, 6378260, 699185},
+ FieldElement{7895026, 4057113, -7081772, -13077756, -17886831, -323126, -716039, 15693155, -5045064, -13373962},
+ },
+ {
+ FieldElement{-7737563, -5869402, -14566319, -7406919, 11385654, 13201616, 31730678, -10962840, -3918636, -9669325},
+ FieldElement{10188286, -15770834, -7336361, 13427543, 22223443, 14896287, 30743455, 7116568, -21786507, 5427593},
+ FieldElement{696102, 13206899, 27047647, -10632082, 15285305, -9853179, 10798490, -4578720, 19236243, 12477404},
+ },
+ {
+ FieldElement{-11229439, 11243796, -17054270, -8040865, -788228, -8167967, -3897669, 11180504, -23169516, 7733644},
+ FieldElement{17800790, -14036179, -27000429, -11766671, 23887827, 3149671, 23466177, -10538171, 10322027, 15313801},
+ FieldElement{26246234, 11968874, 32263343, -5468728, 6830755, -13323031, -15794704, -101982, -24449242, 10890804},
+ },
+ {
+ FieldElement{-31365647, 10271363, -12660625, -6267268, 16690207, -13062544, -14982212, 16484931, 25180797, -5334884},
+ FieldElement{-586574, 10376444, -32586414, -11286356, 19801893, 10997610, 2276632, 9482883, 316878, 13820577},
+ FieldElement{-9882808, -4510367, -2115506, 16457136, -11100081, 11674996, 30756178, -7515054, 30696930, -3712849},
+ },
+ {
+ FieldElement{32988917, -9603412, 12499366, 7910787, -10617257, -11931514, -7342816, -9985397, -32349517, 7392473},
+ FieldElement{-8855661, 15927861, 9866406, -3649411, -2396914, -16655781, -30409476, -9134995, 25112947, -2926644},
+ FieldElement{-2504044, -436966, 25621774, -5678772, 15085042, -5479877, -24884878, -13526194, 5537438, -13914319},
+ },
+ },
+ {
+ {
+ FieldElement{-11225584, 2320285, -9584280, 10149187, -33444663, 5808648, -14876251, -1729667, 31234590, 6090599},
+ FieldElement{-9633316, 116426, 26083934, 2897444, -6364437, -2688086, 609721, 15878753, -6970405, -9034768},
+ FieldElement{-27757857, 247744, -15194774, -9002551, 23288161, -10011936, -23869595, 6503646, 20650474, 1804084},
+ },
+ {
+ FieldElement{-27589786, 15456424, 8972517, 8469608, 15640622, 4439847, 3121995, -10329713, 27842616, -202328},
+ FieldElement{-15306973, 2839644, 22530074, 10026331, 4602058, 5048462, 28248656, 5031932, -11375082, 12714369},
+ FieldElement{20807691, -7270825, 29286141, 11421711, -27876523, -13868230, -21227475, 1035546, -19733229, 12796920},
+ },
+ {
+ FieldElement{12076899, -14301286, -8785001, -11848922, -25012791, 16400684, -17591495, -12899438, 3480665, -15182815},
+ FieldElement{-32361549, 5457597, 28548107, 7833186, 7303070, -11953545, -24363064, -15921875, -33374054, 2771025},
+ FieldElement{-21389266, 421932, 26597266, 6860826, 22486084, -6737172, -17137485, -4210226, -24552282, 15673397},
+ },
+ {
+ FieldElement{-20184622, 2338216, 19788685, -9620956, -4001265, -8740893, -20271184, 4733254, 3727144, -12934448},
+ FieldElement{6120119, 814863, -11794402, -622716, 6812205, -15747771, 2019594, 7975683, 31123697, -10958981},
+ FieldElement{30069250, -11435332, 30434654, 2958439, 18399564, -976289, 12296869, 9204260, -16432438, 9648165},
+ },
+ {
+ FieldElement{32705432, -1550977, 30705658, 7451065, -11805606, 9631813, 3305266, 5248604, -26008332, -11377501},
+ FieldElement{17219865, 2375039, -31570947, -5575615, -19459679, 9219903, 294711, 15298639, 2662509, -16297073},
+ FieldElement{-1172927, -7558695, -4366770, -4287744, -21346413, -8434326, 32087529, -1222777, 32247248, -14389861},
+ },
+ {
+ FieldElement{14312628, 1221556, 17395390, -8700143, -4945741, -8684635, -28197744, -9637817, -16027623, -13378845},
+ FieldElement{-1428825, -9678990, -9235681, 6549687, -7383069, -468664, 23046502, 9803137, 17597934, 2346211},
+ FieldElement{18510800, 15337574, 26171504, 981392, -22241552, 7827556, -23491134, -11323352, 3059833, -11782870},
+ },
+ {
+ FieldElement{10141598, 6082907, 17829293, -1947643, 9830092, 13613136, -25556636, -5544586, -33502212, 3592096},
+ FieldElement{33114168, -15889352, -26525686, -13343397, 33076705, 8716171, 1151462, 1521897, -982665, -6837803},
+ FieldElement{-32939165, -4255815, 23947181, -324178, -33072974, -12305637, -16637686, 3891704, 26353178, 693168},
+ },
+ {
+ FieldElement{30374239, 1595580, -16884039, 13186931, 4600344, 406904, 9585294, -400668, 31375464, 14369965},
+ FieldElement{-14370654, -7772529, 1510301, 6434173, -18784789, -6262728, 32732230, -13108839, 17901441, 16011505},
+ FieldElement{18171223, -11934626, -12500402, 15197122, -11038147, -15230035, -19172240, -16046376, 8764035, 12309598},
+ },
+ },
+ {
+ {
+ FieldElement{5975908, -5243188, -19459362, -9681747, -11541277, 14015782, -23665757, 1228319, 17544096, -10593782},
+ FieldElement{5811932, -1715293, 3442887, -2269310, -18367348, -8359541, -18044043, -15410127, -5565381, 12348900},
+ FieldElement{-31399660, 11407555, 25755363, 6891399, -3256938, 14872274, -24849353, 8141295, -10632534, -585479},
+ },
+ {
+ FieldElement{-12675304, 694026, -5076145, 13300344, 14015258, -14451394, -9698672, -11329050, 30944593, 1130208},
+ FieldElement{8247766, -6710942, -26562381, -7709309, -14401939, -14648910, 4652152, 2488540, 23550156, -271232},
+ FieldElement{17294316, -3788438, 7026748, 15626851, 22990044, 113481, 2267737, -5908146, -408818, -137719},
+ },
+ {
+ FieldElement{16091085, -16253926, 18599252, 7340678, 2137637, -1221657, -3364161, 14550936, 3260525, -7166271},
+ FieldElement{-4910104, -13332887, 18550887, 10864893, -16459325, -7291596, -23028869, -13204905, -12748722, 2701326},
+ FieldElement{-8574695, 16099415, 4629974, -16340524, -20786213, -6005432, -10018363, 9276971, 11329923, 1862132},
+ },
+ {
+ FieldElement{14763076, -15903608, -30918270, 3689867, 3511892, 10313526, -21951088, 12219231, -9037963, -940300},
+ FieldElement{8894987, -3446094, 6150753, 3013931, 301220, 15693451, -31981216, -2909717, -15438168, 11595570},
+ FieldElement{15214962, 3537601, -26238722, -14058872, 4418657, -15230761, 13947276, 10730794, -13489462, -4363670},
+ },
+ {
+ FieldElement{-2538306, 7682793, 32759013, 263109, -29984731, -7955452, -22332124, -10188635, 977108, 699994},
+ FieldElement{-12466472, 4195084, -9211532, 550904, -15565337, 12917920, 19118110, -439841, -30534533, -14337913},
+ FieldElement{31788461, -14507657, 4799989, 7372237, 8808585, -14747943, 9408237, -10051775, 12493932, -5409317},
+ },
+ {
+ FieldElement{-25680606, 5260744, -19235809, -6284470, -3695942, 16566087, 27218280, 2607121, 29375955, 6024730},
+ FieldElement{842132, -2794693, -4763381, -8722815, 26332018, -12405641, 11831880, 6985184, -9940361, 2854096},
+ FieldElement{-4847262, -7969331, 2516242, -5847713, 9695691, -7221186, 16512645, 960770, 12121869, 16648078},
+ },
+ {
+ FieldElement{-15218652, 14667096, -13336229, 2013717, 30598287, -464137, -31504922, -7882064, 20237806, 2838411},
+ FieldElement{-19288047, 4453152, 15298546, -16178388, 22115043, -15972604, 12544294, -13470457, 1068881, -12499905},
+ FieldElement{-9558883, -16518835, 33238498, 13506958, 30505848, -1114596, -8486907, -2630053, 12521378, 4845654},
+ },
+ {
+ FieldElement{-28198521, 10744108, -2958380, 10199664, 7759311, -13088600, 3409348, -873400, -6482306, -12885870},
+ FieldElement{-23561822, 6230156, -20382013, 10655314, -24040585, -11621172, 10477734, -1240216, -3113227, 13974498},
+ FieldElement{12966261, 15550616, -32038948, -1615346, 21025980, -629444, 5642325, 7188737, 18895762, 12629579},
+ },
+ },
+ {
+ {
+ FieldElement{14741879, -14946887, 22177208, -11721237, 1279741, 8058600, 11758140, 789443, 32195181, 3895677},
+ FieldElement{10758205, 15755439, -4509950, 9243698, -4879422, 6879879, -2204575, -3566119, -8982069, 4429647},
+ FieldElement{-2453894, 15725973, -20436342, -10410672, -5803908, -11040220, -7135870, -11642895, 18047436, -15281743},
+ },
+ {
+ FieldElement{-25173001, -11307165, 29759956, 11776784, -22262383, -15820455, 10993114, -12850837, -17620701, -9408468},
+ FieldElement{21987233, 700364, -24505048, 14972008, -7774265, -5718395, 32155026, 2581431, -29958985, 8773375},
+ FieldElement{-25568350, 454463, -13211935, 16126715, 25240068, 8594567, 20656846, 12017935, -7874389, -13920155},
+ },
+ {
+ FieldElement{6028182, 6263078, -31011806, -11301710, -818919, 2461772, -31841174, -5468042, -1721788, -2776725},
+ FieldElement{-12278994, 16624277, 987579, -5922598, 32908203, 1248608, 7719845, -4166698, 28408820, 6816612},
+ FieldElement{-10358094, -8237829, 19549651, -12169222, 22082623, 16147817, 20613181, 13982702, -10339570, 5067943},
+ },
+ {
+ FieldElement{-30505967, -3821767, 12074681, 13582412, -19877972, 2443951, -19719286, 12746132, 5331210, -10105944},
+ FieldElement{30528811, 3601899, -1957090, 4619785, -27361822, -15436388, 24180793, -12570394, 27679908, -1648928},
+ FieldElement{9402404, -13957065, 32834043, 10838634, -26580150, -13237195, 26653274, -8685565, 22611444, -12715406},
+ },
+ {
+ FieldElement{22190590, 1118029, 22736441, 15130463, -30460692, -5991321, 19189625, -4648942, 4854859, 6622139},
+ FieldElement{-8310738, -2953450, -8262579, -3388049, -10401731, -271929, 13424426, -3567227, 26404409, 13001963},
+ FieldElement{-31241838, -15415700, -2994250, 8939346, 11562230, -12840670, -26064365, -11621720, -15405155, 11020693},
+ },
+ {
+ FieldElement{1866042, -7949489, -7898649, -10301010, 12483315, 13477547, 3175636, -12424163, 28761762, 1406734},
+ FieldElement{-448555, -1777666, 13018551, 3194501, -9580420, -11161737, 24760585, -4347088, 25577411, -13378680},
+ FieldElement{-24290378, 4759345, -690653, -1852816, 2066747, 10693769, -29595790, 9884936, -9368926, 4745410},
+ },
+ {
+ FieldElement{-9141284, 6049714, -19531061, -4341411, -31260798, 9944276, -15462008, -11311852, 10931924, -11931931},
+ FieldElement{-16561513, 14112680, -8012645, 4817318, -8040464, -11414606, -22853429, 10856641, -20470770, 13434654},
+ FieldElement{22759489, -10073434, -16766264, -1871422, 13637442, -10168091, 1765144, -12654326, 28445307, -5364710},
+ },
+ {
+ FieldElement{29875063, 12493613, 2795536, -3786330, 1710620, 15181182, -10195717, -8788675, 9074234, 1167180},
+ FieldElement{-26205683, 11014233, -9842651, -2635485, -26908120, 7532294, -18716888, -9535498, 3843903, 9367684},
+ FieldElement{-10969595, -6403711, 9591134, 9582310, 11349256, 108879, 16235123, 8601684, -139197, 4242895},
+ },
+ },
+ {
+ {
+ FieldElement{22092954, -13191123, -2042793, -11968512, 32186753, -11517388, -6574341, 2470660, -27417366, 16625501},
+ FieldElement{-11057722, 3042016, 13770083, -9257922, 584236, -544855, -7770857, 2602725, -27351616, 14247413},
+ FieldElement{6314175, -10264892, -32772502, 15957557, -10157730, 168750, -8618807, 14290061, 27108877, -1180880},
+ },
+ {
+ FieldElement{-8586597, -7170966, 13241782, 10960156, -32991015, -13794596, 33547976, -11058889, -27148451, 981874},
+ FieldElement{22833440, 9293594, -32649448, -13618667, -9136966, 14756819, -22928859, -13970780, -10479804, -16197962},
+ FieldElement{-7768587, 3326786, -28111797, 10783824, 19178761, 14905060, 22680049, 13906969, -15933690, 3797899},
+ },
+ {
+ FieldElement{21721356, -4212746, -12206123, 9310182, -3882239, -13653110, 23740224, -2709232, 20491983, -8042152},
+ FieldElement{9209270, -15135055, -13256557, -6167798, -731016, 15289673, 25947805, 15286587, 30997318, -6703063},
+ FieldElement{7392032, 16618386, 23946583, -8039892, -13265164, -1533858, -14197445, -2321576, 17649998, -250080},
+ },
+ {
+ FieldElement{-9301088, -14193827, 30609526, -3049543, -25175069, -1283752, -15241566, -9525724, -2233253, 7662146},
+ FieldElement{-17558673, 1763594, -33114336, 15908610, -30040870, -12174295, 7335080, -8472199, -3174674, 3440183},
+ FieldElement{-19889700, -5977008, -24111293, -9688870, 10799743, -16571957, 40450, -4431835, 4862400, 1133},
+ },
+ {
+ FieldElement{-32856209, -7873957, -5422389, 14860950, -16319031, 7956142, 7258061, 311861, -30594991, -7379421},
+ FieldElement{-3773428, -1565936, 28985340, 7499440, 24445838, 9325937, 29727763, 16527196, 18278453, 15405622},
+ FieldElement{-4381906, 8508652, -19898366, -3674424, -5984453, 15149970, -13313598, 843523, -21875062, 13626197},
+ },
+ {
+ FieldElement{2281448, -13487055, -10915418, -2609910, 1879358, 16164207, -10783882, 3953792, 13340839, 15928663},
+ FieldElement{31727126, -7179855, -18437503, -8283652, 2875793, -16390330, -25269894, -7014826, -23452306, 5964753},
+ FieldElement{4100420, -5959452, -17179337, 6017714, -18705837, 12227141, -26684835, 11344144, 2538215, -7570755},
+ },
+ {
+ FieldElement{-9433605, 6123113, 11159803, -2156608, 30016280, 14966241, -20474983, 1485421, -629256, -15958862},
+ FieldElement{-26804558, 4260919, 11851389, 9658551, -32017107, 16367492, -20205425, -13191288, 11659922, -11115118},
+ FieldElement{26180396, 10015009, -30844224, -8581293, 5418197, 9480663, 2231568, -10170080, 33100372, -1306171},
+ },
+ {
+ FieldElement{15121113, -5201871, -10389905, 15427821, -27509937, -15992507, 21670947, 4486675, -5931810, -14466380},
+ FieldElement{16166486, -9483733, -11104130, 6023908, -31926798, -1364923, 2340060, -16254968, -10735770, -10039824},
+ FieldElement{28042865, -3557089, -12126526, 12259706, -3717498, -6945899, 6766453, -8689599, 18036436, 5803270},
+ },
+ },
+ {
+ {
+ FieldElement{-817581, 6763912, 11803561, 1585585, 10958447, -2671165, 23855391, 4598332, -6159431, -14117438},
+ FieldElement{-31031306, -14256194, 17332029, -2383520, 31312682, -5967183, 696309, 50292, -20095739, 11763584},
+ FieldElement{-594563, -2514283, -32234153, 12643980, 12650761, 14811489, 665117, -12613632, -19773211, -10713562},
+ },
+ {
+ FieldElement{30464590, -11262872, -4127476, -12734478, 19835327, -7105613, -24396175, 2075773, -17020157, 992471},
+ FieldElement{18357185, -6994433, 7766382, 16342475, -29324918, 411174, 14578841, 8080033, -11574335, -10601610},
+ FieldElement{19598397, 10334610, 12555054, 2555664, 18821899, -10339780, 21873263, 16014234, 26224780, 16452269},
+ },
+ {
+ FieldElement{-30223925, 5145196, 5944548, 16385966, 3976735, 2009897, -11377804, -7618186, -20533829, 3698650},
+ FieldElement{14187449, 3448569, -10636236, -10810935, -22663880, -3433596, 7268410, -10890444, 27394301, 12015369},
+ FieldElement{19695761, 16087646, 28032085, 12999827, 6817792, 11427614, 20244189, -1312777, -13259127, -3402461},
+ },
+ {
+ FieldElement{30860103, 12735208, -1888245, -4699734, -16974906, 2256940, -8166013, 12298312, -8550524, -10393462},
+ FieldElement{-5719826, -11245325, -1910649, 15569035, 26642876, -7587760, -5789354, -15118654, -4976164, 12651793},
+ FieldElement{-2848395, 9953421, 11531313, -5282879, 26895123, -12697089, -13118820, -16517902, 9768698, -2533218},
+ },
+ {
+ FieldElement{-24719459, 1894651, -287698, -4704085, 15348719, -8156530, 32767513, 12765450, 4940095, 10678226},
+ FieldElement{18860224, 15980149, -18987240, -1562570, -26233012, -11071856, -7843882, 13944024, -24372348, 16582019},
+ FieldElement{-15504260, 4970268, -29893044, 4175593, -20993212, -2199756, -11704054, 15444560, -11003761, 7989037},
+ },
+ {
+ FieldElement{31490452, 5568061, -2412803, 2182383, -32336847, 4531686, -32078269, 6200206, -19686113, -14800171},
+ FieldElement{-17308668, -15879940, -31522777, -2831, -32887382, 16375549, 8680158, -16371713, 28550068, -6857132},
+ FieldElement{-28126887, -5688091, 16837845, -1820458, -6850681, 12700016, -30039981, 4364038, 1155602, 5988841},
+ },
+ {
+ FieldElement{21890435, -13272907, -12624011, 12154349, -7831873, 15300496, 23148983, -4470481, 24618407, 8283181},
+ FieldElement{-33136107, -10512751, 9975416, 6841041, -31559793, 16356536, 3070187, -7025928, 1466169, 10740210},
+ FieldElement{-1509399, -15488185, -13503385, -10655916, 32799044, 909394, -13938903, -5779719, -32164649, -15327040},
+ },
+ {
+ FieldElement{3960823, -14267803, -28026090, -15918051, -19404858, 13146868, 15567327, 951507, -3260321, -573935},
+ FieldElement{24740841, 5052253, -30094131, 8961361, 25877428, 6165135, -24368180, 14397372, -7380369, -6144105},
+ FieldElement{-28888365, 3510803, -28103278, -1158478, -11238128, -10631454, -15441463, -14453128, -1625486, -6494814},
+ },
+ },
+ {
+ {
+ FieldElement{793299, -9230478, 8836302, -6235707, -27360908, -2369593, 33152843, -4885251, -9906200, -621852},
+ FieldElement{5666233, 525582, 20782575, -8038419, -24538499, 14657740, 16099374, 1468826, -6171428, -15186581},
+ FieldElement{-4859255, -3779343, -2917758, -6748019, 7778750, 11688288, -30404353, -9871238, -1558923, -9863646},
+ },
+ {
+ FieldElement{10896332, -7719704, 824275, 472601, -19460308, 3009587, 25248958, 14783338, -30581476, -15757844},
+ FieldElement{10566929, 12612572, -31944212, 11118703, -12633376, 12362879, 21752402, 8822496, 24003793, 14264025},
+ FieldElement{27713862, -7355973, -11008240, 9227530, 27050101, 2504721, 23886875, -13117525, 13958495, -5732453},
+ },
+ {
+ FieldElement{-23481610, 4867226, -27247128, 3900521, 29838369, -8212291, -31889399, -10041781, 7340521, -15410068},
+ FieldElement{4646514, -8011124, -22766023, -11532654, 23184553, 8566613, 31366726, -1381061, -15066784, -10375192},
+ FieldElement{-17270517, 12723032, -16993061, 14878794, 21619651, -6197576, 27584817, 3093888, -8843694, 3849921},
+ },
+ {
+ FieldElement{-9064912, 2103172, 25561640, -15125738, -5239824, 9582958, 32477045, -9017955, 5002294, -15550259},
+ FieldElement{-12057553, -11177906, 21115585, -13365155, 8808712, -12030708, 16489530, 13378448, -25845716, 12741426},
+ FieldElement{-5946367, 10645103, -30911586, 15390284, -3286982, -7118677, 24306472, 15852464, 28834118, -7646072},
+ },
+ {
+ FieldElement{-17335748, -9107057, -24531279, 9434953, -8472084, -583362, -13090771, 455841, 20461858, 5491305},
+ FieldElement{13669248, -16095482, -12481974, -10203039, -14569770, -11893198, -24995986, 11293807, -28588204, -9421832},
+ FieldElement{28497928, 6272777, -33022994, 14470570, 8906179, -1225630, 18504674, -14165166, 29867745, -8795943},
+ },
+ {
+ FieldElement{-16207023, 13517196, -27799630, -13697798, 24009064, -6373891, -6367600, -13175392, 22853429, -4012011},
+ FieldElement{24191378, 16712145, -13931797, 15217831, 14542237, 1646131, 18603514, -11037887, 12876623, -2112447},
+ FieldElement{17902668, 4518229, -411702, -2829247, 26878217, 5258055, -12860753, 608397, 16031844, 3723494},
+ },
+ {
+ FieldElement{-28632773, 12763728, -20446446, 7577504, 33001348, -13017745, 17558842, -7872890, 23896954, -4314245},
+ FieldElement{-20005381, -12011952, 31520464, 605201, 2543521, 5991821, -2945064, 7229064, -9919646, -8826859},
+ FieldElement{28816045, 298879, -28165016, -15920938, 19000928, -1665890, -12680833, -2949325, -18051778, -2082915},
+ },
+ {
+ FieldElement{16000882, -344896, 3493092, -11447198, -29504595, -13159789, 12577740, 16041268, -19715240, 7847707},
+ FieldElement{10151868, 10572098, 27312476, 7922682, 14825339, 4723128, -32855931, -6519018, -10020567, 3852848},
+ FieldElement{-11430470, 15697596, -21121557, -4420647, 5386314, 15063598, 16514493, -15932110, 29330899, -15076224},
+ },
+ },
+ {
+ {
+ FieldElement{-25499735, -4378794, -15222908, -6901211, 16615731, 2051784, 3303702, 15490, -27548796, 12314391},
+ FieldElement{15683520, -6003043, 18109120, -9980648, 15337968, -5997823, -16717435, 15921866, 16103996, -3731215},
+ FieldElement{-23169824, -10781249, 13588192, -1628807, -3798557, -1074929, -19273607, 5402699, -29815713, -9841101},
+ },
+ {
+ FieldElement{23190676, 2384583, -32714340, 3462154, -29903655, -1529132, -11266856, 8911517, -25205859, 2739713},
+ FieldElement{21374101, -3554250, -33524649, 9874411, 15377179, 11831242, -33529904, 6134907, 4931255, 11987849},
+ FieldElement{-7732, -2978858, -16223486, 7277597, 105524, -322051, -31480539, 13861388, -30076310, 10117930},
+ },
+ {
+ FieldElement{-29501170, -10744872, -26163768, 13051539, -25625564, 5089643, -6325503, 6704079, 12890019, 15728940},
+ FieldElement{-21972360, -11771379, -951059, -4418840, 14704840, 2695116, 903376, -10428139, 12885167, 8311031},
+ FieldElement{-17516482, 5352194, 10384213, -13811658, 7506451, 13453191, 26423267, 4384730, 1888765, -5435404},
+ },
+ {
+ FieldElement{-25817338, -3107312, -13494599, -3182506, 30896459, -13921729, -32251644, -12707869, -19464434, -3340243},
+ FieldElement{-23607977, -2665774, -526091, 4651136, 5765089, 4618330, 6092245, 14845197, 17151279, -9854116},
+ FieldElement{-24830458, -12733720, -15165978, 10367250, -29530908, -265356, 22825805, -7087279, -16866484, 16176525},
+ },
+ {
+ FieldElement{-23583256, 6564961, 20063689, 3798228, -4740178, 7359225, 2006182, -10363426, -28746253, -10197509},
+ FieldElement{-10626600, -4486402, -13320562, -5125317, 3432136, -6393229, 23632037, -1940610, 32808310, 1099883},
+ FieldElement{15030977, 5768825, -27451236, -2887299, -6427378, -15361371, -15277896, -6809350, 2051441, -15225865},
+ },
+ {
+ FieldElement{-3362323, -7239372, 7517890, 9824992, 23555850, 295369, 5148398, -14154188, -22686354, 16633660},
+ FieldElement{4577086, -16752288, 13249841, -15304328, 19958763, -14537274, 18559670, -10759549, 8402478, -9864273},
+ FieldElement{-28406330, -1051581, -26790155, -907698, -17212414, -11030789, 9453451, -14980072, 17983010, 9967138},
+ },
+ {
+ FieldElement{-25762494, 6524722, 26585488, 9969270, 24709298, 1220360, -1677990, 7806337, 17507396, 3651560},
+ FieldElement{-10420457, -4118111, 14584639, 15971087, -15768321, 8861010, 26556809, -5574557, -18553322, -11357135},
+ FieldElement{2839101, 14284142, 4029895, 3472686, 14402957, 12689363, -26642121, 8459447, -5605463, -7621941},
+ },
+ {
+ FieldElement{-4839289, -3535444, 9744961, 2871048, 25113978, 3187018, -25110813, -849066, 17258084, -7977739},
+ FieldElement{18164541, -10595176, -17154882, -1542417, 19237078, -9745295, 23357533, -15217008, 26908270, 12150756},
+ FieldElement{-30264870, -7647865, 5112249, -7036672, -1499807, -6974257, 43168, -5537701, -32302074, 16215819},
+ },
+ },
+ {
+ {
+ FieldElement{-6898905, 9824394, -12304779, -4401089, -31397141, -6276835, 32574489, 12532905, -7503072, -8675347},
+ FieldElement{-27343522, -16515468, -27151524, -10722951, 946346, 16291093, 254968, 7168080, 21676107, -1943028},
+ FieldElement{21260961, -8424752, -16831886, -11920822, -23677961, 3968121, -3651949, -6215466, -3556191, -7913075},
+ },
+ {
+ FieldElement{16544754, 13250366, -16804428, 15546242, -4583003, 12757258, -2462308, -8680336, -18907032, -9662799},
+ FieldElement{-2415239, -15577728, 18312303, 4964443, -15272530, -12653564, 26820651, 16690659, 25459437, -4564609},
+ FieldElement{-25144690, 11425020, 28423002, -11020557, -6144921, -15826224, 9142795, -2391602, -6432418, -1644817},
+ },
+ {
+ FieldElement{-23104652, 6253476, 16964147, -3768872, -25113972, -12296437, -27457225, -16344658, 6335692, 7249989},
+ FieldElement{-30333227, 13979675, 7503222, -12368314, -11956721, -4621693, -30272269, 2682242, 25993170, -12478523},
+ FieldElement{4364628, 5930691, 32304656, -10044554, -8054781, 15091131, 22857016, -10598955, 31820368, 15075278},
+ },
+ {
+ FieldElement{31879134, -8918693, 17258761, 90626, -8041836, -4917709, 24162788, -9650886, -17970238, 12833045},
+ FieldElement{19073683, 14851414, -24403169, -11860168, 7625278, 11091125, -19619190, 2074449, -9413939, 14905377},
+ FieldElement{24483667, -11935567, -2518866, -11547418, -1553130, 15355506, -25282080, 9253129, 27628530, -7555480},
+ },
+ {
+ FieldElement{17597607, 8340603, 19355617, 552187, 26198470, -3176583, 4593324, -9157582, -14110875, 15297016},
+ FieldElement{510886, 14337390, -31785257, 16638632, 6328095, 2713355, -20217417, -11864220, 8683221, 2921426},
+ FieldElement{18606791, 11874196, 27155355, -5281482, -24031742, 6265446, -25178240, -1278924, 4674690, 13890525},
+ },
+ {
+ FieldElement{13609624, 13069022, -27372361, -13055908, 24360586, 9592974, 14977157, 9835105, 4389687, 288396},
+ FieldElement{9922506, -519394, 13613107, 5883594, -18758345, -434263, -12304062, 8317628, 23388070, 16052080},
+ FieldElement{12720016, 11937594, -31970060, -5028689, 26900120, 8561328, -20155687, -11632979, -14754271, -10812892},
+ },
+ {
+ FieldElement{15961858, 14150409, 26716931, -665832, -22794328, 13603569, 11829573, 7467844, -28822128, 929275},
+ FieldElement{11038231, -11582396, -27310482, -7316562, -10498527, -16307831, -23479533, -9371869, -21393143, 2465074},
+ FieldElement{20017163, -4323226, 27915242, 1529148, 12396362, 15675764, 13817261, -9658066, 2463391, -4622140},
+ },
+ {
+ FieldElement{-16358878, -12663911, -12065183, 4996454, -1256422, 1073572, 9583558, 12851107, 4003896, 12673717},
+ FieldElement{-1731589, -15155870, -3262930, 16143082, 19294135, 13385325, 14741514, -9103726, 7903886, 2348101},
+ FieldElement{24536016, -16515207, 12715592, -3862155, 1511293, 10047386, -3842346, -7129159, -28377538, 10048127},
+ },
+ },
+ {
+ {
+ FieldElement{-12622226, -6204820, 30718825, 2591312, -10617028, 12192840, 18873298, -7297090, -32297756, 15221632},
+ FieldElement{-26478122, -11103864, 11546244, -1852483, 9180880, 7656409, -21343950, 2095755, 29769758, 6593415},
+ FieldElement{-31994208, -2907461, 4176912, 3264766, 12538965, -868111, 26312345, -6118678, 30958054, 8292160},
+ },
+ {
+ FieldElement{31429822, -13959116, 29173532, 15632448, 12174511, -2760094, 32808831, 3977186, 26143136, -3148876},
+ FieldElement{22648901, 1402143, -22799984, 13746059, 7936347, 365344, -8668633, -1674433, -3758243, -2304625},
+ FieldElement{-15491917, 8012313, -2514730, -12702462, -23965846, -10254029, -1612713, -1535569, -16664475, 8194478},
+ },
+ {
+ FieldElement{27338066, -7507420, -7414224, 10140405, -19026427, -6589889, 27277191, 8855376, 28572286, 3005164},
+ FieldElement{26287124, 4821776, 25476601, -4145903, -3764513, -15788984, -18008582, 1182479, -26094821, -13079595},
+ FieldElement{-7171154, 3178080, 23970071, 6201893, -17195577, -4489192, -21876275, -13982627, 32208683, -1198248},
+ },
+ {
+ FieldElement{-16657702, 2817643, -10286362, 14811298, 6024667, 13349505, -27315504, -10497842, -27672585, -11539858},
+ FieldElement{15941029, -9405932, -21367050, 8062055, 31876073, -238629, -15278393, -1444429, 15397331, -4130193},
+ FieldElement{8934485, -13485467, -23286397, -13423241, -32446090, 14047986, 31170398, -1441021, -27505566, 15087184},
+ },
+ {
+ FieldElement{-18357243, -2156491, 24524913, -16677868, 15520427, -6360776, -15502406, 11461896, 16788528, -5868942},
+ FieldElement{-1947386, 16013773, 21750665, 3714552, -17401782, -16055433, -3770287, -10323320, 31322514, -11615635},
+ FieldElement{21426655, -5650218, -13648287, -5347537, -28812189, -4920970, -18275391, -14621414, 13040862, -12112948},
+ },
+ {
+ FieldElement{11293895, 12478086, -27136401, 15083750, -29307421, 14748872, 14555558, -13417103, 1613711, 4896935},
+ FieldElement{-25894883, 15323294, -8489791, -8057900, 25967126, -13425460, 2825960, -4897045, -23971776, -11267415},
+ FieldElement{-15924766, -5229880, -17443532, 6410664, 3622847, 10243618, 20615400, 12405433, -23753030, -8436416},
+ },
+ {
+ FieldElement{-7091295, 12556208, -20191352, 9025187, -17072479, 4333801, 4378436, 2432030, 23097949, -566018},
+ FieldElement{4565804, -16025654, 20084412, -7842817, 1724999, 189254, 24767264, 10103221, -18512313, 2424778},
+ FieldElement{366633, -11976806, 8173090, -6890119, 30788634, 5745705, -7168678, 1344109, -3642553, 12412659},
+ },
+ {
+ FieldElement{-24001791, 7690286, 14929416, -168257, -32210835, -13412986, 24162697, -15326504, -3141501, 11179385},
+ FieldElement{18289522, -14724954, 8056945, 16430056, -21729724, 7842514, -6001441, -1486897, -18684645, -11443503},
+ FieldElement{476239, 6601091, -6152790, -9723375, 17503545, -4863900, 27672959, 13403813, 11052904, 5219329},
+ },
+ },
+ {
+ {
+ FieldElement{20678546, -8375738, -32671898, 8849123, -5009758, 14574752, 31186971, -3973730, 9014762, -8579056},
+ FieldElement{-13644050, -10350239, -15962508, 5075808, -1514661, -11534600, -33102500, 9160280, 8473550, -3256838},
+ FieldElement{24900749, 14435722, 17209120, -15292541, -22592275, 9878983, -7689309, -16335821, -24568481, 11788948},
+ },
+ {
+ FieldElement{-3118155, -11395194, -13802089, 14797441, 9652448, -6845904, -20037437, 10410733, -24568470, -1458691},
+ FieldElement{-15659161, 16736706, -22467150, 10215878, -9097177, 7563911, 11871841, -12505194, -18513325, 8464118},
+ FieldElement{-23400612, 8348507, -14585951, -861714, -3950205, -6373419, 14325289, 8628612, 33313881, -8370517},
+ },
+ {
+ FieldElement{-20186973, -4967935, 22367356, 5271547, -1097117, -4788838, -24805667, -10236854, -8940735, -5818269},
+ FieldElement{-6948785, -1795212, -32625683, -16021179, 32635414, -7374245, 15989197, -12838188, 28358192, -4253904},
+ FieldElement{-23561781, -2799059, -32351682, -1661963, -9147719, 10429267, -16637684, 4072016, -5351664, 5596589},
+ },
+ {
+ FieldElement{-28236598, -3390048, 12312896, 6213178, 3117142, 16078565, 29266239, 2557221, 1768301, 15373193},
+ FieldElement{-7243358, -3246960, -4593467, -7553353, -127927, -912245, -1090902, -4504991, -24660491, 3442910},
+ FieldElement{-30210571, 5124043, 14181784, 8197961, 18964734, -11939093, 22597931, 7176455, -18585478, 13365930},
+ },
+ {
+ FieldElement{-7877390, -1499958, 8324673, 4690079, 6261860, 890446, 24538107, -8570186, -9689599, -3031667},
+ FieldElement{25008904, -10771599, -4305031, -9638010, 16265036, 15721635, 683793, -11823784, 15723479, -15163481},
+ FieldElement{-9660625, 12374379, -27006999, -7026148, -7724114, -12314514, 11879682, 5400171, 519526, -1235876},
+ },
+ {
+ FieldElement{22258397, -16332233, -7869817, 14613016, -22520255, -2950923, -20353881, 7315967, 16648397, 7605640},
+ FieldElement{-8081308, -8464597, -8223311, 9719710, 19259459, -15348212, 23994942, -5281555, -9468848, 4763278},
+ FieldElement{-21699244, 9220969, -15730624, 1084137, -25476107, -2852390, 31088447, -7764523, -11356529, 728112},
+ },
+ {
+ FieldElement{26047220, -11751471, -6900323, -16521798, 24092068, 9158119, -4273545, -12555558, -29365436, -5498272},
+ FieldElement{17510331, -322857, 5854289, 8403524, 17133918, -3112612, -28111007, 12327945, 10750447, 10014012},
+ FieldElement{-10312768, 3936952, 9156313, -8897683, 16498692, -994647, -27481051, -666732, 3424691, 7540221},
+ },
+ {
+ FieldElement{30322361, -6964110, 11361005, -4143317, 7433304, 4989748, -7071422, -16317219, -9244265, 15258046},
+ FieldElement{13054562, -2779497, 19155474, 469045, -12482797, 4566042, 5631406, 2711395, 1062915, -5136345},
+ FieldElement{-19240248, -11254599, -29509029, -7499965, -5835763, 13005411, -6066489, 12194497, 32960380, 1459310},
+ },
+ },
+ {
+ {
+ FieldElement{19852034, 7027924, 23669353, 10020366, 8586503, -6657907, 394197, -6101885, 18638003, -11174937},
+ FieldElement{31395534, 15098109, 26581030, 8030562, -16527914, -5007134, 9012486, -7584354, -6643087, -5442636},
+ FieldElement{-9192165, -2347377, -1997099, 4529534, 25766844, 607986, -13222, 9677543, -32294889, -6456008},
+ },
+ {
+ FieldElement{-2444496, -149937, 29348902, 8186665, 1873760, 12489863, -30934579, -7839692, -7852844, -8138429},
+ FieldElement{-15236356, -15433509, 7766470, 746860, 26346930, -10221762, -27333451, 10754588, -9431476, 5203576},
+ FieldElement{31834314, 14135496, -770007, 5159118, 20917671, -16768096, -7467973, -7337524, 31809243, 7347066},
+ },
+ {
+ FieldElement{-9606723, -11874240, 20414459, 13033986, 13716524, -11691881, 19797970, -12211255, 15192876, -2087490},
+ FieldElement{-12663563, -2181719, 1168162, -3804809, 26747877, -14138091, 10609330, 12694420, 33473243, -13382104},
+ FieldElement{33184999, 11180355, 15832085, -11385430, -1633671, 225884, 15089336, -11023903, -6135662, 14480053},
+ },
+ {
+ FieldElement{31308717, -5619998, 31030840, -1897099, 15674547, -6582883, 5496208, 13685227, 27595050, 8737275},
+ FieldElement{-20318852, -15150239, 10933843, -16178022, 8335352, -7546022, -31008351, -12610604, 26498114, 66511},
+ FieldElement{22644454, -8761729, -16671776, 4884562, -3105614, -13559366, 30540766, -4286747, -13327787, -7515095},
+ },
+ {
+ FieldElement{-28017847, 9834845, 18617207, -2681312, -3401956, -13307506, 8205540, 13585437, -17127465, 15115439},
+ FieldElement{23711543, -672915, 31206561, -8362711, 6164647, -9709987, -33535882, -1426096, 8236921, 16492939},
+ FieldElement{-23910559, -13515526, -26299483, -4503841, 25005590, -7687270, 19574902, 10071562, 6708380, -6222424},
+ },
+ {
+ FieldElement{2101391, -4930054, 19702731, 2367575, -15427167, 1047675, 5301017, 9328700, 29955601, -11678310},
+ FieldElement{3096359, 9271816, -21620864, -15521844, -14847996, -7592937, -25892142, -12635595, -9917575, 6216608},
+ FieldElement{-32615849, 338663, -25195611, 2510422, -29213566, -13820213, 24822830, -6146567, -26767480, 7525079},
+ },
+ {
+ FieldElement{-23066649, -13985623, 16133487, -7896178, -3389565, 778788, -910336, -2782495, -19386633, 11994101},
+ FieldElement{21691500, -13624626, -641331, -14367021, 3285881, -3483596, -25064666, 9718258, -7477437, 13381418},
+ FieldElement{18445390, -4202236, 14979846, 11622458, -1727110, -3582980, 23111648, -6375247, 28535282, 15779576},
+ },
+ {
+ FieldElement{30098053, 3089662, -9234387, 16662135, -21306940, 11308411, -14068454, 12021730, 9955285, -16303356},
+ FieldElement{9734894, -14576830, -7473633, -9138735, 2060392, 11313496, -18426029, 9924399, 20194861, 13380996},
+ FieldElement{-26378102, -7965207, -22167821, 15789297, -18055342, -6168792, -1984914, 15707771, 26342023, 10146099},
+ },
+ },
+ {
+ {
+ FieldElement{-26016874, -219943, 21339191, -41388, 19745256, -2878700, -29637280, 2227040, 21612326, -545728},
+ FieldElement{-13077387, 1184228, 23562814, -5970442, -20351244, -6348714, 25764461, 12243797, -20856566, 11649658},
+ FieldElement{-10031494, 11262626, 27384172, 2271902, 26947504, -15997771, 39944, 6114064, 33514190, 2333242},
+ },
+ {
+ FieldElement{-21433588, -12421821, 8119782, 7219913, -21830522, -9016134, -6679750, -12670638, 24350578, -13450001},
+ FieldElement{-4116307, -11271533, -23886186, 4843615, -30088339, 690623, -31536088, -10406836, 8317860, 12352766},
+ FieldElement{18200138, -14475911, -33087759, -2696619, -23702521, -9102511, -23552096, -2287550, 20712163, 6719373},
+ },
+ {
+ FieldElement{26656208, 6075253, -7858556, 1886072, -28344043, 4262326, 11117530, -3763210, 26224235, -3297458},
+ FieldElement{-17168938, -14854097, -3395676, -16369877, -19954045, 14050420, 21728352, 9493610, 18620611, -16428628},
+ FieldElement{-13323321, 13325349, 11432106, 5964811, 18609221, 6062965, -5269471, -9725556, -30701573, -16479657},
+ },
+ {
+ FieldElement{-23860538, -11233159, 26961357, 1640861, -32413112, -16737940, 12248509, -5240639, 13735342, 1934062},
+ FieldElement{25089769, 6742589, 17081145, -13406266, 21909293, -16067981, -15136294, -3765346, -21277997, 5473616},
+ FieldElement{31883677, -7961101, 1083432, -11572403, 22828471, 13290673, -7125085, 12469656, 29111212, -5451014},
+ },
+ {
+ FieldElement{24244947, -15050407, -26262976, 2791540, -14997599, 16666678, 24367466, 6388839, -10295587, 452383},
+ FieldElement{-25640782, -3417841, 5217916, 16224624, 19987036, -4082269, -24236251, -5915248, 15766062, 8407814},
+ FieldElement{-20406999, 13990231, 15495425, 16395525, 5377168, 15166495, -8917023, -4388953, -8067909, 2276718},
+ },
+ {
+ FieldElement{30157918, 12924066, -17712050, 9245753, 19895028, 3368142, -23827587, 5096219, 22740376, -7303417},
+ FieldElement{2041139, -14256350, 7783687, 13876377, -25946985, -13352459, 24051124, 13742383, -15637599, 13295222},
+ FieldElement{33338237, -8505733, 12532113, 7977527, 9106186, -1715251, -17720195, -4612972, -4451357, -14669444},
+ },
+ {
+ FieldElement{-20045281, 5454097, -14346548, 6447146, 28862071, 1883651, -2469266, -4141880, 7770569, 9620597},
+ FieldElement{23208068, 7979712, 33071466, 8149229, 1758231, -10834995, 30945528, -1694323, -33502340, -14767970},
+ FieldElement{1439958, -16270480, -1079989, -793782, 4625402, 10647766, -5043801, 1220118, 30494170, -11440799},
+ },
+ {
+ FieldElement{-5037580, -13028295, -2970559, -3061767, 15640974, -6701666, -26739026, 926050, -1684339, -13333647},
+ FieldElement{13908495, -3549272, 30919928, -6273825, -21521863, 7989039, 9021034, 9078865, 3353509, 4033511},
+ FieldElement{-29663431, -15113610, 32259991, -344482, 24295849, -12912123, 23161163, 8839127, 27485041, 7356032},
+ },
+ },
+ {
+ {
+ FieldElement{9661027, 705443, 11980065, -5370154, -1628543, 14661173, -6346142, 2625015, 28431036, -16771834},
+ FieldElement{-23839233, -8311415, -25945511, 7480958, -17681669, -8354183, -22545972, 14150565, 15970762, 4099461},
+ FieldElement{29262576, 16756590, 26350592, -8793563, 8529671, -11208050, 13617293, -9937143, 11465739, 8317062},
+ },
+ {
+ FieldElement{-25493081, -6962928, 32500200, -9419051, -23038724, -2302222, 14898637, 3848455, 20969334, -5157516},
+ FieldElement{-20384450, -14347713, -18336405, 13884722, -33039454, 2842114, -21610826, -3649888, 11177095, 14989547},
+ FieldElement{-24496721, -11716016, 16959896, 2278463, 12066309, 10137771, 13515641, 2581286, -28487508, 9930240},
+ },
+ {
+ FieldElement{-17751622, -2097826, 16544300, -13009300, -15914807, -14949081, 18345767, -13403753, 16291481, -5314038},
+ FieldElement{-33229194, 2553288, 32678213, 9875984, 8534129, 6889387, -9676774, 6957617, 4368891, 9788741},
+ FieldElement{16660756, 7281060, -10830758, 12911820, 20108584, -8101676, -21722536, -8613148, 16250552, -11111103},
+ },
+ {
+ FieldElement{-19765507, 2390526, -16551031, 14161980, 1905286, 6414907, 4689584, 10604807, -30190403, 4782747},
+ FieldElement{-1354539, 14736941, -7367442, -13292886, 7710542, -14155590, -9981571, 4383045, 22546403, 437323},
+ FieldElement{31665577, -12180464, -16186830, 1491339, -18368625, 3294682, 27343084, 2786261, -30633590, -14097016},
+ },
+ {
+ FieldElement{-14467279, -683715, -33374107, 7448552, 19294360, 14334329, -19690631, 2355319, -19284671, -6114373},
+ FieldElement{15121312, -15796162, 6377020, -6031361, -10798111, -12957845, 18952177, 15496498, -29380133, 11754228},
+ FieldElement{-2637277, -13483075, 8488727, -14303896, 12728761, -1622493, 7141596, 11724556, 22761615, -10134141},
+ },
+ {
+ FieldElement{16918416, 11729663, -18083579, 3022987, -31015732, -13339659, -28741185, -12227393, 32851222, 11717399},
+ FieldElement{11166634, 7338049, -6722523, 4531520, -29468672, -7302055, 31474879, 3483633, -1193175, -4030831},
+ FieldElement{-185635, 9921305, 31456609, -13536438, -12013818, 13348923, 33142652, 6546660, -19985279, -3948376},
+ },
+ {
+ FieldElement{-32460596, 11266712, -11197107, -7899103, 31703694, 3855903, -8537131, -12833048, -30772034, -15486313},
+ FieldElement{-18006477, 12709068, 3991746, -6479188, -21491523, -10550425, -31135347, -16049879, 10928917, 3011958},
+ FieldElement{-6957757, -15594337, 31696059, 334240, 29576716, 14796075, -30831056, -12805180, 18008031, 10258577},
+ },
+ {
+ FieldElement{-22448644, 15655569, 7018479, -4410003, -30314266, -1201591, -1853465, 1367120, 25127874, 6671743},
+ FieldElement{29701166, -14373934, -10878120, 9279288, -17568, 13127210, 21382910, 11042292, 25838796, 4642684},
+ FieldElement{-20430234, 14955537, -24126347, 8124619, -5369288, -5990470, 30468147, -13900640, 18423289, 4177476},
+ },
+ },
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/ed25519/edwards25519/edwards25519.go b/Godeps/_workspace/src/github.com/tendermint/ed25519/edwards25519/edwards25519.go
new file mode 100644
index 0000000000000000000000000000000000000000..184b4a85963fe18959ba9ec14e0b26be30124a52
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/ed25519/edwards25519/edwards25519.go
@@ -0,0 +1,2127 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package edwards25519 implements operations in GF(2**255-19) and on an
+// Edwards curve that is isomorphic to curve25519. See
+// http://ed25519.cr.yp.to/.
+package edwards25519
+
+// This code is a port of the public domain, "ref10" implementation of ed25519
+// from SUPERCOP.
+
+// FieldElement represents an element of the field GF(2^255 - 19). An element
+// t, entries t[0]...t[9], represents the integer t[0]+2^26 t[1]+2^51 t[2]+2^77
+// t[3]+2^102 t[4]+...+2^230 t[9]. Bounds on each t[i] vary depending on
+// context.
+type FieldElement [10]int32
+
+func FeZero(fe *FieldElement) {
+ for i := range fe {
+ fe[i] = 0
+ }
+}
+
+func FeOne(fe *FieldElement) {
+ FeZero(fe)
+ fe[0] = 1
+}
+
+func FeAdd(dst, a, b *FieldElement) {
+ for i := range dst {
+ dst[i] = a[i] + b[i]
+ }
+}
+
+func FeSub(dst, a, b *FieldElement) {
+ for i := range dst {
+ dst[i] = a[i] - b[i]
+ }
+}
+
+func FeCopy(dst, src *FieldElement) {
+ for i := range dst {
+ dst[i] = src[i]
+ }
+}
+
+// Replace (f,g) with (g,g) if b == 1;
+// replace (f,g) with (f,g) if b == 0.
+//
+// Preconditions: b in {0,1}.
+func FeCMove(f, g *FieldElement, b int32) {
+ var x FieldElement
+ b = -b
+ for i := range x {
+ x[i] = b & (f[i] ^ g[i])
+ }
+
+ for i := range f {
+ f[i] ^= x[i]
+ }
+}
+
+func load3(in []byte) int64 {
+ var r int64
+ r = int64(in[0])
+ r |= int64(in[1]) << 8
+ r |= int64(in[2]) << 16
+ return r
+}
+
+func load4(in []byte) int64 {
+ var r int64
+ r = int64(in[0])
+ r |= int64(in[1]) << 8
+ r |= int64(in[2]) << 16
+ r |= int64(in[3]) << 24
+ return r
+}
+
+func FeFromBytes(dst *FieldElement, src *[32]byte) {
+ h0 := load4(src[:])
+ h1 := load3(src[4:]) << 6
+ h2 := load3(src[7:]) << 5
+ h3 := load3(src[10:]) << 3
+ h4 := load3(src[13:]) << 2
+ h5 := load4(src[16:])
+ h6 := load3(src[20:]) << 7
+ h7 := load3(src[23:]) << 5
+ h8 := load3(src[26:]) << 4
+ h9 := (load3(src[29:]) & 8388607) << 2
+
+ var carry [10]int64
+ carry[9] = (h9 + 1<<24) >> 25
+ h0 += carry[9] * 19
+ h9 -= carry[9] << 25
+ carry[1] = (h1 + 1<<24) >> 25
+ h2 += carry[1]
+ h1 -= carry[1] << 25
+ carry[3] = (h3 + 1<<24) >> 25
+ h4 += carry[3]
+ h3 -= carry[3] << 25
+ carry[5] = (h5 + 1<<24) >> 25
+ h6 += carry[5]
+ h5 -= carry[5] << 25
+ carry[7] = (h7 + 1<<24) >> 25
+ h8 += carry[7]
+ h7 -= carry[7] << 25
+
+ carry[0] = (h0 + 1<<25) >> 26
+ h1 += carry[0]
+ h0 -= carry[0] << 26
+ carry[2] = (h2 + 1<<25) >> 26
+ h3 += carry[2]
+ h2 -= carry[2] << 26
+ carry[4] = (h4 + 1<<25) >> 26
+ h5 += carry[4]
+ h4 -= carry[4] << 26
+ carry[6] = (h6 + 1<<25) >> 26
+ h7 += carry[6]
+ h6 -= carry[6] << 26
+ carry[8] = (h8 + 1<<25) >> 26
+ h9 += carry[8]
+ h8 -= carry[8] << 26
+
+ dst[0] = int32(h0)
+ dst[1] = int32(h1)
+ dst[2] = int32(h2)
+ dst[3] = int32(h3)
+ dst[4] = int32(h4)
+ dst[5] = int32(h5)
+ dst[6] = int32(h6)
+ dst[7] = int32(h7)
+ dst[8] = int32(h8)
+ dst[9] = int32(h9)
+}
+
+// FeToBytes marshals h to s.
+// Preconditions:
+// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+//
+// Write p=2^255-19; q=floor(h/p).
+// Basic claim: q = floor(2^(-255)(h + 19 2^(-25)h9 + 2^(-1))).
+//
+// Proof:
+// Have |h|<=p so |q|<=1 so |19^2 2^(-255) q|<1/4.
+// Also have |h-2^230 h9|<2^230 so |19 2^(-255)(h-2^230 h9)|<1/4.
+//
+// Write y=2^(-1)-19^2 2^(-255)q-19 2^(-255)(h-2^230 h9).
+// Then 0<y<1.
+//
+// Write r=h-pq.
+// Have 0<=r<=p-1=2^255-20.
+// Thus 0<=r+19(2^-255)r<r+19(2^-255)2^255<=2^255-1.
+//
+// Write x=r+19(2^-255)r+y.
+// Then 0<x<2^255 so floor(2^(-255)x) = 0 so floor(q+2^(-255)x) = q.
+//
+// Have q+2^(-255)x = 2^(-255)(h + 19 2^(-25) h9 + 2^(-1))
+// so floor(2^(-255)(h + 19 2^(-25) h9 + 2^(-1))) = q.
+func FeToBytes(s *[32]byte, h *FieldElement) {
+ var carry [10]int32
+
+ q := (19*h[9] + (1 << 24)) >> 25
+ q = (h[0] + q) >> 26
+ q = (h[1] + q) >> 25
+ q = (h[2] + q) >> 26
+ q = (h[3] + q) >> 25
+ q = (h[4] + q) >> 26
+ q = (h[5] + q) >> 25
+ q = (h[6] + q) >> 26
+ q = (h[7] + q) >> 25
+ q = (h[8] + q) >> 26
+ q = (h[9] + q) >> 25
+
+ // Goal: Output h-(2^255-19)q, which is between 0 and 2^255-20.
+ h[0] += 19 * q
+ // Goal: Output h-2^255 q, which is between 0 and 2^255-20.
+
+ carry[0] = h[0] >> 26
+ h[1] += carry[0]
+ h[0] -= carry[0] << 26
+ carry[1] = h[1] >> 25
+ h[2] += carry[1]
+ h[1] -= carry[1] << 25
+ carry[2] = h[2] >> 26
+ h[3] += carry[2]
+ h[2] -= carry[2] << 26
+ carry[3] = h[3] >> 25
+ h[4] += carry[3]
+ h[3] -= carry[3] << 25
+ carry[4] = h[4] >> 26
+ h[5] += carry[4]
+ h[4] -= carry[4] << 26
+ carry[5] = h[5] >> 25
+ h[6] += carry[5]
+ h[5] -= carry[5] << 25
+ carry[6] = h[6] >> 26
+ h[7] += carry[6]
+ h[6] -= carry[6] << 26
+ carry[7] = h[7] >> 25
+ h[8] += carry[7]
+ h[7] -= carry[7] << 25
+ carry[8] = h[8] >> 26
+ h[9] += carry[8]
+ h[8] -= carry[8] << 26
+ carry[9] = h[9] >> 25
+ h[9] -= carry[9] << 25
+ // h10 = carry9
+
+ // Goal: Output h[0]+...+2^255 h10-2^255 q, which is between 0 and 2^255-20.
+ // Have h[0]+...+2^230 h[9] between 0 and 2^255-1;
+ // evidently 2^255 h10-2^255 q = 0.
+ // Goal: Output h[0]+...+2^230 h[9].
+
+ s[0] = byte(h[0] >> 0)
+ s[1] = byte(h[0] >> 8)
+ s[2] = byte(h[0] >> 16)
+ s[3] = byte((h[0] >> 24) | (h[1] << 2))
+ s[4] = byte(h[1] >> 6)
+ s[5] = byte(h[1] >> 14)
+ s[6] = byte((h[1] >> 22) | (h[2] << 3))
+ s[7] = byte(h[2] >> 5)
+ s[8] = byte(h[2] >> 13)
+ s[9] = byte((h[2] >> 21) | (h[3] << 5))
+ s[10] = byte(h[3] >> 3)
+ s[11] = byte(h[3] >> 11)
+ s[12] = byte((h[3] >> 19) | (h[4] << 6))
+ s[13] = byte(h[4] >> 2)
+ s[14] = byte(h[4] >> 10)
+ s[15] = byte(h[4] >> 18)
+ s[16] = byte(h[5] >> 0)
+ s[17] = byte(h[5] >> 8)
+ s[18] = byte(h[5] >> 16)
+ s[19] = byte((h[5] >> 24) | (h[6] << 1))
+ s[20] = byte(h[6] >> 7)
+ s[21] = byte(h[6] >> 15)
+ s[22] = byte((h[6] >> 23) | (h[7] << 3))
+ s[23] = byte(h[7] >> 5)
+ s[24] = byte(h[7] >> 13)
+ s[25] = byte((h[7] >> 21) | (h[8] << 4))
+ s[26] = byte(h[8] >> 4)
+ s[27] = byte(h[8] >> 12)
+ s[28] = byte((h[8] >> 20) | (h[9] << 6))
+ s[29] = byte(h[9] >> 2)
+ s[30] = byte(h[9] >> 10)
+ s[31] = byte(h[9] >> 18)
+}
+
+func FeIsNegative(f *FieldElement) byte {
+ var s [32]byte
+ FeToBytes(&s, f)
+ return s[0] & 1
+}
+
+func FeIsNonZero(f *FieldElement) int32 {
+ var s [32]byte
+ FeToBytes(&s, f)
+ var x uint8
+ for _, b := range s {
+ x |= b
+ }
+ x |= x >> 4
+ x |= x >> 2
+ x |= x >> 1
+ return int32(x & 1)
+}
+
+// FeNeg sets h = -f
+//
+// Preconditions:
+// |f| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+//
+// Postconditions:
+// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+func FeNeg(h, f *FieldElement) {
+ for i := range h {
+ h[i] = -f[i]
+ }
+}
+
+// FeMul calculates h = f * g
+// Can overlap h with f or g.
+//
+// Preconditions:
+// |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
+// |g| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
+//
+// Postconditions:
+// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+//
+// Notes on implementation strategy:
+//
+// Using schoolbook multiplication.
+// Karatsuba would save a little in some cost models.
+//
+// Most multiplications by 2 and 19 are 32-bit precomputations;
+// cheaper than 64-bit postcomputations.
+//
+// There is one remaining multiplication by 19 in the carry chain;
+// one *19 precomputation can be merged into this,
+// but the resulting data flow is considerably less clean.
+//
+// There are 12 carries below.
+// 10 of them are 2-way parallelizable and vectorizable.
+// Can get away with 11 carries, but then data flow is much deeper.
+//
+// With tighter constraints on inputs can squeeze carries into int32.
+func FeMul(h, f, g *FieldElement) {
+ f0 := f[0]
+ f1 := f[1]
+ f2 := f[2]
+ f3 := f[3]
+ f4 := f[4]
+ f5 := f[5]
+ f6 := f[6]
+ f7 := f[7]
+ f8 := f[8]
+ f9 := f[9]
+ g0 := g[0]
+ g1 := g[1]
+ g2 := g[2]
+ g3 := g[3]
+ g4 := g[4]
+ g5 := g[5]
+ g6 := g[6]
+ g7 := g[7]
+ g8 := g[8]
+ g9 := g[9]
+ g1_19 := 19 * g1 /* 1.4*2^29 */
+ g2_19 := 19 * g2 /* 1.4*2^30; still ok */
+ g3_19 := 19 * g3
+ g4_19 := 19 * g4
+ g5_19 := 19 * g5
+ g6_19 := 19 * g6
+ g7_19 := 19 * g7
+ g8_19 := 19 * g8
+ g9_19 := 19 * g9
+ f1_2 := 2 * f1
+ f3_2 := 2 * f3
+ f5_2 := 2 * f5
+ f7_2 := 2 * f7
+ f9_2 := 2 * f9
+ f0g0 := int64(f0) * int64(g0)
+ f0g1 := int64(f0) * int64(g1)
+ f0g2 := int64(f0) * int64(g2)
+ f0g3 := int64(f0) * int64(g3)
+ f0g4 := int64(f0) * int64(g4)
+ f0g5 := int64(f0) * int64(g5)
+ f0g6 := int64(f0) * int64(g6)
+ f0g7 := int64(f0) * int64(g7)
+ f0g8 := int64(f0) * int64(g8)
+ f0g9 := int64(f0) * int64(g9)
+ f1g0 := int64(f1) * int64(g0)
+ f1g1_2 := int64(f1_2) * int64(g1)
+ f1g2 := int64(f1) * int64(g2)
+ f1g3_2 := int64(f1_2) * int64(g3)
+ f1g4 := int64(f1) * int64(g4)
+ f1g5_2 := int64(f1_2) * int64(g5)
+ f1g6 := int64(f1) * int64(g6)
+ f1g7_2 := int64(f1_2) * int64(g7)
+ f1g8 := int64(f1) * int64(g8)
+ f1g9_38 := int64(f1_2) * int64(g9_19)
+ f2g0 := int64(f2) * int64(g0)
+ f2g1 := int64(f2) * int64(g1)
+ f2g2 := int64(f2) * int64(g2)
+ f2g3 := int64(f2) * int64(g3)
+ f2g4 := int64(f2) * int64(g4)
+ f2g5 := int64(f2) * int64(g5)
+ f2g6 := int64(f2) * int64(g6)
+ f2g7 := int64(f2) * int64(g7)
+ f2g8_19 := int64(f2) * int64(g8_19)
+ f2g9_19 := int64(f2) * int64(g9_19)
+ f3g0 := int64(f3) * int64(g0)
+ f3g1_2 := int64(f3_2) * int64(g1)
+ f3g2 := int64(f3) * int64(g2)
+ f3g3_2 := int64(f3_2) * int64(g3)
+ f3g4 := int64(f3) * int64(g4)
+ f3g5_2 := int64(f3_2) * int64(g5)
+ f3g6 := int64(f3) * int64(g6)
+ f3g7_38 := int64(f3_2) * int64(g7_19)
+ f3g8_19 := int64(f3) * int64(g8_19)
+ f3g9_38 := int64(f3_2) * int64(g9_19)
+ f4g0 := int64(f4) * int64(g0)
+ f4g1 := int64(f4) * int64(g1)
+ f4g2 := int64(f4) * int64(g2)
+ f4g3 := int64(f4) * int64(g3)
+ f4g4 := int64(f4) * int64(g4)
+ f4g5 := int64(f4) * int64(g5)
+ f4g6_19 := int64(f4) * int64(g6_19)
+ f4g7_19 := int64(f4) * int64(g7_19)
+ f4g8_19 := int64(f4) * int64(g8_19)
+ f4g9_19 := int64(f4) * int64(g9_19)
+ f5g0 := int64(f5) * int64(g0)
+ f5g1_2 := int64(f5_2) * int64(g1)
+ f5g2 := int64(f5) * int64(g2)
+ f5g3_2 := int64(f5_2) * int64(g3)
+ f5g4 := int64(f5) * int64(g4)
+ f5g5_38 := int64(f5_2) * int64(g5_19)
+ f5g6_19 := int64(f5) * int64(g6_19)
+ f5g7_38 := int64(f5_2) * int64(g7_19)
+ f5g8_19 := int64(f5) * int64(g8_19)
+ f5g9_38 := int64(f5_2) * int64(g9_19)
+ f6g0 := int64(f6) * int64(g0)
+ f6g1 := int64(f6) * int64(g1)
+ f6g2 := int64(f6) * int64(g2)
+ f6g3 := int64(f6) * int64(g3)
+ f6g4_19 := int64(f6) * int64(g4_19)
+ f6g5_19 := int64(f6) * int64(g5_19)
+ f6g6_19 := int64(f6) * int64(g6_19)
+ f6g7_19 := int64(f6) * int64(g7_19)
+ f6g8_19 := int64(f6) * int64(g8_19)
+ f6g9_19 := int64(f6) * int64(g9_19)
+ f7g0 := int64(f7) * int64(g0)
+ f7g1_2 := int64(f7_2) * int64(g1)
+ f7g2 := int64(f7) * int64(g2)
+ f7g3_38 := int64(f7_2) * int64(g3_19)
+ f7g4_19 := int64(f7) * int64(g4_19)
+ f7g5_38 := int64(f7_2) * int64(g5_19)
+ f7g6_19 := int64(f7) * int64(g6_19)
+ f7g7_38 := int64(f7_2) * int64(g7_19)
+ f7g8_19 := int64(f7) * int64(g8_19)
+ f7g9_38 := int64(f7_2) * int64(g9_19)
+ f8g0 := int64(f8) * int64(g0)
+ f8g1 := int64(f8) * int64(g1)
+ f8g2_19 := int64(f8) * int64(g2_19)
+ f8g3_19 := int64(f8) * int64(g3_19)
+ f8g4_19 := int64(f8) * int64(g4_19)
+ f8g5_19 := int64(f8) * int64(g5_19)
+ f8g6_19 := int64(f8) * int64(g6_19)
+ f8g7_19 := int64(f8) * int64(g7_19)
+ f8g8_19 := int64(f8) * int64(g8_19)
+ f8g9_19 := int64(f8) * int64(g9_19)
+ f9g0 := int64(f9) * int64(g0)
+ f9g1_38 := int64(f9_2) * int64(g1_19)
+ f9g2_19 := int64(f9) * int64(g2_19)
+ f9g3_38 := int64(f9_2) * int64(g3_19)
+ f9g4_19 := int64(f9) * int64(g4_19)
+ f9g5_38 := int64(f9_2) * int64(g5_19)
+ f9g6_19 := int64(f9) * int64(g6_19)
+ f9g7_38 := int64(f9_2) * int64(g7_19)
+ f9g8_19 := int64(f9) * int64(g8_19)
+ f9g9_38 := int64(f9_2) * int64(g9_19)
+ h0 := f0g0 + f1g9_38 + f2g8_19 + f3g7_38 + f4g6_19 + f5g5_38 + f6g4_19 + f7g3_38 + f8g2_19 + f9g1_38
+ h1 := f0g1 + f1g0 + f2g9_19 + f3g8_19 + f4g7_19 + f5g6_19 + f6g5_19 + f7g4_19 + f8g3_19 + f9g2_19
+ h2 := f0g2 + f1g1_2 + f2g0 + f3g9_38 + f4g8_19 + f5g7_38 + f6g6_19 + f7g5_38 + f8g4_19 + f9g3_38
+ h3 := f0g3 + f1g2 + f2g1 + f3g0 + f4g9_19 + f5g8_19 + f6g7_19 + f7g6_19 + f8g5_19 + f9g4_19
+ h4 := f0g4 + f1g3_2 + f2g2 + f3g1_2 + f4g0 + f5g9_38 + f6g8_19 + f7g7_38 + f8g6_19 + f9g5_38
+ h5 := f0g5 + f1g4 + f2g3 + f3g2 + f4g1 + f5g0 + f6g9_19 + f7g8_19 + f8g7_19 + f9g6_19
+ h6 := f0g6 + f1g5_2 + f2g4 + f3g3_2 + f4g2 + f5g1_2 + f6g0 + f7g9_38 + f8g8_19 + f9g7_38
+ h7 := f0g7 + f1g6 + f2g5 + f3g4 + f4g3 + f5g2 + f6g1 + f7g0 + f8g9_19 + f9g8_19
+ h8 := f0g8 + f1g7_2 + f2g6 + f3g5_2 + f4g4 + f5g3_2 + f6g2 + f7g1_2 + f8g0 + f9g9_38
+ h9 := f0g9 + f1g8 + f2g7 + f3g6 + f4g5 + f5g4 + f6g3 + f7g2 + f8g1 + f9g0
+ var carry [10]int64
+
+ /*
+ |h0| <= (1.1*1.1*2^52*(1+19+19+19+19)+1.1*1.1*2^50*(38+38+38+38+38))
+ i.e. |h0| <= 1.2*2^59; narrower ranges for h2, h4, h6, h8
+ |h1| <= (1.1*1.1*2^51*(1+1+19+19+19+19+19+19+19+19))
+ i.e. |h1| <= 1.5*2^58; narrower ranges for h3, h5, h7, h9
+ */
+
+ carry[0] = (h0 + (1 << 25)) >> 26
+ h1 += carry[0]
+ h0 -= carry[0] << 26
+ carry[4] = (h4 + (1 << 25)) >> 26
+ h5 += carry[4]
+ h4 -= carry[4] << 26
+ /* |h0| <= 2^25 */
+ /* |h4| <= 2^25 */
+ /* |h1| <= 1.51*2^58 */
+ /* |h5| <= 1.51*2^58 */
+
+ carry[1] = (h1 + (1 << 24)) >> 25
+ h2 += carry[1]
+ h1 -= carry[1] << 25
+ carry[5] = (h5 + (1 << 24)) >> 25
+ h6 += carry[5]
+ h5 -= carry[5] << 25
+ /* |h1| <= 2^24; from now on fits into int32 */
+ /* |h5| <= 2^24; from now on fits into int32 */
+ /* |h2| <= 1.21*2^59 */
+ /* |h6| <= 1.21*2^59 */
+
+ carry[2] = (h2 + (1 << 25)) >> 26
+ h3 += carry[2]
+ h2 -= carry[2] << 26
+ carry[6] = (h6 + (1 << 25)) >> 26
+ h7 += carry[6]
+ h6 -= carry[6] << 26
+ /* |h2| <= 2^25; from now on fits into int32 unchanged */
+ /* |h6| <= 2^25; from now on fits into int32 unchanged */
+ /* |h3| <= 1.51*2^58 */
+ /* |h7| <= 1.51*2^58 */
+
+ carry[3] = (h3 + (1 << 24)) >> 25
+ h4 += carry[3]
+ h3 -= carry[3] << 25
+ carry[7] = (h7 + (1 << 24)) >> 25
+ h8 += carry[7]
+ h7 -= carry[7] << 25
+ /* |h3| <= 2^24; from now on fits into int32 unchanged */
+ /* |h7| <= 2^24; from now on fits into int32 unchanged */
+ /* |h4| <= 1.52*2^33 */
+ /* |h8| <= 1.52*2^33 */
+
+ carry[4] = (h4 + (1 << 25)) >> 26
+ h5 += carry[4]
+ h4 -= carry[4] << 26
+ carry[8] = (h8 + (1 << 25)) >> 26
+ h9 += carry[8]
+ h8 -= carry[8] << 26
+ /* |h4| <= 2^25; from now on fits into int32 unchanged */
+ /* |h8| <= 2^25; from now on fits into int32 unchanged */
+ /* |h5| <= 1.01*2^24 */
+ /* |h9| <= 1.51*2^58 */
+
+ carry[9] = (h9 + (1 << 24)) >> 25
+ h0 += carry[9] * 19
+ h9 -= carry[9] << 25
+ /* |h9| <= 2^24; from now on fits into int32 unchanged */
+ /* |h0| <= 1.8*2^37 */
+
+ carry[0] = (h0 + (1 << 25)) >> 26
+ h1 += carry[0]
+ h0 -= carry[0] << 26
+ /* |h0| <= 2^25; from now on fits into int32 unchanged */
+ /* |h1| <= 1.01*2^24 */
+
+ h[0] = int32(h0)
+ h[1] = int32(h1)
+ h[2] = int32(h2)
+ h[3] = int32(h3)
+ h[4] = int32(h4)
+ h[5] = int32(h5)
+ h[6] = int32(h6)
+ h[7] = int32(h7)
+ h[8] = int32(h8)
+ h[9] = int32(h9)
+}
+
+// FeSquare calculates h = f*f. Can overlap h with f.
+//
+// Preconditions:
+// |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
+//
+// Postconditions:
+// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+func FeSquare(h, f *FieldElement) {
+ f0 := f[0]
+ f1 := f[1]
+ f2 := f[2]
+ f3 := f[3]
+ f4 := f[4]
+ f5 := f[5]
+ f6 := f[6]
+ f7 := f[7]
+ f8 := f[8]
+ f9 := f[9]
+ f0_2 := 2 * f0
+ f1_2 := 2 * f1
+ f2_2 := 2 * f2
+ f3_2 := 2 * f3
+ f4_2 := 2 * f4
+ f5_2 := 2 * f5
+ f6_2 := 2 * f6
+ f7_2 := 2 * f7
+ f5_38 := 38 * f5 // 1.31*2^30
+ f6_19 := 19 * f6 // 1.31*2^30
+ f7_38 := 38 * f7 // 1.31*2^30
+ f8_19 := 19 * f8 // 1.31*2^30
+ f9_38 := 38 * f9 // 1.31*2^30
+ f0f0 := int64(f0) * int64(f0)
+ f0f1_2 := int64(f0_2) * int64(f1)
+ f0f2_2 := int64(f0_2) * int64(f2)
+ f0f3_2 := int64(f0_2) * int64(f3)
+ f0f4_2 := int64(f0_2) * int64(f4)
+ f0f5_2 := int64(f0_2) * int64(f5)
+ f0f6_2 := int64(f0_2) * int64(f6)
+ f0f7_2 := int64(f0_2) * int64(f7)
+ f0f8_2 := int64(f0_2) * int64(f8)
+ f0f9_2 := int64(f0_2) * int64(f9)
+ f1f1_2 := int64(f1_2) * int64(f1)
+ f1f2_2 := int64(f1_2) * int64(f2)
+ f1f3_4 := int64(f1_2) * int64(f3_2)
+ f1f4_2 := int64(f1_2) * int64(f4)
+ f1f5_4 := int64(f1_2) * int64(f5_2)
+ f1f6_2 := int64(f1_2) * int64(f6)
+ f1f7_4 := int64(f1_2) * int64(f7_2)
+ f1f8_2 := int64(f1_2) * int64(f8)
+ f1f9_76 := int64(f1_2) * int64(f9_38)
+ f2f2 := int64(f2) * int64(f2)
+ f2f3_2 := int64(f2_2) * int64(f3)
+ f2f4_2 := int64(f2_2) * int64(f4)
+ f2f5_2 := int64(f2_2) * int64(f5)
+ f2f6_2 := int64(f2_2) * int64(f6)
+ f2f7_2 := int64(f2_2) * int64(f7)
+ f2f8_38 := int64(f2_2) * int64(f8_19)
+ f2f9_38 := int64(f2) * int64(f9_38)
+ f3f3_2 := int64(f3_2) * int64(f3)
+ f3f4_2 := int64(f3_2) * int64(f4)
+ f3f5_4 := int64(f3_2) * int64(f5_2)
+ f3f6_2 := int64(f3_2) * int64(f6)
+ f3f7_76 := int64(f3_2) * int64(f7_38)
+ f3f8_38 := int64(f3_2) * int64(f8_19)
+ f3f9_76 := int64(f3_2) * int64(f9_38)
+ f4f4 := int64(f4) * int64(f4)
+ f4f5_2 := int64(f4_2) * int64(f5)
+ f4f6_38 := int64(f4_2) * int64(f6_19)
+ f4f7_38 := int64(f4) * int64(f7_38)
+ f4f8_38 := int64(f4_2) * int64(f8_19)
+ f4f9_38 := int64(f4) * int64(f9_38)
+ f5f5_38 := int64(f5) * int64(f5_38)
+ f5f6_38 := int64(f5_2) * int64(f6_19)
+ f5f7_76 := int64(f5_2) * int64(f7_38)
+ f5f8_38 := int64(f5_2) * int64(f8_19)
+ f5f9_76 := int64(f5_2) * int64(f9_38)
+ f6f6_19 := int64(f6) * int64(f6_19)
+ f6f7_38 := int64(f6) * int64(f7_38)
+ f6f8_38 := int64(f6_2) * int64(f8_19)
+ f6f9_38 := int64(f6) * int64(f9_38)
+ f7f7_38 := int64(f7) * int64(f7_38)
+ f7f8_38 := int64(f7_2) * int64(f8_19)
+ f7f9_76 := int64(f7_2) * int64(f9_38)
+ f8f8_19 := int64(f8) * int64(f8_19)
+ f8f9_38 := int64(f8) * int64(f9_38)
+ f9f9_38 := int64(f9) * int64(f9_38)
+ h0 := f0f0 + f1f9_76 + f2f8_38 + f3f7_76 + f4f6_38 + f5f5_38
+ h1 := f0f1_2 + f2f9_38 + f3f8_38 + f4f7_38 + f5f6_38
+ h2 := f0f2_2 + f1f1_2 + f3f9_76 + f4f8_38 + f5f7_76 + f6f6_19
+ h3 := f0f3_2 + f1f2_2 + f4f9_38 + f5f8_38 + f6f7_38
+ h4 := f0f4_2 + f1f3_4 + f2f2 + f5f9_76 + f6f8_38 + f7f7_38
+ h5 := f0f5_2 + f1f4_2 + f2f3_2 + f6f9_38 + f7f8_38
+ h6 := f0f6_2 + f1f5_4 + f2f4_2 + f3f3_2 + f7f9_76 + f8f8_19
+ h7 := f0f7_2 + f1f6_2 + f2f5_2 + f3f4_2 + f8f9_38
+ h8 := f0f8_2 + f1f7_4 + f2f6_2 + f3f5_4 + f4f4 + f9f9_38
+ h9 := f0f9_2 + f1f8_2 + f2f7_2 + f3f6_2 + f4f5_2
+ var carry [10]int64
+
+ carry[0] = (h0 + (1 << 25)) >> 26
+ h1 += carry[0]
+ h0 -= carry[0] << 26
+ carry[4] = (h4 + (1 << 25)) >> 26
+ h5 += carry[4]
+ h4 -= carry[4] << 26
+
+ carry[1] = (h1 + (1 << 24)) >> 25
+ h2 += carry[1]
+ h1 -= carry[1] << 25
+ carry[5] = (h5 + (1 << 24)) >> 25
+ h6 += carry[5]
+ h5 -= carry[5] << 25
+
+ carry[2] = (h2 + (1 << 25)) >> 26
+ h3 += carry[2]
+ h2 -= carry[2] << 26
+ carry[6] = (h6 + (1 << 25)) >> 26
+ h7 += carry[6]
+ h6 -= carry[6] << 26
+
+ carry[3] = (h3 + (1 << 24)) >> 25
+ h4 += carry[3]
+ h3 -= carry[3] << 25
+ carry[7] = (h7 + (1 << 24)) >> 25
+ h8 += carry[7]
+ h7 -= carry[7] << 25
+
+ carry[4] = (h4 + (1 << 25)) >> 26
+ h5 += carry[4]
+ h4 -= carry[4] << 26
+ carry[8] = (h8 + (1 << 25)) >> 26
+ h9 += carry[8]
+ h8 -= carry[8] << 26
+
+ carry[9] = (h9 + (1 << 24)) >> 25
+ h0 += carry[9] * 19
+ h9 -= carry[9] << 25
+
+ carry[0] = (h0 + (1 << 25)) >> 26
+ h1 += carry[0]
+ h0 -= carry[0] << 26
+
+ h[0] = int32(h0)
+ h[1] = int32(h1)
+ h[2] = int32(h2)
+ h[3] = int32(h3)
+ h[4] = int32(h4)
+ h[5] = int32(h5)
+ h[6] = int32(h6)
+ h[7] = int32(h7)
+ h[8] = int32(h8)
+ h[9] = int32(h9)
+}
+
+// FeSquare2 sets h = 2 * f * f
+//
+// Can overlap h with f.
+//
+// Preconditions:
+// |f| bounded by 1.65*2^26,1.65*2^25,1.65*2^26,1.65*2^25,etc.
+//
+// Postconditions:
+// |h| bounded by 1.01*2^25,1.01*2^24,1.01*2^25,1.01*2^24,etc.
+// See fe_mul.c for discussion of implementation strategy.
+func FeSquare2(h, f *FieldElement) {
+ f0 := f[0]
+ f1 := f[1]
+ f2 := f[2]
+ f3 := f[3]
+ f4 := f[4]
+ f5 := f[5]
+ f6 := f[6]
+ f7 := f[7]
+ f8 := f[8]
+ f9 := f[9]
+ f0_2 := 2 * f0
+ f1_2 := 2 * f1
+ f2_2 := 2 * f2
+ f3_2 := 2 * f3
+ f4_2 := 2 * f4
+ f5_2 := 2 * f5
+ f6_2 := 2 * f6
+ f7_2 := 2 * f7
+ f5_38 := 38 * f5 // 1.959375*2^30
+ f6_19 := 19 * f6 // 1.959375*2^30
+ f7_38 := 38 * f7 // 1.959375*2^30
+ f8_19 := 19 * f8 // 1.959375*2^30
+ f9_38 := 38 * f9 // 1.959375*2^30
+ f0f0 := int64(f0) * int64(f0)
+ f0f1_2 := int64(f0_2) * int64(f1)
+ f0f2_2 := int64(f0_2) * int64(f2)
+ f0f3_2 := int64(f0_2) * int64(f3)
+ f0f4_2 := int64(f0_2) * int64(f4)
+ f0f5_2 := int64(f0_2) * int64(f5)
+ f0f6_2 := int64(f0_2) * int64(f6)
+ f0f7_2 := int64(f0_2) * int64(f7)
+ f0f8_2 := int64(f0_2) * int64(f8)
+ f0f9_2 := int64(f0_2) * int64(f9)
+ f1f1_2 := int64(f1_2) * int64(f1)
+ f1f2_2 := int64(f1_2) * int64(f2)
+ f1f3_4 := int64(f1_2) * int64(f3_2)
+ f1f4_2 := int64(f1_2) * int64(f4)
+ f1f5_4 := int64(f1_2) * int64(f5_2)
+ f1f6_2 := int64(f1_2) * int64(f6)
+ f1f7_4 := int64(f1_2) * int64(f7_2)
+ f1f8_2 := int64(f1_2) * int64(f8)
+ f1f9_76 := int64(f1_2) * int64(f9_38)
+ f2f2 := int64(f2) * int64(f2)
+ f2f3_2 := int64(f2_2) * int64(f3)
+ f2f4_2 := int64(f2_2) * int64(f4)
+ f2f5_2 := int64(f2_2) * int64(f5)
+ f2f6_2 := int64(f2_2) * int64(f6)
+ f2f7_2 := int64(f2_2) * int64(f7)
+ f2f8_38 := int64(f2_2) * int64(f8_19)
+ f2f9_38 := int64(f2) * int64(f9_38)
+ f3f3_2 := int64(f3_2) * int64(f3)
+ f3f4_2 := int64(f3_2) * int64(f4)
+ f3f5_4 := int64(f3_2) * int64(f5_2)
+ f3f6_2 := int64(f3_2) * int64(f6)
+ f3f7_76 := int64(f3_2) * int64(f7_38)
+ f3f8_38 := int64(f3_2) * int64(f8_19)
+ f3f9_76 := int64(f3_2) * int64(f9_38)
+ f4f4 := int64(f4) * int64(f4)
+ f4f5_2 := int64(f4_2) * int64(f5)
+ f4f6_38 := int64(f4_2) * int64(f6_19)
+ f4f7_38 := int64(f4) * int64(f7_38)
+ f4f8_38 := int64(f4_2) * int64(f8_19)
+ f4f9_38 := int64(f4) * int64(f9_38)
+ f5f5_38 := int64(f5) * int64(f5_38)
+ f5f6_38 := int64(f5_2) * int64(f6_19)
+ f5f7_76 := int64(f5_2) * int64(f7_38)
+ f5f8_38 := int64(f5_2) * int64(f8_19)
+ f5f9_76 := int64(f5_2) * int64(f9_38)
+ f6f6_19 := int64(f6) * int64(f6_19)
+ f6f7_38 := int64(f6) * int64(f7_38)
+ f6f8_38 := int64(f6_2) * int64(f8_19)
+ f6f9_38 := int64(f6) * int64(f9_38)
+ f7f7_38 := int64(f7) * int64(f7_38)
+ f7f8_38 := int64(f7_2) * int64(f8_19)
+ f7f9_76 := int64(f7_2) * int64(f9_38)
+ f8f8_19 := int64(f8) * int64(f8_19)
+ f8f9_38 := int64(f8) * int64(f9_38)
+ f9f9_38 := int64(f9) * int64(f9_38)
+ h0 := f0f0 + f1f9_76 + f2f8_38 + f3f7_76 + f4f6_38 + f5f5_38
+ h1 := f0f1_2 + f2f9_38 + f3f8_38 + f4f7_38 + f5f6_38
+ h2 := f0f2_2 + f1f1_2 + f3f9_76 + f4f8_38 + f5f7_76 + f6f6_19
+ h3 := f0f3_2 + f1f2_2 + f4f9_38 + f5f8_38 + f6f7_38
+ h4 := f0f4_2 + f1f3_4 + f2f2 + f5f9_76 + f6f8_38 + f7f7_38
+ h5 := f0f5_2 + f1f4_2 + f2f3_2 + f6f9_38 + f7f8_38
+ h6 := f0f6_2 + f1f5_4 + f2f4_2 + f3f3_2 + f7f9_76 + f8f8_19
+ h7 := f0f7_2 + f1f6_2 + f2f5_2 + f3f4_2 + f8f9_38
+ h8 := f0f8_2 + f1f7_4 + f2f6_2 + f3f5_4 + f4f4 + f9f9_38
+ h9 := f0f9_2 + f1f8_2 + f2f7_2 + f3f6_2 + f4f5_2
+ var carry [10]int64
+
+ h0 += h0
+ h1 += h1
+ h2 += h2
+ h3 += h3
+ h4 += h4
+ h5 += h5
+ h6 += h6
+ h7 += h7
+ h8 += h8
+ h9 += h9
+
+ carry[0] = (h0 + (1 << 25)) >> 26
+ h1 += carry[0]
+ h0 -= carry[0] << 26
+ carry[4] = (h4 + (1 << 25)) >> 26
+ h5 += carry[4]
+ h4 -= carry[4] << 26
+
+ carry[1] = (h1 + (1 << 24)) >> 25
+ h2 += carry[1]
+ h1 -= carry[1] << 25
+ carry[5] = (h5 + (1 << 24)) >> 25
+ h6 += carry[5]
+ h5 -= carry[5] << 25
+
+ carry[2] = (h2 + (1 << 25)) >> 26
+ h3 += carry[2]
+ h2 -= carry[2] << 26
+ carry[6] = (h6 + (1 << 25)) >> 26
+ h7 += carry[6]
+ h6 -= carry[6] << 26
+
+ carry[3] = (h3 + (1 << 24)) >> 25
+ h4 += carry[3]
+ h3 -= carry[3] << 25
+ carry[7] = (h7 + (1 << 24)) >> 25
+ h8 += carry[7]
+ h7 -= carry[7] << 25
+
+ carry[4] = (h4 + (1 << 25)) >> 26
+ h5 += carry[4]
+ h4 -= carry[4] << 26
+ carry[8] = (h8 + (1 << 25)) >> 26
+ h9 += carry[8]
+ h8 -= carry[8] << 26
+
+ carry[9] = (h9 + (1 << 24)) >> 25
+ h0 += carry[9] * 19
+ h9 -= carry[9] << 25
+
+ carry[0] = (h0 + (1 << 25)) >> 26
+ h1 += carry[0]
+ h0 -= carry[0] << 26
+
+ h[0] = int32(h0)
+ h[1] = int32(h1)
+ h[2] = int32(h2)
+ h[3] = int32(h3)
+ h[4] = int32(h4)
+ h[5] = int32(h5)
+ h[6] = int32(h6)
+ h[7] = int32(h7)
+ h[8] = int32(h8)
+ h[9] = int32(h9)
+}
+
+func FeInvert(out, z *FieldElement) {
+ var t0, t1, t2, t3 FieldElement
+ var i int
+
+ FeSquare(&t0, z) // 2^1
+ FeSquare(&t1, &t0) // 2^2
+ for i = 1; i < 2; i++ { // 2^3
+ FeSquare(&t1, &t1)
+ }
+ FeMul(&t1, z, &t1) // 2^3 + 2^0
+ FeMul(&t0, &t0, &t1) // 2^3 + 2^1 + 2^0
+ FeSquare(&t2, &t0) // 2^4 + 2^2 + 2^1
+ FeMul(&t1, &t1, &t2) // 2^4 + 2^3 + 2^2 + 2^1 + 2^0
+ FeSquare(&t2, &t1) // 5,4,3,2,1
+ for i = 1; i < 5; i++ { // 9,8,7,6,5
+ FeSquare(&t2, &t2)
+ }
+ FeMul(&t1, &t2, &t1) // 9,8,7,6,5,4,3,2,1,0
+ FeSquare(&t2, &t1) // 10..1
+ for i = 1; i < 10; i++ { // 19..10
+ FeSquare(&t2, &t2)
+ }
+ FeMul(&t2, &t2, &t1) // 19..0
+ FeSquare(&t3, &t2) // 20..1
+ for i = 1; i < 20; i++ { // 39..20
+ FeSquare(&t3, &t3)
+ }
+ FeMul(&t2, &t3, &t2) // 39..0
+ FeSquare(&t2, &t2) // 40..1
+ for i = 1; i < 10; i++ { // 49..10
+ FeSquare(&t2, &t2)
+ }
+ FeMul(&t1, &t2, &t1) // 49..0
+ FeSquare(&t2, &t1) // 50..1
+ for i = 1; i < 50; i++ { // 99..50
+ FeSquare(&t2, &t2)
+ }
+ FeMul(&t2, &t2, &t1) // 99..0
+ FeSquare(&t3, &t2) // 100..1
+ for i = 1; i < 100; i++ { // 199..100
+ FeSquare(&t3, &t3)
+ }
+ FeMul(&t2, &t3, &t2) // 199..0
+ FeSquare(&t2, &t2) // 200..1
+ for i = 1; i < 50; i++ { // 249..50
+ FeSquare(&t2, &t2)
+ }
+ FeMul(&t1, &t2, &t1) // 249..0
+ FeSquare(&t1, &t1) // 250..1
+ for i = 1; i < 5; i++ { // 254..5
+ FeSquare(&t1, &t1)
+ }
+ FeMul(out, &t1, &t0) // 254..5,3,1,0
+}
+
+func fePow22523(out, z *FieldElement) {
+ var t0, t1, t2 FieldElement
+ var i int
+
+ FeSquare(&t0, z)
+ for i = 1; i < 1; i++ {
+ FeSquare(&t0, &t0)
+ }
+ FeSquare(&t1, &t0)
+ for i = 1; i < 2; i++ {
+ FeSquare(&t1, &t1)
+ }
+ FeMul(&t1, z, &t1)
+ FeMul(&t0, &t0, &t1)
+ FeSquare(&t0, &t0)
+ for i = 1; i < 1; i++ {
+ FeSquare(&t0, &t0)
+ }
+ FeMul(&t0, &t1, &t0)
+ FeSquare(&t1, &t0)
+ for i = 1; i < 5; i++ {
+ FeSquare(&t1, &t1)
+ }
+ FeMul(&t0, &t1, &t0)
+ FeSquare(&t1, &t0)
+ for i = 1; i < 10; i++ {
+ FeSquare(&t1, &t1)
+ }
+ FeMul(&t1, &t1, &t0)
+ FeSquare(&t2, &t1)
+ for i = 1; i < 20; i++ {
+ FeSquare(&t2, &t2)
+ }
+ FeMul(&t1, &t2, &t1)
+ FeSquare(&t1, &t1)
+ for i = 1; i < 10; i++ {
+ FeSquare(&t1, &t1)
+ }
+ FeMul(&t0, &t1, &t0)
+ FeSquare(&t1, &t0)
+ for i = 1; i < 50; i++ {
+ FeSquare(&t1, &t1)
+ }
+ FeMul(&t1, &t1, &t0)
+ FeSquare(&t2, &t1)
+ for i = 1; i < 100; i++ {
+ FeSquare(&t2, &t2)
+ }
+ FeMul(&t1, &t2, &t1)
+ FeSquare(&t1, &t1)
+ for i = 1; i < 50; i++ {
+ FeSquare(&t1, &t1)
+ }
+ FeMul(&t0, &t1, &t0)
+ FeSquare(&t0, &t0)
+ for i = 1; i < 2; i++ {
+ FeSquare(&t0, &t0)
+ }
+ FeMul(out, &t0, z)
+}
+
+// Group elements are members of the elliptic curve -x^2 + y^2 = 1 + d * x^2 *
+// y^2 where d = -121665/121666.
+//
+// Several representations are used:
+// ProjectiveGroupElement: (X:Y:Z) satisfying x=X/Z, y=Y/Z
+// ExtendedGroupElement: (X:Y:Z:T) satisfying x=X/Z, y=Y/Z, XY=ZT
+// CompletedGroupElement: ((X:Z),(Y:T)) satisfying x=X/Z, y=Y/T
+// PreComputedGroupElement: (y+x,y-x,2dxy)
+
+type ProjectiveGroupElement struct {
+ X, Y, Z FieldElement
+}
+
+type ExtendedGroupElement struct {
+ X, Y, Z, T FieldElement
+}
+
+type CompletedGroupElement struct {
+ X, Y, Z, T FieldElement
+}
+
+type PreComputedGroupElement struct {
+ yPlusX, yMinusX, xy2d FieldElement
+}
+
+type CachedGroupElement struct {
+ yPlusX, yMinusX, Z, T2d FieldElement
+}
+
+func (p *ProjectiveGroupElement) Zero() {
+ FeZero(&p.X)
+ FeOne(&p.Y)
+ FeOne(&p.Z)
+}
+
+func (p *ProjectiveGroupElement) Double(r *CompletedGroupElement) {
+ var t0 FieldElement
+
+ FeSquare(&r.X, &p.X)
+ FeSquare(&r.Z, &p.Y)
+ FeSquare2(&r.T, &p.Z)
+ FeAdd(&r.Y, &p.X, &p.Y)
+ FeSquare(&t0, &r.Y)
+ FeAdd(&r.Y, &r.Z, &r.X)
+ FeSub(&r.Z, &r.Z, &r.X)
+ FeSub(&r.X, &t0, &r.Y)
+ FeSub(&r.T, &r.T, &r.Z)
+}
+
+func (p *ProjectiveGroupElement) ToBytes(s *[32]byte) {
+ var recip, x, y FieldElement
+
+ FeInvert(&recip, &p.Z)
+ FeMul(&x, &p.X, &recip)
+ FeMul(&y, &p.Y, &recip)
+ FeToBytes(s, &y)
+ s[31] ^= FeIsNegative(&x) << 7
+}
+
+func (p *ExtendedGroupElement) Zero() {
+ FeZero(&p.X)
+ FeOne(&p.Y)
+ FeOne(&p.Z)
+ FeZero(&p.T)
+}
+
+func (p *ExtendedGroupElement) Double(r *CompletedGroupElement) {
+ var q ProjectiveGroupElement
+ p.ToProjective(&q)
+ q.Double(r)
+}
+
+func (p *ExtendedGroupElement) ToCached(r *CachedGroupElement) {
+ FeAdd(&r.yPlusX, &p.Y, &p.X)
+ FeSub(&r.yMinusX, &p.Y, &p.X)
+ FeCopy(&r.Z, &p.Z)
+ FeMul(&r.T2d, &p.T, &d2)
+}
+
+func (p *ExtendedGroupElement) ToProjective(r *ProjectiveGroupElement) {
+ FeCopy(&r.X, &p.X)
+ FeCopy(&r.Y, &p.Y)
+ FeCopy(&r.Z, &p.Z)
+}
+
+func (p *ExtendedGroupElement) ToBytes(s *[32]byte) {
+ var recip, x, y FieldElement
+
+ FeInvert(&recip, &p.Z)
+ FeMul(&x, &p.X, &recip)
+ FeMul(&y, &p.Y, &recip)
+ FeToBytes(s, &y)
+ s[31] ^= FeIsNegative(&x) << 7
+}
+
+func (p *ExtendedGroupElement) FromBytes(s *[32]byte) bool {
+ var u, v, v3, vxx, check FieldElement
+
+ FeFromBytes(&p.Y, s)
+ FeOne(&p.Z)
+ FeSquare(&u, &p.Y)
+ FeMul(&v, &u, &d)
+ FeSub(&u, &u, &p.Z) // y = y^2-1
+ FeAdd(&v, &v, &p.Z) // v = dy^2+1
+
+ FeSquare(&v3, &v)
+ FeMul(&v3, &v3, &v) // v3 = v^3
+ FeSquare(&p.X, &v3)
+ FeMul(&p.X, &p.X, &v)
+ FeMul(&p.X, &p.X, &u) // x = uv^7
+
+ fePow22523(&p.X, &p.X) // x = (uv^7)^((q-5)/8)
+ FeMul(&p.X, &p.X, &v3)
+ FeMul(&p.X, &p.X, &u) // x = uv^3(uv^7)^((q-5)/8)
+
+ var tmpX, tmp2 [32]byte
+
+ FeSquare(&vxx, &p.X)
+ FeMul(&vxx, &vxx, &v)
+ FeSub(&check, &vxx, &u) // vx^2-u
+ if FeIsNonZero(&check) == 1 {
+ FeAdd(&check, &vxx, &u) // vx^2+u
+ if FeIsNonZero(&check) == 1 {
+ return false
+ }
+ FeMul(&p.X, &p.X, &SqrtM1)
+
+ FeToBytes(&tmpX, &p.X)
+ for i, v := range tmpX {
+ tmp2[31-i] = v
+ }
+ }
+
+ if FeIsNegative(&p.X) == (s[31] >> 7) {
+ FeNeg(&p.X, &p.X)
+ }
+
+ FeMul(&p.T, &p.X, &p.Y)
+ return true
+}
+
+func (p *CompletedGroupElement) ToProjective(r *ProjectiveGroupElement) {
+ FeMul(&r.X, &p.X, &p.T)
+ FeMul(&r.Y, &p.Y, &p.Z)
+ FeMul(&r.Z, &p.Z, &p.T)
+}
+
+func (p *CompletedGroupElement) ToExtended(r *ExtendedGroupElement) {
+ FeMul(&r.X, &p.X, &p.T)
+ FeMul(&r.Y, &p.Y, &p.Z)
+ FeMul(&r.Z, &p.Z, &p.T)
+ FeMul(&r.T, &p.X, &p.Y)
+}
+
+func (p *PreComputedGroupElement) Zero() {
+ FeOne(&p.yPlusX)
+ FeOne(&p.yMinusX)
+ FeZero(&p.xy2d)
+}
+
+func geAdd(r *CompletedGroupElement, p *ExtendedGroupElement, q *CachedGroupElement) {
+ var t0 FieldElement
+
+ FeAdd(&r.X, &p.Y, &p.X)
+ FeSub(&r.Y, &p.Y, &p.X)
+ FeMul(&r.Z, &r.X, &q.yPlusX)
+ FeMul(&r.Y, &r.Y, &q.yMinusX)
+ FeMul(&r.T, &q.T2d, &p.T)
+ FeMul(&r.X, &p.Z, &q.Z)
+ FeAdd(&t0, &r.X, &r.X)
+ FeSub(&r.X, &r.Z, &r.Y)
+ FeAdd(&r.Y, &r.Z, &r.Y)
+ FeAdd(&r.Z, &t0, &r.T)
+ FeSub(&r.T, &t0, &r.T)
+}
+
+func geSub(r *CompletedGroupElement, p *ExtendedGroupElement, q *CachedGroupElement) {
+ var t0 FieldElement
+
+ FeAdd(&r.X, &p.Y, &p.X)
+ FeSub(&r.Y, &p.Y, &p.X)
+ FeMul(&r.Z, &r.X, &q.yMinusX)
+ FeMul(&r.Y, &r.Y, &q.yPlusX)
+ FeMul(&r.T, &q.T2d, &p.T)
+ FeMul(&r.X, &p.Z, &q.Z)
+ FeAdd(&t0, &r.X, &r.X)
+ FeSub(&r.X, &r.Z, &r.Y)
+ FeAdd(&r.Y, &r.Z, &r.Y)
+ FeSub(&r.Z, &t0, &r.T)
+ FeAdd(&r.T, &t0, &r.T)
+}
+
+func geMixedAdd(r *CompletedGroupElement, p *ExtendedGroupElement, q *PreComputedGroupElement) {
+ var t0 FieldElement
+
+ FeAdd(&r.X, &p.Y, &p.X)
+ FeSub(&r.Y, &p.Y, &p.X)
+ FeMul(&r.Z, &r.X, &q.yPlusX)
+ FeMul(&r.Y, &r.Y, &q.yMinusX)
+ FeMul(&r.T, &q.xy2d, &p.T)
+ FeAdd(&t0, &p.Z, &p.Z)
+ FeSub(&r.X, &r.Z, &r.Y)
+ FeAdd(&r.Y, &r.Z, &r.Y)
+ FeAdd(&r.Z, &t0, &r.T)
+ FeSub(&r.T, &t0, &r.T)
+}
+
+func geMixedSub(r *CompletedGroupElement, p *ExtendedGroupElement, q *PreComputedGroupElement) {
+ var t0 FieldElement
+
+ FeAdd(&r.X, &p.Y, &p.X)
+ FeSub(&r.Y, &p.Y, &p.X)
+ FeMul(&r.Z, &r.X, &q.yMinusX)
+ FeMul(&r.Y, &r.Y, &q.yPlusX)
+ FeMul(&r.T, &q.xy2d, &p.T)
+ FeAdd(&t0, &p.Z, &p.Z)
+ FeSub(&r.X, &r.Z, &r.Y)
+ FeAdd(&r.Y, &r.Z, &r.Y)
+ FeSub(&r.Z, &t0, &r.T)
+ FeAdd(&r.T, &t0, &r.T)
+}
+
+func slide(r *[256]int8, a *[32]byte) {
+ for i := range r {
+ r[i] = int8(1 & (a[i>>3] >> uint(i&7)))
+ }
+
+ for i := range r {
+ if r[i] != 0 {
+ for b := 1; b <= 6 && i+b < 256; b++ {
+ if r[i+b] != 0 {
+ if r[i]+(r[i+b]<<uint(b)) <= 15 {
+ r[i] += r[i+b] << uint(b)
+ r[i+b] = 0
+ } else if r[i]-(r[i+b]<<uint(b)) >= -15 {
+ r[i] -= r[i+b] << uint(b)
+ for k := i + b; k < 256; k++ {
+ if r[k] == 0 {
+ r[k] = 1
+ break
+ }
+ r[k] = 0
+ }
+ } else {
+ break
+ }
+ }
+ }
+ }
+ }
+}
+
+// GeDoubleScalarMultVartime sets r = a*A + b*B
+// where a = a[0]+256*a[1]+...+256^31 a[31].
+// and b = b[0]+256*b[1]+...+256^31 b[31].
+// B is the Ed25519 base point (x,4/5) with x positive.
+func GeDoubleScalarMultVartime(r *ProjectiveGroupElement, a *[32]byte, A *ExtendedGroupElement, b *[32]byte) {
+ var aSlide, bSlide [256]int8
+ var Ai [8]CachedGroupElement // A,3A,5A,7A,9A,11A,13A,15A
+ var t CompletedGroupElement
+ var u, A2 ExtendedGroupElement
+ var i int
+
+ slide(&aSlide, a)
+ slide(&bSlide, b)
+
+ A.ToCached(&Ai[0])
+ A.Double(&t)
+ t.ToExtended(&A2)
+
+ for i := 0; i < 7; i++ {
+ geAdd(&t, &A2, &Ai[i])
+ t.ToExtended(&u)
+ u.ToCached(&Ai[i+1])
+ }
+
+ r.Zero()
+
+ for i = 255; i >= 0; i-- {
+ if aSlide[i] != 0 || bSlide[i] != 0 {
+ break
+ }
+ }
+
+ for ; i >= 0; i-- {
+ r.Double(&t)
+
+ if aSlide[i] > 0 {
+ t.ToExtended(&u)
+ geAdd(&t, &u, &Ai[aSlide[i]/2])
+ } else if aSlide[i] < 0 {
+ t.ToExtended(&u)
+ geSub(&t, &u, &Ai[(-aSlide[i])/2])
+ }
+
+ if bSlide[i] > 0 {
+ t.ToExtended(&u)
+ geMixedAdd(&t, &u, &bi[bSlide[i]/2])
+ } else if bSlide[i] < 0 {
+ t.ToExtended(&u)
+ geMixedSub(&t, &u, &bi[(-bSlide[i])/2])
+ }
+
+ t.ToProjective(r)
+ }
+}
+
+// equal returns 1 if b == c and 0 otherwise.
+func equal(b, c int32) int32 {
+ x := uint32(b ^ c)
+ x--
+ return int32(x >> 31)
+}
+
+// negative returns 1 if b < 0 and 0 otherwise.
+func negative(b int32) int32 {
+ return (b >> 31) & 1
+}
+
+func PreComputedGroupElementCMove(t, u *PreComputedGroupElement, b int32) {
+ FeCMove(&t.yPlusX, &u.yPlusX, b)
+ FeCMove(&t.yMinusX, &u.yMinusX, b)
+ FeCMove(&t.xy2d, &u.xy2d, b)
+}
+
+func selectPoint(t *PreComputedGroupElement, pos int32, b int32) {
+ var minusT PreComputedGroupElement
+ bNegative := negative(b)
+ bAbs := b - (((-bNegative) & b) << 1)
+
+ t.Zero()
+ for i := int32(0); i < 8; i++ {
+ PreComputedGroupElementCMove(t, &base[pos][i], equal(bAbs, i+1))
+ }
+ FeCopy(&minusT.yPlusX, &t.yMinusX)
+ FeCopy(&minusT.yMinusX, &t.yPlusX)
+ FeNeg(&minusT.xy2d, &t.xy2d)
+ PreComputedGroupElementCMove(t, &minusT, bNegative)
+}
+
+// GeScalarMultBase computes h = a*B, where
+// a = a[0]+256*a[1]+...+256^31 a[31]
+// B is the Ed25519 base point (x,4/5) with x positive.
+//
+// Preconditions:
+// a[31] <= 127
+func GeScalarMultBase(h *ExtendedGroupElement, a *[32]byte) {
+ var e [64]int8
+
+ for i, v := range a {
+ e[2*i] = int8(v & 15)
+ e[2*i+1] = int8((v >> 4) & 15)
+ }
+
+ // each e[i] is between 0 and 15 and e[63] is between 0 and 7.
+
+ carry := int8(0)
+ for i := 0; i < 63; i++ {
+ e[i] += carry
+ carry = (e[i] + 8) >> 4
+ e[i] -= carry << 4
+ }
+ e[63] += carry
+ // each e[i] is between -8 and 8.
+
+ h.Zero()
+ var t PreComputedGroupElement
+ var r CompletedGroupElement
+ for i := int32(1); i < 64; i += 2 {
+ selectPoint(&t, i/2, int32(e[i]))
+ geMixedAdd(&r, h, &t)
+ r.ToExtended(h)
+ }
+
+ var s ProjectiveGroupElement
+
+ h.Double(&r)
+ r.ToProjective(&s)
+ s.Double(&r)
+ r.ToProjective(&s)
+ s.Double(&r)
+ r.ToProjective(&s)
+ s.Double(&r)
+ r.ToExtended(h)
+
+ for i := int32(0); i < 64; i += 2 {
+ selectPoint(&t, i/2, int32(e[i]))
+ geMixedAdd(&r, h, &t)
+ r.ToExtended(h)
+ }
+}
+
+// The scalars are GF(2^252 + 27742317777372353535851937790883648493).
+
+// Input:
+// a[0]+256*a[1]+...+256^31*a[31] = a
+// b[0]+256*b[1]+...+256^31*b[31] = b
+// c[0]+256*c[1]+...+256^31*c[31] = c
+//
+// Output:
+// s[0]+256*s[1]+...+256^31*s[31] = (ab+c) mod l
+// where l = 2^252 + 27742317777372353535851937790883648493.
+func ScMulAdd(s, a, b, c *[32]byte) {
+ a0 := 2097151 & load3(a[:])
+ a1 := 2097151 & (load4(a[2:]) >> 5)
+ a2 := 2097151 & (load3(a[5:]) >> 2)
+ a3 := 2097151 & (load4(a[7:]) >> 7)
+ a4 := 2097151 & (load4(a[10:]) >> 4)
+ a5 := 2097151 & (load3(a[13:]) >> 1)
+ a6 := 2097151 & (load4(a[15:]) >> 6)
+ a7 := 2097151 & (load3(a[18:]) >> 3)
+ a8 := 2097151 & load3(a[21:])
+ a9 := 2097151 & (load4(a[23:]) >> 5)
+ a10 := 2097151 & (load3(a[26:]) >> 2)
+ a11 := (load4(a[28:]) >> 7)
+ b0 := 2097151 & load3(b[:])
+ b1 := 2097151 & (load4(b[2:]) >> 5)
+ b2 := 2097151 & (load3(b[5:]) >> 2)
+ b3 := 2097151 & (load4(b[7:]) >> 7)
+ b4 := 2097151 & (load4(b[10:]) >> 4)
+ b5 := 2097151 & (load3(b[13:]) >> 1)
+ b6 := 2097151 & (load4(b[15:]) >> 6)
+ b7 := 2097151 & (load3(b[18:]) >> 3)
+ b8 := 2097151 & load3(b[21:])
+ b9 := 2097151 & (load4(b[23:]) >> 5)
+ b10 := 2097151 & (load3(b[26:]) >> 2)
+ b11 := (load4(b[28:]) >> 7)
+ c0 := 2097151 & load3(c[:])
+ c1 := 2097151 & (load4(c[2:]) >> 5)
+ c2 := 2097151 & (load3(c[5:]) >> 2)
+ c3 := 2097151 & (load4(c[7:]) >> 7)
+ c4 := 2097151 & (load4(c[10:]) >> 4)
+ c5 := 2097151 & (load3(c[13:]) >> 1)
+ c6 := 2097151 & (load4(c[15:]) >> 6)
+ c7 := 2097151 & (load3(c[18:]) >> 3)
+ c8 := 2097151 & load3(c[21:])
+ c9 := 2097151 & (load4(c[23:]) >> 5)
+ c10 := 2097151 & (load3(c[26:]) >> 2)
+ c11 := (load4(c[28:]) >> 7)
+ var carry [23]int64
+
+ s0 := c0 + a0*b0
+ s1 := c1 + a0*b1 + a1*b0
+ s2 := c2 + a0*b2 + a1*b1 + a2*b0
+ s3 := c3 + a0*b3 + a1*b2 + a2*b1 + a3*b0
+ s4 := c4 + a0*b4 + a1*b3 + a2*b2 + a3*b1 + a4*b0
+ s5 := c5 + a0*b5 + a1*b4 + a2*b3 + a3*b2 + a4*b1 + a5*b0
+ s6 := c6 + a0*b6 + a1*b5 + a2*b4 + a3*b3 + a4*b2 + a5*b1 + a6*b0
+ s7 := c7 + a0*b7 + a1*b6 + a2*b5 + a3*b4 + a4*b3 + a5*b2 + a6*b1 + a7*b0
+ s8 := c8 + a0*b8 + a1*b7 + a2*b6 + a3*b5 + a4*b4 + a5*b3 + a6*b2 + a7*b1 + a8*b0
+ s9 := c9 + a0*b9 + a1*b8 + a2*b7 + a3*b6 + a4*b5 + a5*b4 + a6*b3 + a7*b2 + a8*b1 + a9*b0
+ s10 := c10 + a0*b10 + a1*b9 + a2*b8 + a3*b7 + a4*b6 + a5*b5 + a6*b4 + a7*b3 + a8*b2 + a9*b1 + a10*b0
+ s11 := c11 + a0*b11 + a1*b10 + a2*b9 + a3*b8 + a4*b7 + a5*b6 + a6*b5 + a7*b4 + a8*b3 + a9*b2 + a10*b1 + a11*b0
+ s12 := a1*b11 + a2*b10 + a3*b9 + a4*b8 + a5*b7 + a6*b6 + a7*b5 + a8*b4 + a9*b3 + a10*b2 + a11*b1
+ s13 := a2*b11 + a3*b10 + a4*b9 + a5*b8 + a6*b7 + a7*b6 + a8*b5 + a9*b4 + a10*b3 + a11*b2
+ s14 := a3*b11 + a4*b10 + a5*b9 + a6*b8 + a7*b7 + a8*b6 + a9*b5 + a10*b4 + a11*b3
+ s15 := a4*b11 + a5*b10 + a6*b9 + a7*b8 + a8*b7 + a9*b6 + a10*b5 + a11*b4
+ s16 := a5*b11 + a6*b10 + a7*b9 + a8*b8 + a9*b7 + a10*b6 + a11*b5
+ s17 := a6*b11 + a7*b10 + a8*b9 + a9*b8 + a10*b7 + a11*b6
+ s18 := a7*b11 + a8*b10 + a9*b9 + a10*b8 + a11*b7
+ s19 := a8*b11 + a9*b10 + a10*b9 + a11*b8
+ s20 := a9*b11 + a10*b10 + a11*b9
+ s21 := a10*b11 + a11*b10
+ s22 := a11 * b11
+ s23 := int64(0)
+
+ carry[0] = (s0 + (1 << 20)) >> 21
+ s1 += carry[0]
+ s0 -= carry[0] << 21
+ carry[2] = (s2 + (1 << 20)) >> 21
+ s3 += carry[2]
+ s2 -= carry[2] << 21
+ carry[4] = (s4 + (1 << 20)) >> 21
+ s5 += carry[4]
+ s4 -= carry[4] << 21
+ carry[6] = (s6 + (1 << 20)) >> 21
+ s7 += carry[6]
+ s6 -= carry[6] << 21
+ carry[8] = (s8 + (1 << 20)) >> 21
+ s9 += carry[8]
+ s8 -= carry[8] << 21
+ carry[10] = (s10 + (1 << 20)) >> 21
+ s11 += carry[10]
+ s10 -= carry[10] << 21
+ carry[12] = (s12 + (1 << 20)) >> 21
+ s13 += carry[12]
+ s12 -= carry[12] << 21
+ carry[14] = (s14 + (1 << 20)) >> 21
+ s15 += carry[14]
+ s14 -= carry[14] << 21
+ carry[16] = (s16 + (1 << 20)) >> 21
+ s17 += carry[16]
+ s16 -= carry[16] << 21
+ carry[18] = (s18 + (1 << 20)) >> 21
+ s19 += carry[18]
+ s18 -= carry[18] << 21
+ carry[20] = (s20 + (1 << 20)) >> 21
+ s21 += carry[20]
+ s20 -= carry[20] << 21
+ carry[22] = (s22 + (1 << 20)) >> 21
+ s23 += carry[22]
+ s22 -= carry[22] << 21
+
+ carry[1] = (s1 + (1 << 20)) >> 21
+ s2 += carry[1]
+ s1 -= carry[1] << 21
+ carry[3] = (s3 + (1 << 20)) >> 21
+ s4 += carry[3]
+ s3 -= carry[3] << 21
+ carry[5] = (s5 + (1 << 20)) >> 21
+ s6 += carry[5]
+ s5 -= carry[5] << 21
+ carry[7] = (s7 + (1 << 20)) >> 21
+ s8 += carry[7]
+ s7 -= carry[7] << 21
+ carry[9] = (s9 + (1 << 20)) >> 21
+ s10 += carry[9]
+ s9 -= carry[9] << 21
+ carry[11] = (s11 + (1 << 20)) >> 21
+ s12 += carry[11]
+ s11 -= carry[11] << 21
+ carry[13] = (s13 + (1 << 20)) >> 21
+ s14 += carry[13]
+ s13 -= carry[13] << 21
+ carry[15] = (s15 + (1 << 20)) >> 21
+ s16 += carry[15]
+ s15 -= carry[15] << 21
+ carry[17] = (s17 + (1 << 20)) >> 21
+ s18 += carry[17]
+ s17 -= carry[17] << 21
+ carry[19] = (s19 + (1 << 20)) >> 21
+ s20 += carry[19]
+ s19 -= carry[19] << 21
+ carry[21] = (s21 + (1 << 20)) >> 21
+ s22 += carry[21]
+ s21 -= carry[21] << 21
+
+ s11 += s23 * 666643
+ s12 += s23 * 470296
+ s13 += s23 * 654183
+ s14 -= s23 * 997805
+ s15 += s23 * 136657
+ s16 -= s23 * 683901
+ s23 = 0
+
+ s10 += s22 * 666643
+ s11 += s22 * 470296
+ s12 += s22 * 654183
+ s13 -= s22 * 997805
+ s14 += s22 * 136657
+ s15 -= s22 * 683901
+ s22 = 0
+
+ s9 += s21 * 666643
+ s10 += s21 * 470296
+ s11 += s21 * 654183
+ s12 -= s21 * 997805
+ s13 += s21 * 136657
+ s14 -= s21 * 683901
+ s21 = 0
+
+ s8 += s20 * 666643
+ s9 += s20 * 470296
+ s10 += s20 * 654183
+ s11 -= s20 * 997805
+ s12 += s20 * 136657
+ s13 -= s20 * 683901
+ s20 = 0
+
+ s7 += s19 * 666643
+ s8 += s19 * 470296
+ s9 += s19 * 654183
+ s10 -= s19 * 997805
+ s11 += s19 * 136657
+ s12 -= s19 * 683901
+ s19 = 0
+
+ s6 += s18 * 666643
+ s7 += s18 * 470296
+ s8 += s18 * 654183
+ s9 -= s18 * 997805
+ s10 += s18 * 136657
+ s11 -= s18 * 683901
+ s18 = 0
+
+ carry[6] = (s6 + (1 << 20)) >> 21
+ s7 += carry[6]
+ s6 -= carry[6] << 21
+ carry[8] = (s8 + (1 << 20)) >> 21
+ s9 += carry[8]
+ s8 -= carry[8] << 21
+ carry[10] = (s10 + (1 << 20)) >> 21
+ s11 += carry[10]
+ s10 -= carry[10] << 21
+ carry[12] = (s12 + (1 << 20)) >> 21
+ s13 += carry[12]
+ s12 -= carry[12] << 21
+ carry[14] = (s14 + (1 << 20)) >> 21
+ s15 += carry[14]
+ s14 -= carry[14] << 21
+ carry[16] = (s16 + (1 << 20)) >> 21
+ s17 += carry[16]
+ s16 -= carry[16] << 21
+
+ carry[7] = (s7 + (1 << 20)) >> 21
+ s8 += carry[7]
+ s7 -= carry[7] << 21
+ carry[9] = (s9 + (1 << 20)) >> 21
+ s10 += carry[9]
+ s9 -= carry[9] << 21
+ carry[11] = (s11 + (1 << 20)) >> 21
+ s12 += carry[11]
+ s11 -= carry[11] << 21
+ carry[13] = (s13 + (1 << 20)) >> 21
+ s14 += carry[13]
+ s13 -= carry[13] << 21
+ carry[15] = (s15 + (1 << 20)) >> 21
+ s16 += carry[15]
+ s15 -= carry[15] << 21
+
+ s5 += s17 * 666643
+ s6 += s17 * 470296
+ s7 += s17 * 654183
+ s8 -= s17 * 997805
+ s9 += s17 * 136657
+ s10 -= s17 * 683901
+ s17 = 0
+
+ s4 += s16 * 666643
+ s5 += s16 * 470296
+ s6 += s16 * 654183
+ s7 -= s16 * 997805
+ s8 += s16 * 136657
+ s9 -= s16 * 683901
+ s16 = 0
+
+ s3 += s15 * 666643
+ s4 += s15 * 470296
+ s5 += s15 * 654183
+ s6 -= s15 * 997805
+ s7 += s15 * 136657
+ s8 -= s15 * 683901
+ s15 = 0
+
+ s2 += s14 * 666643
+ s3 += s14 * 470296
+ s4 += s14 * 654183
+ s5 -= s14 * 997805
+ s6 += s14 * 136657
+ s7 -= s14 * 683901
+ s14 = 0
+
+ s1 += s13 * 666643
+ s2 += s13 * 470296
+ s3 += s13 * 654183
+ s4 -= s13 * 997805
+ s5 += s13 * 136657
+ s6 -= s13 * 683901
+ s13 = 0
+
+ s0 += s12 * 666643
+ s1 += s12 * 470296
+ s2 += s12 * 654183
+ s3 -= s12 * 997805
+ s4 += s12 * 136657
+ s5 -= s12 * 683901
+ s12 = 0
+
+ carry[0] = (s0 + (1 << 20)) >> 21
+ s1 += carry[0]
+ s0 -= carry[0] << 21
+ carry[2] = (s2 + (1 << 20)) >> 21
+ s3 += carry[2]
+ s2 -= carry[2] << 21
+ carry[4] = (s4 + (1 << 20)) >> 21
+ s5 += carry[4]
+ s4 -= carry[4] << 21
+ carry[6] = (s6 + (1 << 20)) >> 21
+ s7 += carry[6]
+ s6 -= carry[6] << 21
+ carry[8] = (s8 + (1 << 20)) >> 21
+ s9 += carry[8]
+ s8 -= carry[8] << 21
+ carry[10] = (s10 + (1 << 20)) >> 21
+ s11 += carry[10]
+ s10 -= carry[10] << 21
+
+ carry[1] = (s1 + (1 << 20)) >> 21
+ s2 += carry[1]
+ s1 -= carry[1] << 21
+ carry[3] = (s3 + (1 << 20)) >> 21
+ s4 += carry[3]
+ s3 -= carry[3] << 21
+ carry[5] = (s5 + (1 << 20)) >> 21
+ s6 += carry[5]
+ s5 -= carry[5] << 21
+ carry[7] = (s7 + (1 << 20)) >> 21
+ s8 += carry[7]
+ s7 -= carry[7] << 21
+ carry[9] = (s9 + (1 << 20)) >> 21
+ s10 += carry[9]
+ s9 -= carry[9] << 21
+ carry[11] = (s11 + (1 << 20)) >> 21
+ s12 += carry[11]
+ s11 -= carry[11] << 21
+
+ s0 += s12 * 666643
+ s1 += s12 * 470296
+ s2 += s12 * 654183
+ s3 -= s12 * 997805
+ s4 += s12 * 136657
+ s5 -= s12 * 683901
+ s12 = 0
+
+ carry[0] = s0 >> 21
+ s1 += carry[0]
+ s0 -= carry[0] << 21
+ carry[1] = s1 >> 21
+ s2 += carry[1]
+ s1 -= carry[1] << 21
+ carry[2] = s2 >> 21
+ s3 += carry[2]
+ s2 -= carry[2] << 21
+ carry[3] = s3 >> 21
+ s4 += carry[3]
+ s3 -= carry[3] << 21
+ carry[4] = s4 >> 21
+ s5 += carry[4]
+ s4 -= carry[4] << 21
+ carry[5] = s5 >> 21
+ s6 += carry[5]
+ s5 -= carry[5] << 21
+ carry[6] = s6 >> 21
+ s7 += carry[6]
+ s6 -= carry[6] << 21
+ carry[7] = s7 >> 21
+ s8 += carry[7]
+ s7 -= carry[7] << 21
+ carry[8] = s8 >> 21
+ s9 += carry[8]
+ s8 -= carry[8] << 21
+ carry[9] = s9 >> 21
+ s10 += carry[9]
+ s9 -= carry[9] << 21
+ carry[10] = s10 >> 21
+ s11 += carry[10]
+ s10 -= carry[10] << 21
+ carry[11] = s11 >> 21
+ s12 += carry[11]
+ s11 -= carry[11] << 21
+
+ s0 += s12 * 666643
+ s1 += s12 * 470296
+ s2 += s12 * 654183
+ s3 -= s12 * 997805
+ s4 += s12 * 136657
+ s5 -= s12 * 683901
+ s12 = 0
+
+ carry[0] = s0 >> 21
+ s1 += carry[0]
+ s0 -= carry[0] << 21
+ carry[1] = s1 >> 21
+ s2 += carry[1]
+ s1 -= carry[1] << 21
+ carry[2] = s2 >> 21
+ s3 += carry[2]
+ s2 -= carry[2] << 21
+ carry[3] = s3 >> 21
+ s4 += carry[3]
+ s3 -= carry[3] << 21
+ carry[4] = s4 >> 21
+ s5 += carry[4]
+ s4 -= carry[4] << 21
+ carry[5] = s5 >> 21
+ s6 += carry[5]
+ s5 -= carry[5] << 21
+ carry[6] = s6 >> 21
+ s7 += carry[6]
+ s6 -= carry[6] << 21
+ carry[7] = s7 >> 21
+ s8 += carry[7]
+ s7 -= carry[7] << 21
+ carry[8] = s8 >> 21
+ s9 += carry[8]
+ s8 -= carry[8] << 21
+ carry[9] = s9 >> 21
+ s10 += carry[9]
+ s9 -= carry[9] << 21
+ carry[10] = s10 >> 21
+ s11 += carry[10]
+ s10 -= carry[10] << 21
+
+ s[0] = byte(s0 >> 0)
+ s[1] = byte(s0 >> 8)
+ s[2] = byte((s0 >> 16) | (s1 << 5))
+ s[3] = byte(s1 >> 3)
+ s[4] = byte(s1 >> 11)
+ s[5] = byte((s1 >> 19) | (s2 << 2))
+ s[6] = byte(s2 >> 6)
+ s[7] = byte((s2 >> 14) | (s3 << 7))
+ s[8] = byte(s3 >> 1)
+ s[9] = byte(s3 >> 9)
+ s[10] = byte((s3 >> 17) | (s4 << 4))
+ s[11] = byte(s4 >> 4)
+ s[12] = byte(s4 >> 12)
+ s[13] = byte((s4 >> 20) | (s5 << 1))
+ s[14] = byte(s5 >> 7)
+ s[15] = byte((s5 >> 15) | (s6 << 6))
+ s[16] = byte(s6 >> 2)
+ s[17] = byte(s6 >> 10)
+ s[18] = byte((s6 >> 18) | (s7 << 3))
+ s[19] = byte(s7 >> 5)
+ s[20] = byte(s7 >> 13)
+ s[21] = byte(s8 >> 0)
+ s[22] = byte(s8 >> 8)
+ s[23] = byte((s8 >> 16) | (s9 << 5))
+ s[24] = byte(s9 >> 3)
+ s[25] = byte(s9 >> 11)
+ s[26] = byte((s9 >> 19) | (s10 << 2))
+ s[27] = byte(s10 >> 6)
+ s[28] = byte((s10 >> 14) | (s11 << 7))
+ s[29] = byte(s11 >> 1)
+ s[30] = byte(s11 >> 9)
+ s[31] = byte(s11 >> 17)
+}
+
+// Input:
+// s[0]+256*s[1]+...+256^63*s[63] = s
+//
+// Output:
+// s[0]+256*s[1]+...+256^31*s[31] = s mod l
+// where l = 2^252 + 27742317777372353535851937790883648493.
+func ScReduce(out *[32]byte, s *[64]byte) {
+ s0 := 2097151 & load3(s[:])
+ s1 := 2097151 & (load4(s[2:]) >> 5)
+ s2 := 2097151 & (load3(s[5:]) >> 2)
+ s3 := 2097151 & (load4(s[7:]) >> 7)
+ s4 := 2097151 & (load4(s[10:]) >> 4)
+ s5 := 2097151 & (load3(s[13:]) >> 1)
+ s6 := 2097151 & (load4(s[15:]) >> 6)
+ s7 := 2097151 & (load3(s[18:]) >> 3)
+ s8 := 2097151 & load3(s[21:])
+ s9 := 2097151 & (load4(s[23:]) >> 5)
+ s10 := 2097151 & (load3(s[26:]) >> 2)
+ s11 := 2097151 & (load4(s[28:]) >> 7)
+ s12 := 2097151 & (load4(s[31:]) >> 4)
+ s13 := 2097151 & (load3(s[34:]) >> 1)
+ s14 := 2097151 & (load4(s[36:]) >> 6)
+ s15 := 2097151 & (load3(s[39:]) >> 3)
+ s16 := 2097151 & load3(s[42:])
+ s17 := 2097151 & (load4(s[44:]) >> 5)
+ s18 := 2097151 & (load3(s[47:]) >> 2)
+ s19 := 2097151 & (load4(s[49:]) >> 7)
+ s20 := 2097151 & (load4(s[52:]) >> 4)
+ s21 := 2097151 & (load3(s[55:]) >> 1)
+ s22 := 2097151 & (load4(s[57:]) >> 6)
+ s23 := (load4(s[60:]) >> 3)
+
+ s11 += s23 * 666643
+ s12 += s23 * 470296
+ s13 += s23 * 654183
+ s14 -= s23 * 997805
+ s15 += s23 * 136657
+ s16 -= s23 * 683901
+ s23 = 0
+
+ s10 += s22 * 666643
+ s11 += s22 * 470296
+ s12 += s22 * 654183
+ s13 -= s22 * 997805
+ s14 += s22 * 136657
+ s15 -= s22 * 683901
+ s22 = 0
+
+ s9 += s21 * 666643
+ s10 += s21 * 470296
+ s11 += s21 * 654183
+ s12 -= s21 * 997805
+ s13 += s21 * 136657
+ s14 -= s21 * 683901
+ s21 = 0
+
+ s8 += s20 * 666643
+ s9 += s20 * 470296
+ s10 += s20 * 654183
+ s11 -= s20 * 997805
+ s12 += s20 * 136657
+ s13 -= s20 * 683901
+ s20 = 0
+
+ s7 += s19 * 666643
+ s8 += s19 * 470296
+ s9 += s19 * 654183
+ s10 -= s19 * 997805
+ s11 += s19 * 136657
+ s12 -= s19 * 683901
+ s19 = 0
+
+ s6 += s18 * 666643
+ s7 += s18 * 470296
+ s8 += s18 * 654183
+ s9 -= s18 * 997805
+ s10 += s18 * 136657
+ s11 -= s18 * 683901
+ s18 = 0
+
+ var carry [17]int64
+
+ carry[6] = (s6 + (1 << 20)) >> 21
+ s7 += carry[6]
+ s6 -= carry[6] << 21
+ carry[8] = (s8 + (1 << 20)) >> 21
+ s9 += carry[8]
+ s8 -= carry[8] << 21
+ carry[10] = (s10 + (1 << 20)) >> 21
+ s11 += carry[10]
+ s10 -= carry[10] << 21
+ carry[12] = (s12 + (1 << 20)) >> 21
+ s13 += carry[12]
+ s12 -= carry[12] << 21
+ carry[14] = (s14 + (1 << 20)) >> 21
+ s15 += carry[14]
+ s14 -= carry[14] << 21
+ carry[16] = (s16 + (1 << 20)) >> 21
+ s17 += carry[16]
+ s16 -= carry[16] << 21
+
+ carry[7] = (s7 + (1 << 20)) >> 21
+ s8 += carry[7]
+ s7 -= carry[7] << 21
+ carry[9] = (s9 + (1 << 20)) >> 21
+ s10 += carry[9]
+ s9 -= carry[9] << 21
+ carry[11] = (s11 + (1 << 20)) >> 21
+ s12 += carry[11]
+ s11 -= carry[11] << 21
+ carry[13] = (s13 + (1 << 20)) >> 21
+ s14 += carry[13]
+ s13 -= carry[13] << 21
+ carry[15] = (s15 + (1 << 20)) >> 21
+ s16 += carry[15]
+ s15 -= carry[15] << 21
+
+ s5 += s17 * 666643
+ s6 += s17 * 470296
+ s7 += s17 * 654183
+ s8 -= s17 * 997805
+ s9 += s17 * 136657
+ s10 -= s17 * 683901
+ s17 = 0
+
+ s4 += s16 * 666643
+ s5 += s16 * 470296
+ s6 += s16 * 654183
+ s7 -= s16 * 997805
+ s8 += s16 * 136657
+ s9 -= s16 * 683901
+ s16 = 0
+
+ s3 += s15 * 666643
+ s4 += s15 * 470296
+ s5 += s15 * 654183
+ s6 -= s15 * 997805
+ s7 += s15 * 136657
+ s8 -= s15 * 683901
+ s15 = 0
+
+ s2 += s14 * 666643
+ s3 += s14 * 470296
+ s4 += s14 * 654183
+ s5 -= s14 * 997805
+ s6 += s14 * 136657
+ s7 -= s14 * 683901
+ s14 = 0
+
+ s1 += s13 * 666643
+ s2 += s13 * 470296
+ s3 += s13 * 654183
+ s4 -= s13 * 997805
+ s5 += s13 * 136657
+ s6 -= s13 * 683901
+ s13 = 0
+
+ s0 += s12 * 666643
+ s1 += s12 * 470296
+ s2 += s12 * 654183
+ s3 -= s12 * 997805
+ s4 += s12 * 136657
+ s5 -= s12 * 683901
+ s12 = 0
+
+ carry[0] = (s0 + (1 << 20)) >> 21
+ s1 += carry[0]
+ s0 -= carry[0] << 21
+ carry[2] = (s2 + (1 << 20)) >> 21
+ s3 += carry[2]
+ s2 -= carry[2] << 21
+ carry[4] = (s4 + (1 << 20)) >> 21
+ s5 += carry[4]
+ s4 -= carry[4] << 21
+ carry[6] = (s6 + (1 << 20)) >> 21
+ s7 += carry[6]
+ s6 -= carry[6] << 21
+ carry[8] = (s8 + (1 << 20)) >> 21
+ s9 += carry[8]
+ s8 -= carry[8] << 21
+ carry[10] = (s10 + (1 << 20)) >> 21
+ s11 += carry[10]
+ s10 -= carry[10] << 21
+
+ carry[1] = (s1 + (1 << 20)) >> 21
+ s2 += carry[1]
+ s1 -= carry[1] << 21
+ carry[3] = (s3 + (1 << 20)) >> 21
+ s4 += carry[3]
+ s3 -= carry[3] << 21
+ carry[5] = (s5 + (1 << 20)) >> 21
+ s6 += carry[5]
+ s5 -= carry[5] << 21
+ carry[7] = (s7 + (1 << 20)) >> 21
+ s8 += carry[7]
+ s7 -= carry[7] << 21
+ carry[9] = (s9 + (1 << 20)) >> 21
+ s10 += carry[9]
+ s9 -= carry[9] << 21
+ carry[11] = (s11 + (1 << 20)) >> 21
+ s12 += carry[11]
+ s11 -= carry[11] << 21
+
+ s0 += s12 * 666643
+ s1 += s12 * 470296
+ s2 += s12 * 654183
+ s3 -= s12 * 997805
+ s4 += s12 * 136657
+ s5 -= s12 * 683901
+ s12 = 0
+
+ carry[0] = s0 >> 21
+ s1 += carry[0]
+ s0 -= carry[0] << 21
+ carry[1] = s1 >> 21
+ s2 += carry[1]
+ s1 -= carry[1] << 21
+ carry[2] = s2 >> 21
+ s3 += carry[2]
+ s2 -= carry[2] << 21
+ carry[3] = s3 >> 21
+ s4 += carry[3]
+ s3 -= carry[3] << 21
+ carry[4] = s4 >> 21
+ s5 += carry[4]
+ s4 -= carry[4] << 21
+ carry[5] = s5 >> 21
+ s6 += carry[5]
+ s5 -= carry[5] << 21
+ carry[6] = s6 >> 21
+ s7 += carry[6]
+ s6 -= carry[6] << 21
+ carry[7] = s7 >> 21
+ s8 += carry[7]
+ s7 -= carry[7] << 21
+ carry[8] = s8 >> 21
+ s9 += carry[8]
+ s8 -= carry[8] << 21
+ carry[9] = s9 >> 21
+ s10 += carry[9]
+ s9 -= carry[9] << 21
+ carry[10] = s10 >> 21
+ s11 += carry[10]
+ s10 -= carry[10] << 21
+ carry[11] = s11 >> 21
+ s12 += carry[11]
+ s11 -= carry[11] << 21
+
+ s0 += s12 * 666643
+ s1 += s12 * 470296
+ s2 += s12 * 654183
+ s3 -= s12 * 997805
+ s4 += s12 * 136657
+ s5 -= s12 * 683901
+ s12 = 0
+
+ carry[0] = s0 >> 21
+ s1 += carry[0]
+ s0 -= carry[0] << 21
+ carry[1] = s1 >> 21
+ s2 += carry[1]
+ s1 -= carry[1] << 21
+ carry[2] = s2 >> 21
+ s3 += carry[2]
+ s2 -= carry[2] << 21
+ carry[3] = s3 >> 21
+ s4 += carry[3]
+ s3 -= carry[3] << 21
+ carry[4] = s4 >> 21
+ s5 += carry[4]
+ s4 -= carry[4] << 21
+ carry[5] = s5 >> 21
+ s6 += carry[5]
+ s5 -= carry[5] << 21
+ carry[6] = s6 >> 21
+ s7 += carry[6]
+ s6 -= carry[6] << 21
+ carry[7] = s7 >> 21
+ s8 += carry[7]
+ s7 -= carry[7] << 21
+ carry[8] = s8 >> 21
+ s9 += carry[8]
+ s8 -= carry[8] << 21
+ carry[9] = s9 >> 21
+ s10 += carry[9]
+ s9 -= carry[9] << 21
+ carry[10] = s10 >> 21
+ s11 += carry[10]
+ s10 -= carry[10] << 21
+
+ out[0] = byte(s0 >> 0)
+ out[1] = byte(s0 >> 8)
+ out[2] = byte((s0 >> 16) | (s1 << 5))
+ out[3] = byte(s1 >> 3)
+ out[4] = byte(s1 >> 11)
+ out[5] = byte((s1 >> 19) | (s2 << 2))
+ out[6] = byte(s2 >> 6)
+ out[7] = byte((s2 >> 14) | (s3 << 7))
+ out[8] = byte(s3 >> 1)
+ out[9] = byte(s3 >> 9)
+ out[10] = byte((s3 >> 17) | (s4 << 4))
+ out[11] = byte(s4 >> 4)
+ out[12] = byte(s4 >> 12)
+ out[13] = byte((s4 >> 20) | (s5 << 1))
+ out[14] = byte(s5 >> 7)
+ out[15] = byte((s5 >> 15) | (s6 << 6))
+ out[16] = byte(s6 >> 2)
+ out[17] = byte(s6 >> 10)
+ out[18] = byte((s6 >> 18) | (s7 << 3))
+ out[19] = byte(s7 >> 5)
+ out[20] = byte(s7 >> 13)
+ out[21] = byte(s8 >> 0)
+ out[22] = byte(s8 >> 8)
+ out[23] = byte((s8 >> 16) | (s9 << 5))
+ out[24] = byte(s9 >> 3)
+ out[25] = byte(s9 >> 11)
+ out[26] = byte((s9 >> 19) | (s10 << 2))
+ out[27] = byte(s10 >> 6)
+ out[28] = byte((s10 >> 14) | (s11 << 7))
+ out[29] = byte(s11 >> 1)
+ out[30] = byte(s11 >> 9)
+ out[31] = byte(s11 >> 17)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/ed25519/extra25519/extra25519.go b/Godeps/_workspace/src/github.com/tendermint/ed25519/extra25519/extra25519.go
new file mode 100644
index 0000000000000000000000000000000000000000..bbda91686372ac2982d68a41dac8b7fb446eb67a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/ed25519/extra25519/extra25519.go
@@ -0,0 +1,344 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package extra25519
+
+import (
+ "crypto/sha512"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/agl/ed25519/edwards25519"
+)
+
+// PrivateKeyToCurve25519 converts an ed25519 private key into a corresponding
+// curve25519 private key such that the resulting curve25519 public key will
+// equal the result from PublicKeyToCurve25519.
+func PrivateKeyToCurve25519(curve25519Private *[32]byte, privateKey *[64]byte) {
+ h := sha512.New()
+ h.Write(privateKey[:32])
+ digest := h.Sum(nil)
+
+ digest[0] &= 248
+ digest[31] &= 127
+ digest[31] |= 64
+
+ copy(curve25519Private[:], digest)
+}
+
+func edwardsToMontgomeryX(outX, y *edwards25519.FieldElement) {
+ // We only need the x-coordinate of the curve25519 point, which I'll
+ // call u. The isomorphism is u=(y+1)/(1-y), since y=Y/Z, this gives
+ // u=(Y+Z)/(Z-Y). We know that Z=1, thus u=(Y+1)/(1-Y).
+ var oneMinusY edwards25519.FieldElement
+ edwards25519.FeOne(&oneMinusY)
+ edwards25519.FeSub(&oneMinusY, &oneMinusY, y)
+ edwards25519.FeInvert(&oneMinusY, &oneMinusY)
+
+ edwards25519.FeOne(outX)
+ edwards25519.FeAdd(outX, outX, y)
+
+ edwards25519.FeMul(outX, outX, &oneMinusY)
+}
+
+// PublicKeyToCurve25519 converts an Ed25519 public key into the curve25519
+// public key that would be generated from the same private key.
+func PublicKeyToCurve25519(curve25519Public *[32]byte, publicKey *[32]byte) bool {
+ var A edwards25519.ExtendedGroupElement
+ if !A.FromBytes(publicKey) {
+ return false
+ }
+
+ // A.Z = 1 as a postcondition of FromBytes.
+ var x edwards25519.FieldElement
+ edwardsToMontgomeryX(&x, &A.Y)
+ edwards25519.FeToBytes(curve25519Public, &x)
+ return true
+}
+
+// sqrtMinusA is sqrt(-486662)
+var sqrtMinusA = edwards25519.FieldElement{
+ 12222970, 8312128, 11511410, -9067497, 15300785, 241793, -25456130, -14121551, 12187136, -3972024,
+}
+
+// sqrtMinusHalf is sqrt(-1/2)
+var sqrtMinusHalf = edwards25519.FieldElement{
+ -17256545, 3971863, 28865457, -1750208, 27359696, -16640980, 12573105, 1002827, -163343, 11073975,
+}
+
+// halfQMinus1Bytes is (2^255-20)/2 expressed in little endian form.
+var halfQMinus1Bytes = [32]byte{
+ 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f,
+}
+
+// feBytesLess returns one if a <= b and zero otherwise.
+func feBytesLE(a, b *[32]byte) int32 {
+ equalSoFar := int32(-1)
+ greater := int32(0)
+
+ for i := uint(31); i < 32; i-- {
+ x := int32(a[i])
+ y := int32(b[i])
+
+ greater = (^equalSoFar & greater) | (equalSoFar & ((x - y) >> 31))
+ equalSoFar = equalSoFar & (((x ^ y) - 1) >> 31)
+ }
+
+ return int32(^equalSoFar & 1 & greater)
+}
+
+// ScalarBaseMult computes a curve25519 public key from a private key and also
+// a uniform representative for that public key. Note that this function will
+// fail and return false for about half of private keys.
+// See http://elligator.cr.yp.to/elligator-20130828.pdf.
+func ScalarBaseMult(publicKey, representative, privateKey *[32]byte) bool {
+ var maskedPrivateKey [32]byte
+ copy(maskedPrivateKey[:], privateKey[:])
+
+ maskedPrivateKey[0] &= 248
+ maskedPrivateKey[31] &= 127
+ maskedPrivateKey[31] |= 64
+
+ var A edwards25519.ExtendedGroupElement
+ edwards25519.GeScalarMultBase(&A, &maskedPrivateKey)
+
+ var inv1 edwards25519.FieldElement
+ edwards25519.FeSub(&inv1, &A.Z, &A.Y)
+ edwards25519.FeMul(&inv1, &inv1, &A.X)
+ edwards25519.FeInvert(&inv1, &inv1)
+
+ var t0, u edwards25519.FieldElement
+ edwards25519.FeMul(&u, &inv1, &A.X)
+ edwards25519.FeAdd(&t0, &A.Y, &A.Z)
+ edwards25519.FeMul(&u, &u, &t0)
+
+ var v edwards25519.FieldElement
+ edwards25519.FeMul(&v, &t0, &inv1)
+ edwards25519.FeMul(&v, &v, &A.Z)
+ edwards25519.FeMul(&v, &v, &sqrtMinusA)
+
+ var b edwards25519.FieldElement
+ edwards25519.FeAdd(&b, &u, &edwards25519.A)
+
+ var c, b3, b8 edwards25519.FieldElement
+ edwards25519.FeSquare(&b3, &b) // 2
+ edwards25519.FeMul(&b3, &b3, &b) // 3
+ edwards25519.FeSquare(&c, &b3) // 6
+ edwards25519.FeMul(&c, &c, &b) // 7
+ edwards25519.FeMul(&b8, &c, &b) // 8
+ edwards25519.FeMul(&c, &c, &u)
+ q58(&c, &c)
+
+ var chi edwards25519.FieldElement
+ edwards25519.FeSquare(&chi, &c)
+ edwards25519.FeSquare(&chi, &chi)
+
+ edwards25519.FeSquare(&t0, &u)
+ edwards25519.FeMul(&chi, &chi, &t0)
+
+ edwards25519.FeSquare(&t0, &b) // 2
+ edwards25519.FeMul(&t0, &t0, &b) // 3
+ edwards25519.FeSquare(&t0, &t0) // 6
+ edwards25519.FeMul(&t0, &t0, &b) // 7
+ edwards25519.FeSquare(&t0, &t0) // 14
+ edwards25519.FeMul(&chi, &chi, &t0)
+ edwards25519.FeNeg(&chi, &chi)
+
+ var chiBytes [32]byte
+ edwards25519.FeToBytes(&chiBytes, &chi)
+ // chi[1] is either 0 or 0xff
+ if chiBytes[1] == 0xff {
+ return false
+ }
+
+ // Calculate r1 = sqrt(-u/(2*(u+A)))
+ var r1 edwards25519.FieldElement
+ edwards25519.FeMul(&r1, &c, &u)
+ edwards25519.FeMul(&r1, &r1, &b3)
+ edwards25519.FeMul(&r1, &r1, &sqrtMinusHalf)
+
+ var maybeSqrtM1 edwards25519.FieldElement
+ edwards25519.FeSquare(&t0, &r1)
+ edwards25519.FeMul(&t0, &t0, &b)
+ edwards25519.FeAdd(&t0, &t0, &t0)
+ edwards25519.FeAdd(&t0, &t0, &u)
+
+ edwards25519.FeOne(&maybeSqrtM1)
+ edwards25519.FeCMove(&maybeSqrtM1, &edwards25519.SqrtM1, edwards25519.FeIsNonZero(&t0))
+ edwards25519.FeMul(&r1, &r1, &maybeSqrtM1)
+
+ // Calculate r = sqrt(-(u+A)/(2u))
+ var r edwards25519.FieldElement
+ edwards25519.FeSquare(&t0, &c) // 2
+ edwards25519.FeMul(&t0, &t0, &c) // 3
+ edwards25519.FeSquare(&t0, &t0) // 6
+ edwards25519.FeMul(&r, &t0, &c) // 7
+
+ edwards25519.FeSquare(&t0, &u) // 2
+ edwards25519.FeMul(&t0, &t0, &u) // 3
+ edwards25519.FeMul(&r, &r, &t0)
+
+ edwards25519.FeSquare(&t0, &b8) // 16
+ edwards25519.FeMul(&t0, &t0, &b8) // 24
+ edwards25519.FeMul(&t0, &t0, &b) // 25
+ edwards25519.FeMul(&r, &r, &t0)
+ edwards25519.FeMul(&r, &r, &sqrtMinusHalf)
+
+ edwards25519.FeSquare(&t0, &r)
+ edwards25519.FeMul(&t0, &t0, &u)
+ edwards25519.FeAdd(&t0, &t0, &t0)
+ edwards25519.FeAdd(&t0, &t0, &b)
+ edwards25519.FeOne(&maybeSqrtM1)
+ edwards25519.FeCMove(&maybeSqrtM1, &edwards25519.SqrtM1, edwards25519.FeIsNonZero(&t0))
+ edwards25519.FeMul(&r, &r, &maybeSqrtM1)
+
+ var vBytes [32]byte
+ edwards25519.FeToBytes(&vBytes, &v)
+ vInSquareRootImage := feBytesLE(&vBytes, &halfQMinus1Bytes)
+ edwards25519.FeCMove(&r, &r1, vInSquareRootImage)
+
+ edwards25519.FeToBytes(publicKey, &u)
+ edwards25519.FeToBytes(representative, &r)
+ return true
+}
+
+// q58 calculates out = z^((p-5)/8).
+func q58(out, z *edwards25519.FieldElement) {
+ var t1, t2, t3 edwards25519.FieldElement
+ var i int
+
+ edwards25519.FeSquare(&t1, z) // 2^1
+ edwards25519.FeMul(&t1, &t1, z) // 2^1 + 2^0
+ edwards25519.FeSquare(&t1, &t1) // 2^2 + 2^1
+ edwards25519.FeSquare(&t2, &t1) // 2^3 + 2^2
+ edwards25519.FeSquare(&t2, &t2) // 2^4 + 2^3
+ edwards25519.FeMul(&t2, &t2, &t1) // 4,3,2,1
+ edwards25519.FeMul(&t1, &t2, z) // 4..0
+ edwards25519.FeSquare(&t2, &t1) // 5..1
+ for i = 1; i < 5; i++ { // 9,8,7,6,5
+ edwards25519.FeSquare(&t2, &t2)
+ }
+ edwards25519.FeMul(&t1, &t2, &t1) // 9,8,7,6,5,4,3,2,1,0
+ edwards25519.FeSquare(&t2, &t1) // 10..1
+ for i = 1; i < 10; i++ { // 19..10
+ edwards25519.FeSquare(&t2, &t2)
+ }
+ edwards25519.FeMul(&t2, &t2, &t1) // 19..0
+ edwards25519.FeSquare(&t3, &t2) // 20..1
+ for i = 1; i < 20; i++ { // 39..20
+ edwards25519.FeSquare(&t3, &t3)
+ }
+ edwards25519.FeMul(&t2, &t3, &t2) // 39..0
+ edwards25519.FeSquare(&t2, &t2) // 40..1
+ for i = 1; i < 10; i++ { // 49..10
+ edwards25519.FeSquare(&t2, &t2)
+ }
+ edwards25519.FeMul(&t1, &t2, &t1) // 49..0
+ edwards25519.FeSquare(&t2, &t1) // 50..1
+ for i = 1; i < 50; i++ { // 99..50
+ edwards25519.FeSquare(&t2, &t2)
+ }
+ edwards25519.FeMul(&t2, &t2, &t1) // 99..0
+ edwards25519.FeSquare(&t3, &t2) // 100..1
+ for i = 1; i < 100; i++ { // 199..100
+ edwards25519.FeSquare(&t3, &t3)
+ }
+ edwards25519.FeMul(&t2, &t3, &t2) // 199..0
+ edwards25519.FeSquare(&t2, &t2) // 200..1
+ for i = 1; i < 50; i++ { // 249..50
+ edwards25519.FeSquare(&t2, &t2)
+ }
+ edwards25519.FeMul(&t1, &t2, &t1) // 249..0
+ edwards25519.FeSquare(&t1, &t1) // 250..1
+ edwards25519.FeSquare(&t1, &t1) // 251..2
+ edwards25519.FeMul(out, &t1, z) // 251..2,0
+}
+
+// chi calculates out = z^((p-1)/2). The result is either 1, 0, or -1 depending
+// on whether z is a non-zero square, zero, or a non-square.
+func chi(out, z *edwards25519.FieldElement) {
+ var t0, t1, t2, t3 edwards25519.FieldElement
+ var i int
+
+ edwards25519.FeSquare(&t0, z) // 2^1
+ edwards25519.FeMul(&t1, &t0, z) // 2^1 + 2^0
+ edwards25519.FeSquare(&t0, &t1) // 2^2 + 2^1
+ edwards25519.FeSquare(&t2, &t0) // 2^3 + 2^2
+ edwards25519.FeSquare(&t2, &t2) // 4,3
+ edwards25519.FeMul(&t2, &t2, &t0) // 4,3,2,1
+ edwards25519.FeMul(&t1, &t2, z) // 4..0
+ edwards25519.FeSquare(&t2, &t1) // 5..1
+ for i = 1; i < 5; i++ { // 9,8,7,6,5
+ edwards25519.FeSquare(&t2, &t2)
+ }
+ edwards25519.FeMul(&t1, &t2, &t1) // 9,8,7,6,5,4,3,2,1,0
+ edwards25519.FeSquare(&t2, &t1) // 10..1
+ for i = 1; i < 10; i++ { // 19..10
+ edwards25519.FeSquare(&t2, &t2)
+ }
+ edwards25519.FeMul(&t2, &t2, &t1) // 19..0
+ edwards25519.FeSquare(&t3, &t2) // 20..1
+ for i = 1; i < 20; i++ { // 39..20
+ edwards25519.FeSquare(&t3, &t3)
+ }
+ edwards25519.FeMul(&t2, &t3, &t2) // 39..0
+ edwards25519.FeSquare(&t2, &t2) // 40..1
+ for i = 1; i < 10; i++ { // 49..10
+ edwards25519.FeSquare(&t2, &t2)
+ }
+ edwards25519.FeMul(&t1, &t2, &t1) // 49..0
+ edwards25519.FeSquare(&t2, &t1) // 50..1
+ for i = 1; i < 50; i++ { // 99..50
+ edwards25519.FeSquare(&t2, &t2)
+ }
+ edwards25519.FeMul(&t2, &t2, &t1) // 99..0
+ edwards25519.FeSquare(&t3, &t2) // 100..1
+ for i = 1; i < 100; i++ { // 199..100
+ edwards25519.FeSquare(&t3, &t3)
+ }
+ edwards25519.FeMul(&t2, &t3, &t2) // 199..0
+ edwards25519.FeSquare(&t2, &t2) // 200..1
+ for i = 1; i < 50; i++ { // 249..50
+ edwards25519.FeSquare(&t2, &t2)
+ }
+ edwards25519.FeMul(&t1, &t2, &t1) // 249..0
+ edwards25519.FeSquare(&t1, &t1) // 250..1
+ for i = 1; i < 4; i++ { // 253..4
+ edwards25519.FeSquare(&t1, &t1)
+ }
+ edwards25519.FeMul(out, &t1, &t0) // 253..4,2,1
+}
+
+// RepresentativeToPublicKey converts a uniform representative value for a
+// curve25519 public key, as produced by ScalarBaseMult, to a curve25519 public
+// key.
+func RepresentativeToPublicKey(publicKey, representative *[32]byte) {
+ var rr2, v, e edwards25519.FieldElement
+ edwards25519.FeFromBytes(&rr2, representative)
+
+ edwards25519.FeSquare2(&rr2, &rr2)
+ rr2[0]++
+ edwards25519.FeInvert(&rr2, &rr2)
+ edwards25519.FeMul(&v, &edwards25519.A, &rr2)
+ edwards25519.FeNeg(&v, &v)
+
+ var v2, v3 edwards25519.FieldElement
+ edwards25519.FeSquare(&v2, &v)
+ edwards25519.FeMul(&v3, &v, &v2)
+ edwards25519.FeAdd(&e, &v3, &v)
+ edwards25519.FeMul(&v2, &v2, &edwards25519.A)
+ edwards25519.FeAdd(&e, &v2, &e)
+ chi(&e, &e)
+ var eBytes [32]byte
+ edwards25519.FeToBytes(&eBytes, &e)
+ // eBytes[1] is either 0 (for e = 1) or 0xff (for e = -1)
+ eIsMinus1 := int32(eBytes[1]) & 1
+ var negV edwards25519.FieldElement
+ edwards25519.FeNeg(&negV, &v)
+ edwards25519.FeCMove(&v, &negV, eIsMinus1)
+
+ edwards25519.FeZero(&v2)
+ edwards25519.FeCMove(&v2, &edwards25519.A, eIsMinus1)
+ edwards25519.FeSub(&v, &v, &v2)
+
+ edwards25519.FeToBytes(publicKey, &v)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/ed25519/extra25519/extra25519_test.go b/Godeps/_workspace/src/github.com/tendermint/ed25519/extra25519/extra25519_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..1e1dbdc0ae48a27cd7a7f6e094c980554205bcba
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/ed25519/extra25519/extra25519_test.go
@@ -0,0 +1,78 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package extra25519
+
+import (
+ "bytes"
+ "crypto/rand"
+ "testing"
+
+ "code.google.com/p/go.crypto/curve25519"
+ "github.com/agl/ed25519"
+)
+
+func TestCurve25519Conversion(t *testing.T) {
+ public, private, _ := ed25519.GenerateKey(rand.Reader)
+
+ var curve25519Public, curve25519Public2, curve25519Private [32]byte
+ PrivateKeyToCurve25519(&curve25519Private, private)
+ curve25519.ScalarBaseMult(&curve25519Public, &curve25519Private)
+
+ if !PublicKeyToCurve25519(&curve25519Public2, public) {
+ t.Fatalf("PublicKeyToCurve25519 failed")
+ }
+
+ if !bytes.Equal(curve25519Public[:], curve25519Public2[:]) {
+ t.Errorf("Values didn't match: curve25519 produced %x, conversion produced %x", curve25519Public[:], curve25519Public2[:])
+ }
+}
+
+func TestElligator(t *testing.T) {
+ var publicKey, publicKey2, publicKey3, representative, privateKey [32]byte
+
+ for i := 0; i < 1000; i++ {
+ rand.Reader.Read(privateKey[:])
+
+ if !ScalarBaseMult(&publicKey, &representative, &privateKey) {
+ continue
+ }
+ RepresentativeToPublicKey(&publicKey2, &representative)
+ if !bytes.Equal(publicKey[:], publicKey2[:]) {
+ t.Fatal("The resulting public key doesn't match the initial one.")
+ }
+
+ curve25519.ScalarBaseMult(&publicKey3, &privateKey)
+ if !bytes.Equal(publicKey[:], publicKey3[:]) {
+ t.Fatal("The public key doesn't match the value that curve25519 produced.")
+ }
+ }
+}
+
+func BenchmarkKeyGeneration(b *testing.B) {
+ var publicKey, representative, privateKey [32]byte
+
+ // Find the private key that results in a point that's in the image of the map.
+ for {
+ rand.Reader.Read(privateKey[:])
+ if ScalarBaseMult(&publicKey, &representative, &privateKey) {
+ break
+ }
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ ScalarBaseMult(&publicKey, &representative, &privateKey);
+ }
+}
+
+func BenchmarkMap(b *testing.B) {
+ var publicKey, representative [32]byte
+ rand.Reader.Read(representative[:])
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ RepresentativeToPublicKey(&publicKey, &representative);
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/ed25519/testdata/sign.input.gz b/Godeps/_workspace/src/github.com/tendermint/ed25519/testdata/sign.input.gz
new file mode 100644
index 0000000000000000000000000000000000000000..41030690c0db39a0279304a46f002a625caa9080
Binary files /dev/null and b/Godeps/_workspace/src/github.com/tendermint/ed25519/testdata/sign.input.gz differ
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/.travis.yml b/Godeps/_workspace/src/github.com/tendermint/log15/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..a66c49b9c1f534a608f6c0e41d0d94fa93f526f5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/.travis.yml
@@ -0,0 +1,9 @@
+language: go
+
+go:
+ - 1.0
+ - 1.1
+ - 1.2
+ - 1.3
+ - release
+ - tip
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/CONTRIBUTORS b/Godeps/_workspace/src/github.com/tendermint/log15/CONTRIBUTORS
new file mode 100644
index 0000000000000000000000000000000000000000..a0866713be09a01e96c2597c6158f96135000fbb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/CONTRIBUTORS
@@ -0,0 +1,11 @@
+Contributors to log15:
+
+- Aaron L
+- Alan Shreve
+- Chris Hines
+- Ciaran Downey
+- Dmitry Chestnykh
+- Evan Shaw
+- Péter Szilágyi
+- Trevor Gattis
+- Vincent Vanackere
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/LICENSE b/Godeps/_workspace/src/github.com/tendermint/log15/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..5f0d1fb6a7bbfdb5f1af9c717888e59a0d146e26
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/LICENSE
@@ -0,0 +1,13 @@
+Copyright 2014 Alan Shreve
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/README.md b/Godeps/_workspace/src/github.com/tendermint/log15/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..49313fffafd1e80a9a2b0608f2c50b34d317590c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/README.md
@@ -0,0 +1,60 @@
+
+
+# log15 [](https://godoc.org/gopkg.in/inconshreveable/log15.v2)
+
+Package log15 provides an opinionated, simple toolkit for best-practice logging in Go (golang) that is both human and machine readable. It is modeled after the Go standard library's [`io`](http://golang.org/pkg/io/) and [`net/http`](http://golang.org/pkg/net/http/) packages and is an alternative to the standard library's [`log`](http://golang.org/pkg/log/) package.
+
+## Features
+- A simple, easy-to-understand API
+- Promotes structured logging by encouraging use of key/value pairs
+- Child loggers which inherit and add their own private context
+- Lazy evaluation of expensive operations
+- Simple Handler interface allowing for construction of flexible, custom logging configurations with a tiny API.
+- Color terminal support
+- Built-in support for logging to files, streams, syslog, and the network
+- Support for forking records to multiple handlers, buffering records for output, failing over from failed handler writes, + more
+
+## Versioning
+The API of the master branch of log15 should always be considered unstable. Using a stable version
+of the log15 package is supported by gopkg.in. Include your dependency like so:
+
+```go
+import log "gopkg.in/inconshreveable/log15.v2"
+```
+
+## Examples
+
+```go
+// all loggers can have key/value context
+srvlog := log.New("module", "app/server")
+
+// all log messages can have key/value context
+srvlog.Warn("abnormal conn rate", "rate", curRate, "low", lowRate, "high", highRate)
+
+// child loggers with inherited context
+connlog := srvlog.New("raddr", c.RemoteAddr())
+connlog.Info("connection open")
+
+// lazy evaluation
+connlog.Debug("ping remote", "latency", log.Lazy(pingRemote))
+
+// flexible configuration
+srvlog.SetHandler(log.MultiHandler(
+ log.StreamHandler(os.Stderr, log.LogfmtFormat()),
+ log.LvlFilterHandler(
+ log.LvlError,
+ log.Must.FileHandler("errors.json", log.JsonHandler())))
+```
+
+## FAQ
+
+### The varargs style is brittle and error prone! Can I have type safety please?
+Yes. Use `log.Ctx`:
+
+```go
+srvlog := log.New(log.Ctx{"module": "app/server"})
+srvlog.Warn("abnormal conn rate", log.Ctx{"rate": curRate, "low": lowRate, "high": highRate})
+```
+
+## License
+Apache
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/RELEASING.md b/Godeps/_workspace/src/github.com/tendermint/log15/RELEASING.md
new file mode 100644
index 0000000000000000000000000000000000000000..589a4dcc618100363edc8f528d8d4a19b3d62f13
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/RELEASING.md
@@ -0,0 +1,19 @@
+# log15's release strategy
+
+log15 uses gopkg.in to manage versioning releases so that consumers who don't vendor dependencies can rely upon a stable API.
+
+## Master
+
+Master is considered to have no API stability guarantee, so merging new code that passes tests into master is always okay.
+
+## Releasing a new API-compatible version
+
+The process to release a new API-compatible version is described below. For the purposes of this example, we'll assume you're trying to release a new version of v2
+
+1. `git checkout v2`
+1. `git merge master`
+1. Audit the code for any imports of sub-packages. Modify any import references from `github.com/inconshrevealbe/log15/<pkg>` -> `gopkg.in/inconshreveable/log15.v2/<pkg>`
+1. `git commit`
+1. `git tag`, find the latest tag of the style v2.X.
+1. `git tag v2.X+1` If the last version was v2.6, you would run `git tag v2.7`
+1. `git push --tags git@github.com:inconshreveable/log15.git v2`
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/bench_test.go b/Godeps/_workspace/src/github.com/tendermint/log15/bench_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..e692e6193916328a8593e42064c380b2dbf3fc5d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/bench_test.go
@@ -0,0 +1,129 @@
+package log15
+
+import (
+ "bytes"
+ "testing"
+ "time"
+)
+
+func BenchmarkStreamNoCtx(b *testing.B) {
+ lg := New()
+
+ buf := bytes.Buffer{}
+ lg.SetHandler(StreamHandler(&buf, LogfmtFormat()))
+
+ for i := 0; i < b.N; i++ {
+ lg.Info("test message")
+ buf.Reset()
+ }
+}
+
+func BenchmarkDiscard(b *testing.B) {
+ lg := New()
+ lg.SetHandler(DiscardHandler())
+
+ for i := 0; i < b.N; i++ {
+ lg.Info("test message")
+ }
+}
+
+func BenchmarkCallerFileHandler(b *testing.B) {
+ lg := New()
+ lg.SetHandler(CallerFileHandler(DiscardHandler()))
+
+ for i := 0; i < b.N; i++ {
+ lg.Info("test message")
+ }
+}
+
+func BenchmarkCallerFuncHandler(b *testing.B) {
+ lg := New()
+ lg.SetHandler(CallerFuncHandler(DiscardHandler()))
+
+ for i := 0; i < b.N; i++ {
+ lg.Info("test message")
+ }
+}
+
+func BenchmarkLogfmtNoCtx(b *testing.B) {
+ r := Record{
+ Time: time.Now(),
+ Lvl: LvlInfo,
+ Msg: "test message",
+ Ctx: []interface{}{},
+ }
+
+ logfmt := LogfmtFormat()
+ for i := 0; i < b.N; i++ {
+ logfmt.Format(&r)
+ }
+}
+
+func BenchmarkJsonNoCtx(b *testing.B) {
+ r := Record{
+ Time: time.Now(),
+ Lvl: LvlInfo,
+ Msg: "test message",
+ Ctx: []interface{}{},
+ }
+
+ jsonfmt := JsonFormat()
+ for i := 0; i < b.N; i++ {
+ jsonfmt.Format(&r)
+ }
+}
+
+func BenchmarkMultiLevelFilter(b *testing.B) {
+ handler := MultiHandler(
+ LvlFilterHandler(LvlDebug, DiscardHandler()),
+ LvlFilterHandler(LvlError, DiscardHandler()),
+ )
+
+ lg := New()
+ lg.SetHandler(handler)
+ for i := 0; i < b.N; i++ {
+ lg.Info("test message")
+ }
+}
+
+func BenchmarkDescendant1(b *testing.B) {
+ lg := New()
+ lg.SetHandler(DiscardHandler())
+ lg = lg.New()
+ for i := 0; i < b.N; i++ {
+ lg.Info("test message")
+ }
+}
+
+func BenchmarkDescendant2(b *testing.B) {
+ lg := New()
+ lg.SetHandler(DiscardHandler())
+ for i := 0; i < 2; i++ {
+ lg = lg.New()
+ }
+ for i := 0; i < b.N; i++ {
+ lg.Info("test message")
+ }
+}
+
+func BenchmarkDescendant4(b *testing.B) {
+ lg := New()
+ lg.SetHandler(DiscardHandler())
+ for i := 0; i < 4; i++ {
+ lg = lg.New()
+ }
+ for i := 0; i < b.N; i++ {
+ lg.Info("test message")
+ }
+}
+
+func BenchmarkDescendant8(b *testing.B) {
+ lg := New()
+ lg.SetHandler(DiscardHandler())
+ for i := 0; i < 8; i++ {
+ lg = lg.New()
+ }
+ for i := 0; i < b.N; i++ {
+ lg.Info("test message")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/doc.go b/Godeps/_workspace/src/github.com/tendermint/log15/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..e60af69be90b4f9c37a8876a51cb133dfa59f5b2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/doc.go
@@ -0,0 +1,302 @@
+/*
+Package log15 provides an opinionated, simple toolkit for best-practice logging that is
+both human and machine readable. It is modeled after the standard library's io and net/http
+packages.
+
+This package enforces you to only log key/value pairs. Keys must be strings. Values may be
+any type that you like. The default output format is logfmt, but you may also choose to use
+JSON instead if that suits you. Here's how you log:
+
+ log.Info("page accessed", "path", r.URL.Path, "user_id", user.id)
+
+This will output a line that looks like:
+
+ lvl=info t=2014-05-02T16:07:23-0700 msg="page access" path=/org/71/profile user_id=9
+
+Getting Started
+
+To get started, you'll want to import the library:
+
+ import log "gopkg.in/inconshreveable/log15.v2"
+
+
+Now you're ready to start logging:
+
+ func main() {
+ log.Info("Program starting", "args", os.Args())
+ }
+
+
+Convention
+
+Because recording a human-meaningful message is common and good practice, the first argument to every
+logging method is the value to the *implicit* key 'msg'.
+
+Additionally, the level you choose for a message will be automatically added with the key 'lvl', and so
+will the current timestamp with key 't'.
+
+You may supply any additional context as a set of key/value pairs to the logging function. log15 allows
+you to favor terseness, ordering, and speed over safety. This is a reasonable tradeoff for
+logging functions. You don't need to explicitly state keys/values, log15 understands that they alternate
+in the variadic argument list:
+
+ log.Warn("size out of bounds", "low", lowBound, "high", highBound, "val", val)
+
+If you really do favor your type-safety, you may choose to pass a log.Ctx instead:
+
+ log.Warn("size out of bounds", log.Ctx{"low": lowBound, "high": highBound, "val": val})
+
+
+Context loggers
+
+Frequently, you want to add context to a logger so that you can track actions associated with it. An http
+request is a good example. You can easily create new loggers that have context that is automatically included
+with each log line:
+
+ requestlogger := log.New("path", r.URL.Path)
+
+ // later
+ requestlogger.Debug("db txn commit", "duration", txnTimer.Finish())
+
+This will output a log line that includes the path context that is attached to the logger:
+
+ lvl=dbug t=2014-05-02T16:07:23-0700 path=/repo/12/add_hook msg="db txn commit" duration=0.12
+
+
+Handlers
+
+The Handler interface defines where log lines are printed to and how they are formated. Handler is a
+single interface that is inspired by net/http's handler interface:
+
+ type Handler interface {
+ Log(r *Record)
+ }
+
+
+Handlers can filter records, format them, or dispatch to multiple other Handlers.
+This package implements a number of Handlers for common logging patterns that are
+can be easily composed to create flexible, custom logging structures.
+
+Here's an example handler that prints logfmt output to Stdout:
+
+ handler := log.StreamHandler(os.Stdout, log.LogfmtFormat())
+
+Here's an example handler that defers to two other handlers. One handler only prints records
+from the rpc package in logfmt to standard out. The other prints records at Error level
+or above in JSON formatted output to the file /var/log/service.json
+
+ handler := log.MultiHandler(
+ log.LvlFilterHandler(log.LvlError, log.Must.FileHandler("/var/log/service.json", log.JsonFormat())),
+ log.MatchFilterHandler("pkg", "app/rpc" log.StdoutHandler())
+ )
+
+Custom Handlers
+
+The Handler interface is so simple that it's also trivial to write your own. Let's create an
+example handler which tries to write to one handler, but if that fails it falls back to
+writing to another handler and includes the error that it encountered when trying to write
+to the primary. This might be useful when trying to log over a network socket, but if that
+fails you want to log those records to a file on disk.
+
+ type BackupHandler struct {
+ Primary Handler
+ Secondary Handler
+ }
+
+ func (h *BackupHandler) Log (r *Record) error {
+ err := h.Primary.Log(r)
+ if err != nil {
+ r.Ctx = append(ctx, "primary_err", err)
+ return h.Secondary.Log(r)
+ }
+ return nil
+ }
+
+This pattern is so useful that a generic version that handles an arbitrary number of Handlers
+is included as part of this library called FailoverHandler.
+
+Logging Expensive Operations
+
+Sometimes, you want to log values that are extremely expensive to compute, but you don't want to pay
+the price of computing them if you haven't turned up your logging level to a high level of detail.
+
+This package provides a simple type to annotate a logging operation that you want to be evaluated
+lazily, just when it is about to be logged, so that it would not be evaluated if an upstream Handler
+filters it out. Just wrap any function which takes no arguments with the log.Lazy type. For example:
+
+ func factorRSAKey() (factors []int) {
+ // return the factors of a very large number
+ }
+
+ log.Debug("factors", log.Lazy{factorRSAKey})
+
+If this message is not logged for any reason (like logging at the Error level), then
+factorRSAKey is never evaluated.
+
+Dynamic context values
+
+The same log.Lazy mechanism can be used to attach context to a logger which you want to be
+evaluated when the message is logged, but not when the logger is created. For example, let's imagine
+a game where you have Player objects:
+
+ type Player struct {
+ name string
+ alive bool
+ log.Logger
+ }
+
+You always want to log a player's name and whether they're alive or dead, so when you create the player
+object, you might do:
+
+ p := &Player{name: name, alive: true}
+ p.Logger = log.New("name", p.name, "alive", p.alive)
+
+Only now, even after a player has died, the logger will still report they are alive because the logging
+context is evaluated when the logger was created. By using the Lazy wrapper, we can defer the evaluation
+of whether the player is alive or not to each log message, so that the log records will reflect the player's
+current state no matter when the log message is written:
+
+ p := &Player{name: name, alive: true}
+ isAlive := func() bool { return p.alive }
+ player.Logger = log.New("name", p.name, "alive", log.Lazy{isAlive})
+
+Terminal Format
+
+If log15 detects that stdout is a terminal, it will configure the default
+handler for it (which is log.StdoutHandler) to use TerminalFormat. This format
+logs records nicely for your terminal, including color-coded output based
+on log level.
+
+Error Handling
+
+Becasuse log15 allows you to step around the type system, there are a few ways you can specify
+invalid arguments to the logging functions. You could, for example, wrap something that is not
+a zero-argument function with log.Lazy or pass a context key that is not a string. Since logging libraries
+are typically the mechanism by which errors are reported, it would be onerous for the logging functions
+to return errors. Instead, log15 handles errors by making these guarantees to you:
+
+- Any log record containing an error will still be printed with the error explained to you as part of the log record.
+
+- Any log record containing an error will include the context key LOG15_ERROR, enabling you to easily
+(and if you like, automatically) detect if any of your logging calls are passing bad values.
+
+Understanding this, you might wonder why the Handler interface can return an error value in its Log method. Handlers
+are encouraged to return errors only if they fail to write their log records out to an external source like if the
+syslog daemon is not responding. This allows the construction of useful handlers which cope with those failures
+like the FailoverHandler.
+
+Library Use
+
+log15 is intended to be useful for library authors as a way to provide configurable logging to
+users of their library. Best practice for use in a library is to always disable all output for your logger
+by default and to provide a public Logger instance that consumers of your library can configure. Like so:
+
+ package yourlib
+
+ import "gopkg.in/inconshreveable/log15.v2"
+
+ var Log = log.New()
+
+ func init() {
+ Log.SetHandler(log.DiscardHandler())
+ }
+
+Users of your library may then enable it if they like:
+
+ import "gopkg.in/inconshreveable/log15.v2"
+ import "example.com/yourlib"
+
+ func main() {
+ handler := // custom handler setup
+ yourlib.Log.SetHandler(handler)
+ }
+
+Best practices attaching logger context
+
+The ability to attach context to a logger is a powerful one. Where should you do it and why?
+I favor embedding a Logger directly into any persistent object in my application and adding
+unique, tracing context keys to it. For instance, imagine I am writing a web browser:
+
+ type Tab struct {
+ url string
+ render *RenderingContext
+ // ...
+
+ Logger
+ }
+
+ func NewTab(url string) *Tab {
+ return &Tab {
+ // ...
+ url: url,
+
+ Logger: log.New("url", url),
+ }
+ }
+
+When a new tab is created, I assign a logger to it with the url of
+the tab as context so it can easily be traced through the logs.
+Now, whenever we perform any operation with the tab, we'll log with its
+embedded logger and it will include the tab title automatically:
+
+ tab.Debug("moved position", "idx", tab.idx)
+
+There's only one problem. What if the tab url changes? We could
+use log.Lazy to make sure the current url is always written, but that
+would mean that we couldn't trace a tab's full lifetime through our
+logs after the user navigate to a new URL.
+
+Instead, think about what values to attach to your loggers the
+same way you think about what to use as a key in a SQL database schema.
+If it's possible to use a natural key that is unique for the lifetime of the
+object, do so. But otherwise, log15's ext package has a handy RandId
+function to let you generate what you might call "surrogate keys"
+They're just random hex identifiers to use for tracing. Back to our
+Tab example, we would prefer to set up our Logger like so:
+
+ import logext "gopkg.in/inconshreveable/log15.v2/ext"
+
+ t := &Tab {
+ // ...
+ url: url,
+ }
+
+ t.Logger = log.New("id", logext.RandId(8), "url", log.Lazy{t.getUrl})
+ return t
+
+Now we'll have a unique traceable identifier even across loading new urls, but
+we'll still be able to see the tab's current url in the log messages.
+
+Must
+
+For all Handler functions which can return an error, there is a version of that
+function which will return no error but panics on failure. They are all available
+on the Must object. For example:
+
+ log.Must.FileHandler("/path", log.JsonFormat)
+ log.Must.NetHandler("tcp", ":1234", log.JsonFormat)
+
+Inspiration and Credit
+
+All of the following excellent projects inspired the design of this library:
+
+code.google.com/p/log4go
+
+github.com/op/go-logging
+
+github.com/technoweenie/grohl
+
+github.com/Sirupsen/logrus
+
+github.com/kr/logfmt
+
+github.com/spacemonkeygo/spacelog
+
+golang's stdlib, notably io and net/http
+
+The Name
+
+https://xkcd.com/927/
+
+*/
+package log15
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/ext/ext_test.go b/Godeps/_workspace/src/github.com/tendermint/log15/ext/ext_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..be276b32fd128847faf7d793d044d52478161280
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/ext/ext_test.go
@@ -0,0 +1,109 @@
+package ext
+
+import (
+ "errors"
+ log "github.com/inconshreveable/log15"
+ "math"
+ "testing"
+)
+
+func testHandler() (log.Handler, *log.Record) {
+ rec := new(log.Record)
+ return log.FuncHandler(func(r *log.Record) error {
+ *rec = *r
+ return nil
+ }), rec
+}
+
+func TestHotSwapHandler(t *testing.T) {
+ t.Parallel()
+
+ h1, r1 := testHandler()
+
+ l := log.New()
+ h := HotSwapHandler(h1)
+ l.SetHandler(h)
+
+ l.Info("to h1")
+ if r1.Msg != "to h1" {
+ t.Fatalf("didn't get expected message to h1")
+ }
+
+ h2, r2 := testHandler()
+ h.Swap(h2)
+ l.Info("to h2")
+ if r2.Msg != "to h2" {
+ t.Fatalf("didn't get expected message to h2")
+ }
+}
+
+func TestSpeculativeHandler(t *testing.T) {
+ t.Parallel()
+
+ // test with an even multiple of the buffer size, less than full buffer size
+ // and not a multiple of the buffer size
+ for _, count := range []int{10000, 50, 432} {
+ recs := make(chan *log.Record)
+ done := make(chan int)
+ spec := SpeculativeHandler(100, log.ChannelHandler(recs))
+
+ go func() {
+ defer close(done)
+ expectedCount := int(math.Min(float64(count), float64(100)))
+ expectedIdx := count - expectedCount
+ for r := range recs {
+ if r.Ctx[1] != expectedIdx {
+ t.Errorf("Bad ctx 'i', got %d expected %d", r.Ctx[1], expectedIdx)
+ return
+ }
+ expectedIdx++
+ expectedCount--
+
+ if expectedCount == 0 {
+ // got everything we expected
+ break
+ }
+ }
+
+ select {
+ case <-recs:
+ t.Errorf("got an extra record we shouldn't have!")
+ default:
+ }
+ }()
+
+ lg := log.New()
+ lg.SetHandler(spec)
+ for i := 0; i < count; i++ {
+ lg.Debug("test speculative", "i", i)
+ }
+
+ go spec.Flush()
+
+ // wait for the go routine to finish
+ <-done
+ }
+}
+
+func TestErrorHandler(t *testing.T) {
+ t.Parallel()
+
+ h, r := testHandler()
+ lg := log.New()
+ lg.SetHandler(EscalateErrHandler(
+ log.LvlFilterHandler(log.LvlError, h)))
+
+ lg.Debug("some function result", "err", nil)
+ if r.Msg != "" {
+ t.Fatalf("Expected debug level message to be filtered")
+ }
+
+ lg.Debug("some function result", "err", errors.New("failed operation"))
+ if r.Msg != "some function result" {
+ t.Fatalf("Expected debug level message to be escalated and pass lvlfilter")
+ }
+
+ if r.Lvl != log.LvlError {
+ t.Fatalf("Expected debug level message to be escalated to LvlError")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/ext/handler.go b/Godeps/_workspace/src/github.com/tendermint/log15/ext/handler.go
new file mode 100644
index 0000000000000000000000000000000000000000..e0c5a9ed165e82b51f291f36e1369bbd7baee0b2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/ext/handler.go
@@ -0,0 +1,116 @@
+package ext
+
+import (
+ "sync"
+ "sync/atomic"
+ "unsafe"
+
+ log "github.com/inconshreveable/log15"
+)
+
+// EscalateErrHandler wraps another handler and passes all records through
+// unchanged except if the logged context contains a non-nil error
+// value in its context. In that case, the record's level is raised
+// to LvlError unless it was already more serious (LvlCrit).
+//
+// This allows you to log the result of all functions for debugging
+// and still capture error conditions when in production with a single
+// log line. As an example, the following the log record will be written
+// out only if there was an error writing a value to redis:
+//
+// logger := logext.EscalateErrHandler(
+// log.LvlFilterHandler(log.LvlInfo, log.StdoutHandler))
+//
+// reply, err := redisConn.Do("SET", "foo", "bar")
+// logger.Debug("Wrote value to redis", "reply", reply, "err", err)
+// if err != nil {
+// return err
+// }
+//
+func EscalateErrHandler(h log.Handler) log.Handler {
+ return log.FuncHandler(func(r *log.Record) error {
+ if r.Lvl > log.LvlError {
+ for i := 1; i < len(r.Ctx); i++ {
+ if v, ok := r.Ctx[i].(error); ok && v != nil {
+ r.Lvl = log.LvlError
+ break
+ }
+ }
+ }
+ return h.Log(r)
+ })
+}
+
+// SpeculativeHandler is a handler for speculative logging. It
+// keeps a ring buffer of the given size full of the last events
+// logged into it. When Flush is called, all buffered log records
+// are written to the wrapped handler. This is extremely for
+// continuosly capturing debug level output, but only flushing those
+// log records if an exceptional condition is encountered.
+func SpeculativeHandler(size int, h log.Handler) *Speculative {
+ return &Speculative{
+ handler: h,
+ recs: make([]*log.Record, size),
+ }
+}
+
+type Speculative struct {
+ mu sync.Mutex
+ idx int
+ recs []*log.Record
+ handler log.Handler
+ full bool
+}
+
+func (h *Speculative) Log(r *log.Record) error {
+ h.mu.Lock()
+ defer h.mu.Unlock()
+ h.recs[h.idx] = r
+ h.idx = (h.idx + 1) % len(h.recs)
+ h.full = h.full || h.idx == 0
+ return nil
+}
+
+func (h *Speculative) Flush() {
+ recs := make([]*log.Record, 0)
+ func() {
+ h.mu.Lock()
+ defer h.mu.Unlock()
+ if h.full {
+ recs = append(recs, h.recs[h.idx:]...)
+ }
+ recs = append(recs, h.recs[:h.idx]...)
+
+ // reset state
+ h.full = false
+ h.idx = 0
+ }()
+
+ // don't hold the lock while we flush to the wrapped handler
+ for _, r := range recs {
+ h.handler.Log(r)
+ }
+}
+
+// HotSwapHandler wraps another handler that may swapped out
+// dynamically at runtime in a thread-safe fashion.
+// HotSwapHandler is the same functionality
+// used to implement the SetHandler method for the default
+// implementation of Logger.
+func HotSwapHandler(h log.Handler) *HotSwap {
+ hs := new(HotSwap)
+ hs.Swap(h)
+ return hs
+}
+
+type HotSwap struct {
+ handler unsafe.Pointer
+}
+
+func (h *HotSwap) Log(r *log.Record) error {
+ return (*(*log.Handler)(atomic.LoadPointer(&h.handler))).Log(r)
+}
+
+func (h *HotSwap) Swap(newHandler log.Handler) {
+ atomic.StorePointer(&h.handler, unsafe.Pointer(&newHandler))
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/ext/id.go b/Godeps/_workspace/src/github.com/tendermint/log15/ext/id.go
new file mode 100644
index 0000000000000000000000000000000000000000..0bfb1551f3a2d9d1c7d6d007f3a6ef637a22be3d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/ext/id.go
@@ -0,0 +1,47 @@
+package ext
+
+import (
+ "fmt"
+ "math/rand"
+ "sync"
+ "time"
+)
+
+var r = rand.New(&lockedSource{src: rand.NewSource(time.Now().Unix())})
+
+// RandId creates a random identifier of the requested length.
+// Useful for assigning mostly-unique identifiers for logging
+// and identification that are unlikely to collide because of
+// short lifespan or low set cardinality
+func RandId(idlen int) string {
+ b := make([]byte, idlen)
+ var randVal uint32
+ for i := 0; i < idlen; i++ {
+ byteIdx := i % 4
+ if byteIdx == 0 {
+ randVal = r.Uint32()
+ }
+ b[i] = byte((randVal >> (8 * uint(byteIdx))) & 0xFF)
+ }
+ return fmt.Sprintf("%x", b)
+}
+
+// lockedSource is a wrapper to allow a rand.Source to be used
+// concurrently (same type as the one used internally in math/rand).
+type lockedSource struct {
+ lk sync.Mutex
+ src rand.Source
+}
+
+func (r *lockedSource) Int63() (n int64) {
+ r.lk.Lock()
+ n = r.src.Int63()
+ r.lk.Unlock()
+ return
+}
+
+func (r *lockedSource) Seed(seed int64) {
+ r.lk.Lock()
+ r.src.Seed(seed)
+ r.lk.Unlock()
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/format.go b/Godeps/_workspace/src/github.com/tendermint/log15/format.go
new file mode 100644
index 0000000000000000000000000000000000000000..6ea8c81b727edd0d076937fe9f64185422d728cf
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/format.go
@@ -0,0 +1,250 @@
+package log15
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "strconv"
+ "strings"
+ "time"
+)
+
+const (
+ timeFormat = "2006-01-02T15:04:05-0700"
+ termTimeFormat = "01-02|15:04:05"
+ floatFormat = 'f'
+ termMsgJust = 40
+)
+
+type Format interface {
+ Format(r *Record) []byte
+}
+
+// FormatFunc returns a new Format object which uses
+// the given function to perform record formatting.
+func FormatFunc(f func(*Record) []byte) Format {
+ return formatFunc(f)
+}
+
+type formatFunc func(*Record) []byte
+
+func (f formatFunc) Format(r *Record) []byte {
+ return f(r)
+}
+
+// TerminalFormat formats log records optimized for human readability on
+// a terminal with color-coded level output and terser human friendly timestamp.
+// This format should only be used for interactive programs or while developing.
+//
+// [TIME] [LEVEL] MESAGE key=value key=value ...
+//
+// Example:
+//
+// [May 16 20:58:45] [DBUG] remove route ns=haproxy addr=127.0.0.1:50002
+//
+func TerminalFormat() Format {
+ return FormatFunc(func(r *Record) []byte {
+ var color = 0
+ switch r.Lvl {
+ case LvlCrit:
+ color = 35
+ case LvlError:
+ color = 31
+ case LvlWarn:
+ color = 33
+ case LvlInfo:
+ color = 32
+ case LvlDebug:
+ color = 36
+ }
+
+ b := &bytes.Buffer{}
+ lvl := strings.ToUpper(r.Lvl.String())
+ if color > 0 {
+ fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%s] %s ", color, lvl, r.Time.Format(termTimeFormat), r.Msg)
+ } else {
+ fmt.Fprintf(b, "[%s] [%s] %s ", lvl, r.Time.Format(termTimeFormat), r.Msg)
+ }
+
+ // try to justify the log output for short messages
+ if len(r.Ctx) > 0 && len(r.Msg) < termMsgJust {
+ b.Write(bytes.Repeat([]byte{' '}, termMsgJust-len(r.Msg)))
+ }
+
+ // print the keys logfmt style
+ logfmt(b, r.Ctx, color)
+ return b.Bytes()
+ })
+}
+
+// LogfmtFormat prints records in logfmt format, an easy machine-parseable but human-readable
+// format for key/value pairs.
+//
+// For more details see: http://godoc.org/github.com/kr/logfmt
+//
+func LogfmtFormat() Format {
+ return FormatFunc(func(r *Record) []byte {
+ common := []interface{}{r.KeyNames.Time, r.Time, r.KeyNames.Lvl, r.Lvl, r.KeyNames.Msg, r.Msg}
+ buf := &bytes.Buffer{}
+ logfmt(buf, append(common, r.Ctx...), 0)
+ return buf.Bytes()
+ })
+}
+
+func logfmt(buf *bytes.Buffer, ctx []interface{}, color int) {
+ for i := 0; i < len(ctx); i += 2 {
+ if i != 0 {
+ buf.WriteByte(' ')
+ }
+
+ k, ok := ctx[i].(string)
+ v := formatLogfmtValue(ctx[i+1])
+ if !ok {
+ k, v = errorKey, formatLogfmtValue(k)
+ }
+
+ // XXX: we should probably check that all of your key bytes aren't invalid
+ if color > 0 {
+ fmt.Fprintf(buf, "\x1b[%dm%s\x1b[0m=%s", color, k, v)
+ } else {
+ fmt.Fprintf(buf, "%s=%s", k, v)
+ }
+ }
+
+ buf.WriteByte('\n')
+}
+
+// JsonFormat formats log records as JSON objects separated by newlines.
+// It is the equivalent of JsonFormatEx(false, true).
+func JsonFormat() Format {
+ return JsonFormatEx(false, true)
+}
+
+// JsonFormatEx formats log records as JSON objects. If pretty is true,
+// records will be pretty-printed. If lineSeparated is true, records
+// will be logged with a new line between each record.
+func JsonFormatEx(pretty, lineSeparated bool) Format {
+ jsonMarshal := json.Marshal
+ if pretty {
+ jsonMarshal = func(v interface{}) ([]byte, error) {
+ return json.MarshalIndent(v, "", " ")
+ }
+ }
+
+ return FormatFunc(func(r *Record) []byte {
+ props := make(map[string]interface{})
+
+ props[r.KeyNames.Time] = r.Time
+ props[r.KeyNames.Lvl] = r.Lvl
+ props[r.KeyNames.Msg] = r.Msg
+
+ for i := 0; i < len(r.Ctx); i += 2 {
+ k, ok := r.Ctx[i].(string)
+ if !ok {
+ props[errorKey] = fmt.Sprintf("%+v is not a string key", r.Ctx[i])
+ }
+ props[k] = formatJsonValue(r.Ctx[i+1])
+ }
+
+ b, err := jsonMarshal(props)
+ if err != nil {
+ b, _ = jsonMarshal(map[string]string{
+ errorKey: err.Error(),
+ })
+ return b
+ }
+
+ if lineSeparated {
+ b = append(b, '\n')
+ }
+
+ return b
+ })
+}
+
+func formatShared(value interface{}) interface{} {
+ switch v := value.(type) {
+ case time.Time:
+ return v.Format(timeFormat)
+
+ case error:
+ return v.Error()
+
+ case fmt.Stringer:
+ return v.String()
+
+ default:
+ return v
+ }
+}
+
+func formatJsonValue(value interface{}) interface{} {
+ value = formatShared(value)
+ switch value.(type) {
+ case int, int8, int16, int32, int64, float32, float64, uint, uint8, uint16, uint32, uint64, string:
+ return value
+ default:
+ return fmt.Sprintf("%+v", value)
+ }
+}
+
+// formatValue formats a value for serialization
+func formatLogfmtValue(value interface{}) string {
+ if value == nil {
+ return "nil"
+ }
+
+ value = formatShared(value)
+ switch v := value.(type) {
+ case bool:
+ return strconv.FormatBool(v)
+ case float32:
+ return strconv.FormatFloat(float64(v), floatFormat, 3, 64)
+ case float64:
+ return strconv.FormatFloat(v, floatFormat, 3, 64)
+ case int, int8, int16, int32, int64, uint, uint16, uint32, uint64:
+ return fmt.Sprintf("%d", value)
+ case string:
+ return escapeString(v)
+ case uint8:
+ return fmt.Sprintf("%X", value)
+ case []byte:
+ return fmt.Sprintf("%X", value)
+ default:
+ return escapeString(fmt.Sprintf("%+v", value))
+ }
+}
+
+func escapeString(s string) string {
+ needQuotes := false
+ e := bytes.Buffer{}
+ e.WriteByte('"')
+ for _, r := range s {
+ if r <= ' ' || r == '=' || r == '"' {
+ needQuotes = true
+ }
+
+ switch r {
+ case '\\', '"':
+ e.WriteByte('\\')
+ e.WriteByte(byte(r))
+ case '\n':
+ e.WriteByte('\\')
+ e.WriteByte('n')
+ case '\r':
+ e.WriteByte('\\')
+ e.WriteByte('r')
+ case '\t':
+ e.WriteByte('\\')
+ e.WriteByte('t')
+ default:
+ e.WriteRune(r)
+ }
+ }
+ e.WriteByte('"')
+ start, stop := 0, e.Len()
+ if !needQuotes {
+ start, stop = 1, stop-1
+ }
+ return string(e.Bytes()[start:stop])
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/handler.go b/Godeps/_workspace/src/github.com/tendermint/log15/handler.go
new file mode 100644
index 0000000000000000000000000000000000000000..5dc7299843978865fec11d9103ea519e1ee5af89
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/handler.go
@@ -0,0 +1,387 @@
+package log15
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "net"
+ "os"
+ "reflect"
+ "sync"
+ "sync/atomic"
+ "unsafe"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/inconshreveable/log15/stack"
+)
+
+// A Logger prints its log records by writing to a Handler.
+// The Handler interface defines where and how log records are written.
+// Handlers are composable, providing you great flexibility in combining
+// them to achieve the logging structure that suits your applications.
+type Handler interface {
+ Log(r *Record) error
+}
+
+// FuncHandler returns a Handler that logs records with the given
+// function.
+func FuncHandler(fn func(r *Record) error) Handler {
+ return funcHandler(fn)
+}
+
+type funcHandler func(r *Record) error
+
+func (h funcHandler) Log(r *Record) error {
+ return h(r)
+}
+
+// StreamHandler writes log records to an io.Writer
+// with the given format. StreamHandler can be used
+// to easily begin writing log records to other
+// outputs.
+//
+// StreamHandler wraps itself with LazyHandler and SyncHandler
+// to evaluate Lazy objects and perform safe concurrent writes.
+func StreamHandler(wr io.Writer, fmtr Format) Handler {
+ h := FuncHandler(func(r *Record) error {
+ _, err := wr.Write(fmtr.Format(r))
+ return err
+ })
+ return LazyHandler(SyncHandler(h))
+}
+
+// SyncHandler can be wrapped around a handler to guarantee that
+// only a single Log operation can proceed at a time. It's necessary
+// for thread-safe concurrent writes.
+func SyncHandler(h Handler) Handler {
+ var mu sync.Mutex
+ return FuncHandler(func(r *Record) error {
+ defer mu.Unlock()
+ mu.Lock()
+ return h.Log(r)
+ })
+}
+
+// FileHandler returns a handler which writes log records to the give file
+// using the given format. If the path
+// already exists, FileHandler will append to the given file. If it does not,
+// FileHandler will create the file with mode 0644.
+func FileHandler(path string, fmtr Format) (Handler, error) {
+ f, err := os.OpenFile(path, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
+ if err != nil {
+ return nil, err
+ }
+ return closingHandler{f, StreamHandler(f, fmtr)}, nil
+}
+
+// NetHandler opens a socket to the given address and writes records
+// over the connection.
+func NetHandler(network, addr string, fmtr Format) (Handler, error) {
+ conn, err := net.Dial(network, addr)
+ if err != nil {
+ return nil, err
+ }
+
+ return closingHandler{conn, StreamHandler(conn, fmtr)}, nil
+}
+
+// XXX: closingHandler is essentially unused at the moment
+// it's meant for a future time when the Handler interface supports
+// a possible Close() operation
+type closingHandler struct {
+ io.WriteCloser
+ Handler
+}
+
+func (h *closingHandler) Close() error {
+ return h.WriteCloser.Close()
+}
+
+// CallerFileHandler returns a Handler that adds the line number and file of
+// the calling function to the context with key "caller".
+func CallerFileHandler(h Handler) Handler {
+ return FuncHandler(func(r *Record) error {
+ call := stack.Call(r.CallPC[0])
+ r.Ctx = append(r.Ctx, "caller", fmt.Sprint(call))
+ return h.Log(r)
+ })
+}
+
+// CallerFuncHandler returns a Handler that adds the calling function name to
+// the context with key "fn".
+func CallerFuncHandler(h Handler) Handler {
+ return FuncHandler(func(r *Record) error {
+ call := stack.Call(r.CallPC[0])
+ r.Ctx = append(r.Ctx, "fn", fmt.Sprintf("%+n", call))
+ return h.Log(r)
+ })
+}
+
+// CallerStackHandler returns a Handler that adds a stack trace to the context
+// with key "stack". The stack trace is formated as a space separated list of
+// call sites inside matching []'s. The most recent call site is listed first.
+// Each call site is formatted according to format. See the documentation of
+// log15/stack.Call.Format for the list of supported formats.
+func CallerStackHandler(format string, h Handler) Handler {
+ return FuncHandler(func(r *Record) error {
+ s := stack.Callers().
+ TrimBelow(stack.Call(r.CallPC[0])).
+ TrimRuntime()
+ if len(s) > 0 {
+ buf := &bytes.Buffer{}
+ buf.WriteByte('[')
+ for i, pc := range s {
+ if i > 0 {
+ buf.WriteByte(' ')
+ }
+ fmt.Fprintf(buf, format, pc)
+ }
+ buf.WriteByte(']')
+ r.Ctx = append(r.Ctx, "stack", buf.String())
+ }
+ return h.Log(r)
+ })
+}
+
+// FilterHandler returns a Handler that only writes records to the
+// wrapped Handler if the given function evaluates true. For example,
+// to only log records where the 'err' key is not nil:
+//
+// logger.SetHandler(FilterHandler(func(r *Record) bool {
+// for i := 0; i < len(r.Ctx); i += 2 {
+// if r.Ctx[i] == "err" {
+// return r.Ctx[i+1] != nil
+// }
+// }
+// return false
+// }, h))
+//
+func FilterHandler(fn func(r *Record) bool, h Handler) Handler {
+ return FuncHandler(func(r *Record) error {
+ if fn(r) {
+ return h.Log(r)
+ }
+ return nil
+ })
+}
+
+// MatchFilterHandler returns a Handler that only writes records
+// to the wrapped Handler if the given key in the logged
+// context matches the value. For example, to only log records
+// from your ui package:
+//
+// log.MatchFilterHandler("pkg", "app/ui", log.StdoutHandler)
+//
+func MatchFilterHandler(key string, value interface{}, h Handler) Handler {
+ return FilterHandler(func(r *Record) (pass bool) {
+ switch key {
+ case r.KeyNames.Lvl:
+ return r.Lvl == value
+ case r.KeyNames.Time:
+ return r.Time == value
+ case r.KeyNames.Msg:
+ return r.Msg == value
+ }
+
+ for i := 0; i < len(r.Ctx); i += 2 {
+ if r.Ctx[i] == key {
+ return r.Ctx[i+1] == value
+ }
+ }
+ return false
+ }, h)
+}
+
+// LvlFilterHandler returns a Handler that only writes
+// records which are less than the given verbosity
+// level to the wrapped Handler. For example, to only
+// log Error/Crit records:
+//
+// log.LvlFilterHandler(log.Error, log.StdoutHandler)
+//
+func LvlFilterHandler(maxLvl Lvl, h Handler) Handler {
+ return FilterHandler(func(r *Record) (pass bool) {
+ return r.Lvl <= maxLvl
+ }, h)
+}
+
+// A MultiHandler dispatches any write to each of its handlers.
+// This is useful for writing different types of log information
+// to different locations. For example, to log to a file and
+// standard error:
+//
+// log.MultiHandler(
+// log.Must.FileHandler("/var/log/app.log", log.LogfmtFormat()),
+// log.StderrHandler)
+//
+func MultiHandler(hs ...Handler) Handler {
+ return FuncHandler(func(r *Record) error {
+ for _, h := range hs {
+ // what to do about failures?
+ h.Log(r)
+ }
+ return nil
+ })
+}
+
+// A FailoverHandler writes all log records to the first handler
+// specified, but will failover and write to the second handler if
+// the first handler has failed, and so on for all handlers specified.
+// For example you might want to log to a network socket, but failover
+// to writing to a file if the network fails, and then to
+// standard out if the file write fails:
+//
+// log.FailoverHandler(
+// log.Must.NetHandler("tcp", ":9090", log.JsonFormat()),
+// log.Must.FileHandler("/var/log/app.log", log.LogfmtFormat()),
+// log.StdoutHandler)
+//
+// All writes that do not go to the first handler will add context with keys of
+// the form "failover_err_{idx}" which explain the error encountered while
+// trying to write to the handlers before them in the list.
+func FailoverHandler(hs ...Handler) Handler {
+ return FuncHandler(func(r *Record) error {
+ var err error
+ for i, h := range hs {
+ err = h.Log(r)
+ if err == nil {
+ return nil
+ } else {
+ r.Ctx = append(r.Ctx, fmt.Sprintf("failover_err_%d", i), err)
+ }
+ }
+
+ return err
+ })
+}
+
+// ChannelHandler writes all records to the given channel.
+// It blocks if the channel is full. Useful for async processing
+// of log messages, it's used by BufferedHandler.
+func ChannelHandler(recs chan<- *Record) Handler {
+ return FuncHandler(func(r *Record) error {
+ recs <- r
+ return nil
+ })
+}
+
+// BufferedHandler writes all records to a buffered
+// channel of the given size which flushes into the wrapped
+// handler whenever it is available for writing. Since these
+// writes happen asynchronously, all writes to a BufferedHandler
+// never return an error and any errors from the wrapped handler are ignored.
+func BufferedHandler(bufSize int, h Handler) Handler {
+ recs := make(chan *Record, bufSize)
+ go func() {
+ for m := range recs {
+ _ = h.Log(m)
+ }
+ }()
+ return ChannelHandler(recs)
+}
+
+// swapHandler wraps another handler that may be swapped out
+// dynamically at runtime in a thread-safe fashion.
+type swapHandler struct {
+ handler unsafe.Pointer
+}
+
+func (h *swapHandler) Log(r *Record) error {
+ return (*(*Handler)(atomic.LoadPointer(&h.handler))).Log(r)
+}
+
+func (h *swapHandler) Swap(newHandler Handler) {
+ atomic.StorePointer(&h.handler, unsafe.Pointer(&newHandler))
+}
+
+// LazyHandler writes all values to the wrapped handler after evaluating
+// any lazy functions in the record's context. It is already wrapped
+// around StreamHandler and SyslogHandler in this library, you'll only need
+// it if you write your own Handler.
+func LazyHandler(h Handler) Handler {
+ return FuncHandler(func(r *Record) error {
+ // go through the values (odd indices) and reassign
+ // the values of any lazy fn to the result of its execution
+ hadErr := false
+ for i := 1; i < len(r.Ctx); i += 2 {
+ lz, ok := r.Ctx[i].(Lazy)
+ if ok {
+ v, err := evaluateLazy(lz)
+ if err != nil {
+ hadErr = true
+ r.Ctx[i] = err
+ } else {
+ if cs, ok := v.(stack.Trace); ok {
+ v = cs.TrimBelow(stack.Call(r.CallPC[0])).
+ TrimRuntime()
+ }
+ r.Ctx[i] = v
+ }
+ }
+ }
+
+ if hadErr {
+ r.Ctx = append(r.Ctx, errorKey, "bad lazy")
+ }
+
+ return h.Log(r)
+ })
+}
+
+func evaluateLazy(lz Lazy) (interface{}, error) {
+ t := reflect.TypeOf(lz.Fn)
+
+ if t.Kind() != reflect.Func {
+ return nil, fmt.Errorf("INVALID_LAZY, not func: %+v", lz.Fn)
+ }
+
+ if t.NumIn() > 0 {
+ return nil, fmt.Errorf("INVALID_LAZY, func takes args: %+v", lz.Fn)
+ }
+
+ if t.NumOut() == 0 {
+ return nil, fmt.Errorf("INVALID_LAZY, no func return val: %+v", lz.Fn)
+ }
+
+ value := reflect.ValueOf(lz.Fn)
+ results := value.Call([]reflect.Value{})
+ if len(results) == 1 {
+ return results[0].Interface(), nil
+ } else {
+ values := make([]interface{}, len(results))
+ for i, v := range results {
+ values[i] = v.Interface()
+ }
+ return values, nil
+ }
+}
+
+// DiscardHandler reports success for all writes but does nothing.
+// It is useful for dynamically disabling logging at runtime via
+// a Logger's SetHandler method.
+func DiscardHandler() Handler {
+ return FuncHandler(func(r *Record) error {
+ return nil
+ })
+}
+
+// The Must object provides the following Handler creation functions
+// which instead of returning an error parameter only return a Handler
+// and panic on failure: FileHandler, NetHandler, SyslogHandler, SyslogNetHandler
+var Must muster
+
+func must(h Handler, err error) Handler {
+ if err != nil {
+ panic(err)
+ }
+ return h
+}
+
+type muster struct{}
+
+func (m muster) FileHandler(path string, fmtr Format) Handler {
+ return must(FileHandler(path, fmtr))
+}
+
+func (m muster) NetHandler(network, addr string, fmtr Format) Handler {
+ return must(NetHandler(network, addr, fmtr))
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/log15_test.go b/Godeps/_workspace/src/github.com/tendermint/log15/log15_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..516f7a4bce42e7a2474062ef4d1b86d9f12ef215
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/log15_test.go
@@ -0,0 +1,556 @@
+package log15
+
+import (
+ "bufio"
+ "bytes"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "net"
+ "regexp"
+ "runtime"
+ "sync"
+ "testing"
+ "time"
+)
+
+func testHandler() (Handler, *Record) {
+ rec := new(Record)
+ return FuncHandler(func(r *Record) error {
+ *rec = *r
+ return nil
+ }), rec
+}
+
+func testLogger() (Logger, Handler, *Record) {
+ l := New()
+ h, r := testHandler()
+ l.SetHandler(LazyHandler(h))
+ return l, h, r
+}
+
+func TestLazy(t *testing.T) {
+ t.Parallel()
+
+ x := 1
+ lazy := func() int {
+ return x
+ }
+
+ l, _, r := testLogger()
+ l.Info("", "x", Lazy{lazy})
+ if r.Ctx[1] != 1 {
+ t.Fatalf("Lazy function not evaluated, got %v, expected %d", r.Ctx[1], 1)
+ }
+
+ x = 2
+ l.Info("", "x", Lazy{lazy})
+ if r.Ctx[1] != 2 {
+ t.Fatalf("Lazy function not evaluated, got %v, expected %d", r.Ctx[1], 1)
+ }
+}
+
+func TestInvalidLazy(t *testing.T) {
+ t.Parallel()
+
+ l, _, r := testLogger()
+ validate := func() {
+ if len(r.Ctx) < 4 {
+ t.Fatalf("Invalid lazy, got %d args, expecting at least 4", len(r.Ctx))
+ }
+
+ if r.Ctx[2] != errorKey {
+ t.Fatalf("Invalid lazy, got key %s expecting %s", r.Ctx[2], errorKey)
+ }
+ }
+
+ l.Info("", "x", Lazy{1})
+ validate()
+
+ l.Info("", "x", Lazy{func(x int) int { return x }})
+ validate()
+
+ l.Info("", "x", Lazy{func() {}})
+ validate()
+}
+
+func TestCtx(t *testing.T) {
+ t.Parallel()
+
+ l, _, r := testLogger()
+ l.Info("", Ctx{"x": 1, "y": "foo", "tester": t})
+ if len(r.Ctx) != 6 {
+ t.Fatalf("Expecting Ctx tansformed into %d ctx args, got %d: %v", 6, len(r.Ctx), r.Ctx)
+ }
+}
+
+func testFormatter(f Format) (Logger, *bytes.Buffer) {
+ l := New()
+ var buf bytes.Buffer
+ l.SetHandler(StreamHandler(&buf, f))
+ return l, &buf
+}
+
+func TestJson(t *testing.T) {
+ t.Parallel()
+
+ l, buf := testFormatter(JsonFormat())
+ l.Error("some message", "x", 1, "y", 3.2)
+
+ var v map[string]interface{}
+ decoder := json.NewDecoder(buf)
+ if err := decoder.Decode(&v); err != nil {
+ t.Fatalf("Error decoding JSON: %v", v)
+ }
+
+ validate := func(key string, expected interface{}) {
+ if v[key] != expected {
+ t.Fatalf("Got %v expected %v for %v", v[key], expected, key)
+ }
+ }
+
+ validate("msg", "some message")
+ validate("x", float64(1)) // all numbers are floats in JSON land
+ validate("y", 3.2)
+}
+
+func TestLogfmt(t *testing.T) {
+ t.Parallel()
+
+ l, buf := testFormatter(LogfmtFormat())
+ l.Error("some message", "x", 1, "y", 3.2, "equals", "=", "quote", "\"")
+
+ // skip timestamp in comparison
+ got := buf.Bytes()[27:buf.Len()]
+ expected := []byte(`lvl=eror msg="some message" x=1 y=3.200 equals="=" quote="\""` + "\n")
+ if !bytes.Equal(got, expected) {
+ t.Fatalf("Got %s, expected %s", got, expected)
+ }
+}
+
+func TestMultiHandler(t *testing.T) {
+ t.Parallel()
+
+ h1, r1 := testHandler()
+ h2, r2 := testHandler()
+ l := New()
+ l.SetHandler(MultiHandler(h1, h2))
+ l.Debug("clone")
+
+ if r1.Msg != "clone" {
+ t.Fatalf("wrong value for h1.Msg. Got %s expected %s", r1.Msg, "clone")
+ }
+
+ if r2.Msg != "clone" {
+ t.Fatalf("wrong value for h2.Msg. Got %s expected %s", r2.Msg, "clone")
+ }
+
+}
+
+type waitHandler struct {
+ ch chan Record
+}
+
+func (h *waitHandler) Log(r *Record) error {
+ h.ch <- *r
+ return nil
+}
+
+func TestBufferedHandler(t *testing.T) {
+ t.Parallel()
+
+ ch := make(chan Record)
+ l := New()
+ l.SetHandler(BufferedHandler(0, &waitHandler{ch}))
+
+ l.Debug("buffer")
+ if r := <-ch; r.Msg != "buffer" {
+ t.Fatalf("wrong value for r.Msg. Got %s expected %s", r.Msg, "")
+ }
+}
+
+func TestLogContext(t *testing.T) {
+ t.Parallel()
+
+ l, _, r := testLogger()
+ l = l.New("foo", "bar")
+ l.Crit("baz")
+
+ if len(r.Ctx) != 2 {
+ t.Fatalf("Expected logger context in record context. Got length %d, expected %d", len(r.Ctx), 2)
+ }
+
+ if r.Ctx[0] != "foo" {
+ t.Fatalf("Wrong context key, got %s expected %s", r.Ctx[0], "foo")
+ }
+
+ if r.Ctx[1] != "bar" {
+ t.Fatalf("Wrong context value, got %s expected %s", r.Ctx[1], "bar")
+ }
+}
+
+func TestMapCtx(t *testing.T) {
+ t.Parallel()
+
+ l, _, r := testLogger()
+ l.Crit("test", Ctx{"foo": "bar"})
+
+ if len(r.Ctx) != 2 {
+ t.Fatalf("Wrong context length, got %d, expected %d", len(r.Ctx), 2)
+ }
+
+ if r.Ctx[0] != "foo" {
+ t.Fatalf("Wrong context key, got %s expected %s", r.Ctx[0], "foo")
+ }
+
+ if r.Ctx[1] != "bar" {
+ t.Fatalf("Wrong context value, got %s expected %s", r.Ctx[1], "bar")
+ }
+}
+
+func TestLvlFilterHandler(t *testing.T) {
+ t.Parallel()
+
+ l := New()
+ h, r := testHandler()
+ l.SetHandler(LvlFilterHandler(LvlWarn, h))
+ l.Info("info'd")
+
+ if r.Msg != "" {
+ t.Fatalf("Expected zero record, but got record with msg: %v", r.Msg)
+ }
+
+ l.Warn("warned")
+ if r.Msg != "warned" {
+ t.Fatalf("Got record msg %s expected %s", r.Msg, "warned")
+ }
+
+ l.Warn("error'd")
+ if r.Msg != "error'd" {
+ t.Fatalf("Got record msg %s expected %s", r.Msg, "error'd")
+ }
+}
+
+func TestNetHandler(t *testing.T) {
+ t.Parallel()
+
+ l, err := net.Listen("tcp", "localhost:0")
+ if err != nil {
+ t.Fatalf("Failed to listen: %v", l)
+ }
+
+ errs := make(chan error)
+ go func() {
+ c, err := l.Accept()
+ if err != nil {
+ t.Errorf("Failed to accept conneciton: %v", err)
+ return
+ }
+
+ rd := bufio.NewReader(c)
+ s, err := rd.ReadString('\n')
+ if err != nil {
+ t.Errorf("Failed to read string: %v", err)
+ }
+
+ got := s[27:]
+ expected := "lvl=info msg=test x=1\n"
+ if got != expected {
+ t.Errorf("Got log line %s, expected %s", got, expected)
+ }
+
+ errs <- nil
+ }()
+
+ lg := New()
+ h, err := NetHandler("tcp", l.Addr().String(), LogfmtFormat())
+ if err != nil {
+ t.Fatal(err)
+ }
+ lg.SetHandler(h)
+ lg.Info("test", "x", 1)
+
+ select {
+ case <-time.After(time.Second):
+ t.Fatalf("Test timed out!")
+ case <-errs:
+ // ok
+ }
+}
+
+func TestMatchFilterHandler(t *testing.T) {
+ t.Parallel()
+
+ l, h, r := testLogger()
+ l.SetHandler(MatchFilterHandler("err", nil, h))
+
+ l.Crit("test", "foo", "bar")
+ if r.Msg != "" {
+ t.Fatalf("expected filter handler to discard msg")
+ }
+
+ l.Crit("test2", "err", "bad fd")
+ if r.Msg != "" {
+ t.Fatalf("expected filter handler to discard msg")
+ }
+
+ l.Crit("test3", "err", nil)
+ if r.Msg != "test3" {
+ t.Fatalf("expected filter handler to allow msg")
+ }
+}
+
+func TestMatchFilterBuiltin(t *testing.T) {
+ t.Parallel()
+
+ l, h, r := testLogger()
+ l.SetHandler(MatchFilterHandler("lvl", LvlError, h))
+ l.Info("does not pass")
+
+ if r.Msg != "" {
+ t.Fatalf("got info level record that should not have matched")
+ }
+
+ l.Error("error!")
+ if r.Msg != "error!" {
+ t.Fatalf("did not get error level record that should have matched")
+ }
+
+ r.Msg = ""
+ l.SetHandler(MatchFilterHandler("msg", "matching message", h))
+ l.Info("doesn't match")
+ if r.Msg != "" {
+ t.Fatalf("got record with wrong message matched")
+ }
+
+ l.Debug("matching message")
+ if r.Msg != "matching message" {
+ t.Fatalf("did not get record which matches")
+ }
+}
+
+type failingWriter struct {
+ fail bool
+}
+
+func (w *failingWriter) Write(buf []byte) (int, error) {
+ if w.fail {
+ return 0, errors.New("fail")
+ } else {
+ return len(buf), nil
+ }
+}
+
+func TestFailoverHandler(t *testing.T) {
+ t.Parallel()
+
+ l := New()
+ h, r := testHandler()
+ w := &failingWriter{false}
+
+ l.SetHandler(FailoverHandler(
+ StreamHandler(w, JsonFormat()),
+ h))
+
+ l.Debug("test ok")
+ if r.Msg != "" {
+ t.Fatalf("expected no failover")
+ }
+
+ w.fail = true
+ l.Debug("test failover", "x", 1)
+ if r.Msg != "test failover" {
+ t.Fatalf("expected failover")
+ }
+
+ if len(r.Ctx) != 4 {
+ t.Fatalf("expected additional failover ctx")
+ }
+
+ got := r.Ctx[2]
+ expected := "failover_err_0"
+ if got != expected {
+ t.Fatalf("expected failover ctx. got: %s, expected %s", got, expected)
+ }
+}
+
+// https://github.com/inconshreveable/log15/issues/16
+func TestIndependentSetHandler(t *testing.T) {
+ t.Parallel()
+
+ parent, _, r := testLogger()
+ child := parent.New()
+ child.SetHandler(DiscardHandler())
+ parent.Info("test")
+ if r.Msg != "test" {
+ t.Fatalf("parent handler affected by child")
+ }
+}
+
+// https://github.com/inconshreveable/log15/issues/16
+func TestInheritHandler(t *testing.T) {
+ t.Parallel()
+
+ parent, _, r := testLogger()
+ child := parent.New()
+ parent.SetHandler(DiscardHandler())
+ child.Info("test")
+ if r.Msg == "test" {
+ t.Fatalf("child handler affected not affected by parent")
+ }
+}
+
+func TestCallerFileHandler(t *testing.T) {
+ t.Parallel()
+
+ l := New()
+ h, r := testHandler()
+ l.SetHandler(CallerFileHandler(h))
+
+ l.Info("baz")
+ _, _, line, _ := runtime.Caller(0)
+
+ if len(r.Ctx) != 2 {
+ t.Fatalf("Expected caller in record context. Got length %d, expected %d", len(r.Ctx), 2)
+ }
+
+ const key = "caller"
+
+ if r.Ctx[0] != key {
+ t.Fatalf("Wrong context key, got %s expected %s", r.Ctx[0], key)
+ }
+
+ s, ok := r.Ctx[1].(string)
+ if !ok {
+ t.Fatalf("Wrong context value type, got %T expected string", r.Ctx[1])
+ }
+
+ exp := fmt.Sprint("log15_test.go:", line-1)
+ if s != exp {
+ t.Fatalf("Wrong context value, got %s expected string matching %s", s, exp)
+ }
+}
+
+func TestCallerFuncHandler(t *testing.T) {
+ t.Parallel()
+
+ l := New()
+ h, r := testHandler()
+ l.SetHandler(CallerFuncHandler(h))
+
+ l.Info("baz")
+
+ if len(r.Ctx) != 2 {
+ t.Fatalf("Expected caller in record context. Got length %d, expected %d", len(r.Ctx), 2)
+ }
+
+ const key = "fn"
+
+ if r.Ctx[0] != key {
+ t.Fatalf("Wrong context key, got %s expected %s", r.Ctx[0], key)
+ }
+
+ const regex = ".*\\.TestCallerFuncHandler"
+
+ s, ok := r.Ctx[1].(string)
+ if !ok {
+ t.Fatalf("Wrong context value type, got %T expected string", r.Ctx[1])
+ }
+
+ match, err := regexp.MatchString(regex, s)
+ if err != nil {
+ t.Fatalf("Error matching %s to regex %s: %v", s, regex, err)
+ }
+
+ if !match {
+ t.Fatalf("Wrong context value, got %s expected string matching %s", s, regex)
+ }
+}
+
+// https://github.com/inconshreveable/log15/issues/27
+func TestCallerStackHandler(t *testing.T) {
+ t.Parallel()
+
+ l := New()
+ h, r := testHandler()
+ l.SetHandler(CallerStackHandler("%#v", h))
+
+ lines := []int{}
+
+ func() {
+ l.Info("baz")
+ _, _, line, _ := runtime.Caller(0)
+ lines = append(lines, line-1)
+ }()
+ _, file, line, _ := runtime.Caller(0)
+ lines = append(lines, line-1)
+
+ if len(r.Ctx) != 2 {
+ t.Fatalf("Expected stack in record context. Got length %d, expected %d", len(r.Ctx), 2)
+ }
+
+ const key = "stack"
+
+ if r.Ctx[0] != key {
+ t.Fatalf("Wrong context key, got %s expected %s", r.Ctx[0], key)
+ }
+
+ s, ok := r.Ctx[1].(string)
+ if !ok {
+ t.Fatalf("Wrong context value type, got %T expected string", r.Ctx[1])
+ }
+
+ exp := "["
+ for i, line := range lines {
+ if i > 0 {
+ exp += " "
+ }
+ exp += fmt.Sprint(file, ":", line)
+ }
+ exp += "]"
+
+ if s != exp {
+ t.Fatalf("Wrong context value, got %s expected string matching %s", s, exp)
+ }
+}
+
+// tests that when logging concurrently to the same logger
+// from multiple goroutines that the calls are handled independently
+// this test tries to trigger a previous bug where concurrent calls could
+// corrupt each other's context values
+//
+// this test runs N concurrent goroutines each logging a fixed number of
+// records and a handler that buckets them based on the index passed in the context.
+// if the logger is not concurrent-safe then the values in the buckets will not all be the same
+//
+// https://github.com/inconshreveable/log15/pull/30
+func TestConcurrent(t *testing.T) {
+ root := New()
+ // this was the first value that triggered
+ // go to allocate extra capacity in the logger's context slice which
+ // was necessary to trigger the bug
+ const ctxLen = 34
+ l := root.New(make([]interface{}, ctxLen)...)
+ const goroutines = 8
+ var res [goroutines]int
+ l.SetHandler(SyncHandler(FuncHandler(func(r *Record) error {
+ res[r.Ctx[ctxLen+1].(int)]++
+ return nil
+ })))
+ var wg sync.WaitGroup
+ wg.Add(goroutines)
+ for i := 0; i < goroutines; i++ {
+ go func(idx int) {
+ defer wg.Done()
+ for j := 0; j < 10000; j++ {
+ l.Info("test message", "goroutine_idx", idx)
+ }
+ }(i)
+ }
+ wg.Wait()
+ for _, val := range res[:] {
+ if val != 10000 {
+ t.Fatalf("Wrong number of messages for context: %+v", res)
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/logger.go b/Godeps/_workspace/src/github.com/tendermint/log15/logger.go
new file mode 100644
index 0000000000000000000000000000000000000000..dcd7cf8dba28bbf7a251f4a045fed323ab0eec8b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/logger.go
@@ -0,0 +1,201 @@
+package log15
+
+import (
+ "fmt"
+ "runtime"
+ "time"
+)
+
+const timeKey = "t"
+const lvlKey = "lvl"
+const msgKey = "msg"
+const errorKey = "LOG15_ERROR"
+
+type Lvl int
+
+const (
+ LvlCrit Lvl = iota
+ LvlError
+ LvlWarn
+ LvlInfo
+ LvlDebug
+)
+
+// Returns the name of a Lvl
+func (l Lvl) String() string {
+ switch l {
+ case LvlDebug:
+ return "dbug"
+ case LvlInfo:
+ return "info"
+ case LvlWarn:
+ return "warn"
+ case LvlError:
+ return "eror"
+ case LvlCrit:
+ return "crit"
+ default:
+ panic("bad level")
+ }
+}
+
+// Returns the appropriate Lvl from a string name.
+// Useful for parsing command line args and configuration files.
+func LvlFromString(lvlString string) (Lvl, error) {
+ switch lvlString {
+ case "debug", "dbug":
+ return LvlDebug, nil
+ case "info":
+ return LvlInfo, nil
+ case "warn":
+ return LvlWarn, nil
+ case "error", "eror":
+ return LvlError, nil
+ case "crit":
+ return LvlCrit, nil
+ default:
+ return LvlDebug, fmt.Errorf("Unknown level: %v", lvlString)
+ }
+}
+
+// A Record is what a Logger asks its handler to write
+type Record struct {
+ Time time.Time
+ Lvl Lvl
+ Msg string
+ Ctx []interface{}
+ CallPC [1]uintptr
+ KeyNames RecordKeyNames
+}
+
+type RecordKeyNames struct {
+ Time string
+ Msg string
+ Lvl string
+}
+
+// A Logger writes key/value pairs to a Handler
+type Logger interface {
+ // New returns a new Logger that has this logger's context plus the given context
+ New(ctx ...interface{}) Logger
+
+ // SetHandler updates the logger to write records to the specified handler.
+ SetHandler(h Handler)
+
+ // Log a message at the given level with context key/value pairs
+ Debug(msg string, ctx ...interface{})
+ Info(msg string, ctx ...interface{})
+ Warn(msg string, ctx ...interface{})
+ Error(msg string, ctx ...interface{})
+ Crit(msg string, ctx ...interface{})
+}
+
+type logger struct {
+ ctx []interface{}
+ h *swapHandler
+}
+
+func (l *logger) write(msg string, lvl Lvl, ctx []interface{}) {
+ r := Record{
+ Time: time.Now(),
+ Lvl: lvl,
+ Msg: msg,
+ Ctx: newContext(l.ctx, ctx),
+ KeyNames: RecordKeyNames{
+ Time: timeKey,
+ Msg: msgKey,
+ Lvl: lvlKey,
+ },
+ }
+ runtime.Callers(3, r.CallPC[:])
+ l.h.Log(&r)
+}
+
+func (l *logger) New(ctx ...interface{}) Logger {
+ child := &logger{newContext(l.ctx, ctx), new(swapHandler)}
+ child.SetHandler(l.h)
+ return child
+}
+
+func newContext(prefix []interface{}, suffix []interface{}) []interface{} {
+ normalizedSuffix := normalize(suffix)
+ newCtx := make([]interface{}, len(prefix)+len(normalizedSuffix))
+ n := copy(newCtx, prefix)
+ copy(newCtx[n:], normalizedSuffix)
+ return newCtx
+}
+
+func (l *logger) Debug(msg string, ctx ...interface{}) {
+ l.write(msg, LvlDebug, ctx)
+}
+
+func (l *logger) Info(msg string, ctx ...interface{}) {
+ l.write(msg, LvlInfo, ctx)
+}
+
+func (l *logger) Warn(msg string, ctx ...interface{}) {
+ l.write(msg, LvlWarn, ctx)
+}
+
+func (l *logger) Error(msg string, ctx ...interface{}) {
+ l.write(msg, LvlError, ctx)
+}
+
+func (l *logger) Crit(msg string, ctx ...interface{}) {
+ l.write(msg, LvlCrit, ctx)
+}
+
+func (l *logger) SetHandler(h Handler) {
+ l.h.Swap(h)
+}
+
+func normalize(ctx []interface{}) []interface{} {
+ // if the caller passed a Ctx object, then expand it
+ if len(ctx) == 1 {
+ if ctxMap, ok := ctx[0].(Ctx); ok {
+ ctx = ctxMap.toArray()
+ }
+ }
+
+ // ctx needs to be even because it's a series of key/value pairs
+ // no one wants to check for errors on logging functions,
+ // so instead of erroring on bad input, we'll just make sure
+ // that things are the right length and users can fix bugs
+ // when they see the output looks wrong
+ if len(ctx)%2 != 0 {
+ ctx = append(ctx, nil, errorKey, "Normalized odd number of arguments by adding nil")
+ }
+
+ return ctx
+}
+
+// Lazy allows you to defer calculation of a logged value that is expensive
+// to compute until it is certain that it must be evaluated with the given filters.
+//
+// Lazy may also be used in conjunction with a Logger's New() function
+// to generate a child logger which always reports the current value of changing
+// state.
+//
+// You may wrap any function which takes no arguments to Lazy. It may return any
+// number of values of any type.
+type Lazy struct {
+ Fn interface{}
+}
+
+// Ctx is a map of key/value pairs to pass as context to a log function
+// Use this only if you really need greater safety around the arguments you pass
+// to the logging functions.
+type Ctx map[string]interface{}
+
+func (c Ctx) toArray() []interface{} {
+ arr := make([]interface{}, len(c)*2)
+
+ i := 0
+ for k, v := range c {
+ arr[i] = k
+ arr[i+1] = v
+ i += 2
+ }
+
+ return arr
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/root.go b/Godeps/_workspace/src/github.com/tendermint/log15/root.go
new file mode 100644
index 0000000000000000000000000000000000000000..0c442acee75d88453db694e735a372c2c4146aad
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/root.go
@@ -0,0 +1,67 @@
+package log15
+
+import (
+ "os"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/inconshreveable/log15/term"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/mattn/go-colorable"
+)
+
+var (
+ root *logger
+ StdoutHandler = StreamHandler(os.Stdout, LogfmtFormat())
+ StderrHandler = StreamHandler(os.Stderr, LogfmtFormat())
+)
+
+func init() {
+ if term.IsTty(os.Stdout.Fd()) {
+ StdoutHandler = StreamHandler(colorable.NewColorableStdout(), TerminalFormat())
+ }
+
+ if term.IsTty(os.Stderr.Fd()) {
+ StderrHandler = StreamHandler(colorable.NewColorableStderr(), TerminalFormat())
+ }
+
+ root = &logger{[]interface{}{}, new(swapHandler)}
+ root.SetHandler(StdoutHandler)
+}
+
+// New returns a new logger with the given context.
+// New is a convenient alias for Root().New
+func New(ctx ...interface{}) Logger {
+ return root.New(ctx...)
+}
+
+// Root returns the root logger
+func Root() Logger {
+ return root
+}
+
+// The following functions bypass the exported logger methods (logger.Debug,
+// etc.) to keep the call depth the same for all paths to logger.write so
+// runtime.Caller(2) always refers to the call site in client code.
+
+// Debug is a convenient alias for Root().Debug
+func Debug(msg string, ctx ...interface{}) {
+ root.write(msg, LvlDebug, ctx)
+}
+
+// Info is a convenient alias for Root().Info
+func Info(msg string, ctx ...interface{}) {
+ root.write(msg, LvlInfo, ctx)
+}
+
+// Warn is a convenient alias for Root().Warn
+func Warn(msg string, ctx ...interface{}) {
+ root.write(msg, LvlWarn, ctx)
+}
+
+// Error is a convenient alias for Root().Error
+func Error(msg string, ctx ...interface{}) {
+ root.write(msg, LvlError, ctx)
+}
+
+// Crit is a convenient alias for Root().Crit
+func Crit(msg string, ctx ...interface{}) {
+ root.write(msg, LvlCrit, ctx)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/stack/stack.go b/Godeps/_workspace/src/github.com/tendermint/log15/stack/stack.go
new file mode 100644
index 0000000000000000000000000000000000000000..ae3021ccea335c6693b6061661815e31beb25f4b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/stack/stack.go
@@ -0,0 +1,225 @@
+// Package stack implements utilities to capture, manipulate, and format call
+// stacks.
+package stack
+
+import (
+ "fmt"
+ "path/filepath"
+ "runtime"
+ "strings"
+)
+
+// Call records a single function invocation from a goroutine stack. It is a
+// wrapper for the program counter values returned by runtime.Caller and
+// runtime.Callers and consumed by runtime.FuncForPC.
+type Call uintptr
+
+// Format implements fmt.Formatter with support for the following verbs.
+//
+// %s source file
+// %d line number
+// %n function name
+// %v equivalent to %s:%d
+//
+// It accepts the '+' and '#' flags for most of the verbs as follows.
+//
+// %+s path of source file relative to the compile time GOPATH
+// %#s full path of source file
+// %+n import path qualified function name
+// %+v equivalent to %+s:%d
+// %#v equivalent to %#s:%d
+func (pc Call) Format(s fmt.State, c rune) {
+ // BUG(ChrisHines): Subtracting one from pc is a work around for
+ // https://code.google.com/p/go/issues/detail?id=7690. The idea for this
+ // work around comes from rsc's initial patch at
+ // https://codereview.appspot.com/84100043/#ps20001, but as noted in the
+ // issue discussion, it is not a complete fix since it doesn't handle some
+ // cases involving signals. Just the same, it handles all of the other
+ // cases I have tested.
+ pcFix := uintptr(pc) - 1
+ fn := runtime.FuncForPC(pcFix)
+ if fn == nil {
+ fmt.Fprintf(s, "%%!%c(NOFUNC)", c)
+ return
+ }
+
+ switch c {
+ case 's', 'v':
+ file, line := fn.FileLine(pcFix)
+ switch {
+ case s.Flag('#'):
+ // done
+ case s.Flag('+'):
+ // Here we want to get the source file path relative to the
+ // compile time GOPATH. As of Go 1.3.x there is no direct way to
+ // know the compiled GOPATH at runtime, but we can infer the
+ // number of path segments in the GOPATH. We note that fn.Name()
+ // returns the function name qualified by the import path, which
+ // does not include the GOPATH. Thus we can trim segments from the
+ // beginning of the file path until the number of path separators
+ // remaining is one more than the number of path separators in the
+ // function name. For example, given:
+ //
+ // GOPATH /home/user
+ // file /home/user/src/pkg/sub/file.go
+ // fn.Name() pkg/sub.Type.Method
+ //
+ // We want to produce:
+ //
+ // pkg/sub/file.go
+ //
+ // From this we can easily see that fn.Name() has one less path
+ // separator than our desired output.
+ const sep = "/"
+ impCnt := strings.Count(fn.Name(), sep) + 1
+ pathCnt := strings.Count(file, sep)
+ for pathCnt > impCnt {
+ i := strings.Index(file, sep)
+ if i == -1 {
+ break
+ }
+ file = file[i+len(sep):]
+ pathCnt--
+ }
+ default:
+ const sep = "/"
+ if i := strings.LastIndex(file, sep); i != -1 {
+ file = file[i+len(sep):]
+ }
+ }
+ fmt.Fprint(s, file)
+ if c == 'v' {
+ fmt.Fprint(s, ":", line)
+ }
+
+ case 'd':
+ _, line := fn.FileLine(pcFix)
+ fmt.Fprint(s, line)
+
+ case 'n':
+ name := fn.Name()
+ if !s.Flag('+') {
+ const pathSep = "/"
+ if i := strings.LastIndex(name, pathSep); i != -1 {
+ name = name[i+len(pathSep):]
+ }
+ const pkgSep = "."
+ if i := strings.Index(name, pkgSep); i != -1 {
+ name = name[i+len(pkgSep):]
+ }
+ }
+ fmt.Fprint(s, name)
+ }
+}
+
+// Callers returns a Trace for the current goroutine with element 0
+// identifying the calling function.
+func Callers() Trace {
+ pcs := poolBuf()
+ pcs = pcs[:cap(pcs)]
+ n := runtime.Callers(2, pcs)
+ cs := make([]Call, n)
+ for i, pc := range pcs[:n] {
+ cs[i] = Call(pc)
+ }
+ putPoolBuf(pcs)
+ return cs
+}
+
+// name returns the import path qualified name of the function containing the
+// call.
+func (pc Call) name() string {
+ pcFix := uintptr(pc) - 1 // work around for go issue #7690
+ fn := runtime.FuncForPC(pcFix)
+ if fn == nil {
+ return "???"
+ }
+ return fn.Name()
+}
+
+func (pc Call) file() string {
+ pcFix := uintptr(pc) - 1 // work around for go issue #7690
+ fn := runtime.FuncForPC(pcFix)
+ if fn == nil {
+ return "???"
+ }
+ file, _ := fn.FileLine(pcFix)
+ return file
+}
+
+// Trace records a sequence of function invocations from a goroutine stack.
+type Trace []Call
+
+// Format implements fmt.Formatter by printing the Trace as square brackes ([,
+// ]) surrounding a space separated list of Calls each formatted with the
+// supplied verb and options.
+func (pcs Trace) Format(s fmt.State, c rune) {
+ s.Write([]byte("["))
+ for i, pc := range pcs {
+ if i > 0 {
+ s.Write([]byte(" "))
+ }
+ pc.Format(s, c)
+ }
+ s.Write([]byte("]"))
+}
+
+// TrimBelow returns a slice of the Trace with all entries below pc removed.
+func (pcs Trace) TrimBelow(pc Call) Trace {
+ for len(pcs) > 0 && pcs[0] != pc {
+ pcs = pcs[1:]
+ }
+ return pcs
+}
+
+// TrimAbove returns a slice of the Trace with all entries above pc removed.
+func (pcs Trace) TrimAbove(pc Call) Trace {
+ for len(pcs) > 0 && pcs[len(pcs)-1] != pc {
+ pcs = pcs[:len(pcs)-1]
+ }
+ return pcs
+}
+
+// TrimBelowName returns a slice of the Trace with all entries below the
+// lowest with function name name removed.
+func (pcs Trace) TrimBelowName(name string) Trace {
+ for len(pcs) > 0 && pcs[0].name() != name {
+ pcs = pcs[1:]
+ }
+ return pcs
+}
+
+// TrimAboveName returns a slice of the Trace with all entries above the
+// highest with function name name removed.
+func (pcs Trace) TrimAboveName(name string) Trace {
+ for len(pcs) > 0 && pcs[len(pcs)-1].name() != name {
+ pcs = pcs[:len(pcs)-1]
+ }
+ return pcs
+}
+
+var goroot string
+
+func init() {
+ goroot = filepath.ToSlash(runtime.GOROOT())
+ if runtime.GOOS == "windows" {
+ goroot = strings.ToLower(goroot)
+ }
+}
+
+func inGoroot(path string) bool {
+ if runtime.GOOS == "windows" {
+ path = strings.ToLower(path)
+ }
+ return strings.HasPrefix(path, goroot)
+}
+
+// TrimRuntime returns a slice of the Trace with the topmost entries from the
+// go runtime removed. It considers any calls originating from files under
+// GOROOT as part of the runtime.
+func (pcs Trace) TrimRuntime() Trace {
+ for len(pcs) > 0 && inGoroot(pcs[len(pcs)-1].file()) {
+ pcs = pcs[:len(pcs)-1]
+ }
+ return pcs
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/stack/stack_pool.go b/Godeps/_workspace/src/github.com/tendermint/log15/stack/stack_pool.go
new file mode 100644
index 0000000000000000000000000000000000000000..34f2ca9707543de0a377ae920eefda21547e4929
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/stack/stack_pool.go
@@ -0,0 +1,19 @@
+// +build go1.3
+
+package stack
+
+import (
+ "sync"
+)
+
+var pcStackPool = sync.Pool{
+ New: func() interface{} { return make([]uintptr, 1000) },
+}
+
+func poolBuf() []uintptr {
+ return pcStackPool.Get().([]uintptr)
+}
+
+func putPoolBuf(p []uintptr) {
+ pcStackPool.Put(p)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/stack/stack_pool_chan.go b/Godeps/_workspace/src/github.com/tendermint/log15/stack/stack_pool_chan.go
new file mode 100644
index 0000000000000000000000000000000000000000..aa449edf5021bb28bbdffee3d222dbdcecd111c3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/stack/stack_pool_chan.go
@@ -0,0 +1,27 @@
+// +build !go1.3
+
+package stack
+
+const (
+ stackPoolSize = 64
+)
+
+var (
+ pcStackPool = make(chan []uintptr, stackPoolSize)
+)
+
+func poolBuf() []uintptr {
+ select {
+ case p := <-pcStackPool:
+ return p
+ default:
+ return make([]uintptr, 1000)
+ }
+}
+
+func putPoolBuf(p []uintptr) {
+ select {
+ case pcStackPool <- p:
+ default:
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/stack/stack_test.go b/Godeps/_workspace/src/github.com/tendermint/log15/stack/stack_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..64cd7d08075a7c43b884ce6076545c30a0564990
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/stack/stack_test.go
@@ -0,0 +1,231 @@
+package stack_test
+
+import (
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path"
+ "path/filepath"
+ "runtime"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/inconshreveable/log15/stack"
+)
+
+type testType struct{}
+
+func (tt testType) testMethod() (pc uintptr, file string, line int, ok bool) {
+ return runtime.Caller(0)
+}
+
+func TestCallFormat(t *testing.T) {
+ t.Parallel()
+
+ pc, file, line, ok := runtime.Caller(0)
+ if !ok {
+ t.Fatal("runtime.Caller(0) failed")
+ }
+
+ gopathSrc := filepath.Join(os.Getenv("GOPATH"), "src")
+ relFile, err := filepath.Rel(gopathSrc, file)
+ if err != nil {
+ t.Fatalf("failed to determine path relative to GOPATH: %v", err)
+ }
+ relFile = filepath.ToSlash(relFile)
+
+ pc2, file2, line2, ok2 := testType{}.testMethod()
+ if !ok2 {
+ t.Fatal("runtime.Caller(0) failed")
+ }
+ relFile2, err := filepath.Rel(gopathSrc, file)
+ if err != nil {
+ t.Fatalf("failed to determine path relative to GOPATH: %v", err)
+ }
+ relFile2 = filepath.ToSlash(relFile2)
+
+ data := []struct {
+ pc uintptr
+ desc string
+ fmt string
+ out string
+ }{
+ {0, "error", "%s", "%!s(NOFUNC)"},
+
+ {pc, "func", "%s", path.Base(file)},
+ {pc, "func", "%+s", relFile},
+ {pc, "func", "%#s", file},
+ {pc, "func", "%d", fmt.Sprint(line)},
+ {pc, "func", "%n", "TestCallFormat"},
+ {pc, "func", "%+n", runtime.FuncForPC(pc).Name()},
+ {pc, "func", "%v", fmt.Sprint(path.Base(file), ":", line)},
+ {pc, "func", "%+v", fmt.Sprint(relFile, ":", line)},
+ {pc, "func", "%#v", fmt.Sprint(file, ":", line)},
+ {pc, "func", "%v|%[1]n()", fmt.Sprint(path.Base(file), ":", line, "|", "TestCallFormat()")},
+
+ {pc2, "meth", "%s", path.Base(file2)},
+ {pc2, "meth", "%+s", relFile2},
+ {pc2, "meth", "%#s", file2},
+ {pc2, "meth", "%d", fmt.Sprint(line2)},
+ {pc2, "meth", "%n", "testType.testMethod"},
+ {pc2, "meth", "%+n", runtime.FuncForPC(pc2).Name()},
+ {pc2, "meth", "%v", fmt.Sprint(path.Base(file2), ":", line2)},
+ {pc2, "meth", "%+v", fmt.Sprint(relFile2, ":", line2)},
+ {pc2, "meth", "%#v", fmt.Sprint(file2, ":", line2)},
+ {pc2, "meth", "%v|%[1]n()", fmt.Sprint(path.Base(file2), ":", line2, "|", "testType.testMethod()")},
+ }
+
+ for _, d := range data {
+ got := fmt.Sprintf(d.fmt, stack.Call(d.pc))
+ if got != d.out {
+ t.Errorf("fmt.Sprintf(%q, Call(%s)) = %s, want %s", d.fmt, d.desc, got, d.out)
+ }
+ }
+}
+
+func BenchmarkCallVFmt(b *testing.B) {
+ pc, _, _, ok := runtime.Caller(0)
+ if !ok {
+ b.Fatal("runtime.Caller(0) failed")
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Fprint(ioutil.Discard, stack.Call(pc))
+ }
+}
+
+func BenchmarkCallPlusVFmt(b *testing.B) {
+ pc, _, _, ok := runtime.Caller(0)
+ if !ok {
+ b.Fatal("runtime.Caller(0) failed")
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Fprintf(ioutil.Discard, "%+v", stack.Call(pc))
+ }
+}
+
+func BenchmarkCallSharpVFmt(b *testing.B) {
+ pc, _, _, ok := runtime.Caller(0)
+ if !ok {
+ b.Fatal("runtime.Caller(0) failed")
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Fprintf(ioutil.Discard, "%#v", stack.Call(pc))
+ }
+}
+
+func BenchmarkCallSFmt(b *testing.B) {
+ pc, _, _, ok := runtime.Caller(0)
+ if !ok {
+ b.Fatal("runtime.Caller(0) failed")
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Fprintf(ioutil.Discard, "%s", stack.Call(pc))
+ }
+}
+
+func BenchmarkCallPlusSFmt(b *testing.B) {
+ pc, _, _, ok := runtime.Caller(0)
+ if !ok {
+ b.Fatal("runtime.Caller(0) failed")
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Fprintf(ioutil.Discard, "%+s", stack.Call(pc))
+ }
+}
+
+func BenchmarkCallSharpSFmt(b *testing.B) {
+ pc, _, _, ok := runtime.Caller(0)
+ if !ok {
+ b.Fatal("runtime.Caller(0) failed")
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Fprintf(ioutil.Discard, "%#s", stack.Call(pc))
+ }
+}
+
+func BenchmarkCallDFmt(b *testing.B) {
+ pc, _, _, ok := runtime.Caller(0)
+ if !ok {
+ b.Fatal("runtime.Caller(0) failed")
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Fprintf(ioutil.Discard, "%d", stack.Call(pc))
+ }
+}
+
+func BenchmarkCallNFmt(b *testing.B) {
+ pc, _, _, ok := runtime.Caller(0)
+ if !ok {
+ b.Fatal("runtime.Caller(0) failed")
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Fprintf(ioutil.Discard, "%n", stack.Call(pc))
+ }
+}
+
+func BenchmarkCallPlusNFmt(b *testing.B) {
+ pc, _, _, ok := runtime.Caller(0)
+ if !ok {
+ b.Fatal("runtime.Caller(0) failed")
+ }
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Fprintf(ioutil.Discard, "%+n", stack.Call(pc))
+ }
+}
+
+func BenchmarkCallers(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ stack.Callers()
+ }
+}
+
+func deepStack(depth int, b *testing.B) stack.Trace {
+ if depth > 0 {
+ return deepStack(depth-1, b)
+ }
+ b.StartTimer()
+ s := stack.Callers()
+ b.StopTimer()
+ return s
+}
+
+func BenchmarkCallers10(b *testing.B) {
+ b.StopTimer()
+
+ for i := 0; i < b.N; i++ {
+ deepStack(10, b)
+ }
+}
+
+func BenchmarkCallers50(b *testing.B) {
+ b.StopTimer()
+
+ for i := 0; i < b.N; i++ {
+ deepStack(50, b)
+ }
+}
+
+func BenchmarkCallers100(b *testing.B) {
+ b.StopTimer()
+
+ for i := 0; i < b.N; i++ {
+ deepStack(100, b)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/syslog.go b/Godeps/_workspace/src/github.com/tendermint/log15/syslog.go
new file mode 100644
index 0000000000000000000000000000000000000000..36c12b11f7a7d98d9c74377ddb08dda7379fda67
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/syslog.go
@@ -0,0 +1,55 @@
+// +build !windows,!plan9
+
+package log15
+
+import (
+ "log/syslog"
+ "strings"
+)
+
+// SyslogHandler opens a connection to the system syslog daemon by calling
+// syslog.New and writes all records to it.
+func SyslogHandler(tag string, fmtr Format) (Handler, error) {
+ wr, err := syslog.New(syslog.LOG_INFO, tag)
+ return sharedSyslog(fmtr, wr, err)
+}
+
+// SyslogHandler opens a connection to a log daemon over the network and writes
+// all log records to it.
+func SyslogNetHandler(net, addr string, tag string, fmtr Format) (Handler, error) {
+ wr, err := syslog.Dial(net, addr, syslog.LOG_INFO, tag)
+ return sharedSyslog(fmtr, wr, err)
+}
+
+func sharedSyslog(fmtr Format, sysWr *syslog.Writer, err error) (Handler, error) {
+ if err != nil {
+ return nil, err
+ }
+ h := FuncHandler(func(r *Record) error {
+ var syslogFn = sysWr.Info
+ switch r.Lvl {
+ case LvlCrit:
+ syslogFn = sysWr.Crit
+ case LvlError:
+ syslogFn = sysWr.Err
+ case LvlWarn:
+ syslogFn = sysWr.Warning
+ case LvlInfo:
+ syslogFn = sysWr.Info
+ case LvlDebug:
+ syslogFn = sysWr.Debug
+ }
+
+ s := strings.TrimSpace(string(fmtr.Format(r)))
+ return syslogFn(s)
+ })
+ return LazyHandler(&closingHandler{sysWr, h}), nil
+}
+
+func (m muster) SyslogHandler(tag string, fmtr Format) Handler {
+ return must(SyslogHandler(tag, fmtr))
+}
+
+func (m muster) SyslogNetHandler(net, addr string, tag string, fmtr Format) Handler {
+ return must(SyslogNetHandler(net, addr, tag, fmtr))
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/term/LICENSE b/Godeps/_workspace/src/github.com/tendermint/log15/term/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..f090cb42f370bda9e7f4f58d9b8b8ee2750c115f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/term/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Simon Eskildsen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/term/terminal_darwin.go b/Godeps/_workspace/src/github.com/tendermint/log15/term/terminal_darwin.go
new file mode 100644
index 0000000000000000000000000000000000000000..b05de4cb8c8f89c5f7a70b192b84a07c545fc2e5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/term/terminal_darwin.go
@@ -0,0 +1,12 @@
+// Based on ssh/terminal:
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package term
+
+import "syscall"
+
+const ioctlReadTermios = syscall.TIOCGETA
+
+type Termios syscall.Termios
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/term/terminal_freebsd.go b/Godeps/_workspace/src/github.com/tendermint/log15/term/terminal_freebsd.go
new file mode 100644
index 0000000000000000000000000000000000000000..cfaceab337a2aaf905c895618e0121ec8bb3236b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/term/terminal_freebsd.go
@@ -0,0 +1,18 @@
+package term
+
+import (
+ "syscall"
+)
+
+const ioctlReadTermios = syscall.TIOCGETA
+
+// Go 1.2 doesn't include Termios for FreeBSD. This should be added in 1.3 and this could be merged with terminal_darwin.
+type Termios struct {
+ Iflag uint32
+ Oflag uint32
+ Cflag uint32
+ Lflag uint32
+ Cc [20]uint8
+ Ispeed uint32
+ Ospeed uint32
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/term/terminal_linux.go b/Godeps/_workspace/src/github.com/tendermint/log15/term/terminal_linux.go
new file mode 100644
index 0000000000000000000000000000000000000000..5e2419c6dbc9a40173d91590d436be1a83f9abaf
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/term/terminal_linux.go
@@ -0,0 +1,12 @@
+// Based on ssh/terminal:
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package term
+
+import "syscall"
+
+const ioctlReadTermios = syscall.TCGETS
+
+type Termios syscall.Termios
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/term/terminal_notwindows.go b/Godeps/_workspace/src/github.com/tendermint/log15/term/terminal_notwindows.go
new file mode 100644
index 0000000000000000000000000000000000000000..c0b201a5308991fe68a003c3684805fcb34fa556
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/term/terminal_notwindows.go
@@ -0,0 +1,20 @@
+// Based on ssh/terminal:
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build linux,!appengine darwin freebsd
+
+package term
+
+import (
+ "syscall"
+ "unsafe"
+)
+
+// IsTty returns true if the given file descriptor is a terminal.
+func IsTty(fd uintptr) bool {
+ var termios Termios
+ _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
+ return err == 0
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/log15/term/terminal_windows.go b/Godeps/_workspace/src/github.com/tendermint/log15/term/terminal_windows.go
new file mode 100644
index 0000000000000000000000000000000000000000..df3c30c15892a7bf23de61064e84d6842c145957
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/log15/term/terminal_windows.go
@@ -0,0 +1,26 @@
+// Based on ssh/terminal:
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package term
+
+import (
+ "syscall"
+ "unsafe"
+)
+
+var kernel32 = syscall.NewLazyDLL("kernel32.dll")
+
+var (
+ procGetConsoleMode = kernel32.NewProc("GetConsoleMode")
+)
+
+// IsTty returns true if the given file descriptor is a terminal.
+func IsTty(fd uintptr) bool {
+ var st uint32
+ r, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, fd, uintptr(unsafe.Pointer(&st)), 0)
+ return r != 0 && e == 0
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/account/account.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/account/account.go
new file mode 100644
index 0000000000000000000000000000000000000000..1c1492abc9f02a2aa525ce527e305c2a403b8404
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/account/account.go
@@ -0,0 +1,67 @@
+package account
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle"
+)
+
+// Signable is an interface for all signable things.
+// It typically removes signatures before serializing.
+type Signable interface {
+ WriteSignBytes(chainID string, w io.Writer, n *int64, err *error)
+}
+
+// SignBytes is a convenience method for getting the bytes to sign of a Signable.
+func SignBytes(chainID string, o Signable) []byte {
+ buf, n, err := new(bytes.Buffer), new(int64), new(error)
+ o.WriteSignBytes(chainID, buf, n, err)
+ if *err != nil {
+ panic(err)
+ }
+ return buf.Bytes()
+}
+
+// HashSignBytes is a convenience method for getting the hash of the bytes of a signable
+func HashSignBytes(chainID string, o Signable) []byte {
+ return merkle.HashFromBinary(SignBytes(chainID, o))
+}
+
+//-----------------------------------------------------------------------------
+
+// Account resides in the application state, and is mutated by transactions
+// on the blockchain.
+// Serialized by binary.[read|write]Reflect
+type Account struct {
+ Address []byte `json:"address"`
+ PubKey PubKey `json:"pub_key"`
+ Sequence uint `json:"sequence"`
+ Balance uint64 `json:"balance"`
+ Code []byte `json:"code"` // VM code
+ StorageRoot []byte `json:"storage_root"` // VM storage merkle root.
+}
+
+func (acc *Account) Copy() *Account {
+ accCopy := *acc
+ return &accCopy
+}
+
+func (acc *Account) String() string {
+ return fmt.Sprintf("Account{%X:%v C:%v S:%X}", acc.Address, acc.PubKey, len(acc.Code), acc.StorageRoot)
+}
+
+func AccountEncoder(o interface{}, w io.Writer, n *int64, err *error) {
+ binary.WriteBinary(o.(*Account), w, n, err)
+}
+
+func AccountDecoder(r io.Reader, n *int64, err *error) interface{} {
+ return binary.ReadBinary(&Account{}, r, n, err)
+}
+
+var AccountCodec = binary.Codec{
+ Encode: AccountEncoder,
+ Decode: AccountDecoder,
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/account/priv_account.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/account/priv_account.go
new file mode 100644
index 0000000000000000000000000000000000000000..6ec8db4e7c6c7fa543adf24b44e68788ac7859cc
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/account/priv_account.go
@@ -0,0 +1,61 @@
+package account
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/ed25519"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+type PrivAccount struct {
+ Address []byte `json:"address"`
+ PubKey PubKey `json:"pub_key"`
+ PrivKey PrivKey `json:"priv_key"`
+}
+
+// Generates a new account with private key.
+func GenPrivAccount() *PrivAccount {
+ privKeyBytes := new([64]byte)
+ copy(privKeyBytes[:32], CRandBytes(32))
+ pubKeyBytes := ed25519.MakePublicKey(privKeyBytes)
+ pubKey := PubKeyEd25519(pubKeyBytes[:])
+ privKey := PrivKeyEd25519(privKeyBytes[:])
+ return &PrivAccount{
+ Address: pubKey.Address(),
+ PubKey: pubKey,
+ PrivKey: privKey,
+ }
+}
+
+// Generates a new account with private key from SHA256 hash of a secret
+func GenPrivAccountFromSecret(secret []byte) *PrivAccount {
+ privKey32 := binary.BinarySha256(secret)
+ privKeyBytes := new([64]byte)
+ copy(privKeyBytes[:32], privKey32)
+ pubKeyBytes := ed25519.MakePublicKey(privKeyBytes)
+ pubKey := PubKeyEd25519(pubKeyBytes[:])
+ privKey := PrivKeyEd25519(privKeyBytes[:])
+ return &PrivAccount{
+ Address: pubKey.Address(),
+ PubKey: pubKey,
+ PrivKey: privKey,
+ }
+}
+
+func GenPrivAccountFromKey(privKeyBytes [64]byte) *PrivAccount {
+ pubKeyBytes := ed25519.MakePublicKey(&privKeyBytes)
+ pubKey := PubKeyEd25519(pubKeyBytes[:])
+ privKey := PrivKeyEd25519(privKeyBytes[:])
+ return &PrivAccount{
+ Address: pubKey.Address(),
+ PubKey: pubKey,
+ PrivKey: privKey,
+ }
+}
+
+func (privAccount *PrivAccount) Sign(chainID string, o Signable) Signature {
+ return privAccount.PrivKey.Sign(SignBytes(chainID, o))
+}
+
+func (privAccount *PrivAccount) String() string {
+ return Fmt("PrivAccount{%X}", privAccount.Address)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/account/priv_key.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/account/priv_key.go
new file mode 100644
index 0000000000000000000000000000000000000000..7478ff5260532520c4452e902a4692e85fa9bd6a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/account/priv_key.go
@@ -0,0 +1,48 @@
+package account
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/ed25519"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+// PrivKey is part of PrivAccount and state.PrivValidator.
+type PrivKey interface {
+ Sign(msg []byte) Signature
+ PubKey() PubKey
+}
+
+// Types of PrivKey implementations
+const (
+ PrivKeyTypeEd25519 = byte(0x01)
+)
+
+// for binary.readReflect
+var _ = binary.RegisterInterface(
+ struct{ PrivKey }{},
+ binary.ConcreteType{PrivKeyEd25519{}, PrivKeyTypeEd25519},
+)
+
+//-------------------------------------
+
+// Implements PrivKey
+type PrivKeyEd25519 []byte
+
+func (privKey PrivKeyEd25519) Sign(msg []byte) Signature {
+ pubKey := privKey.PubKey().(PubKeyEd25519)
+ privKeyBytes := new([64]byte)
+ copy(privKeyBytes[:32], privKey[:])
+ copy(privKeyBytes[32:], pubKey[:])
+ signatureBytes := ed25519.Sign(privKeyBytes, msg)
+ return SignatureEd25519(signatureBytes[:])
+}
+
+func (key PrivKeyEd25519) PubKey() PubKey {
+ keyBytes := new([64]byte)
+ copy(keyBytes[:], key[:])
+ return PubKeyEd25519(ed25519.MakePublicKey(keyBytes)[:])
+}
+
+func (key PrivKeyEd25519) String() string {
+ return Fmt("PrivKeyEd25519{*****}")
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/account/pub_key.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/account/pub_key.go
new file mode 100644
index 0000000000000000000000000000000000000000..7f0686e2f115c7af84aaf778e09ac93d5097e0a1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/account/pub_key.go
@@ -0,0 +1,59 @@
+package account
+
+import (
+ "errors"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/ed25519"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+// PubKey is part of Account and Validator.
+type PubKey interface {
+ IsNil() bool
+ Address() []byte
+ VerifyBytes(msg []byte, sig Signature) bool
+}
+
+// Types of PubKey implementations
+const (
+ PubKeyTypeEd25519 = byte(0x01)
+)
+
+// for binary.readReflect
+var _ = binary.RegisterInterface(
+ struct{ PubKey }{},
+ binary.ConcreteType{PubKeyEd25519{}, PubKeyTypeEd25519},
+)
+
+//-------------------------------------
+
+// Implements PubKey
+type PubKeyEd25519 []byte
+
+func (pubKey PubKeyEd25519) IsNil() bool { return false }
+
+// TODO: Or should this just be BinaryRipemd160(key)? (The difference is the TypeByte.)
+func (pubKey PubKeyEd25519) Address() []byte { return binary.BinaryRipemd160(pubKey) }
+
+func (pubKey PubKeyEd25519) VerifyBytes(msg []byte, sig_ Signature) bool {
+ sig, ok := sig_.(SignatureEd25519)
+ if !ok {
+ panic("PubKeyEd25519 expects an SignatureEd25519 signature")
+ }
+ pubKeyBytes := new([32]byte)
+ copy(pubKeyBytes[:], pubKey)
+ sigBytes := new([64]byte)
+ copy(sigBytes[:], sig)
+ return ed25519.Verify(pubKeyBytes, msg, sigBytes)
+}
+
+func (pubKey PubKeyEd25519) ValidateBasic() error {
+ if len(pubKey) != ed25519.PublicKeySize {
+ return errors.New("Invalid PubKeyEd25519 key size")
+ }
+ return nil
+}
+
+func (pubKey PubKeyEd25519) String() string {
+ return Fmt("PubKeyEd25519{%X}", []byte(pubKey))
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/account/signature.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/account/signature.go
new file mode 100644
index 0000000000000000000000000000000000000000..d542d9be41401ad38092a64fc3edc861e085e4ff
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/account/signature.go
@@ -0,0 +1,34 @@
+package account
+
+import (
+ "fmt"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+// Signature is a part of Txs and consensus Votes.
+type Signature interface {
+}
+
+// Types of Signature implementations
+const (
+ SignatureTypeEd25519 = byte(0x01)
+)
+
+// for binary.readReflect
+var _ = binary.RegisterInterface(
+ struct{ Signature }{},
+ binary.ConcreteType{SignatureEd25519{}, SignatureTypeEd25519},
+)
+
+//-------------------------------------
+
+// Implements Signature
+type SignatureEd25519 []byte
+
+func (sig SignatureEd25519) IsNil() bool { return false }
+
+func (sig SignatureEd25519) IsZero() bool { return len(sig) == 0 }
+
+func (sig SignatureEd25519) String() string { return fmt.Sprintf("%X", Fingerprint(sig)) }
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/account/signature_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/account/signature_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..edd8745093410bd67bf0b079c33f5c39a4adc1e9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/account/signature_test.go
@@ -0,0 +1,68 @@
+package account
+
+import (
+ "bytes"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/ed25519"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+func TestSignAndValidate(t *testing.T) {
+
+ privAccount := GenPrivAccount()
+ pubKey := privAccount.PubKey
+ privKey := privAccount.PrivKey
+
+ msg := CRandBytes(128)
+ sig := privKey.Sign(msg)
+ t.Logf("msg: %X, sig: %X", msg, sig)
+
+ // Test the signature
+ if !pubKey.VerifyBytes(msg, sig) {
+ t.Errorf("Account message signature verification failed")
+ }
+
+ // Mutate the signature, just one bit.
+ sig.(SignatureEd25519)[0] ^= byte(0x01)
+
+ if pubKey.VerifyBytes(msg, sig) {
+ t.Errorf("Account message signature verification should have failed but passed instead")
+ }
+}
+
+func TestBinaryDecode(t *testing.T) {
+
+ privAccount := GenPrivAccount()
+ pubKey := privAccount.PubKey
+ privKey := privAccount.PrivKey
+
+ msg := CRandBytes(128)
+ sig := privKey.Sign(msg)
+ t.Logf("msg: %X, sig: %X", msg, sig)
+
+ buf, n, err := new(bytes.Buffer), new(int64), new(error)
+ binary.WriteBinary(sig, buf, n, err)
+ if *err != nil {
+ t.Fatalf("Failed to write Signature: %v", err)
+ }
+
+ if len(buf.Bytes()) != ed25519.SignatureSize+3 {
+ // 1 byte TypeByte, 2 bytes length, 64 bytes signature bytes
+ t.Fatalf("Unexpected signature write size: %v", len(buf.Bytes()))
+ }
+ if buf.Bytes()[0] != SignatureTypeEd25519 {
+ t.Fatalf("Unexpected signature type byte")
+ }
+
+ sig2, ok := binary.ReadBinary(SignatureEd25519{}, buf, n, err).(SignatureEd25519)
+ if !ok || *err != nil {
+ t.Fatalf("Failed to read Signature: %v", err)
+ }
+
+ // Test the signature
+ if !pubKey.VerifyBytes(msg, sig2) {
+ t.Errorf("Account message signature verification failed")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/alert/alert.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/alert/alert.go
new file mode 100644
index 0000000000000000000000000000000000000000..497be012cd64708407554ad46cf04fbf7209ea46
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/alert/alert.go
@@ -0,0 +1,64 @@
+package alert
+
+import (
+ "fmt"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/sfreiberg/gotwilio"
+)
+
+var lastAlertUnix int64 = 0
+var alertCountSince int = 0
+
+// Sends a critical alert message to administrators.
+func Alert(message string) {
+ log.Error("<!> ALERT <!>\n" + message)
+ now := time.Now().Unix()
+ if now-lastAlertUnix > int64(config.GetInt("alert_min_interval")) {
+ message = fmt.Sprintf("%v:%v", config.GetString("chain_id"), message)
+ if alertCountSince > 0 {
+ message = fmt.Sprintf("%v (+%v more since)", message, alertCountSince)
+ alertCountSince = 0
+ }
+ if len(config.GetString("alert_twilio_sid")) > 0 {
+ go sendTwilio(message)
+ }
+ if len(config.GetString("alert_email_recipients")) > 0 {
+ go sendEmail(message)
+ }
+ } else {
+ alertCountSince++
+ }
+}
+
+func sendTwilio(message string) {
+ defer func() {
+ if err := recover(); err != nil {
+ log.Error("sendTwilio error", "error", err)
+ }
+ }()
+ if len(message) > 50 {
+ message = message[:50]
+ }
+ twilio := gotwilio.NewTwilioClient(config.GetString("alert_twilio_sid"), config.GetString("alert_twilio_token"))
+ res, exp, err := twilio.SendSMS(config.GetString("alert_twilio_from"), config.GetString("alert_twilio_to"), message, "", "")
+ if exp != nil || err != nil {
+ log.Error("sendTwilio error", "res", res, "exp", exp, "error", err)
+ }
+}
+
+func sendEmail(message string) {
+ defer func() {
+ if err := recover(); err != nil {
+ log.Error("sendEmail error", "error", err)
+ }
+ }()
+ subject := message
+ if len(subject) > 80 {
+ subject = subject[:80]
+ }
+ err := SendEmail(subject, message, config.GetStringSlice("alert_email_recipients"))
+ if err != nil {
+ log.Error("sendEmail error", "error", err, "message", message)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/alert/config.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/alert/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..2354e5617adec9dc143745cf456148fbe81c5528
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/alert/config.go
@@ -0,0 +1,13 @@
+package alert
+
+import (
+ cfg "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config"
+)
+
+var config cfg.Config = nil
+
+func init() {
+ cfg.OnConfig(func(newConfig cfg.Config) {
+ config = newConfig
+ })
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/alert/email.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/alert/email.go
new file mode 100644
index 0000000000000000000000000000000000000000..c183f1d588ebac91c993f363857ccff64224e24f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/alert/email.go
@@ -0,0 +1,176 @@
+// Forked from github.com/SlyMarbo/gmail
+package alert
+
+import (
+ "bytes"
+ "crypto/tls"
+ "encoding/base64"
+ "errors"
+ "fmt"
+ "io/ioutil"
+ "net/smtp"
+ "path/filepath"
+ "regexp"
+ "strings"
+)
+
+// Convenience function
+func SendEmail(subject, body string, tos []string) error {
+ email := Compose(subject, body)
+ email.From = config.GetString("smtp_user")
+ email.ContentType = "text/html; charset=utf-8"
+ email.AddRecipients(tos...)
+ err := email.Send()
+ return err
+}
+
+// Email represents a single message, which may contain
+// attachments.
+type Email struct {
+ From string
+ To []string
+ Subject string
+ ContentType string
+ Body string
+ Attachments map[string][]byte
+}
+
+// Compose begins a new email, filling the subject and body,
+// and allocating memory for the list of recipients and the
+// attachments.
+func Compose(Subject, Body string) *Email {
+ out := new(Email)
+ out.To = make([]string, 0, 1)
+ out.Subject = Subject
+ out.Body = Body
+ out.Attachments = make(map[string][]byte)
+ return out
+}
+
+// Attach takes a filename and adds this to the message.
+// Note that since only the filename is stored (and not
+// its path, for privacy reasons), multiple files in
+// different directories but with the same filename and
+// extension cannot be sent.
+func (e *Email) Attach(Filename string) error {
+ b, err := ioutil.ReadFile(Filename)
+ if err != nil {
+ return err
+ }
+
+ _, fname := filepath.Split(Filename)
+ e.Attachments[fname] = b
+ return nil
+}
+
+// AddRecipient adds a single recipient.
+func (e *Email) AddRecipient(Recipient string) {
+ e.To = append(e.To, Recipient)
+}
+
+// AddRecipients adds one or more recipients.
+func (e *Email) AddRecipients(Recipients ...string) {
+ e.To = append(e.To, Recipients...)
+}
+
+// Send sends the email, returning any error encountered.
+func (e *Email) Send() error {
+ if e.From == "" {
+ return errors.New("Error: No sender specified. Please set the Email.From field.")
+ }
+ if e.To == nil || len(e.To) == 0 {
+ return errors.New("Error: No recipient specified. Please set the Email.To field.")
+ }
+
+ auth := smtp.PlainAuth(
+ "",
+ config.GetString("smtp_user"),
+ config.GetString("smtp_password"),
+ config.GetString("smtp_host"),
+ )
+
+ conn, err := smtp.Dial(fmt.Sprintf("%v:%v", config.GetString("smtp_host"), config.GetString("smtp_port")))
+ if err != nil {
+ return err
+ }
+
+ err = conn.StartTLS(&tls.Config{})
+ if err != nil {
+ return err
+ }
+
+ err = conn.Auth(auth)
+ if err != nil {
+ return err
+ }
+
+ err = conn.Mail(e.From)
+ if err != nil {
+ if strings.Contains(err.Error(), "530 5.5.1") {
+ return errors.New("Error: Authentication failure. Your username or password is incorrect.")
+ }
+ return err
+ }
+
+ for _, recipient := range e.To {
+ err = conn.Rcpt(recipient)
+ if err != nil {
+ return err
+ }
+ }
+
+ wc, err := conn.Data()
+ if err != nil {
+ return err
+ }
+ defer wc.Close()
+ _, err = wc.Write(e.Bytes())
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (e *Email) Bytes() []byte {
+ buf := bytes.NewBuffer(nil)
+
+ var subject = e.Subject
+ subject = regexp.MustCompile("\n+").ReplaceAllString(subject, " ")
+ subject = regexp.MustCompile(" +").ReplaceAllString(subject, " ")
+ buf.WriteString("Subject: " + subject + "\n")
+ buf.WriteString("To: <" + strings.Join(e.To, ">,<") + ">\n")
+ buf.WriteString("MIME-Version: 1.0\n")
+
+ // Boundary is used by MIME to separate files.
+ boundary := "f46d043c813270fc6b04c2d223da"
+
+ if len(e.Attachments) > 0 {
+ buf.WriteString("Content-Type: multipart/mixed; boundary=" + boundary + "\n")
+ buf.WriteString("--" + boundary + "\n")
+ }
+
+ if e.ContentType == "" {
+ e.ContentType = "text/plain; charset=utf-8"
+ }
+ buf.WriteString(fmt.Sprintf("Content-Type: %s\n\n", e.ContentType))
+ buf.WriteString(e.Body)
+
+ if len(e.Attachments) > 0 {
+ for k, v := range e.Attachments {
+ buf.WriteString("\n\n--" + boundary + "\n")
+ buf.WriteString("Content-Type: application/octet-stream\n")
+ buf.WriteString("Content-Transfer-Encoding: base64\n")
+ buf.WriteString("Content-Disposition: attachment; filename=\"" + k + "\"\n\n")
+
+ b := make([]byte, base64.StdEncoding.EncodedLen(len(v)))
+ base64.StdEncoding.Encode(b, v)
+ buf.Write(b)
+ buf.WriteString("\n--" + boundary)
+ }
+
+ buf.WriteString("--")
+ }
+
+ return buf.Bytes()
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/alert/log.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/alert/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..9fccbd85accab8da8660a1e8bf2064db2c2cddf8
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/alert/log.go
@@ -0,0 +1,7 @@
+package alert
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/logger"
+)
+
+var log = logger.New("module", "alert")
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/README.md b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..c490d0e577f07fc6fd2e8e97c20bc6f9a029937c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/README.md
@@ -0,0 +1,138 @@
+### NOTICE
+
+This documentation is out of date.
+* 0x00 is reserved as a nil byte for RegisterInterface
+* moved TypeByte() into RegisterInterface/ConcreteType
+* Pointers that don't have a declared TypeByte() are
+ encoded with a leading 0x00 (nil) or 0x01.
+
+# `tendermint/binary`
+
+The `binary` submodule encodes primary types and structs into bytes.
+
+## Primary types
+
+uint\*, int\*, string, time, byteslice and byteslice-slice types can be
+encoded and decoded with the following methods:
+
+The following writes `o uint64` to `w io.Writer`, and increments `n` and/or sets `err`
+```go
+WriteUint64(o uint64, w io.Writer, n *int64, err *error)
+
+// Typical usage:
+buf, n, err := new(bytes.Buffer), new(int64), new(error)
+WriteUint64(uint64(x), buf, n, err)
+if *err != nil {
+ panic(err)
+}
+
+```
+
+The following reads a `uint64` from `r io.Reader`, and increments `n` and/or sets `err`
+```go
+var o = ReadUint64(r io.Reader, n *int64, err *error)
+```
+
+Similar methods for `uint32`, `uint16`, `uint8`, `int64`, `int32`, `int16`, `int8` exist.
+Protobuf variable length encoding is done with `uint` and `int` types:
+```go
+WriteUvarint(o uint, w io.Writer, n *int64, err *error)
+var o = ReadUvarint(r io.Reader, n *int64, err *error)
+```
+
+Byteslices can be written with:
+```go
+WriteByteSlice(bz []byte, w io.Writer, n *int64, err *error)
+```
+
+Byteslices (and all slices such as byteslice-slices) are prepended with
+`uvarint` encoded length, so `ReadByteSlice()` knows how many bytes to read.
+
+Note that there is no type information encoded -- the caller is assumed to know what types
+to decode.
+
+## Struct Types
+
+Struct types can be automatically encoded with reflection. Unlike json-encoding, no field
+name or type information is encoded. Field values are simply encoded in order.
+
+```go
+type Foo struct {
+ MyString string
+ MyUint32 uint32
+ myPrivateBytes []byte
+}
+
+foo := Foo{"my string", math.MaxUint32, []byte("my private bytes")}
+
+buf, n, err := new(bytes.Buffer), new(int64), new(error)
+WriteBinary(foo, buf, n, err)
+
+// fmt.Printf("%X", buf.Bytes()) gives:
+// 096D7920737472696E67FFFFFFFF
+// 09: uvarint encoded length of string "my string"
+// 6D7920737472696E67: bytes of string "my string"
+// FFFFFFFF: bytes for MaxUint32
+// Note that the unexported "myPrivateBytes" isn't encoded.
+
+foo2 := ReadBinary(Foo{}, buf, n, err).(Foo)
+
+// Or, to decode onto a pointer:
+foo2 := ReadBinary(&Foo{}, buf, n, err).(*Foo)
+```
+
+WriteBinary and ReadBinary can encode/decode structs recursively. However, interface field
+values are a bit more complicated.
+
+```go
+type Greeter interface {
+ Greet() string
+}
+
+type Dog struct{}
+func (d Dog) Greet() string { return "Woof!" }
+
+type Cat struct{}
+func (c Cat) Greet() string { return "Meow!" }
+
+type Foo struct {
+ Greeter
+}
+
+foo := Foo{Dog{}}
+
+buf, n, err := new(bytes.Buffer), new(int64), new(error)
+WriteBinary(foo, buf, n, err)
+
+// This errors because we don't know whether to read a Dog or Cat.
+foo2 := ReadBinary(Foo{}, buf, n, err)
+```
+
+In the above example, `ReadBinary()` fails because the `Greeter` field for `Foo{}`
+is ambiguous -- it could be either a `Dog{}` or a `Cat{}`, like a union structure.
+The solution is to declare the concrete implementation types for interfaces:
+
+```go
+type Dog struct{}
+func (d Dog) TypeByte() byte { return GreeterTypeDog }
+func (d Dog) Greet() string { return "Woof!" }
+
+type Cat struct{}
+func (c Cat) TypeByte() byte { return GreeterTypeCat }
+func (c Cat) Greet() string { return "Meow!" }
+
+var _ = RegisterInterface(
+ struct{Greeter}{},
+ ConcreteType{Dog{}},
+ ConcreteType{Cat{}},
+})
+```
+
+NOTE: The TypeByte() is written and expected to be read even when the struct
+is encoded or decoded directly:
+
+```go
+WriteBinary(Dog{}, buf, n, err) // Writes GreeterTypeDog byte
+dog_ := ReadBinary(Dog{}, buf, n, err) // Expects to read GreeterTypeDog byte
+dog := dog_.(Dog) // ok if *err != nil, otherwise dog_ == nil.
+```
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/binary.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/binary.go
new file mode 100644
index 0000000000000000000000000000000000000000..890ac76aadfdd42c013a510bf0dc4558fa1a7acd
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/binary.go
@@ -0,0 +1,81 @@
+package binary
+
+import (
+ "encoding/json"
+ "io"
+ "reflect"
+)
+
+func ReadBinary(o interface{}, r io.Reader, n *int64, err *error) interface{} {
+ rv, rt := reflect.ValueOf(o), reflect.TypeOf(o)
+ if rv.Kind() == reflect.Ptr {
+ readReflectBinary(rv.Elem(), rt.Elem(), Options{}, r, n, err)
+ return o
+ } else {
+ ptrRv := reflect.New(rt)
+ readReflectBinary(ptrRv.Elem(), rt, Options{}, r, n, err)
+ return ptrRv.Elem().Interface()
+ }
+}
+
+func WriteBinary(o interface{}, w io.Writer, n *int64, err *error) {
+ rv := reflect.ValueOf(o)
+ rt := reflect.TypeOf(o)
+ if rv.Kind() == reflect.Ptr {
+ rv, rt = rv.Elem(), rt.Elem()
+ }
+ writeReflectBinary(rv, rt, Options{}, w, n, err)
+}
+
+func ReadJSON(o interface{}, bytes []byte, err *error) interface{} {
+ var object interface{}
+ *err = json.Unmarshal(bytes, &object)
+ if *err != nil {
+ return o
+ }
+
+ return ReadJSONObject(o, object, err)
+}
+
+func ReadJSONObject(o interface{}, object interface{}, err *error) interface{} {
+ rv, rt := reflect.ValueOf(o), reflect.TypeOf(o)
+ if rv.Kind() == reflect.Ptr {
+ readReflectJSON(rv.Elem(), rt.Elem(), object, err)
+ return o
+ } else {
+ ptrRv := reflect.New(rt)
+ readReflectJSON(ptrRv.Elem(), rt, object, err)
+ return ptrRv.Elem().Interface()
+ }
+}
+
+func WriteJSON(o interface{}, w io.Writer, n *int64, err *error) {
+ rv := reflect.ValueOf(o)
+ rt := reflect.TypeOf(o)
+ if rv.Kind() == reflect.Ptr {
+ rv, rt = rv.Elem(), rt.Elem()
+ }
+ writeReflectJSON(rv, rt, w, n, err)
+}
+
+// Write all of bz to w
+// Increment n and set err accordingly.
+func WriteTo(bz []byte, w io.Writer, n *int64, err *error) {
+ if *err != nil {
+ return
+ }
+ n_, err_ := w.Write(bz)
+ *n += int64(n_)
+ *err = err_
+}
+
+// Read len(buf) from r
+// Increment n and set err accordingly.
+func ReadFull(buf []byte, r io.Reader, n *int64, err *error) {
+ if *err != nil {
+ return
+ }
+ n_, err_ := io.ReadFull(r, buf)
+ *n += int64(n_)
+ *err = err_
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/byteslice.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/byteslice.go
new file mode 100644
index 0000000000000000000000000000000000000000..052b786ea6503130bdb8fc8b827d2b5918b24c7f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/byteslice.go
@@ -0,0 +1,62 @@
+package binary
+
+import (
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "io"
+)
+
+const (
+ ByteSliceChunk = 1024
+)
+
+func WriteByteSlice(bz []byte, w io.Writer, n *int64, err *error) {
+ WriteUvarint(uint(len(bz)), w, n, err)
+ WriteTo(bz, w, n, err)
+}
+
+func ReadByteSlice(r io.Reader, n *int64, err *error) []byte {
+ length := int(ReadUvarint(r, n, err))
+ if *err != nil {
+ return nil
+ }
+
+ var buf, tmpBuf []byte
+ // read one ByteSliceChunk at a time and append
+ for i := 0; i*ByteSliceChunk < length; i++ {
+ tmpBuf = make([]byte, MinInt(ByteSliceChunk, length-i*ByteSliceChunk))
+ ReadFull(tmpBuf, r, n, err)
+ if *err != nil {
+ return nil
+ }
+ buf = append(buf, tmpBuf...)
+ }
+ return buf
+}
+
+//-----------------------------------------------------------------------------
+
+func WriteByteSlices(bzz [][]byte, w io.Writer, n *int64, err *error) {
+ WriteUvarint(uint(len(bzz)), w, n, err)
+ for _, bz := range bzz {
+ WriteByteSlice(bz, w, n, err)
+ if *err != nil {
+ return
+ }
+ }
+}
+
+func ReadByteSlices(r io.Reader, n *int64, err *error) [][]byte {
+ length := int(ReadUvarint(r, n, err))
+ if *err != nil {
+ return nil
+ }
+ bzz := make([][]byte, length)
+ for i := 0; i < length; i++ {
+ bz := ReadByteSlice(r, n, err)
+ if *err != nil {
+ return nil
+ }
+ bzz[i] = bz
+ }
+ return bzz
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/codec.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/codec.go
new file mode 100644
index 0000000000000000000000000000000000000000..85c9a0cfc40cc85a5a29ff5371a7159953088d83
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/codec.go
@@ -0,0 +1,168 @@
+package binary
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "reflect"
+ "time"
+)
+
+type Encoder func(o interface{}, w io.Writer, n *int64, err *error)
+type Decoder func(r io.Reader, n *int64, err *error) interface{}
+type Comparator func(o1 interface{}, o2 interface{}) int
+
+type Codec struct {
+ Encode Encoder
+ Decode Decoder
+ Compare Comparator
+}
+
+const (
+ typeByte = byte(0x01)
+ typeInt8 = byte(0x02)
+ // typeUint8 = byte(0x03)
+ typeInt16 = byte(0x04)
+ typeUint16 = byte(0x05)
+ typeInt32 = byte(0x06)
+ typeUint32 = byte(0x07)
+ typeInt64 = byte(0x08)
+ typeUint64 = byte(0x09)
+ typeVarint = byte(0x0A)
+ typeUvarint = byte(0x0B)
+ typeString = byte(0x10)
+ typeByteSlice = byte(0x11)
+ typeTime = byte(0x20)
+)
+
+func BasicCodecEncoder(o interface{}, w io.Writer, n *int64, err *error) {
+ switch o := o.(type) {
+ case nil:
+ panic("nil type unsupported")
+ case byte:
+ WriteByte(typeByte, w, n, err)
+ WriteByte(o, w, n, err)
+ case int8:
+ WriteByte(typeInt8, w, n, err)
+ WriteInt8(o, w, n, err)
+ //case uint8:
+ // WriteByte( typeUint8, w, n, err)
+ // WriteUint8( o, w, n, err)
+ case int16:
+ WriteByte(typeInt16, w, n, err)
+ WriteInt16(o, w, n, err)
+ case uint16:
+ WriteByte(typeUint16, w, n, err)
+ WriteUint16(o, w, n, err)
+ case int32:
+ WriteByte(typeInt32, w, n, err)
+ WriteInt32(o, w, n, err)
+ case uint32:
+ WriteByte(typeUint32, w, n, err)
+ WriteUint32(o, w, n, err)
+ case int64:
+ WriteByte(typeInt64, w, n, err)
+ WriteInt64(o, w, n, err)
+ case uint64:
+ WriteByte(typeUint64, w, n, err)
+ WriteUint64(o, w, n, err)
+ case int:
+ WriteByte(typeVarint, w, n, err)
+ WriteVarint(o, w, n, err)
+ case uint:
+ WriteByte(typeUvarint, w, n, err)
+ WriteUvarint(o, w, n, err)
+ case string:
+ WriteByte(typeString, w, n, err)
+ WriteString(o, w, n, err)
+ case []byte:
+ WriteByte(typeByteSlice, w, n, err)
+ WriteByteSlice(o, w, n, err)
+ case time.Time:
+ WriteByte(typeTime, w, n, err)
+ WriteTime(o, w, n, err)
+ default:
+ panic(fmt.Sprintf("Unsupported type: %v", reflect.TypeOf(o)))
+ }
+}
+
+func BasicCodecDecoder(r io.Reader, n *int64, err *error) (o interface{}) {
+ type_ := ReadByte(r, n, err)
+ switch type_ {
+ case typeByte:
+ o = ReadByte(r, n, err)
+ case typeInt8:
+ o = ReadInt8(r, n, err)
+ //case typeUint8:
+ // o = ReadUint8(r, n, err)
+ case typeInt16:
+ o = ReadInt16(r, n, err)
+ case typeUint16:
+ o = ReadUint16(r, n, err)
+ case typeInt32:
+ o = ReadInt32(r, n, err)
+ case typeUint32:
+ o = ReadUint32(r, n, err)
+ case typeInt64:
+ o = ReadInt64(r, n, err)
+ case typeUint64:
+ o = ReadUint64(r, n, err)
+ case typeVarint:
+ o = ReadVarint(r, n, err)
+ case typeUvarint:
+ o = ReadUvarint(r, n, err)
+ case typeString:
+ o = ReadString(r, n, err)
+ case typeByteSlice:
+ o = ReadByteSlice(r, n, err)
+ case typeTime:
+ o = ReadTime(r, n, err)
+ default:
+ if *err != nil {
+ panic(*err)
+ } else {
+ panic(fmt.Sprintf("Unsupported type byte: %X", type_))
+ }
+ }
+ return o
+}
+
+func BasicCodecComparator(o1 interface{}, o2 interface{}) int {
+ switch o1.(type) {
+ case byte:
+ return int(o1.(byte) - o2.(byte))
+ case int8:
+ return int(o1.(int8) - o2.(int8))
+ //case uint8:
+ case int16:
+ return int(o1.(int16) - o2.(int16))
+ case uint16:
+ return int(o1.(uint16) - o2.(uint16))
+ case int32:
+ return int(o1.(int32) - o2.(int32))
+ case uint32:
+ return int(o1.(uint32) - o2.(uint32))
+ case int64:
+ return int(o1.(int64) - o2.(int64))
+ case uint64:
+ return int(o1.(uint64) - o2.(uint64))
+ case int:
+ return o1.(int) - o2.(int)
+ case uint:
+ return int(o1.(uint)) - int(o2.(uint))
+ case string:
+ return bytes.Compare([]byte(o1.(string)), []byte(o2.(string)))
+ case []byte:
+ return bytes.Compare(o1.([]byte), o2.([]byte))
+ case time.Time:
+ return int(o1.(time.Time).UnixNano() - o2.(time.Time).UnixNano())
+ default:
+ panic(fmt.Sprintf("Unsupported type: %v", reflect.TypeOf(o1)))
+ }
+}
+
+var BasicCodec = Codec{
+ Encode: BasicCodecEncoder,
+ Decode: BasicCodecDecoder,
+ Compare: BasicCodecComparator,
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/int.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/int.go
new file mode 100644
index 0000000000000000000000000000000000000000..90f3f4323ebba86a7c1490e9786fcdbe24fee82b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/int.go
@@ -0,0 +1,268 @@
+package binary
+
+import (
+ "encoding/binary"
+ "errors"
+ "io"
+)
+
+// Byte
+
+func WriteByte(b byte, w io.Writer, n *int64, err *error) {
+ WriteTo([]byte{b}, w, n, err)
+}
+
+func ReadByte(r io.Reader, n *int64, err *error) byte {
+ buf := make([]byte, 1)
+ ReadFull(buf, r, n, err)
+ return buf[0]
+}
+
+// Int8
+
+func WriteInt8(i int8, w io.Writer, n *int64, err *error) {
+ WriteByte(byte(i), w, n, err)
+}
+
+func ReadInt8(r io.Reader, n *int64, err *error) int8 {
+ return int8(ReadByte(r, n, err))
+}
+
+// Uint8
+
+func WriteUint8(i uint8, w io.Writer, n *int64, err *error) {
+ WriteByte(byte(i), w, n, err)
+}
+
+func ReadUint8(r io.Reader, n *int64, err *error) uint8 {
+ return uint8(ReadByte(r, n, err))
+}
+
+// Int16
+
+func WriteInt16(i int16, w io.Writer, n *int64, err *error) {
+ buf := make([]byte, 2)
+ binary.BigEndian.PutUint16(buf, uint16(i))
+ *n += 2
+ WriteTo(buf, w, n, err)
+}
+
+func ReadInt16(r io.Reader, n *int64, err *error) int16 {
+ buf := make([]byte, 2)
+ ReadFull(buf, r, n, err)
+ return int16(binary.BigEndian.Uint16(buf))
+}
+
+// Uint16
+
+func WriteUint16(i uint16, w io.Writer, n *int64, err *error) {
+ buf := make([]byte, 2)
+ binary.BigEndian.PutUint16(buf, uint16(i))
+ *n += 2
+ WriteTo(buf, w, n, err)
+}
+
+func ReadUint16(r io.Reader, n *int64, err *error) uint16 {
+ buf := make([]byte, 2)
+ ReadFull(buf, r, n, err)
+ return uint16(binary.BigEndian.Uint16(buf))
+}
+
+// []Uint16
+
+func WriteUint16s(iz []uint16, w io.Writer, n *int64, err *error) {
+ WriteUint32(uint32(len(iz)), w, n, err)
+ for _, i := range iz {
+ WriteUint16(i, w, n, err)
+ if *err != nil {
+ return
+ }
+ }
+}
+
+func ReadUint16s(r io.Reader, n *int64, err *error) []uint16 {
+ length := ReadUint32(r, n, err)
+ if *err != nil {
+ return nil
+ }
+ iz := make([]uint16, length)
+ for j := uint32(0); j < length; j++ {
+ ii := ReadUint16(r, n, err)
+ if *err != nil {
+ return nil
+ }
+ iz[j] = ii
+ }
+ return iz
+}
+
+// Int32
+
+func WriteInt32(i int32, w io.Writer, n *int64, err *error) {
+ buf := make([]byte, 4)
+ binary.BigEndian.PutUint32(buf, uint32(i))
+ *n += 4
+ WriteTo(buf, w, n, err)
+}
+
+func ReadInt32(r io.Reader, n *int64, err *error) int32 {
+ buf := make([]byte, 4)
+ ReadFull(buf, r, n, err)
+ return int32(binary.BigEndian.Uint32(buf))
+}
+
+// Uint32
+
+func WriteUint32(i uint32, w io.Writer, n *int64, err *error) {
+ buf := make([]byte, 4)
+ binary.BigEndian.PutUint32(buf, uint32(i))
+ *n += 4
+ WriteTo(buf, w, n, err)
+}
+
+func ReadUint32(r io.Reader, n *int64, err *error) uint32 {
+ buf := make([]byte, 4)
+ ReadFull(buf, r, n, err)
+ return uint32(binary.BigEndian.Uint32(buf))
+}
+
+// Int64
+
+func WriteInt64(i int64, w io.Writer, n *int64, err *error) {
+ buf := make([]byte, 8)
+ binary.BigEndian.PutUint64(buf, uint64(i))
+ *n += 8
+ WriteTo(buf, w, n, err)
+}
+
+func ReadInt64(r io.Reader, n *int64, err *error) int64 {
+ buf := make([]byte, 8)
+ ReadFull(buf, r, n, err)
+ return int64(binary.BigEndian.Uint64(buf))
+}
+
+// Uint64
+
+func WriteUint64(i uint64, w io.Writer, n *int64, err *error) {
+ buf := make([]byte, 8)
+ binary.BigEndian.PutUint64(buf, uint64(i))
+ *n += 8
+ WriteTo(buf, w, n, err)
+}
+
+func ReadUint64(r io.Reader, n *int64, err *error) uint64 {
+ buf := make([]byte, 8)
+ ReadFull(buf, r, n, err)
+ return uint64(binary.BigEndian.Uint64(buf))
+}
+
+// Varint
+
+func uvarintSize(i_ uint) int {
+ i := uint64(i_)
+ if i == 0 {
+ return 0
+ }
+ if i < 1<<8 {
+ return 1
+ }
+ if i < 1<<16 {
+ return 2
+ }
+ if i < 1<<24 {
+ return 3
+ }
+ if i < 1<<32 {
+ return 4
+ }
+ if i < 1<<40 {
+ return 5
+ }
+ if i < 1<<48 {
+ return 6
+ }
+ if i < 1<<56 {
+ return 7
+ }
+ return 8
+}
+
+func WriteVarint(i int, w io.Writer, n *int64, err *error) {
+ var negate = false
+ if i < 0 {
+ negate = true
+ i = -i
+ }
+ var size = uvarintSize(uint(i))
+ if negate {
+ // e.g. 0xF1 for a single negative byte
+ WriteUint8(uint8(size+0xF0), w, n, err)
+ } else {
+ WriteUint8(uint8(size), w, n, err)
+ }
+ if size > 0 {
+ buf := make([]byte, 8)
+ binary.BigEndian.PutUint64(buf, uint64(i))
+ WriteTo(buf[(8-size):], w, n, err)
+ }
+ *n += int64(1 + size)
+}
+
+func ReadVarint(r io.Reader, n *int64, err *error) int {
+ var size = ReadUint8(r, n, err)
+ var negate = false
+ if (size >> 4) == 0xF {
+ negate = true
+ size = size & 0x0F
+ }
+ if size > 8 {
+ setFirstErr(err, errors.New("Varint overflow"))
+ return 0
+ }
+ if size == 0 {
+ return 0
+ }
+ buf := make([]byte, 8)
+ ReadFull(buf[(8-size):], r, n, err)
+ *n += int64(1 + size)
+ var i = int(binary.BigEndian.Uint64(buf))
+ if negate {
+ return -i
+ } else {
+ return i
+ }
+}
+
+// Uvarint
+
+func WriteUvarint(i uint, w io.Writer, n *int64, err *error) {
+ var size = uvarintSize(i)
+ WriteUint8(uint8(size), w, n, err)
+ if size > 0 {
+ buf := make([]byte, 8)
+ binary.BigEndian.PutUint64(buf, uint64(i))
+ WriteTo(buf[(8-size):], w, n, err)
+ }
+ *n += int64(1 + size)
+}
+
+func ReadUvarint(r io.Reader, n *int64, err *error) uint {
+ var size = ReadUint8(r, n, err)
+ if size > 8 {
+ setFirstErr(err, errors.New("Uvarint overflow"))
+ return 0
+ }
+ if size == 0 {
+ return 0
+ }
+ buf := make([]byte, 8)
+ ReadFull(buf[(8-size):], r, n, err)
+ *n += int64(1 + size)
+ return uint(binary.BigEndian.Uint64(buf))
+}
+
+func setFirstErr(err *error, newErr error) {
+ if *err == nil && newErr != nil {
+ *err = newErr
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/int_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/int_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..49348fae7f2b304e37e11c914a9bbefcfb9397ef
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/int_test.go
@@ -0,0 +1,79 @@
+package binary
+
+import (
+ "bytes"
+ "fmt"
+ "testing"
+)
+
+func TestVarint(t *testing.T) {
+
+ check := func(i int, s string) {
+ buf := new(bytes.Buffer)
+ n, err := new(int64), new(error)
+ WriteVarint(i, buf, n, err)
+ bufBytes := buf.Bytes() // Read before consuming below.
+ i_ := ReadVarint(buf, n, err)
+ if i != i_ {
+ fmt.Println(bufBytes)
+ t.Fatalf("Encoded %v and got %v", i, i_)
+ }
+ if s != "" {
+ if bufHex := fmt.Sprintf("%X", bufBytes); bufHex != s {
+ t.Fatalf("Encoded %v, expected %v", bufHex, s)
+ }
+ }
+ }
+
+ // 123457 is some prime.
+ for i := -(2 << 33); i < (2 << 33); i += 123457 {
+ check(i, "")
+ }
+
+ // Near zero
+ check(-1, "F101")
+ check(0, "00")
+ check(1, "0101")
+ // Positives
+ check(1<<32-1, "04FFFFFFFF")
+ check(1<<32+0, "050100000000")
+ check(1<<32+1, "050100000001")
+ check(1<<53-1, "071FFFFFFFFFFFFF")
+ // Negatives
+ check(-1<<32+1, "F4FFFFFFFF")
+ check(-1<<32-0, "F50100000000")
+ check(-1<<32-1, "F50100000001")
+ check(-1<<53+1, "F71FFFFFFFFFFFFF")
+}
+
+func TestUvarint(t *testing.T) {
+
+ check := func(i uint, s string) {
+ buf := new(bytes.Buffer)
+ n, err := new(int64), new(error)
+ WriteUvarint(i, buf, n, err)
+ bufBytes := buf.Bytes()
+ i_ := ReadUvarint(buf, n, err)
+ if i != i_ {
+ fmt.Println(buf.Bytes())
+ t.Fatalf("Encoded %v and got %v", i, i_)
+ }
+ if s != "" {
+ if bufHex := fmt.Sprintf("%X", bufBytes); bufHex != s {
+ t.Fatalf("Encoded %v, expected %v", bufHex, s)
+ }
+ }
+ }
+
+ // 123457 is some prime.
+ for i := 0; i < (2 << 33); i += 123457 {
+ check(uint(i), "")
+ }
+
+ check(1, "0101")
+ check(1<<32-1, "04FFFFFFFF")
+ check(1<<32+0, "050100000000")
+ check(1<<32+1, "050100000001")
+ check(1<<53-1, "071FFFFFFFFFFFFF")
+
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/log.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..a688997b722ec243d969807f77bafe56218bf37d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/log.go
@@ -0,0 +1,18 @@
+package binary
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/logger"
+)
+
+var log = logger.New("module", "binary")
+
+func init() {
+ log.SetHandler(
+ log15.LvlFilterHandler(
+ log15.LvlWarn,
+ //log15.LvlDebug,
+ logger.RootHandler(),
+ ),
+ )
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/reflect.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/reflect.go
new file mode 100644
index 0000000000000000000000000000000000000000..7a2468df6a581064a1cf09f4c105bdcf84ff9ec1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/reflect.go
@@ -0,0 +1,824 @@
+package binary
+
+import (
+ "encoding/hex"
+ "encoding/json"
+ "errors"
+ "io"
+ "reflect"
+ "sync"
+ "time"
+
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+const (
+ ReflectSliceChunk = 1024
+)
+
+type TypeInfo struct {
+ Type reflect.Type // The type
+
+ // If Type is kind reflect.Interface, is registered
+ IsRegisteredInterface bool
+ ByteToType map[byte]reflect.Type
+ TypeToByte map[reflect.Type]byte
+
+ // If Type is concrete
+ Byte byte
+
+ // If Type is kind reflect.Struct
+ Fields []StructFieldInfo
+}
+
+type Options struct {
+ JSONName string // (JSON) Corresponding JSON field name. (override with `json=""`)
+ Varint bool // (Binary) Use length-prefixed encoding for (u)int*
+}
+
+func getOptionsFromField(field reflect.StructField) (skip bool, opts Options) {
+ jsonName := field.Tag.Get("json")
+ if jsonName == "-" {
+ skip = true
+ return
+ } else if jsonName == "" {
+ jsonName = field.Name
+ }
+ varint := false
+ binTag := field.Tag.Get("binary")
+ if binTag == "varint" { // TODO: extend
+ varint = true
+ }
+ opts = Options{
+ JSONName: jsonName,
+ Varint: varint,
+ }
+ return
+}
+
+type StructFieldInfo struct {
+ Index int // Struct field index
+ Type reflect.Type // Struct field type
+ Options // Encoding options
+}
+
+func (info StructFieldInfo) unpack() (int, reflect.Type, Options) {
+ return info.Index, info.Type, info.Options
+}
+
+// e.g. If o is struct{Foo}{}, return is the Foo interface type.
+func GetTypeFromStructDeclaration(o interface{}) reflect.Type {
+ rt := reflect.TypeOf(o)
+ if rt.NumField() != 1 {
+ panic("Unexpected number of fields in struct-wrapped declaration of type")
+ }
+ return rt.Field(0).Type
+}
+
+func SetByteForType(typeByte byte, rt reflect.Type) {
+ typeInfo := GetTypeInfo(rt)
+ if typeInfo.Byte != 0x00 && typeInfo.Byte != typeByte {
+ panic(Fmt("Type %v already registered with type byte %X", rt, typeByte))
+ }
+ typeInfo.Byte = typeByte
+ // If pointer, we need to set it for the concrete type as well.
+ if rt.Kind() == reflect.Ptr {
+ SetByteForType(typeByte, rt.Elem())
+ }
+}
+
+// Predeclaration of common types
+var (
+ timeType = GetTypeFromStructDeclaration(struct{ time.Time }{})
+)
+
+const (
+ rfc2822 = "Mon Jan 02 15:04:05 -0700 2006"
+)
+
+// NOTE: do not access typeInfos directly, but call GetTypeInfo()
+var typeInfosMtx sync.Mutex
+var typeInfos = map[reflect.Type]*TypeInfo{}
+
+func GetTypeInfo(rt reflect.Type) *TypeInfo {
+ typeInfosMtx.Lock()
+ defer typeInfosMtx.Unlock()
+ info := typeInfos[rt]
+ if info == nil {
+ info = MakeTypeInfo(rt)
+ typeInfos[rt] = info
+ }
+ return info
+}
+
+// For use with the RegisterInterface declaration
+type ConcreteType struct {
+ O interface{}
+ Byte byte
+}
+
+// Must use this to register an interface to properly decode the
+// underlying concrete type.
+func RegisterInterface(o interface{}, ctypes ...ConcreteType) *TypeInfo {
+ it := GetTypeFromStructDeclaration(o)
+ if it.Kind() != reflect.Interface {
+ panic("RegisterInterface expects an interface")
+ }
+ toType := make(map[byte]reflect.Type, 0)
+ toByte := make(map[reflect.Type]byte, 0)
+ for _, ctype := range ctypes {
+ crt := reflect.TypeOf(ctype.O)
+ typeByte := ctype.Byte
+ SetByteForType(typeByte, crt)
+ if typeByte == 0x00 {
+ panic(Fmt("Byte of 0x00 is reserved for nil (%v)", ctype))
+ }
+ if toType[typeByte] != nil {
+ panic(Fmt("Duplicate Byte for type %v and %v", ctype, toType[typeByte]))
+ }
+ toType[typeByte] = crt
+ toByte[crt] = typeByte
+ }
+ typeInfo := &TypeInfo{
+ Type: it,
+ IsRegisteredInterface: true,
+ ByteToType: toType,
+ TypeToByte: toByte,
+ }
+ typeInfos[it] = typeInfo
+ return typeInfo
+}
+
+func MakeTypeInfo(rt reflect.Type) *TypeInfo {
+ info := &TypeInfo{Type: rt}
+
+ // If struct, register field name options
+ if rt.Kind() == reflect.Struct {
+ numFields := rt.NumField()
+ structFields := []StructFieldInfo{}
+ for i := 0; i < numFields; i++ {
+ field := rt.Field(i)
+ if field.PkgPath != "" {
+ continue
+ }
+ skip, opts := getOptionsFromField(field)
+ if skip {
+ continue
+ }
+ structFields = append(structFields, StructFieldInfo{
+ Index: i,
+ Type: field.Type,
+ Options: opts,
+ })
+ }
+ info.Fields = structFields
+ }
+
+ return info
+}
+
+func readReflectBinary(rv reflect.Value, rt reflect.Type, opts Options, r io.Reader, n *int64, err *error) {
+
+ // Get typeInfo
+ typeInfo := GetTypeInfo(rt)
+
+ if rt.Kind() == reflect.Interface {
+ if !typeInfo.IsRegisteredInterface {
+ // There's no way we can read such a thing.
+ *err = errors.New(Fmt("Cannot read unregistered interface type %v", rt))
+ return
+ }
+ typeByte := ReadByte(r, n, err)
+ if *err != nil {
+ return
+ }
+ if typeByte == 0x00 {
+ return // nil
+ }
+ crt, ok := typeInfo.ByteToType[typeByte]
+ if !ok {
+ *err = errors.New(Fmt("Unexpected type byte %X for type %v", typeByte, rt))
+ return
+ }
+ crv := reflect.New(crt).Elem()
+ r = NewPrefixedReader([]byte{typeByte}, r)
+ readReflectBinary(crv, crt, opts, r, n, err)
+ rv.Set(crv) // NOTE: orig rv is ignored.
+ return
+ }
+
+ if rt.Kind() == reflect.Ptr {
+ typeByte := ReadByte(r, n, err)
+ if *err != nil {
+ return
+ }
+ if typeByte == 0x00 {
+ return // nil
+ }
+ // Create new if rv is nil.
+ if rv.IsNil() {
+ newRv := reflect.New(rt.Elem())
+ rv.Set(newRv)
+ rv = newRv
+ }
+ // Dereference pointer
+ rv, rt = rv.Elem(), rt.Elem()
+ typeInfo = GetTypeInfo(rt)
+ if typeInfo.Byte != 0x00 {
+ r = NewPrefixedReader([]byte{typeByte}, r)
+ }
+ // continue...
+ }
+
+ // Read Byte prefix
+ if typeInfo.Byte != 0x00 {
+ typeByte := ReadByte(r, n, err)
+ if typeByte != typeInfo.Byte {
+ *err = errors.New(Fmt("Expected Byte of %X but got %X", typeInfo.Byte, typeByte))
+ return
+ }
+ }
+
+ switch rt.Kind() {
+ case reflect.Slice:
+ elemRt := rt.Elem()
+ if elemRt.Kind() == reflect.Uint8 {
+ // Special case: Byteslices
+ byteslice := ReadByteSlice(r, n, err)
+ log.Debug("Read byteslice", "bytes", byteslice)
+ rv.Set(reflect.ValueOf(byteslice))
+ } else {
+ var sliceRv reflect.Value
+ // Read length
+ length := int(ReadUvarint(r, n, err))
+ log.Debug(Fmt("Read length: %v", length))
+ sliceRv = reflect.MakeSlice(rt, 0, 0)
+ // read one ReflectSliceChunk at a time and append
+ for i := 0; i*ReflectSliceChunk < length; i++ {
+ l := MinInt(ReflectSliceChunk, length-i*ReflectSliceChunk)
+ tmpSliceRv := reflect.MakeSlice(rt, l, l)
+ for j := 0; j < l; j++ {
+ elemRv := tmpSliceRv.Index(j)
+ readReflectBinary(elemRv, elemRt, opts, r, n, err)
+ if *err != nil {
+ return
+ }
+ }
+ sliceRv = reflect.AppendSlice(sliceRv, tmpSliceRv)
+ }
+
+ rv.Set(sliceRv)
+ }
+
+ case reflect.Struct:
+ if rt == timeType {
+ // Special case: time.Time
+ t := ReadTime(r, n, err)
+ log.Debug(Fmt("Read time: %v", t))
+ rv.Set(reflect.ValueOf(t))
+ } else {
+ for _, fieldInfo := range typeInfo.Fields {
+ i, fieldType, opts := fieldInfo.unpack()
+ fieldRv := rv.Field(i)
+ readReflectBinary(fieldRv, fieldType, opts, r, n, err)
+ }
+ }
+
+ case reflect.String:
+ str := ReadString(r, n, err)
+ log.Debug(Fmt("Read string: %v", str))
+ rv.SetString(str)
+
+ case reflect.Int64:
+ if opts.Varint {
+ num := ReadVarint(r, n, err)
+ log.Debug(Fmt("Read num: %v", num))
+ rv.SetInt(int64(num))
+ } else {
+ num := ReadInt64(r, n, err)
+ log.Debug(Fmt("Read num: %v", num))
+ rv.SetInt(int64(num))
+ }
+
+ case reflect.Int32:
+ num := ReadUint32(r, n, err)
+ log.Debug(Fmt("Read num: %v", num))
+ rv.SetInt(int64(num))
+
+ case reflect.Int16:
+ num := ReadUint16(r, n, err)
+ log.Debug(Fmt("Read num: %v", num))
+ rv.SetInt(int64(num))
+
+ case reflect.Int8:
+ num := ReadUint8(r, n, err)
+ log.Debug(Fmt("Read num: %v", num))
+ rv.SetInt(int64(num))
+
+ case reflect.Int:
+ num := ReadVarint(r, n, err)
+ log.Debug(Fmt("Read num: %v", num))
+ rv.SetInt(int64(num))
+
+ case reflect.Uint64:
+ if opts.Varint {
+ num := ReadUvarint(r, n, err)
+ log.Debug(Fmt("Read num: %v", num))
+ rv.SetUint(uint64(num))
+ } else {
+ num := ReadUint64(r, n, err)
+ log.Debug(Fmt("Read num: %v", num))
+ rv.SetUint(uint64(num))
+ }
+
+ case reflect.Uint32:
+ num := ReadUint32(r, n, err)
+ log.Debug(Fmt("Read num: %v", num))
+ rv.SetUint(uint64(num))
+
+ case reflect.Uint16:
+ num := ReadUint16(r, n, err)
+ log.Debug(Fmt("Read num: %v", num))
+ rv.SetUint(uint64(num))
+
+ case reflect.Uint8:
+ num := ReadUint8(r, n, err)
+ log.Debug(Fmt("Read num: %v", num))
+ rv.SetUint(uint64(num))
+
+ case reflect.Uint:
+ num := ReadUvarint(r, n, err)
+ log.Debug(Fmt("Read num: %v", num))
+ rv.SetUint(uint64(num))
+
+ case reflect.Bool:
+ num := ReadUint8(r, n, err)
+ log.Debug(Fmt("Read bool: %v", num))
+ rv.SetBool(num > 0)
+
+ default:
+ panic(Fmt("Unknown field type %v", rt.Kind()))
+ }
+}
+
+// rv: the reflection value of the thing to write
+// rt: the type of rv as declared in the container, not necessarily rv.Type().
+func writeReflectBinary(rv reflect.Value, rt reflect.Type, opts Options, w io.Writer, n *int64, err *error) {
+
+ // Get typeInfo
+ typeInfo := GetTypeInfo(rt)
+
+ if rt.Kind() == reflect.Interface {
+ if rv.IsNil() {
+ // XXX ensure that typeByte 0 is reserved.
+ WriteByte(0x00, w, n, err)
+ return
+ }
+ crv := rv.Elem() // concrete reflection value
+ crt := crv.Type() // concrete reflection type
+ if typeInfo.IsRegisteredInterface {
+ // See if the crt is registered.
+ // If so, we're more restrictive.
+ _, ok := typeInfo.TypeToByte[crt]
+ if !ok {
+ switch crt.Kind() {
+ case reflect.Ptr:
+ *err = errors.New(Fmt("Unexpected pointer type %v. Was it registered as a value receiver rather than as a pointer receiver?", crt))
+ case reflect.Struct:
+ *err = errors.New(Fmt("Unexpected struct type %v. Was it registered as a pointer receiver rather than as a value receiver?", crt))
+ default:
+ *err = errors.New(Fmt("Unexpected type %v.", crt))
+ }
+ return
+ }
+ } else {
+ // We support writing unsafely for convenience.
+ }
+ // We don't have to write the typeByte here,
+ // the writeReflectBinary() call below will write it.
+ writeReflectBinary(crv, crt, opts, w, n, err)
+ return
+ }
+
+ if rt.Kind() == reflect.Ptr {
+ // Dereference pointer
+ rv, rt = rv.Elem(), rt.Elem()
+ typeInfo = GetTypeInfo(rt)
+ if !rv.IsValid() {
+ WriteByte(0x00, w, n, err)
+ return
+ }
+ if typeInfo.Byte == 0x00 {
+ WriteByte(0x01, w, n, err)
+ // continue...
+ } else {
+ // continue...
+ }
+ }
+
+ // Write type byte
+ if typeInfo.Byte != 0x00 {
+ WriteByte(typeInfo.Byte, w, n, err)
+ }
+
+ // All other types
+ switch rt.Kind() {
+ case reflect.Slice:
+ elemRt := rt.Elem()
+ if elemRt.Kind() == reflect.Uint8 {
+ // Special case: Byteslices
+ byteslice := rv.Bytes()
+ WriteByteSlice(byteslice, w, n, err)
+ } else {
+ // Write length
+ length := rv.Len()
+ WriteUvarint(uint(length), w, n, err)
+ // Write elems
+ for i := 0; i < length; i++ {
+ elemRv := rv.Index(i)
+ writeReflectBinary(elemRv, elemRt, opts, w, n, err)
+ }
+ }
+
+ case reflect.Struct:
+ if rt == timeType {
+ // Special case: time.Time
+ WriteTime(rv.Interface().(time.Time), w, n, err)
+ } else {
+ for _, fieldInfo := range typeInfo.Fields {
+ i, fieldType, opts := fieldInfo.unpack()
+ fieldRv := rv.Field(i)
+ writeReflectBinary(fieldRv, fieldType, opts, w, n, err)
+ }
+ }
+
+ case reflect.String:
+ WriteString(rv.String(), w, n, err)
+
+ case reflect.Int64:
+ if opts.Varint {
+ WriteVarint(int(rv.Int()), w, n, err)
+ } else {
+ WriteInt64(rv.Int(), w, n, err)
+ }
+
+ case reflect.Int32:
+ WriteInt32(int32(rv.Int()), w, n, err)
+
+ case reflect.Int16:
+ WriteInt16(int16(rv.Int()), w, n, err)
+
+ case reflect.Int8:
+ WriteInt8(int8(rv.Int()), w, n, err)
+
+ case reflect.Int:
+ WriteVarint(int(rv.Int()), w, n, err)
+
+ case reflect.Uint64:
+ if opts.Varint {
+ WriteUvarint(uint(rv.Uint()), w, n, err)
+ } else {
+ WriteUint64(rv.Uint(), w, n, err)
+ }
+
+ case reflect.Uint32:
+ WriteUint32(uint32(rv.Uint()), w, n, err)
+
+ case reflect.Uint16:
+ WriteUint16(uint16(rv.Uint()), w, n, err)
+
+ case reflect.Uint8:
+ WriteUint8(uint8(rv.Uint()), w, n, err)
+
+ case reflect.Uint:
+ WriteUvarint(uint(rv.Uint()), w, n, err)
+
+ case reflect.Bool:
+ if rv.Bool() {
+ WriteUint8(uint8(1), w, n, err)
+ } else {
+ WriteUint8(uint8(0), w, n, err)
+ }
+
+ default:
+ panic(Fmt("Unknown field type %v", rt.Kind()))
+ }
+}
+
+//-----------------------------------------------------------------------------
+
+func readByteJSON(o interface{}) (typeByte byte, rest interface{}, err error) {
+ oSlice, ok := o.([]interface{})
+ if !ok {
+ err = errors.New(Fmt("Expected type [Byte,?] but got type %v", reflect.TypeOf(o)))
+ return
+ }
+ if len(oSlice) != 2 {
+ err = errors.New(Fmt("Expected [Byte,?] len 2 but got len %v", len(oSlice)))
+ return
+ }
+ typeByte_, ok := oSlice[0].(float64)
+ typeByte = byte(typeByte_)
+ rest = oSlice[1]
+ return
+}
+
+func readReflectJSON(rv reflect.Value, rt reflect.Type, o interface{}, err *error) {
+
+ // Get typeInfo
+ typeInfo := GetTypeInfo(rt)
+
+ if rt.Kind() == reflect.Interface {
+ if !typeInfo.IsRegisteredInterface {
+ // There's no way we can read such a thing.
+ *err = errors.New(Fmt("Cannot read unregistered interface type %v", rt))
+ return
+ }
+ if o == nil {
+ return // nil
+ }
+ typeByte, _, err_ := readByteJSON(o)
+ if err_ != nil {
+ *err = err_
+ return
+ }
+ crt, ok := typeInfo.ByteToType[typeByte]
+ if !ok {
+ *err = errors.New(Fmt("Byte %X not registered for interface %v", typeByte, rt))
+ return
+ }
+ crv := reflect.New(crt).Elem()
+ readReflectJSON(crv, crt, o, err)
+ rv.Set(crv) // NOTE: orig rv is ignored.
+ return
+ }
+
+ if rt.Kind() == reflect.Ptr {
+ if o == nil {
+ return // nil
+ }
+ // Create new struct if rv is nil.
+ if rv.IsNil() {
+ newRv := reflect.New(rt.Elem())
+ rv.Set(newRv)
+ rv = newRv
+ }
+ // Dereference pointer
+ rv, rt = rv.Elem(), rt.Elem()
+ typeInfo = GetTypeInfo(rt)
+ // continue...
+ }
+
+ // Read Byte prefix
+ if typeInfo.Byte != 0x00 {
+ typeByte, rest, err_ := readByteJSON(o)
+ if err_ != nil {
+ *err = err_
+ return
+ }
+ if typeByte != typeInfo.Byte {
+ *err = errors.New(Fmt("Expected Byte of %X but got %X", typeInfo.Byte, byte(typeByte)))
+ return
+ }
+ o = rest
+ }
+
+ switch rt.Kind() {
+ case reflect.Slice:
+ elemRt := rt.Elem()
+ if elemRt.Kind() == reflect.Uint8 {
+ // Special case: Byteslices
+ oString, ok := o.(string)
+ if !ok {
+ *err = errors.New(Fmt("Expected string but got type %v", reflect.TypeOf(o)))
+ return
+ }
+ byteslice, err_ := hex.DecodeString(oString)
+ if err_ != nil {
+ *err = err_
+ return
+ }
+ log.Debug("Read byteslice", "bytes", byteslice)
+ rv.Set(reflect.ValueOf(byteslice))
+ } else {
+ // Read length
+ oSlice, ok := o.([]interface{})
+ if !ok {
+ *err = errors.New(Fmt("Expected array of %v but got type %v", rt, reflect.TypeOf(o)))
+ return
+ }
+ length := len(oSlice)
+ log.Debug(Fmt("Read length: %v", length))
+ sliceRv := reflect.MakeSlice(rt, length, length)
+ // Read elems
+ for i := 0; i < length; i++ {
+ elemRv := sliceRv.Index(i)
+ readReflectJSON(elemRv, elemRt, oSlice[i], err)
+ }
+ rv.Set(sliceRv)
+ }
+
+ case reflect.Struct:
+ if rt == timeType {
+ // Special case: time.Time
+ str, ok := o.(string)
+ if !ok {
+ *err = errors.New(Fmt("Expected string but got type %v", reflect.TypeOf(o)))
+ return
+ }
+ log.Debug(Fmt("Read time: %v", str))
+ t, err_ := time.Parse(rfc2822, str)
+ if err_ != nil {
+ *err = err_
+ return
+ }
+ rv.Set(reflect.ValueOf(t))
+ } else {
+ oMap, ok := o.(map[string]interface{})
+ if !ok {
+ *err = errors.New(Fmt("Expected map but got type %v", reflect.TypeOf(o)))
+ return
+ }
+ // TODO: ensure that all fields are set?
+ // TODO: disallow unknown oMap fields?
+ for _, fieldInfo := range typeInfo.Fields {
+ i, fieldType, opts := fieldInfo.unpack()
+ value, ok := oMap[opts.JSONName]
+ if !ok {
+ continue // Skip missing fields.
+ }
+ fieldRv := rv.Field(i)
+ readReflectJSON(fieldRv, fieldType, value, err)
+ }
+ }
+
+ case reflect.String:
+ str, ok := o.(string)
+ if !ok {
+ *err = errors.New(Fmt("Expected string but got type %v", reflect.TypeOf(o)))
+ return
+ }
+ log.Debug(Fmt("Read string: %v", str))
+ rv.SetString(str)
+
+ case reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8, reflect.Int:
+ num, ok := o.(float64)
+ if !ok {
+ *err = errors.New(Fmt("Expected numeric but got type %v", reflect.TypeOf(o)))
+ return
+ }
+ log.Debug(Fmt("Read num: %v", num))
+ rv.SetInt(int64(num))
+
+ case reflect.Uint64, reflect.Uint32, reflect.Uint16, reflect.Uint8, reflect.Uint:
+ num, ok := o.(float64)
+ if !ok {
+ *err = errors.New(Fmt("Expected numeric but got type %v", reflect.TypeOf(o)))
+ return
+ }
+ if num < 0 {
+ *err = errors.New(Fmt("Expected unsigned numeric but got %v", num))
+ return
+ }
+ log.Debug(Fmt("Read num: %v", num))
+ rv.SetUint(uint64(num))
+
+ case reflect.Bool:
+ bl, ok := o.(bool)
+ if !ok {
+ *err = errors.New(Fmt("Expected boolean but got type %v", reflect.TypeOf(o)))
+ return
+ }
+ log.Debug(Fmt("Read boolean: %v", bl))
+ rv.SetBool(bl)
+
+ default:
+ panic(Fmt("Unknown field type %v", rt.Kind()))
+ }
+}
+
+func writeReflectJSON(rv reflect.Value, rt reflect.Type, w io.Writer, n *int64, err *error) {
+ log.Debug(Fmt("writeReflectJSON(%v, %v, %v, %v, %v)", rv, rt, w, n, err))
+
+ // Get typeInfo
+ typeInfo := GetTypeInfo(rt)
+
+ if rt.Kind() == reflect.Interface {
+ if rv.IsNil() {
+ // XXX ensure that typeByte 0 is reserved.
+ WriteTo([]byte("null"), w, n, err)
+ return
+ }
+ crv := rv.Elem() // concrete reflection value
+ crt := crv.Type() // concrete reflection type
+ if typeInfo.IsRegisteredInterface {
+ // See if the crt is registered.
+ // If so, we're more restrictive.
+ _, ok := typeInfo.TypeToByte[crt]
+ if !ok {
+ switch crt.Kind() {
+ case reflect.Ptr:
+ *err = errors.New(Fmt("Unexpected pointer type %v. Was it registered as a value receiver rather than as a pointer receiver?", crt))
+ case reflect.Struct:
+ *err = errors.New(Fmt("Unexpected struct type %v. Was it registered as a pointer receiver rather than as a value receiver?", crt))
+ default:
+ *err = errors.New(Fmt("Unexpected type %v.", crt))
+ }
+ return
+ }
+ } else {
+ // We support writing unsafely for convenience.
+ }
+ // We don't have to write the typeByte here,
+ // the writeReflectJSON() call below will write it.
+ writeReflectJSON(crv, crt, w, n, err)
+ return
+ }
+
+ if rt.Kind() == reflect.Ptr {
+ // Dereference pointer
+ rv, rt = rv.Elem(), rt.Elem()
+ typeInfo = GetTypeInfo(rt)
+ if !rv.IsValid() {
+ WriteTo([]byte("null"), w, n, err)
+ return
+ }
+ // continue...
+ }
+
+ // Write Byte
+ if typeInfo.Byte != 0x00 {
+ WriteTo([]byte(Fmt("[%v,", typeInfo.Byte)), w, n, err)
+ defer WriteTo([]byte("]"), w, n, err)
+ }
+
+ // All other types
+ switch rt.Kind() {
+ case reflect.Slice:
+ elemRt := rt.Elem()
+ if elemRt.Kind() == reflect.Uint8 {
+ // Special case: Byteslices
+ byteslice := rv.Bytes()
+ WriteTo([]byte(Fmt("\"%X\"", byteslice)), w, n, err)
+ //WriteByteSlice(byteslice, w, n, err)
+ } else {
+ WriteTo([]byte("["), w, n, err)
+ // Write elems
+ length := rv.Len()
+ for i := 0; i < length; i++ {
+ elemRv := rv.Index(i)
+ writeReflectJSON(elemRv, elemRt, w, n, err)
+ if i < length-1 {
+ WriteTo([]byte(","), w, n, err)
+ }
+ }
+ WriteTo([]byte("]"), w, n, err)
+ }
+
+ case reflect.Struct:
+ if rt == timeType {
+ // Special case: time.Time
+ t := rv.Interface().(time.Time)
+ str := t.Format(rfc2822)
+ jsonBytes, err_ := json.Marshal(str)
+ if err_ != nil {
+ *err = err_
+ return
+ }
+ WriteTo(jsonBytes, w, n, err)
+ } else {
+ WriteTo([]byte("{"), w, n, err)
+ wroteField := false
+ for _, fieldInfo := range typeInfo.Fields {
+ i, fieldType, opts := fieldInfo.unpack()
+ fieldRv := rv.Field(i)
+ if wroteField {
+ WriteTo([]byte(","), w, n, err)
+ } else {
+ wroteField = true
+ }
+ WriteTo([]byte(Fmt("\"%v\":", opts.JSONName)), w, n, err)
+ writeReflectJSON(fieldRv, fieldType, w, n, err)
+ }
+ WriteTo([]byte("}"), w, n, err)
+ }
+
+ case reflect.String:
+ fallthrough
+ case reflect.Uint64, reflect.Uint32, reflect.Uint16, reflect.Uint8, reflect.Uint:
+ fallthrough
+ case reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8, reflect.Int:
+ fallthrough
+ case reflect.Bool:
+ jsonBytes, err_ := json.Marshal(rv.Interface())
+ if err_ != nil {
+ *err = err_
+ return
+ }
+ WriteTo(jsonBytes, w, n, err)
+
+ default:
+ panic(Fmt("Unknown field type %v", rt.Kind()))
+ }
+
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/reflect_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/reflect_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..b92866b589b870ab9a2efbb7acc1d3fca7ff8f2f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/reflect_test.go
@@ -0,0 +1,465 @@
+package binary
+
+import (
+ "bytes"
+ "fmt"
+ "reflect"
+ "testing"
+ "time"
+
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+type SimpleStruct struct {
+ String string
+ Bytes []byte
+ Time time.Time
+}
+
+//-------------------------------------
+
+type Animal interface{}
+
+const (
+ AnimalTypeCat = byte(0x01)
+ AnimalTypeDog = byte(0x02)
+ AnimalTypeSnake = byte(0x03)
+ AnimalTypeViper = byte(0x04)
+)
+
+// Implements Animal
+type Cat struct {
+ SimpleStruct
+}
+
+// Implements Animal
+type Dog struct {
+ SimpleStruct
+}
+
+// Implements Animal
+type Snake []byte
+
+// Implements Animal
+type Viper struct {
+ Bytes []byte
+}
+
+var _ = RegisterInterface(
+ struct{ Animal }{},
+ ConcreteType{Cat{}, AnimalTypeCat},
+ ConcreteType{Dog{}, AnimalTypeDog},
+ ConcreteType{Snake{}, AnimalTypeSnake},
+ ConcreteType{&Viper{}, AnimalTypeViper},
+)
+
+func TestAnimalInterface(t *testing.T) {
+ var foo Animal
+
+ // Type of pointer to Animal
+ rt := reflect.TypeOf(&foo)
+ fmt.Printf("rt: %v\n", rt)
+
+ // Type of Animal itself.
+ // NOTE: normally this is acquired through other means
+ // like introspecting on method signatures, or struct fields.
+ rte := rt.Elem()
+ fmt.Printf("rte: %v\n", rte)
+
+ // Get a new pointer to the interface
+ // NOTE: calling .Interface() is to get the actual value,
+ // instead of reflection values.
+ ptr := reflect.New(rte).Interface()
+ fmt.Printf("ptr: %v", ptr)
+
+ // Make a binary byteslice that represents a snake.
+ snakeBytes := BinaryBytes(Snake([]byte("snake")))
+ snakeReader := bytes.NewReader(snakeBytes)
+
+ // Now you can read it.
+ n, err := new(int64), new(error)
+ it := *ReadBinary(ptr, snakeReader, n, err).(*Animal)
+ fmt.Println(it, reflect.TypeOf(it))
+}
+
+//-------------------------------------
+
+type Constructor func() interface{}
+type Instantiator func() (o interface{}, ptr interface{})
+type Validator func(o interface{}, t *testing.T)
+
+type TestCase struct {
+ Constructor
+ Instantiator
+ Validator
+}
+
+//-------------------------------------
+
+func constructBasic() interface{} {
+ cat := Cat{
+ SimpleStruct{
+ String: "String",
+ Bytes: []byte("Bytes"),
+ Time: time.Unix(123, 0),
+ },
+ }
+ return cat
+}
+
+func instantiateBasic() (interface{}, interface{}) {
+ return Cat{}, &Cat{}
+}
+
+func validateBasic(o interface{}, t *testing.T) {
+ cat := o.(Cat)
+ if cat.String != "String" {
+ t.Errorf("Expected cat.String == 'String', got %v", cat.String)
+ }
+ if string(cat.Bytes) != "Bytes" {
+ t.Errorf("Expected cat.Bytes == 'Bytes', got %X", cat.Bytes)
+ }
+ if cat.Time.Unix() != 123 {
+ t.Errorf("Expected cat.Time == 'Unix(123)', got %v", cat.Time)
+ }
+}
+
+//-------------------------------------
+
+type NilTestStruct struct {
+ IntPtr *int
+ CatPtr *Cat
+ Animal Animal
+}
+
+func constructNilTestStruct() interface{} {
+ return NilTestStruct{}
+}
+
+func instantiateNilTestStruct() (interface{}, interface{}) {
+ return NilTestStruct{}, &NilTestStruct{}
+}
+
+func validateNilTestStruct(o interface{}, t *testing.T) {
+ nts := o.(NilTestStruct)
+ if nts.IntPtr != nil {
+ t.Errorf("Expected nts.IntPtr to be nil, got %v", nts.IntPtr)
+ }
+ if nts.CatPtr != nil {
+ t.Errorf("Expected nts.CatPtr to be nil, got %v", nts.CatPtr)
+ }
+ if nts.Animal != nil {
+ t.Errorf("Expected nts.Animal to be nil, got %v", nts.Animal)
+ }
+}
+
+//-------------------------------------
+
+type ComplexStruct struct {
+ Name string
+ Animal Animal
+}
+
+func constructComplex() interface{} {
+ c := ComplexStruct{
+ Name: "Complex",
+ Animal: constructBasic(),
+ }
+ return c
+}
+
+func instantiateComplex() (interface{}, interface{}) {
+ return ComplexStruct{}, &ComplexStruct{}
+}
+
+func validateComplex(o interface{}, t *testing.T) {
+ c2 := o.(ComplexStruct)
+ if cat, ok := c2.Animal.(Cat); ok {
+ validateBasic(cat, t)
+ } else {
+ t.Errorf("Expected c2.Animal to be of type cat, got %v", reflect.ValueOf(c2.Animal).Elem().Type())
+ }
+}
+
+//-------------------------------------
+
+type ComplexStruct2 struct {
+ Cat Cat
+ Dog *Dog
+ Snake Snake
+ Snake2 *Snake
+ Viper Viper
+ Viper2 *Viper
+}
+
+func constructComplex2() interface{} {
+ snake_ := Snake([]byte("hiss"))
+ snakePtr_ := &snake_
+
+ c := ComplexStruct2{
+ Cat: Cat{
+ SimpleStruct{
+ String: "String",
+ Bytes: []byte("Bytes"),
+ },
+ },
+ Dog: &Dog{
+ SimpleStruct{
+ String: "Woof",
+ Bytes: []byte("Bark"),
+ },
+ },
+ Snake: Snake([]byte("hiss")),
+ Snake2: snakePtr_,
+ Viper: Viper{Bytes: []byte("hizz")},
+ Viper2: &Viper{Bytes: []byte("hizz")},
+ }
+ return c
+}
+
+func instantiateComplex2() (interface{}, interface{}) {
+ return ComplexStruct2{}, &ComplexStruct2{}
+}
+
+func validateComplex2(o interface{}, t *testing.T) {
+ c2 := o.(ComplexStruct2)
+ cat := c2.Cat
+ if cat.String != "String" {
+ t.Errorf("Expected cat.String == 'String', got %v", cat.String)
+ }
+ if string(cat.Bytes) != "Bytes" {
+ t.Errorf("Expected cat.Bytes == 'Bytes', got %X", cat.Bytes)
+ }
+
+ dog := c2.Dog
+ if dog.String != "Woof" {
+ t.Errorf("Expected dog.String == 'Woof', got %v", dog.String)
+ }
+ if string(dog.Bytes) != "Bark" {
+ t.Errorf("Expected dog.Bytes == 'Bark', got %X", dog.Bytes)
+ }
+
+ snake := c2.Snake
+ if string(snake) != "hiss" {
+ t.Errorf("Expected string(snake) == 'hiss', got %v", string(snake))
+ }
+
+ snake2 := c2.Snake2
+ if string(*snake2) != "hiss" {
+ t.Errorf("Expected string(snake2) == 'hiss', got %v", string(*snake2))
+ }
+
+ viper := c2.Viper
+ if string(viper.Bytes) != "hizz" {
+ t.Errorf("Expected string(viper.Bytes) == 'hizz', got %v", string(viper.Bytes))
+ }
+
+ viper2 := c2.Viper2
+ if string(viper2.Bytes) != "hizz" {
+ t.Errorf("Expected string(viper2.Bytes) == 'hizz', got %v", string(viper2.Bytes))
+ }
+}
+
+//-------------------------------------
+
+type ComplexStructArray struct {
+ Animals []Animal
+}
+
+func constructComplexArray() interface{} {
+ c := ComplexStructArray{
+ Animals: []Animal{
+ Cat{
+ SimpleStruct{
+ String: "String",
+ Bytes: []byte("Bytes"),
+ },
+ },
+ Dog{
+ SimpleStruct{
+ String: "Woof",
+ Bytes: []byte("Bark"),
+ },
+ },
+ Snake([]byte("hiss")),
+ &Viper{
+ Bytes: []byte("hizz"),
+ },
+ },
+ }
+ return c
+}
+
+func instantiateComplexArray() (interface{}, interface{}) {
+ return ComplexStructArray{}, &ComplexStructArray{}
+}
+
+func validateComplexArray(o interface{}, t *testing.T) {
+ c2 := o.(ComplexStructArray)
+ if cat, ok := c2.Animals[0].(Cat); ok {
+ if cat.String != "String" {
+ t.Errorf("Expected cat.String == 'String', got %v", cat.String)
+ }
+ if string(cat.Bytes) != "Bytes" {
+ t.Errorf("Expected cat.Bytes == 'Bytes', got %X", cat.Bytes)
+ }
+ } else {
+ t.Errorf("Expected c2.Animals[0] to be of type cat, got %v", reflect.ValueOf(c2.Animals[0]).Elem().Type())
+ }
+
+ if dog, ok := c2.Animals[1].(Dog); ok {
+ if dog.String != "Woof" {
+ t.Errorf("Expected dog.String == 'Woof', got %v", dog.String)
+ }
+ if string(dog.Bytes) != "Bark" {
+ t.Errorf("Expected dog.Bytes == 'Bark', got %X", dog.Bytes)
+ }
+ } else {
+ t.Errorf("Expected c2.Animals[1] to be of type dog, got %v", reflect.ValueOf(c2.Animals[1]).Elem().Type())
+ }
+
+ if snake, ok := c2.Animals[2].(Snake); ok {
+ if string(snake) != "hiss" {
+ t.Errorf("Expected string(snake) == 'hiss', got %v", string(snake))
+ }
+ } else {
+ t.Errorf("Expected c2.Animals[2] to be of type Snake, got %v", reflect.ValueOf(c2.Animals[2]).Elem().Type())
+ }
+
+ if viper, ok := c2.Animals[3].(*Viper); ok {
+ if string(viper.Bytes) != "hizz" {
+ t.Errorf("Expected string(viper.Bytes) == 'hizz', got %v", string(viper.Bytes))
+ }
+ } else {
+ t.Errorf("Expected c2.Animals[3] to be of type *Viper, got %v", reflect.ValueOf(c2.Animals[3]).Elem().Type())
+ }
+}
+
+//-----------------------------------------------------------------------------
+
+var testCases = []TestCase{}
+
+func init() {
+ testCases = append(testCases, TestCase{constructBasic, instantiateBasic, validateBasic})
+ testCases = append(testCases, TestCase{constructComplex, instantiateComplex, validateComplex})
+ testCases = append(testCases, TestCase{constructComplex2, instantiateComplex2, validateComplex2})
+ testCases = append(testCases, TestCase{constructComplexArray, instantiateComplexArray, validateComplexArray})
+ testCases = append(testCases, TestCase{constructNilTestStruct, instantiateNilTestStruct, validateNilTestStruct})
+}
+
+func TestBinary(t *testing.T) {
+
+ for i, testCase := range testCases {
+
+ log.Info(fmt.Sprintf("Running test case %v", i))
+
+ // Construct an object
+ o := testCase.Constructor()
+
+ // Write the object
+ data := BinaryBytes(o)
+ t.Logf("Binary: %X", data)
+
+ instance, instancePtr := testCase.Instantiator()
+
+ // Read onto a struct
+ n, err := new(int64), new(error)
+ res := ReadBinary(instance, bytes.NewReader(data), n, err)
+ if *err != nil {
+ t.Fatalf("Failed to read into instance: %v", *err)
+ }
+
+ // Validate object
+ testCase.Validator(res, t)
+
+ // Read onto a pointer
+ n, err = new(int64), new(error)
+ res = ReadBinary(instancePtr, bytes.NewReader(data), n, err)
+ if *err != nil {
+ t.Fatalf("Failed to read into instance: %v", *err)
+ }
+
+ if res != instancePtr {
+ t.Errorf("Expected pointer to pass through")
+ }
+
+ // Validate object
+ testCase.Validator(reflect.ValueOf(res).Elem().Interface(), t)
+ }
+
+}
+
+func TestJSON(t *testing.T) {
+
+ for i, testCase := range testCases {
+
+ log.Info(fmt.Sprintf("Running test case %v", i))
+
+ // Construct an object
+ o := testCase.Constructor()
+
+ // Write the object
+ data := JSONBytes(o)
+ t.Logf("JSON: %v", string(data))
+
+ instance, instancePtr := testCase.Instantiator()
+
+ // Read onto a struct
+ err := new(error)
+ res := ReadJSON(instance, data, err)
+ if *err != nil {
+ t.Fatalf("Failed to read cat: %v", *err)
+ }
+
+ // Validate object
+ testCase.Validator(res, t)
+
+ // Read onto a pointer
+ res = ReadJSON(instancePtr, data, err)
+ if *err != nil {
+ t.Fatalf("Failed to read cat: %v", *err)
+ }
+
+ if res != instancePtr {
+ t.Errorf("Expected pointer to pass through")
+ }
+
+ // Validate object
+ testCase.Validator(reflect.ValueOf(res).Elem().Interface(), t)
+ }
+
+}
+
+//------------------------------------------------------------------------------
+
+type Foo struct {
+ FieldA string `json:"fieldA"` // json field name is "fieldA"
+ FieldB string // json field name is "FieldB"
+ fieldC string // not exported, not serialized.
+}
+
+func TestJSONFieldNames(t *testing.T) {
+ for i := 0; i < 20; i++ { // Try to ensure deterministic success.
+ foo := Foo{"a", "b", "c"}
+ stringified := string(JSONBytes(foo))
+ expected := `{"fieldA":"a","FieldB":"b"}`
+ if stringified != expected {
+ t.Fatalf("JSONFieldNames error: expected %v, got %v",
+ expected, stringified)
+ }
+ }
+}
+
+//------------------------------------------------------------------------------
+
+func TestBadAlloc(t *testing.T) {
+ n, err := new(int64), new(error)
+ instance := new([]byte)
+ data := RandBytes(ByteSliceChunk * 100)
+ b := new(bytes.Buffer)
+ // this slice of data claims to be much bigger than it really is
+ WriteUvarint(uint(10000000000000000), b, n, err)
+ b.Write(data)
+ res := ReadBinary(instance, b, n, err)
+ fmt.Println(res, *err)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/string.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/string.go
new file mode 100644
index 0000000000000000000000000000000000000000..c7ebd7f7718c3f7b274e0a1162dbc22b95e4a791
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/string.go
@@ -0,0 +1,20 @@
+package binary
+
+import "io"
+
+// String
+
+func WriteString(s string, w io.Writer, n *int64, err *error) {
+ WriteUvarint(uint(len(s)), w, n, err)
+ WriteTo([]byte(s), w, n, err)
+}
+
+func ReadString(r io.Reader, n *int64, err *error) string {
+ length := ReadUvarint(r, n, err)
+ if *err != nil {
+ return ""
+ }
+ buf := make([]byte, int(length))
+ ReadFull(buf, r, n, err)
+ return string(buf)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/time.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/time.go
new file mode 100644
index 0000000000000000000000000000000000000000..9c678046a3c16297fc20e1c2f778d35a160e43d7
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/time.go
@@ -0,0 +1,17 @@
+package binary
+
+import (
+ "io"
+ "time"
+)
+
+// Time
+
+func WriteTime(t time.Time, w io.Writer, n *int64, err *error) {
+ WriteInt64(t.UnixNano(), w, n, err)
+}
+
+func ReadTime(r io.Reader, n *int64, err *error) time.Time {
+ t := ReadInt64(r, n, err)
+ return time.Unix(0, t)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/util.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..b72d4952a5026ec6fce149f194913c3b4eda98dd
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/binary/util.go
@@ -0,0 +1,57 @@
+package binary
+
+import (
+ "bytes"
+ "crypto/sha256"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/code.google.com/p/go.crypto/ripemd160"
+)
+
+func BinaryBytes(o interface{}) []byte {
+ w, n, err := new(bytes.Buffer), new(int64), new(error)
+ WriteBinary(o, w, n, err)
+ if *err != nil {
+ panic(*err)
+ }
+ return w.Bytes()
+}
+
+func JSONBytes(o interface{}) []byte {
+ w, n, err := new(bytes.Buffer), new(int64), new(error)
+ WriteJSON(o, w, n, err)
+ if *err != nil {
+ panic(*err)
+ }
+ return w.Bytes()
+}
+
+// NOTE: does not care about the type, only the binary representation.
+func BinaryEqual(a, b interface{}) bool {
+ aBytes := BinaryBytes(a)
+ bBytes := BinaryBytes(b)
+ return bytes.Equal(aBytes, bBytes)
+}
+
+// NOTE: does not care about the type, only the binary representation.
+func BinaryCompare(a, b interface{}) int {
+ aBytes := BinaryBytes(a)
+ bBytes := BinaryBytes(b)
+ return bytes.Compare(aBytes, bBytes)
+}
+
+func BinarySha256(o interface{}) []byte {
+ hasher, n, err := sha256.New(), new(int64), new(error)
+ WriteBinary(o, hasher, n, err)
+ if *err != nil {
+ panic(*err)
+ }
+ return hasher.Sum(nil)
+}
+
+func BinaryRipemd160(o interface{}) []byte {
+ hasher, n, err := ripemd160.New(), new(int64), new(error)
+ WriteBinary(o, hasher, n, err)
+ if *err != nil {
+ panic(*err)
+ }
+ return hasher.Sum(nil)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain/log.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..68783ee2d7fc9ceb5f924de601a78292d45192e9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain/log.go
@@ -0,0 +1,7 @@
+package blockchain
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/logger"
+)
+
+var log = logger.New("module", "blockchain")
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain/pool.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain/pool.go
new file mode 100644
index 0000000000000000000000000000000000000000..65588d769be683d79ce67737bfdeba3812486222
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain/pool.go
@@ -0,0 +1,398 @@
+package blockchain
+
+import (
+ "sync"
+ "sync/atomic"
+ "time"
+
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+const (
+ maxTries = 3
+ inputsChannelCapacity = 200
+ requestIntervalMS = 500
+ maxPendingRequests = 200
+ maxTotalRequests = 300
+ maxRequestsPerPeer = 300
+)
+
+var (
+ requestTimeoutSeconds = time.Duration(3)
+)
+
+/*
+ Peers self report their heights when a new peer joins the block pool.
+ Starting from pool.height (inclusive), we request blocks
+ in sequence from peers that reported higher heights than ours.
+ Every so often we ask peers what height they're on so we can keep going.
+
+ Requests are continuously made for blocks of heigher heights until
+ the limits. If most of the requests have no available peers, and we
+ are not at peer limits, we can probably switch to consensus reactor
+*/
+
+type BlockPool struct {
+ // block requests
+ requestsMtx sync.Mutex
+ requests map[uint]*bpRequest
+ height uint // the lowest key in requests.
+ numUnassigned int32 // number of requests not yet assigned to a peer
+ numPending int32 // number of requests pending assignment or block response
+
+ // peers
+ peersMtx sync.Mutex
+ peers map[string]*bpPeer
+
+ requestsCh chan<- BlockRequest
+ timeoutsCh chan<- string
+ repeater *RepeatTimer
+
+ running int32 // atomic
+}
+
+func NewBlockPool(start uint, requestsCh chan<- BlockRequest, timeoutsCh chan<- string) *BlockPool {
+ return &BlockPool{
+ peers: make(map[string]*bpPeer),
+
+ requests: make(map[uint]*bpRequest),
+ height: start,
+ numUnassigned: 0,
+ numPending: 0,
+
+ requestsCh: requestsCh,
+ timeoutsCh: timeoutsCh,
+ repeater: NewRepeatTimer("", requestIntervalMS*time.Millisecond),
+
+ running: 0,
+ }
+}
+
+func (pool *BlockPool) Start() {
+ if atomic.CompareAndSwapInt32(&pool.running, 0, 1) {
+ log.Info("Starting BlockPool")
+ go pool.run()
+ }
+}
+
+func (pool *BlockPool) Stop() {
+ if atomic.CompareAndSwapInt32(&pool.running, 1, 0) {
+ log.Info("Stopping BlockPool")
+ pool.repeater.Stop()
+ }
+}
+
+func (pool *BlockPool) IsRunning() bool {
+ return atomic.LoadInt32(&pool.running) == 1
+}
+
+// Run spawns requests as needed.
+func (pool *BlockPool) run() {
+RUN_LOOP:
+ for {
+ if atomic.LoadInt32(&pool.running) == 0 {
+ break RUN_LOOP
+ }
+ _, numPending := pool.GetStatus()
+ if numPending >= maxPendingRequests {
+ // sleep for a bit.
+ time.Sleep(requestIntervalMS * time.Millisecond)
+ } else if len(pool.requests) >= maxTotalRequests {
+ // sleep for a bit.
+ time.Sleep(requestIntervalMS * time.Millisecond)
+ } else {
+ // request for more blocks.
+ pool.makeNextRequest()
+ }
+ }
+}
+
+func (pool *BlockPool) GetStatus() (uint, int32) {
+ pool.requestsMtx.Lock() // Lock
+ defer pool.requestsMtx.Unlock()
+
+ return pool.height, pool.numPending
+}
+
+// We need to see the second block's Validation to validate the first block.
+// So we peek two blocks at a time.
+func (pool *BlockPool) PeekTwoBlocks() (first *types.Block, second *types.Block) {
+ pool.requestsMtx.Lock() // Lock
+ defer pool.requestsMtx.Unlock()
+
+ if r := pool.requests[pool.height]; r != nil {
+ first = r.block
+ }
+ if r := pool.requests[pool.height+1]; r != nil {
+ second = r.block
+ }
+ return
+}
+
+// Pop the first block at pool.height
+// It must have been validated by 'second'.Validation from PeekTwoBlocks().
+func (pool *BlockPool) PopRequest() {
+ pool.requestsMtx.Lock() // Lock
+ defer pool.requestsMtx.Unlock()
+
+ if r := pool.requests[pool.height]; r == nil || r.block == nil {
+ panic("PopRequest() requires a valid block")
+ }
+
+ delete(pool.requests, pool.height)
+ pool.height++
+}
+
+// Invalidates the block at pool.height.
+// Remove the peer and request from others.
+func (pool *BlockPool) RedoRequest(height uint) {
+ pool.requestsMtx.Lock() // Lock
+ defer pool.requestsMtx.Unlock()
+
+ request := pool.requests[height]
+ if request.block == nil {
+ panic("Expected block to be non-nil")
+ }
+ // TODO: record this malfeasance
+ // maybe punish peer on switch (an invalid block!)
+ pool.RemovePeer(request.peerId) // Lock on peersMtx.
+ request.block = nil
+ request.peerId = ""
+ pool.numPending++
+ pool.numUnassigned++
+
+ go requestRoutine(pool, height)
+}
+
+func (pool *BlockPool) hasBlock(height uint) bool {
+ pool.requestsMtx.Lock() // Lock
+ defer pool.requestsMtx.Unlock()
+
+ request := pool.requests[height]
+ return request != nil && request.block != nil
+}
+
+func (pool *BlockPool) setPeerForRequest(height uint, peerId string) {
+ pool.requestsMtx.Lock() // Lock
+ defer pool.requestsMtx.Unlock()
+
+ request := pool.requests[height]
+ if request == nil {
+ return
+ }
+ pool.numUnassigned--
+ request.peerId = peerId
+}
+
+func (pool *BlockPool) removePeerForRequest(height uint, peerId string) {
+ pool.requestsMtx.Lock() // Lock
+ defer pool.requestsMtx.Unlock()
+
+ request := pool.requests[height]
+ if request == nil {
+ return
+ }
+ pool.numUnassigned++
+ request.peerId = ""
+}
+
+func (pool *BlockPool) AddBlock(block *types.Block, peerId string) {
+ pool.requestsMtx.Lock() // Lock
+ defer pool.requestsMtx.Unlock()
+
+ request := pool.requests[block.Height]
+ if request == nil {
+ return
+ }
+ if request.peerId != peerId {
+ return
+ }
+ if request.block != nil {
+ return
+ }
+ request.block = block
+ pool.numPending--
+}
+
+func (pool *BlockPool) getPeer(peerId string) *bpPeer {
+ pool.peersMtx.Lock() // Lock
+ defer pool.peersMtx.Unlock()
+
+ peer := pool.peers[peerId]
+ return peer
+}
+
+// Sets the peer's alleged blockchain height.
+func (pool *BlockPool) SetPeerHeight(peerId string, height uint) {
+ pool.peersMtx.Lock() // Lock
+ defer pool.peersMtx.Unlock()
+
+ peer := pool.peers[peerId]
+ if peer != nil {
+ peer.height = height
+ } else {
+ peer = &bpPeer{
+ height: height,
+ id: peerId,
+ numRequests: 0,
+ }
+ pool.peers[peerId] = peer
+ }
+}
+
+func (pool *BlockPool) RemovePeer(peerId string) {
+ pool.peersMtx.Lock() // Lock
+ defer pool.peersMtx.Unlock()
+
+ delete(pool.peers, peerId)
+}
+
+// Pick an available peer with at least the given minHeight.
+// If no peers are available, returns nil.
+func (pool *BlockPool) pickIncrAvailablePeer(minHeight uint) *bpPeer {
+ pool.peersMtx.Lock()
+ defer pool.peersMtx.Unlock()
+
+ for _, peer := range pool.peers {
+ if peer.numRequests >= maxRequestsPerPeer {
+ continue
+ }
+ if peer.height < minHeight {
+ continue
+ }
+ peer.numRequests++
+ return peer
+ }
+ return nil
+}
+
+func (pool *BlockPool) decrPeer(peerId string) {
+ pool.peersMtx.Lock()
+ defer pool.peersMtx.Unlock()
+
+ peer := pool.peers[peerId]
+ if peer == nil {
+ return
+ }
+ peer.numRequests--
+}
+
+func (pool *BlockPool) makeNextRequest() {
+ pool.requestsMtx.Lock() // Lock
+ defer pool.requestsMtx.Unlock()
+
+ nextHeight := pool.height + uint(len(pool.requests))
+ request := &bpRequest{
+ height: nextHeight,
+ peerId: "",
+ block: nil,
+ }
+
+ pool.requests[nextHeight] = request
+ pool.numUnassigned++
+ pool.numPending++
+
+ go requestRoutine(pool, nextHeight)
+}
+
+func (pool *BlockPool) sendRequest(height uint, peerId string) {
+ if atomic.LoadInt32(&pool.running) == 0 {
+ return
+ }
+ pool.requestsCh <- BlockRequest{height, peerId}
+}
+
+func (pool *BlockPool) sendTimeout(peerId string) {
+ if atomic.LoadInt32(&pool.running) == 0 {
+ return
+ }
+ pool.timeoutsCh <- peerId
+}
+
+func (pool *BlockPool) debug() string {
+ pool.requestsMtx.Lock() // Lock
+ defer pool.requestsMtx.Unlock()
+
+ str := ""
+ for h := pool.height; h < pool.height+uint(len(pool.requests)); h++ {
+ if pool.requests[h] == nil {
+ str += Fmt("H(%v):X ", h)
+ } else {
+ str += Fmt("H(%v):", h)
+ str += Fmt("B?(%v) ", pool.requests[h].block != nil)
+ }
+ }
+ return str
+}
+
+//-------------------------------------
+
+type bpPeer struct {
+ id string
+ height uint
+ numRequests int32
+}
+
+type bpRequest struct {
+ height uint
+ peerId string
+ block *types.Block
+}
+
+//-------------------------------------
+
+// Responsible for making more requests as necessary
+// Returns only when a block is found (e.g. AddBlock() is called)
+func requestRoutine(pool *BlockPool, height uint) {
+ for {
+ var peer *bpPeer = nil
+ PICK_LOOP:
+ for {
+ if !pool.IsRunning() {
+ log.Debug("BlockPool not running. Stopping requestRoutine", "height", height)
+ return
+ }
+ peer = pool.pickIncrAvailablePeer(height)
+ if peer == nil {
+ //log.Debug("No peers available", "height", height)
+ time.Sleep(requestIntervalMS * time.Millisecond)
+ continue PICK_LOOP
+ }
+ break PICK_LOOP
+ }
+
+ // set the peer, decrement numUnassigned
+ pool.setPeerForRequest(height, peer.id)
+
+ for try := 0; try < maxTries; try++ {
+ pool.sendRequest(height, peer.id)
+ time.Sleep(requestTimeoutSeconds * time.Second)
+ // if successful the block is either in the pool,
+ if pool.hasBlock(height) {
+ pool.decrPeer(peer.id)
+ return
+ }
+ // or already processed and we've moved past it
+ bpHeight, _ := pool.GetStatus()
+ if height < bpHeight {
+ pool.decrPeer(peer.id)
+ return
+ }
+ }
+
+ // unset the peer, increment numUnassigned
+ pool.removePeerForRequest(height, peer.id)
+
+ // this peer failed us, try again
+ pool.RemovePeer(peer.id)
+ pool.sendTimeout(peer.id)
+ }
+}
+
+//-------------------------------------
+
+type BlockRequest struct {
+ Height uint
+ PeerId string
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain/pool_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain/pool_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..0e45ca4d940454300043d4191a7f0a361b434855
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain/pool_test.go
@@ -0,0 +1,128 @@
+package blockchain
+
+import (
+ "math/rand"
+ "testing"
+ "time"
+
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+type testPeer struct {
+ id string
+ height uint
+}
+
+func makePeers(numPeers int, minHeight, maxHeight uint) map[string]testPeer {
+ peers := make(map[string]testPeer, numPeers)
+ for i := 0; i < numPeers; i++ {
+ peerId := RandStr(12)
+ height := minHeight + uint(rand.Intn(int(maxHeight-minHeight)))
+ peers[peerId] = testPeer{peerId, height}
+ }
+ return peers
+}
+
+func TestBasic(t *testing.T) {
+ peers := makePeers(10, 0, 1000)
+ start := uint(42)
+ timeoutsCh := make(chan string, 100)
+ requestsCh := make(chan BlockRequest, 100)
+ pool := NewBlockPool(start, requestsCh, timeoutsCh)
+ pool.Start()
+
+ // Introduce each peer.
+ go func() {
+ for _, peer := range peers {
+ pool.SetPeerHeight(peer.id, peer.height)
+ }
+ }()
+
+ // Start a goroutine to pull blocks
+ go func() {
+ for {
+ if !pool.IsRunning() {
+ return
+ }
+ first, second := pool.PeekTwoBlocks()
+ if first != nil && second != nil {
+ pool.PopRequest()
+ } else {
+ time.Sleep(1 * time.Second)
+ }
+ }
+ }()
+
+ // Pull from channels
+ for {
+ select {
+ case peerId := <-timeoutsCh:
+ t.Errorf("timeout: %v", peerId)
+ case request := <-requestsCh:
+ log.Debug("TEST: Pulled new BlockRequest", "request", request)
+ if request.Height == 300 {
+ return // Done!
+ }
+ // Request desired, pretend like we got the block immediately.
+ go func() {
+ block := &types.Block{Header: &types.Header{Height: request.Height}}
+ pool.AddBlock(block, request.PeerId)
+ log.Debug("TEST: Added block", "block", request.Height, "peer", request.PeerId)
+ }()
+ }
+ }
+
+ pool.Stop()
+}
+
+func TestTimeout(t *testing.T) {
+ peers := makePeers(10, 0, 1000)
+ start := uint(42)
+ timeoutsCh := make(chan string, 100)
+ requestsCh := make(chan BlockRequest, 100)
+ pool := NewBlockPool(start, requestsCh, timeoutsCh)
+ pool.Start()
+
+ // Introduce each peer.
+ go func() {
+ for _, peer := range peers {
+ pool.SetPeerHeight(peer.id, peer.height)
+ }
+ }()
+
+ // Start a goroutine to pull blocks
+ go func() {
+ for {
+ if !pool.IsRunning() {
+ return
+ }
+ first, second := pool.PeekTwoBlocks()
+ if first != nil && second != nil {
+ pool.PopRequest()
+ } else {
+ time.Sleep(1 * time.Second)
+ }
+ }
+ }()
+
+ // Pull from channels
+ counter := 0
+ timedOut := map[string]struct{}{}
+ for {
+ select {
+ case peerId := <-timeoutsCh:
+ log.Debug("Timeout", "peerId", peerId)
+ if _, ok := timedOut[peerId]; !ok {
+ counter++
+ if counter == len(peers) {
+ return // Done!
+ }
+ }
+ case request := <-requestsCh:
+ log.Debug("TEST: Pulled new BlockRequest", "request", request)
+ }
+ }
+
+ pool.Stop()
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain/reactor.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain/reactor.go
new file mode 100644
index 0000000000000000000000000000000000000000..fb07f3a404c1ae0b93844a0e9cd7536de76133c7
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain/reactor.go
@@ -0,0 +1,339 @@
+package blockchain
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "reflect"
+ "sync/atomic"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/events"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p"
+ sm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+const (
+ BlockchainChannel = byte(0x40)
+ defaultChannelCapacity = 100
+ defaultSleepIntervalMS = 500
+ trySyncIntervalMS = 100
+ // stop syncing when last block's time is
+ // within this much of the system time.
+ // stopSyncingDurationMinutes = 10
+
+ // ask for best height every 10s
+ statusUpdateIntervalSeconds = 10
+ // check if we should switch to consensus reactor
+ switchToConsensusIntervalSeconds = 10
+)
+
+type consensusReactor interface {
+ // for when we switch from blockchain reactor and fast sync to
+ // the consensus machine
+ SwitchToConsensus(*sm.State)
+}
+
+// BlockchainReactor handles long-term catchup syncing.
+type BlockchainReactor struct {
+ sw *p2p.Switch
+ state *sm.State
+ store *BlockStore
+ pool *BlockPool
+ sync bool
+ requestsCh chan BlockRequest
+ timeoutsCh chan string
+ lastBlock *types.Block
+ quit chan struct{}
+ running uint32
+
+ evsw events.Fireable
+}
+
+func NewBlockchainReactor(state *sm.State, store *BlockStore, sync bool) *BlockchainReactor {
+ if state.LastBlockHeight != store.Height() &&
+ state.LastBlockHeight != store.Height()-1 { // XXX double check this logic.
+ panic(Fmt("state (%v) and store (%v) height mismatch", state.LastBlockHeight, store.Height()))
+ }
+ requestsCh := make(chan BlockRequest, defaultChannelCapacity)
+ timeoutsCh := make(chan string, defaultChannelCapacity)
+ pool := NewBlockPool(
+ store.Height()+1,
+ requestsCh,
+ timeoutsCh,
+ )
+ bcR := &BlockchainReactor{
+ state: state,
+ store: store,
+ pool: pool,
+ sync: sync,
+ requestsCh: requestsCh,
+ timeoutsCh: timeoutsCh,
+ quit: make(chan struct{}),
+ running: uint32(0),
+ }
+ return bcR
+}
+
+// Implements Reactor
+func (bcR *BlockchainReactor) Start(sw *p2p.Switch) {
+ if atomic.CompareAndSwapUint32(&bcR.running, 0, 1) {
+ log.Info("Starting BlockchainReactor")
+ bcR.sw = sw
+ if bcR.sync {
+ bcR.pool.Start()
+ go bcR.poolRoutine()
+ }
+ }
+}
+
+// Implements Reactor
+func (bcR *BlockchainReactor) Stop() {
+ if atomic.CompareAndSwapUint32(&bcR.running, 1, 0) {
+ log.Info("Stopping BlockchainReactor")
+ close(bcR.quit)
+ bcR.pool.Stop()
+ }
+}
+
+// Implements Reactor
+func (bcR *BlockchainReactor) GetChannels() []*p2p.ChannelDescriptor {
+ return []*p2p.ChannelDescriptor{
+ &p2p.ChannelDescriptor{
+ Id: BlockchainChannel,
+ Priority: 5,
+ SendQueueCapacity: 100,
+ },
+ }
+}
+
+// Implements Reactor
+func (bcR *BlockchainReactor) AddPeer(peer *p2p.Peer) {
+ // Send peer our state.
+ peer.Send(BlockchainChannel, &bcStatusResponseMessage{bcR.store.Height()})
+}
+
+// Implements Reactor
+func (bcR *BlockchainReactor) RemovePeer(peer *p2p.Peer, reason interface{}) {
+ // Remove peer from the pool.
+ bcR.pool.RemovePeer(peer.Key)
+}
+
+// Implements Reactor
+func (bcR *BlockchainReactor) Receive(chId byte, src *p2p.Peer, msgBytes []byte) {
+ _, msg, err := DecodeMessage(msgBytes)
+ if err != nil {
+ log.Warn("Error decoding message", "error", err)
+ return
+ }
+
+ log.Info("Received message", "msg", msg)
+
+ switch msg := msg.(type) {
+ case *bcBlockRequestMessage:
+ // Got a request for a block. Respond with block if we have it.
+ block := bcR.store.LoadBlock(msg.Height)
+ if block != nil {
+ msg := &bcBlockResponseMessage{Block: block}
+ queued := src.TrySend(BlockchainChannel, msg)
+ if !queued {
+ // queue is full, just ignore.
+ }
+ } else {
+ // TODO peer is asking for things we don't have.
+ }
+ case *bcBlockResponseMessage:
+ // Got a block.
+ bcR.pool.AddBlock(msg.Block, src.Key)
+ case *bcStatusRequestMessage:
+ // Send peer our state.
+ queued := src.TrySend(BlockchainChannel, &bcStatusResponseMessage{bcR.store.Height()})
+ if !queued {
+ // sorry
+ }
+ case *bcStatusResponseMessage:
+ // Got a peer status. Unverified.
+ bcR.pool.SetPeerHeight(src.Key, msg.Height)
+ default:
+ log.Warn(Fmt("Unknown message type %v", reflect.TypeOf(msg)))
+ }
+}
+
+// Handle messages from the poolReactor telling the reactor what to do.
+// NOTE: Don't sleep in the FOR_LOOP or otherwise slow it down!
+// (Except for the SYNC_LOOP, which is the primary purpose and must be synchronous.)
+func (bcR *BlockchainReactor) poolRoutine() {
+
+ trySyncTicker := time.NewTicker(trySyncIntervalMS * time.Millisecond)
+ statusUpdateTicker := time.NewTicker(statusUpdateIntervalSeconds * time.Second)
+ switchToConsensusTicker := time.NewTicker(switchToConsensusIntervalSeconds * time.Second)
+
+FOR_LOOP:
+ for {
+ select {
+ case request := <-bcR.requestsCh: // chan BlockRequest
+ peer := bcR.sw.Peers().Get(request.PeerId)
+ if peer == nil {
+ // We can't assign the request.
+ continue FOR_LOOP
+ }
+ msg := &bcBlockRequestMessage{request.Height}
+ queued := peer.TrySend(BlockchainChannel, msg)
+ if !queued {
+ // We couldn't make the request, send-queue full.
+ // The pool handles retries, so just let it go.
+ continue FOR_LOOP
+ }
+ case peerId := <-bcR.timeoutsCh: // chan string
+ // Peer timed out.
+ peer := bcR.sw.Peers().Get(peerId)
+ if peer != nil {
+ bcR.sw.StopPeerForError(peer, errors.New("BlockchainReactor Timeout"))
+ }
+ case _ = <-statusUpdateTicker.C:
+ // ask for status updates
+ go bcR.BroadcastStatusRequest()
+ case _ = <-switchToConsensusTicker.C:
+ // not thread safe access for numUnassigned and numPending but should be fine
+ // TODO make threadsafe and use exposed functions
+ outbound, inbound, _ := bcR.sw.NumPeers()
+ log.Debug("Consensus ticker", "numUnassigned", bcR.pool.numUnassigned, "numPending", bcR.pool.numPending,
+ "total", len(bcR.pool.requests), "outbound", outbound, "inbound", inbound)
+ // NOTE: this condition is very strict right now. may need to weaken
+ // If all `maxPendingRequests` requests are unassigned
+ // and we have some peers (say >= 3), then we're caught up
+ maxPending := bcR.pool.numPending == maxPendingRequests
+ allUnassigned := bcR.pool.numPending == bcR.pool.numUnassigned
+ enoughPeers := outbound+inbound >= 3
+ if maxPending && allUnassigned && enoughPeers {
+ log.Info("Time to switch to consensus reactor!", "height", bcR.pool.height)
+ bcR.pool.Stop()
+
+ conR := bcR.sw.Reactor("CONSENSUS").(consensusReactor)
+ conR.SwitchToConsensus(bcR.state)
+
+ break FOR_LOOP
+ }
+ case _ = <-trySyncTicker.C: // chan time
+ // This loop can be slow as long as it's doing syncing work.
+ SYNC_LOOP:
+ for i := 0; i < 10; i++ {
+ // See if there are any blocks to sync.
+ first, second := bcR.pool.PeekTwoBlocks()
+ //log.Debug("TrySync peeked", "first", first, "second", second)
+ if first == nil || second == nil {
+ // We need both to sync the first block.
+ break SYNC_LOOP
+ }
+ firstParts := first.MakePartSet()
+ firstPartsHeader := firstParts.Header()
+ // Finally, verify the first block using the second's validation.
+ err := bcR.state.BondedValidators.VerifyValidation(
+ bcR.state.ChainID, first.Hash(), firstPartsHeader, first.Height, second.Validation)
+ if err != nil {
+ log.Debug("error in validation", "error", err)
+ bcR.pool.RedoRequest(first.Height)
+ break SYNC_LOOP
+ } else {
+ bcR.pool.PopRequest()
+ err := sm.ExecBlock(bcR.state, first, firstPartsHeader)
+ if err != nil {
+ // TODO This is bad, are we zombie?
+ panic(Fmt("Failed to process committed block: %v", err))
+ }
+ bcR.store.SaveBlock(first, firstParts, second.Validation)
+ bcR.state.Save()
+ }
+ }
+ continue FOR_LOOP
+ case <-bcR.quit:
+ break FOR_LOOP
+ }
+ }
+}
+
+func (bcR *BlockchainReactor) BroadcastStatusResponse() error {
+ bcR.sw.Broadcast(BlockchainChannel, &bcStatusResponseMessage{bcR.store.Height()})
+ return nil
+}
+
+func (bcR *BlockchainReactor) BroadcastStatusRequest() error {
+ bcR.sw.Broadcast(BlockchainChannel, &bcStatusRequestMessage{bcR.store.Height()})
+ return nil
+}
+
+// implements events.Eventable
+func (bcR *BlockchainReactor) SetFireable(evsw events.Fireable) {
+ bcR.evsw = evsw
+}
+
+//-----------------------------------------------------------------------------
+// Messages
+
+const (
+ msgTypeBlockRequest = byte(0x10)
+ msgTypeBlockResponse = byte(0x11)
+ msgTypeStatusResponse = byte(0x20)
+ msgTypeStatusRequest = byte(0x21)
+)
+
+type BlockchainMessage interface{}
+
+var _ = binary.RegisterInterface(
+ struct{ BlockchainMessage }{},
+ binary.ConcreteType{&bcBlockRequestMessage{}, msgTypeBlockRequest},
+ binary.ConcreteType{&bcBlockResponseMessage{}, msgTypeBlockResponse},
+ binary.ConcreteType{&bcStatusResponseMessage{}, msgTypeStatusResponse},
+ binary.ConcreteType{&bcStatusRequestMessage{}, msgTypeStatusRequest},
+)
+
+func DecodeMessage(bz []byte) (msgType byte, msg BlockchainMessage, err error) {
+ msgType = bz[0]
+ n := new(int64)
+ r := bytes.NewReader(bz)
+ msg = binary.ReadBinary(struct{ BlockchainMessage }{}, r, n, &err).(struct{ BlockchainMessage }).BlockchainMessage
+ return
+}
+
+//-------------------------------------
+
+type bcBlockRequestMessage struct {
+ Height uint
+}
+
+func (m *bcBlockRequestMessage) String() string {
+ return fmt.Sprintf("[bcBlockRequestMessage %v]", m.Height)
+}
+
+//-------------------------------------
+
+type bcBlockResponseMessage struct {
+ Block *types.Block
+}
+
+func (m *bcBlockResponseMessage) String() string {
+ return fmt.Sprintf("[bcBlockResponseMessage %v]", m.Block.Height)
+}
+
+//-------------------------------------
+
+type bcStatusRequestMessage struct {
+ Height uint
+}
+
+func (m *bcStatusRequestMessage) String() string {
+ return fmt.Sprintf("[bcStatusRequestMessage %v]", m.Height)
+}
+
+//-------------------------------------
+
+type bcStatusResponseMessage struct {
+ Height uint
+}
+
+func (m *bcStatusResponseMessage) String() string {
+ return fmt.Sprintf("[bcStatusResponseMessage %v]", m.Height)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain/store.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain/store.go
new file mode 100644
index 0000000000000000000000000000000000000000..497572c2d8c71cb849e236f164ae633545e0aacb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain/store.go
@@ -0,0 +1,232 @@
+package blockchain
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "io"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ dbm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/db"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+/*
+Simple low level store for blocks.
+
+There are three types of information stored:
+ - BlockMeta: Meta information about each block
+ - Block part: Parts of each block, aggregated w/ PartSet
+ - Validation: The Validation part of each block, for gossiping commit votes
+
+Currently the commit signatures are duplicated in the Block parts as
+well as the Validation. In the future this may change, perhaps by moving
+the Validation data outside the Block.
+*/
+type BlockStore struct {
+ height uint
+ db dbm.DB
+}
+
+func NewBlockStore(db dbm.DB) *BlockStore {
+ bsjson := LoadBlockStoreStateJSON(db)
+ return &BlockStore{
+ height: bsjson.Height,
+ db: db,
+ }
+}
+
+// Height() returns the last known contiguous block height.
+func (bs *BlockStore) Height() uint {
+ return bs.height
+}
+
+func (bs *BlockStore) GetReader(key []byte) io.Reader {
+ bytez := bs.db.Get(key)
+ if bytez == nil {
+ return nil
+ }
+ return bytes.NewReader(bytez)
+}
+
+func (bs *BlockStore) LoadBlock(height uint) *types.Block {
+ var n int64
+ var err error
+ r := bs.GetReader(calcBlockMetaKey(height))
+ if r == nil {
+ panic(Fmt("Block does not exist at height %v", height))
+ }
+ meta := binary.ReadBinary(&types.BlockMeta{}, r, &n, &err).(*types.BlockMeta)
+ if err != nil {
+ panic(Fmt("Error reading block meta: %v", err))
+ }
+ bytez := []byte{}
+ for i := uint(0); i < meta.Parts.Total; i++ {
+ part := bs.LoadBlockPart(height, i)
+ bytez = append(bytez, part.Bytes...)
+ }
+ block := binary.ReadBinary(&types.Block{}, bytes.NewReader(bytez), &n, &err).(*types.Block)
+ if err != nil {
+ panic(Fmt("Error reading block: %v", err))
+ }
+ return block
+}
+
+func (bs *BlockStore) LoadBlockPart(height uint, index uint) *types.Part {
+ var n int64
+ var err error
+ r := bs.GetReader(calcBlockPartKey(height, index))
+ if r == nil {
+ panic(Fmt("BlockPart does not exist for height %v index %v", height, index))
+ }
+ part := binary.ReadBinary(&types.Part{}, r, &n, &err).(*types.Part)
+ if err != nil {
+ panic(Fmt("Error reading block part: %v", err))
+ }
+ return part
+}
+
+func (bs *BlockStore) LoadBlockMeta(height uint) *types.BlockMeta {
+ var n int64
+ var err error
+ r := bs.GetReader(calcBlockMetaKey(height))
+ if r == nil {
+ panic(Fmt("BlockMeta does not exist for height %v", height))
+ }
+ meta := binary.ReadBinary(&types.BlockMeta{}, r, &n, &err).(*types.BlockMeta)
+ if err != nil {
+ panic(Fmt("Error reading block meta: %v", err))
+ }
+ return meta
+}
+
+// NOTE: the Commit-vote heights are for the block at `height-1`
+// Since these are included in the subsequent block, the height
+// is off by 1.
+func (bs *BlockStore) LoadBlockValidation(height uint) *types.Validation {
+ var n int64
+ var err error
+ r := bs.GetReader(calcBlockValidationKey(height))
+ if r == nil {
+ panic(Fmt("BlockValidation does not exist for height %v", height))
+ }
+ validation := binary.ReadBinary(&types.Validation{}, r, &n, &err).(*types.Validation)
+ if err != nil {
+ panic(Fmt("Error reading validation: %v", err))
+ }
+ return validation
+}
+
+// NOTE: the Commit-vote heights are for the block at `height`
+func (bs *BlockStore) LoadSeenValidation(height uint) *types.Validation {
+ var n int64
+ var err error
+ r := bs.GetReader(calcSeenValidationKey(height))
+ if r == nil {
+ panic(Fmt("SeenValidation does not exist for height %v", height))
+ }
+ validation := binary.ReadBinary(&types.Validation{}, r, &n, &err).(*types.Validation)
+ if err != nil {
+ panic(Fmt("Error reading validation: %v", err))
+ }
+ return validation
+}
+
+// blockParts: Must be parts of the block
+// seenValidation: The +2/3 commits that were seen which finalized the height.
+// If all the nodes restart after committing a block,
+// we need this to reload the commits to catch-up nodes to the
+// most recent height. Otherwise they'd stall at H-1.
+// Also good to have to debug consensus issues & punish wrong-signers
+// whose commits weren't included in the block.
+func (bs *BlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, seenValidation *types.Validation) {
+ height := block.Height
+ if height != bs.height+1 {
+ panic(Fmt("BlockStore can only save contiguous blocks. Wanted %v, got %v", bs.height+1, height))
+ }
+ if !blockParts.IsComplete() {
+ panic(Fmt("BlockStore can only save complete block part sets"))
+ }
+
+ // Save block meta
+ meta := types.NewBlockMeta(block, blockParts)
+ metaBytes := binary.BinaryBytes(meta)
+ bs.db.Set(calcBlockMetaKey(height), metaBytes)
+
+ // Save block parts
+ for i := uint(0); i < blockParts.Total(); i++ {
+ bs.saveBlockPart(height, i, blockParts.GetPart(i))
+ }
+
+ // Save block validation (duplicate and separate from the Block)
+ blockValidationBytes := binary.BinaryBytes(block.Validation)
+ bs.db.Set(calcBlockValidationKey(height), blockValidationBytes)
+
+ // Save seen validation (seen +2/3 commits)
+ seenValidationBytes := binary.BinaryBytes(seenValidation)
+ bs.db.Set(calcSeenValidationKey(height), seenValidationBytes)
+
+ // Save new BlockStoreStateJSON descriptor
+ BlockStoreStateJSON{Height: height}.Save(bs.db)
+
+ // Done!
+ bs.height = height
+}
+
+func (bs *BlockStore) saveBlockPart(height uint, index uint, part *types.Part) {
+ if height != bs.height+1 {
+ panic(Fmt("BlockStore can only save contiguous blocks. Wanted %v, got %v", bs.height+1, height))
+ }
+ partBytes := binary.BinaryBytes(part)
+ bs.db.Set(calcBlockPartKey(height, index), partBytes)
+}
+
+//-----------------------------------------------------------------------------
+
+func calcBlockMetaKey(height uint) []byte {
+ return []byte(fmt.Sprintf("H:%v", height))
+}
+
+func calcBlockPartKey(height uint, partIndex uint) []byte {
+ return []byte(fmt.Sprintf("P:%v:%v", height, partIndex))
+}
+
+func calcBlockValidationKey(height uint) []byte {
+ return []byte(fmt.Sprintf("V:%v", height))
+}
+
+func calcSeenValidationKey(height uint) []byte {
+ return []byte(fmt.Sprintf("SV:%v", height))
+}
+
+//-----------------------------------------------------------------------------
+
+var blockStoreKey = []byte("blockStore")
+
+type BlockStoreStateJSON struct {
+ Height uint
+}
+
+func (bsj BlockStoreStateJSON) Save(db dbm.DB) {
+ bytes, err := json.Marshal(bsj)
+ if err != nil {
+ panic(Fmt("Could not marshal state bytes: %v", err))
+ }
+ db.Set(blockStoreKey, bytes)
+}
+
+func LoadBlockStoreStateJSON(db dbm.DB) BlockStoreStateJSON {
+ bytes := db.Get(blockStoreKey)
+ if bytes == nil {
+ return BlockStoreStateJSON{
+ Height: 0,
+ }
+ }
+ bsj := BlockStoreStateJSON{}
+ err := json.Unmarshal(bytes, &bsj)
+ if err != nil {
+ panic(Fmt("Could not unmarshal bytes: %X", bytes))
+ }
+ return bsj
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/array.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/array.go
new file mode 100644
index 0000000000000000000000000000000000000000..adedc42bee59b606617f0076903cda97c2f05d64
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/array.go
@@ -0,0 +1,5 @@
+package common
+
+func Arr(items ...interface{}) []interface{} {
+ return items
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/bit_array.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/bit_array.go
new file mode 100644
index 0000000000000000000000000000000000000000..eb314335bad8f1f9ca0c3301e38183090f961d55
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/bit_array.go
@@ -0,0 +1,274 @@
+package common
+
+import (
+ "fmt"
+ "math/rand"
+ "strings"
+ "sync"
+)
+
+type BitArray struct {
+ mtx sync.Mutex
+ Bits uint `json:"bits"` // NOTE: persisted via reflect, must be exported
+ Elems []uint64 `json:"elems"` // NOTE: persisted via reflect, must be exported
+}
+
+func NewBitArray(bits uint) *BitArray {
+ return &BitArray{
+ Bits: bits,
+ Elems: make([]uint64, (bits+63)/64),
+ }
+}
+
+func (bA *BitArray) Size() uint {
+ if bA == nil {
+ return 0
+ }
+ return bA.Bits
+}
+
+// NOTE: behavior is undefined if i >= bA.Bits
+func (bA *BitArray) GetIndex(i uint) bool {
+ if bA == nil {
+ return false
+ }
+ bA.mtx.Lock()
+ defer bA.mtx.Unlock()
+ return bA.getIndex(i)
+}
+
+func (bA *BitArray) getIndex(i uint) bool {
+ if i >= bA.Bits {
+ return false
+ }
+ return bA.Elems[i/64]&(uint64(1)<<(i%64)) > 0
+}
+
+// NOTE: behavior is undefined if i >= bA.Bits
+func (bA *BitArray) SetIndex(i uint, v bool) bool {
+ if bA == nil {
+ return false
+ }
+ bA.mtx.Lock()
+ defer bA.mtx.Unlock()
+ return bA.setIndex(i, v)
+}
+
+func (bA *BitArray) setIndex(i uint, v bool) bool {
+ if i >= bA.Bits {
+ return false
+ }
+ if v {
+ bA.Elems[i/64] |= (uint64(1) << (i % 64))
+ } else {
+ bA.Elems[i/64] &= ^(uint64(1) << (i % 64))
+ }
+ return true
+}
+
+func (bA *BitArray) Copy() *BitArray {
+ if bA == nil {
+ return nil
+ }
+ bA.mtx.Lock()
+ defer bA.mtx.Unlock()
+ return bA.copy()
+}
+
+func (bA *BitArray) copy() *BitArray {
+ c := make([]uint64, len(bA.Elems))
+ copy(c, bA.Elems)
+ return &BitArray{
+ Bits: bA.Bits,
+ Elems: c,
+ }
+}
+
+func (bA *BitArray) copyBits(bits uint) *BitArray {
+ c := make([]uint64, (bits+63)/64)
+ copy(c, bA.Elems)
+ return &BitArray{
+ Bits: bits,
+ Elems: c,
+ }
+}
+
+// Returns a BitArray of larger bits size.
+func (bA *BitArray) Or(o *BitArray) *BitArray {
+ if bA == nil {
+ o.Copy()
+ }
+ bA.mtx.Lock()
+ defer bA.mtx.Unlock()
+ c := bA.copyBits(MaxUint(bA.Bits, o.Bits))
+ for i := 0; i < len(c.Elems); i++ {
+ c.Elems[i] |= o.Elems[i]
+ }
+ return c
+}
+
+// Returns a BitArray of smaller bit size.
+func (bA *BitArray) And(o *BitArray) *BitArray {
+ if bA == nil {
+ return nil
+ }
+ bA.mtx.Lock()
+ defer bA.mtx.Unlock()
+ return bA.and(o)
+}
+
+func (bA *BitArray) and(o *BitArray) *BitArray {
+ c := bA.copyBits(MinUint(bA.Bits, o.Bits))
+ for i := 0; i < len(c.Elems); i++ {
+ c.Elems[i] &= o.Elems[i]
+ }
+ return c
+}
+
+func (bA *BitArray) Not() *BitArray {
+ if bA == nil {
+ return nil // Degenerate
+ }
+ bA.mtx.Lock()
+ defer bA.mtx.Unlock()
+ c := bA.copy()
+ for i := 0; i < len(c.Elems); i++ {
+ c.Elems[i] = ^c.Elems[i]
+ }
+ return c
+}
+
+func (bA *BitArray) Sub(o *BitArray) *BitArray {
+ if bA == nil {
+ return nil
+ }
+ bA.mtx.Lock()
+ defer bA.mtx.Unlock()
+ if bA.Bits > o.Bits {
+ c := bA.copy()
+ for i := 0; i < len(o.Elems)-1; i++ {
+ c.Elems[i] &= ^c.Elems[i]
+ }
+ i := uint(len(o.Elems) - 1)
+ if i >= 0 {
+ for idx := i * 64; idx < o.Bits; idx++ {
+ c.setIndex(idx, c.getIndex(idx) && !o.GetIndex(idx))
+ }
+ }
+ return c
+ } else {
+ return bA.and(o.Not()) // Note degenerate case where o == nil
+ }
+}
+
+func (bA *BitArray) IsFull() bool {
+ if bA == nil {
+ return true
+ }
+ bA.mtx.Lock()
+ defer bA.mtx.Unlock()
+
+ if bA.Bits == 0 {
+ return false
+ }
+
+ // Check all elements except the last
+ for _, elem := range bA.Elems[:len(bA.Elems)-1] {
+ if (^elem) != 0 {
+ return false
+ }
+ }
+
+ // Check that the last element has (lastElemBits) 1's
+ lastElemBits := (bA.Bits+63)%64 + 1
+ lastElem := bA.Elems[len(bA.Elems)-1]
+ return (lastElem+1)&((uint64(1)<<lastElemBits)-1) == 0
+}
+
+func (bA *BitArray) PickRandom() (uint, bool) {
+ if bA == nil {
+ return 0, false
+ }
+ bA.mtx.Lock()
+ defer bA.mtx.Unlock()
+
+ length := len(bA.Elems)
+ if length == 0 {
+ return 0, false
+ }
+ randElemStart := rand.Intn(length)
+ for i := 0; i < length; i++ {
+ elemIdx := ((i + randElemStart) % length)
+ if elemIdx < length-1 {
+ if bA.Elems[elemIdx] > 0 {
+ randBitStart := rand.Intn(64)
+ for j := 0; j < 64; j++ {
+ bitIdx := ((j + randBitStart) % 64)
+ if (bA.Elems[elemIdx] & (uint64(1) << uint(bitIdx))) > 0 {
+ return 64*uint(elemIdx) + uint(bitIdx), true
+ }
+ }
+ panic("should not happen")
+ }
+ } else {
+ // Special case for last elem, to ignore straggler bits
+ elemBits := int(bA.Bits) % 64
+ if elemBits == 0 {
+ elemBits = 64
+ }
+ randBitStart := rand.Intn(elemBits)
+ for j := 0; j < elemBits; j++ {
+ bitIdx := ((j + randBitStart) % elemBits)
+ if (bA.Elems[elemIdx] & (uint64(1) << uint(bitIdx))) > 0 {
+ return 64*uint(elemIdx) + uint(bitIdx), true
+ }
+ }
+ }
+ }
+ return 0, false
+}
+
+func (bA *BitArray) String() string {
+ if bA == nil {
+ return "nil-BitArray"
+ }
+ bA.mtx.Lock()
+ defer bA.mtx.Unlock()
+ return bA.stringIndented("")
+}
+
+func (bA *BitArray) StringIndented(indent string) string {
+ if bA == nil {
+ return "nil-BitArray"
+ }
+ bA.mtx.Lock()
+ defer bA.mtx.Unlock()
+ return bA.stringIndented(indent)
+}
+
+func (bA *BitArray) stringIndented(indent string) string {
+
+ lines := []string{}
+ bits := ""
+ for i := uint(0); i < bA.Bits; i++ {
+ if bA.getIndex(i) {
+ bits += "X"
+ } else {
+ bits += "_"
+ }
+ if i%100 == 99 {
+ lines = append(lines, bits)
+ bits = ""
+ }
+ if i%10 == 9 {
+ bits += " "
+ }
+ if i%50 == 49 {
+ bits += " "
+ }
+ }
+ if len(bits) > 0 {
+ lines = append(lines, bits)
+ }
+ return fmt.Sprintf("BA{%v:%v}", bA.Bits, strings.Join(lines, indent))
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/bit_array_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/bit_array_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..a0a1f397f842592aa059985588a18dc4cbf2adcb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/bit_array_test.go
@@ -0,0 +1,120 @@
+package common
+
+import (
+ "testing"
+)
+
+func randBitArray(bits uint) (*BitArray, []byte) {
+ src := RandBytes(int((bits + 7) / 8))
+ bA := NewBitArray(bits)
+ for i := uint(0); i < uint(len(src)); i++ {
+ for j := uint(0); j < 8; j++ {
+ if i*8+j >= bits {
+ return bA, src
+ }
+ setBit := src[i]&(1<<j) > 0
+ bA.SetIndex(i*8+j, setBit)
+ }
+ }
+ return bA, src
+}
+
+func TestAnd(t *testing.T) {
+
+ bA1, _ := randBitArray(51)
+ bA2, _ := randBitArray(31)
+ bA3 := bA1.And(bA2)
+
+ if bA3.Bits != 31 {
+ t.Error("Expected min bits", bA3.Bits)
+ }
+ if len(bA3.Elems) != len(bA2.Elems) {
+ t.Error("Expected min elems length")
+ }
+ for i := uint(0); i < bA3.Bits; i++ {
+ expected := bA1.GetIndex(i) && bA2.GetIndex(i)
+ if bA3.GetIndex(i) != expected {
+ t.Error("Wrong bit from bA3", i, bA1.GetIndex(i), bA2.GetIndex(i), bA3.GetIndex(i))
+ }
+ }
+}
+
+func TestOr(t *testing.T) {
+
+ bA1, _ := randBitArray(51)
+ bA2, _ := randBitArray(31)
+ bA3 := bA1.Or(bA2)
+
+ if bA3.Bits != 51 {
+ t.Error("Expected max bits")
+ }
+ if len(bA3.Elems) != len(bA1.Elems) {
+ t.Error("Expected max elems length")
+ }
+ for i := uint(0); i < bA3.Bits; i++ {
+ expected := bA1.GetIndex(i) || bA2.GetIndex(i)
+ if bA3.GetIndex(i) != expected {
+ t.Error("Wrong bit from bA3", i, bA1.GetIndex(i), bA2.GetIndex(i), bA3.GetIndex(i))
+ }
+ }
+}
+
+func TestSub1(t *testing.T) {
+
+ bA1, _ := randBitArray(31)
+ bA2, _ := randBitArray(51)
+ bA3 := bA1.Sub(bA2)
+
+ if bA3.Bits != bA1.Bits {
+ t.Error("Expected bA1 bits")
+ }
+ if len(bA3.Elems) != len(bA1.Elems) {
+ t.Error("Expected bA1 elems length")
+ }
+ for i := uint(0); i < bA3.Bits; i++ {
+ expected := bA1.GetIndex(i)
+ if bA2.GetIndex(i) {
+ expected = false
+ }
+ if bA3.GetIndex(i) != expected {
+ t.Error("Wrong bit from bA3", i, bA1.GetIndex(i), bA2.GetIndex(i), bA3.GetIndex(i))
+ }
+ }
+}
+
+func TestSub2(t *testing.T) {
+
+ bA1, _ := randBitArray(51)
+ bA2, _ := randBitArray(31)
+ bA3 := bA1.Sub(bA2)
+
+ if bA3.Bits != bA1.Bits {
+ t.Error("Expected bA1 bits")
+ }
+ if len(bA3.Elems) != len(bA1.Elems) {
+ t.Error("Expected bA1 elems length")
+ }
+ for i := uint(0); i < bA3.Bits; i++ {
+ expected := bA1.GetIndex(i)
+ if i < bA2.Bits && bA2.GetIndex(i) {
+ expected = false
+ }
+ if bA3.GetIndex(i) != expected {
+ t.Error("Wrong bit from bA3")
+ }
+ }
+}
+
+func TestPickRandom(t *testing.T) {
+ for idx := 0; idx < 123; idx++ {
+ bA1 := NewBitArray(123)
+ bA1.SetIndex(uint(idx), true)
+ index, ok := bA1.PickRandom()
+ if !ok {
+ t.Fatal("Expected to pick element but got none")
+ }
+ if index != uint(idx) {
+ t.Fatalf("Expected to pick element at %v but got wrong index", idx)
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/byteslice.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/byteslice.go
new file mode 100644
index 0000000000000000000000000000000000000000..da42db81054a3ee6920633519c54f560dab1914d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/byteslice.go
@@ -0,0 +1,34 @@
+package common
+
+func Fingerprint(slice []byte) []byte {
+ fingerprint := make([]byte, 6)
+ copy(fingerprint, slice)
+ return fingerprint
+}
+
+func IsZeros(slice []byte) bool {
+ for _, byt := range slice {
+ if byt != byte(0) {
+ return false
+ }
+ }
+ return true
+}
+
+func RightPadBytes(slice []byte, l int) []byte {
+ if l < len(slice) {
+ return slice
+ }
+ padded := make([]byte, l)
+ copy(padded[0:len(slice)], slice)
+ return padded
+}
+
+func LeftPadBytes(slice []byte, l int) []byte {
+ if l < len(slice) {
+ return slice
+ }
+ padded := make([]byte, l)
+ copy(padded[l-len(slice):], slice)
+ return padded
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/cmap.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/cmap.go
new file mode 100644
index 0000000000000000000000000000000000000000..5de6fa2fa506dcb114aeba3622ff4f9e91857cd0
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/cmap.go
@@ -0,0 +1,62 @@
+package common
+
+import "sync"
+
+// CMap is a goroutine-safe map
+type CMap struct {
+ m map[string]interface{}
+ l sync.Mutex
+}
+
+func NewCMap() *CMap {
+ return &CMap{
+ m: make(map[string]interface{}, 0),
+ }
+}
+
+func (cm *CMap) Set(key string, value interface{}) {
+ cm.l.Lock()
+ defer cm.l.Unlock()
+ cm.m[key] = value
+}
+
+func (cm *CMap) Get(key string) interface{} {
+ cm.l.Lock()
+ defer cm.l.Unlock()
+ return cm.m[key]
+}
+
+func (cm *CMap) Has(key string) bool {
+ cm.l.Lock()
+ defer cm.l.Unlock()
+ _, ok := cm.m[key]
+ return ok
+}
+
+func (cm *CMap) Delete(key string) {
+ cm.l.Lock()
+ defer cm.l.Unlock()
+ delete(cm.m, key)
+}
+
+func (cm *CMap) Size() int {
+ cm.l.Lock()
+ defer cm.l.Unlock()
+ return len(cm.m)
+}
+
+func (cm *CMap) Clear() {
+ cm.l.Lock()
+ defer cm.l.Unlock()
+ cm.m = make(map[string]interface{}, 0)
+}
+
+func (cm *CMap) Values() []interface{} {
+ cm.l.Lock()
+ defer cm.l.Unlock()
+ items := []interface{}{}
+ for _, v := range cm.m {
+ items = append(items, v)
+ }
+ return items
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/colors.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/colors.go
new file mode 100644
index 0000000000000000000000000000000000000000..776b22e2e19418065006149c9bc3af16bd1f0617
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/colors.go
@@ -0,0 +1,84 @@
+package common
+
+import (
+ "fmt"
+ "strings"
+)
+
+const (
+ ANSIReset = "\x1b[0m"
+ ANSIBright = "\x1b[1m"
+ ANSIDim = "\x1b[2m"
+ ANSIUnderscore = "\x1b[4m"
+ ANSIBlink = "\x1b[5m"
+ ANSIReverse = "\x1b[7m"
+ ANSIHidden = "\x1b[8m"
+
+ ANSIFgBlack = "\x1b[30m"
+ ANSIFgRed = "\x1b[31m"
+ ANSIFgGreen = "\x1b[32m"
+ ANSIFgYellow = "\x1b[33m"
+ ANSIFgBlue = "\x1b[34m"
+ ANSIFgMagenta = "\x1b[35m"
+ ANSIFgCyan = "\x1b[36m"
+ ANSIFgWhite = "\x1b[37m"
+
+ ANSIBgBlack = "\x1b[40m"
+ ANSIBgRed = "\x1b[41m"
+ ANSIBgGreen = "\x1b[42m"
+ ANSIBgYellow = "\x1b[43m"
+ ANSIBgBlue = "\x1b[44m"
+ ANSIBgMagenta = "\x1b[45m"
+ ANSIBgCyan = "\x1b[46m"
+ ANSIBgWhite = "\x1b[47m"
+)
+
+// color the string s with color 'color'
+// unless s is already colored
+func treat(s string, color string) string {
+ if len(s) > 2 && s[:2] == "\x1b[" {
+ return s
+ } else {
+ return color + s + ANSIReset
+ }
+}
+
+func treatAll(color string, args ...interface{}) string {
+ var parts []string
+ for _, arg := range args {
+ parts = append(parts, treat(fmt.Sprintf("%v", arg), color))
+ }
+ return strings.Join(parts, "")
+}
+
+func Black(args ...interface{}) string {
+ return treatAll(ANSIFgBlack, args...)
+}
+
+func Red(args ...interface{}) string {
+ return treatAll(ANSIFgRed, args...)
+}
+
+func Green(args ...interface{}) string {
+ return treatAll(ANSIFgGreen, args...)
+}
+
+func Yellow(args ...interface{}) string {
+ return treatAll(ANSIFgYellow, args...)
+}
+
+func Blue(args ...interface{}) string {
+ return treatAll(ANSIFgBlue, args...)
+}
+
+func Magenta(args ...interface{}) string {
+ return treatAll(ANSIFgMagenta, args...)
+}
+
+func Cyan(args ...interface{}) string {
+ return treatAll(ANSIFgCyan, args...)
+}
+
+func White(args ...interface{}) string {
+ return treatAll(ANSIFgWhite, args...)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/errors.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/errors.go
new file mode 100644
index 0000000000000000000000000000000000000000..a3312e97f37cce57d4eed5462af52f74b511ef9c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/errors.go
@@ -0,0 +1,18 @@
+package common
+
+import (
+ "fmt"
+)
+
+type StackError struct {
+ Err interface{}
+ Stack []byte
+}
+
+func (se StackError) String() string {
+ return fmt.Sprintf("Error: %v\nStack: %s", se.Err, se.Stack)
+}
+
+func (se StackError) Error() string {
+ return se.String()
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/heap.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/heap.go
new file mode 100644
index 0000000000000000000000000000000000000000..4a96d7aaa3470a18ab87055cd2bd138e6e1c9e58
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/heap.go
@@ -0,0 +1,103 @@
+package common
+
+import (
+ "container/heap"
+)
+
+type Comparable interface {
+ Less(o interface{}) bool
+}
+
+//-----------------------------------------------------------------------------
+
+/*
+Example usage:
+ h := NewHeap()
+
+ h.Push(String("msg1"), 1)
+ h.Push(String("msg3"), 3)
+ h.Push(String("msg2"), 2)
+
+ fmt.Println(h.Pop())
+ fmt.Println(h.Pop())
+ fmt.Println(h.Pop())
+*/
+
+type Heap struct {
+ pq priorityQueue
+}
+
+func NewHeap() *Heap {
+ return &Heap{pq: make([]*pqItem, 0)}
+}
+
+func (h *Heap) Len() int64 {
+ return int64(len(h.pq))
+}
+
+func (h *Heap) Push(value interface{}, priority Comparable) {
+ heap.Push(&h.pq, &pqItem{value: value, priority: priority})
+}
+
+func (h *Heap) Peek() interface{} {
+ if len(h.pq) == 0 {
+ return nil
+ }
+ return h.pq[0].value
+}
+
+func (h *Heap) Update(value interface{}, priority Comparable) {
+ h.pq.Update(h.pq[0], value, priority)
+}
+
+func (h *Heap) Pop() interface{} {
+ item := heap.Pop(&h.pq).(*pqItem)
+ return item.value
+}
+
+//-----------------------------------------------------------------------------
+
+///////////////////////
+// From: http://golang.org/pkg/container/heap/#example__priorityQueue
+
+type pqItem struct {
+ value interface{}
+ priority Comparable
+ index int
+}
+
+type priorityQueue []*pqItem
+
+func (pq priorityQueue) Len() int { return len(pq) }
+
+func (pq priorityQueue) Less(i, j int) bool {
+ return pq[i].priority.Less(pq[j].priority)
+}
+
+func (pq priorityQueue) Swap(i, j int) {
+ pq[i], pq[j] = pq[j], pq[i]
+ pq[i].index = i
+ pq[j].index = j
+}
+
+func (pq *priorityQueue) Push(x interface{}) {
+ n := len(*pq)
+ item := x.(*pqItem)
+ item.index = n
+ *pq = append(*pq, item)
+}
+
+func (pq *priorityQueue) Pop() interface{} {
+ old := *pq
+ n := len(old)
+ item := old[n-1]
+ item.index = -1 // for safety
+ *pq = old[0 : n-1]
+ return item
+}
+
+func (pq *priorityQueue) Update(item *pqItem, value interface{}, priority Comparable) {
+ item.value = value
+ item.priority = priority
+ heap.Fix(pq, item.index)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/int.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/int.go
new file mode 100644
index 0000000000000000000000000000000000000000..c6e85dc62d169c67365996c6c6e2f0e865f7fa9e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/int.go
@@ -0,0 +1,39 @@
+package common
+
+import (
+ "encoding/binary"
+ "sort"
+)
+
+// Sort for []uint64
+
+type Uint64Slice []uint64
+
+func (p Uint64Slice) Len() int { return len(p) }
+func (p Uint64Slice) Less(i, j int) bool { return p[i] < p[j] }
+func (p Uint64Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
+func (p Uint64Slice) Sort() { sort.Sort(p) }
+
+func SearchUint64s(a []uint64, x uint64) int {
+ return sort.Search(len(a), func(i int) bool { return a[i] >= x })
+}
+
+func (p Uint64Slice) Search(x uint64) int { return SearchUint64s(p, x) }
+
+//-----------------------------------------------------------------------------
+
+func PutUint64LE(dest []byte, i uint64) {
+ binary.LittleEndian.PutUint64(dest, i)
+}
+
+func GetUint64LE(src []byte) uint64 {
+ return binary.LittleEndian.Uint64(src)
+}
+
+func PutUint64BE(dest []byte, i uint64) {
+ binary.BigEndian.PutUint64(dest, i)
+}
+
+func GetUint64BE(src []byte) uint64 {
+ return binary.BigEndian.Uint64(src)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/io.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/io.go
new file mode 100644
index 0000000000000000000000000000000000000000..0c33b07569c3977bab84e037a7c567a759ebd923
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/io.go
@@ -0,0 +1,24 @@
+package common
+
+import (
+ "io"
+)
+
+type PrefixedReader struct {
+ Prefix []byte
+ reader io.Reader
+}
+
+func NewPrefixedReader(prefix []byte, reader io.Reader) *PrefixedReader {
+ return &PrefixedReader{prefix, reader}
+}
+
+func (pr *PrefixedReader) Read(p []byte) (n int, err error) {
+ if len(pr.Prefix) > 0 {
+ read := copy(p, pr.Prefix)
+ pr.Prefix = pr.Prefix[read:]
+ return read, nil
+ } else {
+ return pr.reader.Read(p)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/math.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/math.go
new file mode 100644
index 0000000000000000000000000000000000000000..b037d1a71efbbc796ec65dc50bd2878d43fc57cc
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/math.go
@@ -0,0 +1,157 @@
+package common
+
+func MaxInt8(a, b int8) int8 {
+ if a > b {
+ return a
+ }
+ return b
+}
+
+func MaxUint8(a, b uint8) uint8 {
+ if a > b {
+ return a
+ }
+ return b
+}
+
+func MaxInt16(a, b int16) int16 {
+ if a > b {
+ return a
+ }
+ return b
+}
+
+func MaxUint16(a, b uint16) uint16 {
+ if a > b {
+ return a
+ }
+ return b
+}
+
+func MaxInt32(a, b int32) int32 {
+ if a > b {
+ return a
+ }
+ return b
+}
+
+func MaxUint32(a, b uint32) uint32 {
+ if a > b {
+ return a
+ }
+ return b
+}
+
+func MaxInt64(a, b int64) int64 {
+ if a > b {
+ return a
+ }
+ return b
+}
+
+func MaxUint64(a, b uint64) uint64 {
+ if a > b {
+ return a
+ }
+ return b
+}
+
+func MaxInt(a, b int) int {
+ if a > b {
+ return a
+ }
+ return b
+}
+
+func MaxUint(a, b uint) uint {
+ if a > b {
+ return a
+ }
+ return b
+}
+
+//-----------------------------------------------------------------------------
+
+func MinInt8(a, b int8) int8 {
+ if a < b {
+ return a
+ }
+ return b
+}
+
+func MinUint8(a, b uint8) uint8 {
+ if a < b {
+ return a
+ }
+ return b
+}
+
+func MinInt16(a, b int16) int16 {
+ if a < b {
+ return a
+ }
+ return b
+}
+
+func MinUint16(a, b uint16) uint16 {
+ if a < b {
+ return a
+ }
+ return b
+}
+
+func MinInt32(a, b int32) int32 {
+ if a < b {
+ return a
+ }
+ return b
+}
+
+func MinUint32(a, b uint32) uint32 {
+ if a < b {
+ return a
+ }
+ return b
+}
+
+func MinInt64(a, b int64) int64 {
+ if a < b {
+ return a
+ }
+ return b
+}
+
+func MinUint64(a, b uint64) uint64 {
+ if a < b {
+ return a
+ }
+ return b
+}
+
+func MinInt(a, b int) int {
+ if a < b {
+ return a
+ }
+ return b
+}
+
+func MinUint(a, b uint) uint {
+ if a < b {
+ return a
+ }
+ return b
+}
+
+//-----------------------------------------------------------------------------
+
+func ExpUint64(a, b uint64) uint64 {
+ accum := uint64(1)
+ for b > 0 {
+ if b&1 == 1 {
+ accum *= a
+ }
+ a *= a
+ b >>= 1
+ }
+ return accum
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/os.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/os.go
new file mode 100644
index 0000000000000000000000000000000000000000..53febecbe5abed683b417c7c625f3795d9afc2c9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/os.go
@@ -0,0 +1,98 @@
+package common
+
+import (
+ "fmt"
+ "io/ioutil"
+ "os"
+ "os/signal"
+)
+
+func TrapSignal(cb func()) {
+ c := make(chan os.Signal, 1)
+ signal.Notify(c, os.Interrupt)
+ signal.Notify(c, os.Kill)
+ go func() {
+ for sig := range c {
+ fmt.Printf("captured %v, exiting...\n", sig)
+ if cb != nil {
+ cb()
+ }
+ os.Exit(1)
+ }
+ }()
+ select {}
+}
+
+func Exit(s string) {
+ fmt.Printf(s + "\n")
+ os.Exit(1)
+}
+
+func EnsureDir(dir string) error {
+ if _, err := os.Stat(dir); os.IsNotExist(err) {
+ err := os.MkdirAll(dir, 0700)
+ if err != nil {
+ return fmt.Errorf("Could not create directory %v. %v", dir, err)
+ }
+ }
+ return nil
+}
+
+func FileExists(filePath string) bool {
+ _, err := os.Stat(filePath)
+ return !os.IsNotExist(err)
+}
+
+func ReadFile(filePath string) ([]byte, error) {
+ return ioutil.ReadFile(filePath)
+}
+
+func MustReadFile(filePath string) []byte {
+ fileBytes, err := ioutil.ReadFile(filePath)
+ if err != nil {
+ Exit(Fmt("MustReadFile failed: %v", err))
+ return nil
+ }
+ return fileBytes
+}
+
+func WriteFile(filePath string, contents []byte) error {
+ err := ioutil.WriteFile(filePath, contents, 0600)
+ if err != nil {
+ return err
+ }
+ fmt.Printf("File written to %v.\n", filePath)
+ return nil
+}
+
+func MustWriteFile(filePath string, contents []byte) {
+ err := WriteFile(filePath, contents)
+ if err != nil {
+ Exit(Fmt("MustWriteFile failed: %v", err))
+ }
+}
+
+// Writes to newBytes to filePath.
+// Guaranteed not to lose *both* oldBytes and newBytes,
+// (assuming that the OS is perfect)
+func WriteFileAtomic(filePath string, newBytes []byte) error {
+ // If a file already exists there, copy to filePath+".bak" (overwrite anything)
+ if _, err := os.Stat(filePath); !os.IsNotExist(err) {
+ fileBytes, err := ioutil.ReadFile(filePath)
+ if err != nil {
+ return fmt.Errorf("Could not read file %v. %v", filePath, err)
+ }
+ err = ioutil.WriteFile(filePath+".bak", fileBytes, 0600)
+ if err != nil {
+ return fmt.Errorf("Could not write file %v. %v", filePath+".bak", err)
+ }
+ }
+ // Write newBytes to filePath.new
+ err := ioutil.WriteFile(filePath+".new", newBytes, 0600)
+ if err != nil {
+ return fmt.Errorf("Could not write file %v. %v", filePath+".new", err)
+ }
+ // Move filePath.new to filePath
+ err = os.Rename(filePath+".new", filePath)
+ return err
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/random.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/random.go
new file mode 100644
index 0000000000000000000000000000000000000000..62a5092203b58df5be9b300dd59aa94332a660f2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/random.go
@@ -0,0 +1,133 @@
+package common
+
+import (
+ crand "crypto/rand"
+ "encoding/hex"
+ "math/rand"
+ "time"
+)
+
+const (
+ strChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" // 62 characters
+)
+
+func init() {
+ // Seed math/rand with "secure" int64
+ b := CRandBytes(8)
+ var seed uint64
+ for i := 0; i < 8; i++ {
+ seed |= uint64(b[i])
+ seed <<= 8
+ }
+ rand.Seed(int64(seed))
+}
+
+// Constructs an alphanumeric string of given length.
+func RandStr(length int) string {
+ chars := []byte{}
+MAIN_LOOP:
+ for {
+ val := rand.Int63()
+ for i := 0; i < 10; i++ {
+ v := int(val & 0x3f) // rightmost 6 bits
+ if v >= 62 { // only 62 characters in strChars
+ val >>= 6
+ continue
+ } else {
+ chars = append(chars, strChars[v])
+ if len(chars) == length {
+ break MAIN_LOOP
+ }
+ val >>= 6
+ }
+ }
+ }
+
+ return string(chars)
+}
+
+func RandUint16() uint16 {
+ return uint16(rand.Uint32() & (1<<16 - 1))
+}
+
+func RandUint32() uint32 {
+ return rand.Uint32()
+}
+
+func RandUint64() uint64 {
+ return uint64(rand.Uint32())<<32 + uint64(rand.Uint32())
+}
+
+func RandUint() uint {
+ return uint(rand.Int())
+}
+
+func RandInt() int {
+ return rand.Int()
+}
+
+// Distributed pseudo-exponentially to test for various cases
+func RandUint16Exp() uint16 {
+ bits := rand.Uint32() % 16
+ if bits == 0 {
+ return 0
+ }
+ n := uint16(1 << (bits - 1))
+ n += uint16(rand.Int31()) & ((1 << (bits - 1)) - 1)
+ return n
+}
+
+// Distributed pseudo-exponentially to test for various cases
+func RandUint32Exp() uint32 {
+ bits := rand.Uint32() % 32
+ if bits == 0 {
+ return 0
+ }
+ n := uint32(1 << (bits - 1))
+ n += uint32(rand.Int31()) & ((1 << (bits - 1)) - 1)
+ return n
+}
+
+// Distributed pseudo-exponentially to test for various cases
+func RandUint64Exp() uint64 {
+ bits := rand.Uint32() % 64
+ if bits == 0 {
+ return 0
+ }
+ n := uint64(1 << (bits - 1))
+ n += uint64(rand.Int63()) & ((1 << (bits - 1)) - 1)
+ return n
+}
+
+func RandFloat32() float32 {
+ return rand.Float32()
+}
+
+func RandTime() time.Time {
+ return time.Unix(int64(RandUint64Exp()), 0)
+}
+
+func RandBytes(n int) []byte {
+ bs := make([]byte, n)
+ for i := 0; i < n; i++ {
+ bs[i] = byte(rand.Intn(256))
+ }
+ return bs
+}
+
+//-----------------------------------------------------------------------------
+// CRand* methods are crypto safe.
+
+func CRandBytes(numBytes int) []byte {
+ b := make([]byte, numBytes)
+ _, err := crand.Read(b)
+ if err != nil {
+ panic(err)
+ }
+ return b
+}
+
+// RandHex(24) gives 96 bits of randomness, strong enough for most purposes.
+func CRandHex(numDigits int) string {
+ return hex.EncodeToString(CRandBytes(numDigits / 2))
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/repeat_timer.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/repeat_timer.go
new file mode 100644
index 0000000000000000000000000000000000000000..ce491f20a0d33a6450eb78c61a99cc4e3d1a16d8
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/repeat_timer.go
@@ -0,0 +1,66 @@
+package common
+
+import "time"
+import "sync"
+
+/*
+RepeatTimer repeatedly sends a struct{}{} to .Ch after each "dur" period.
+It's good for keeping connections alive.
+*/
+type RepeatTimer struct {
+ Ch chan time.Time
+
+ mtx sync.Mutex
+ name string
+ ticker *time.Ticker
+ quit chan struct{}
+ dur time.Duration
+}
+
+func NewRepeatTimer(name string, dur time.Duration) *RepeatTimer {
+ var t = &RepeatTimer{
+ Ch: make(chan time.Time),
+ ticker: time.NewTicker(dur),
+ quit: make(chan struct{}),
+ name: name,
+ dur: dur,
+ }
+ go t.fireRoutine(t.ticker)
+ return t
+}
+
+func (t *RepeatTimer) fireRoutine(ticker *time.Ticker) {
+ for {
+ select {
+ case t_ := <-ticker.C:
+ t.Ch <- t_
+ case <-t.quit:
+ return
+ }
+ }
+}
+
+// Wait the duration again before firing.
+func (t *RepeatTimer) Reset() {
+ t.Stop()
+
+ t.mtx.Lock() // Lock
+ defer t.mtx.Unlock()
+
+ t.ticker = time.NewTicker(t.dur)
+ t.quit = make(chan struct{})
+ go t.fireRoutine(t.ticker)
+}
+
+func (t *RepeatTimer) Stop() bool {
+ t.mtx.Lock() // Lock
+ defer t.mtx.Unlock()
+
+ exists := t.ticker != nil
+ if exists {
+ t.ticker.Stop()
+ t.ticker = nil
+ close(t.quit)
+ }
+ return exists
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/string.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/string.go
new file mode 100644
index 0000000000000000000000000000000000000000..a4d221b7402b0814fc3ae9db0653b0b5bf55ae6e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/string.go
@@ -0,0 +1,24 @@
+package common
+
+import (
+ "fmt"
+ "strings"
+)
+
+var Fmt = fmt.Sprintf
+
+func RightPadString(s string, totalLength int) string {
+ remaining := totalLength - len(s)
+ if remaining > 0 {
+ s = s + strings.Repeat(" ", remaining)
+ }
+ return s
+}
+
+func LeftPadString(s string, totalLength int) string {
+ remaining := totalLength - len(s)
+ if remaining > 0 {
+ s = strings.Repeat(" ", remaining) + s
+ }
+ return s
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/test/assert.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/test/assert.go
new file mode 100644
index 0000000000000000000000000000000000000000..a6ffed0cec39bb8079a9d698645a876640fea7a6
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/test/assert.go
@@ -0,0 +1,14 @@
+package test
+
+import (
+ "testing"
+)
+
+func AssertPanics(t *testing.T, msg string, f func()) {
+ defer func() {
+ if err := recover(); err == nil {
+ t.Errorf("Should have panic'd, but didn't: %v", msg)
+ }
+ }()
+ f()
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/test/mutate.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/test/mutate.go
new file mode 100644
index 0000000000000000000000000000000000000000..5931ae6a002627576add7d0ff09b2015a22dd449
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/test/mutate.go
@@ -0,0 +1,28 @@
+package test
+
+import (
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+// Contract: !bytes.Equal(input, output) && len(input) >= len(output)
+func MutateByteSlice(bytez []byte) []byte {
+ // If bytez is empty, panic
+ if len(bytez) == 0 {
+ panic("Cannot mutate an empty bytez")
+ }
+
+ // Copy bytez
+ mBytez := make([]byte, len(bytez))
+ copy(mBytez, bytez)
+ bytez = mBytez
+
+ // Try a random mutation
+ switch RandInt() % 2 {
+ case 0: // Mutate a single byte
+ bytez[RandInt()%len(bytez)] += byte(RandInt()%255 + 1)
+ case 1: // Remove an arbitrary byte
+ pos := RandInt() % len(bytez)
+ bytez = append(bytez[:pos], bytez[pos+1:]...)
+ }
+ return bytez
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/throttle_timer.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/throttle_timer.go
new file mode 100644
index 0000000000000000000000000000000000000000..c1c012a010abae1b09021dbd15d1ba3ede5665fb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/throttle_timer.go
@@ -0,0 +1,52 @@
+package common
+
+import (
+ "sync/atomic"
+ "time"
+)
+
+/*
+ThrottleTimer fires an event at most "dur" after each .Set() call.
+If a short burst of .Set() calls happens, ThrottleTimer fires once.
+If a long continuous burst of .Set() calls happens, ThrottleTimer fires
+at most once every "dur".
+*/
+type ThrottleTimer struct {
+ Name string
+ Ch chan struct{}
+ quit chan struct{}
+ dur time.Duration
+ timer *time.Timer
+ isSet uint32
+}
+
+func NewThrottleTimer(name string, dur time.Duration) *ThrottleTimer {
+ var ch = make(chan struct{})
+ var quit = make(chan struct{})
+ var t = &ThrottleTimer{Name: name, Ch: ch, dur: dur, quit: quit}
+ t.timer = time.AfterFunc(dur, t.fireRoutine)
+ t.timer.Stop()
+ return t
+}
+
+func (t *ThrottleTimer) fireRoutine() {
+ select {
+ case t.Ch <- struct{}{}:
+ atomic.StoreUint32(&t.isSet, 0)
+ case <-t.quit:
+ // do nothing
+ default:
+ t.timer.Reset(t.dur)
+ }
+}
+
+func (t *ThrottleTimer) Set() {
+ if atomic.CompareAndSwapUint32(&t.isSet, 0, 1) {
+ t.timer.Reset(t.dur)
+ }
+}
+
+func (t *ThrottleTimer) Stop() bool {
+ close(t.quit)
+ return t.timer.Stop()
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/common/word.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/word.go
new file mode 100644
index 0000000000000000000000000000000000000000..264a7dcc1281186d01a01374e33998a6f15a2cbf
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/common/word.go
@@ -0,0 +1,79 @@
+package common
+
+import (
+ "bytes"
+ "sort"
+)
+
+var (
+ Zero256 = Word256{0}
+ One256 = Word256{1}
+)
+
+type Word256 [32]byte
+
+func (w Word256) String() string { return string(w[:]) }
+func (w Word256) Copy() Word256 { return w }
+func (w Word256) Bytes() []byte { return w[:] } // copied.
+func (w Word256) Prefix(n int) []byte { return w[:n] }
+func (w Word256) Postfix(n int) []byte { return w[32-n:] }
+func (w Word256) IsZero() bool {
+ accum := byte(0)
+ for _, byt := range w {
+ accum |= byt
+ }
+ return accum == 0
+}
+func (w Word256) Compare(other Word256) int {
+ return bytes.Compare(w[:], other[:])
+}
+
+func Uint64ToWord256(i uint64) Word256 {
+ buf := [8]byte{}
+ PutUint64BE(buf[:], i)
+ return LeftPadWord256(buf[:])
+}
+
+func RightPadWord256(bz []byte) (word Word256) {
+ copy(word[:], bz)
+ return
+}
+
+func LeftPadWord256(bz []byte) (word Word256) {
+ copy(word[32-len(bz):], bz)
+ return
+}
+
+func Uint64FromWord256(word Word256) uint64 {
+ buf := word.Postfix(8)
+ return GetUint64BE(buf)
+}
+
+//-------------------------------------
+
+type Tuple256 struct {
+ First Word256
+ Second Word256
+}
+
+func (tuple Tuple256) Compare(other Tuple256) int {
+ firstCompare := tuple.First.Compare(other.First)
+ if firstCompare == 0 {
+ return tuple.Second.Compare(other.Second)
+ } else {
+ return firstCompare
+ }
+}
+
+func Tuple256Split(t Tuple256) (Word256, Word256) {
+ return t.First, t.Second
+}
+
+type Tuple256Slice []Tuple256
+
+func (p Tuple256Slice) Len() int { return len(p) }
+func (p Tuple256Slice) Less(i, j int) bool {
+ return p[i].Compare(p[j]) < 0
+}
+func (p Tuple256Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
+func (p Tuple256Slice) Sort() { sort.Sort(p) }
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/config/config.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/config/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..27e2037a5b6284f4fee39968d4d8eecac0e9d9a1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/config/config.go
@@ -0,0 +1,95 @@
+package config
+
+import (
+ "bufio"
+ "fmt"
+ "os"
+ "strings"
+ "sync"
+ "time"
+)
+
+func Prompt(prompt string, defaultValue string) string {
+ fmt.Print(prompt)
+ reader := bufio.NewReader(os.Stdin)
+ line, err := reader.ReadString('\n')
+ if err != nil {
+ log.Warn("Error reading stdin", "err", err)
+ return defaultValue
+ } else {
+ line = strings.TrimSpace(line)
+ if line == "" {
+ return defaultValue
+ }
+ return line
+ }
+}
+
+type Config interface {
+ Get(key string) interface{}
+ GetBool(key string) bool
+ GetFloat64(key string) float64
+ GetInt(key string) int
+ GetString(key string) string
+ GetStringMap(key string) map[string]interface{}
+ GetStringMapString(key string) map[string]string
+ GetStringSlice(key string) []string
+ GetTime(key string) time.Time
+ IsSet(key string) bool
+ Set(key string, value interface{})
+}
+
+type MapConfig map[string]interface{}
+
+func (cfg MapConfig) Get(key string) interface{} { return cfg[key] }
+func (cfg MapConfig) GetBool(key string) bool { return cfg[key].(bool) }
+func (cfg MapConfig) GetFloat64(key string) float64 { return cfg[key].(float64) }
+func (cfg MapConfig) GetInt(key string) int { return cfg[key].(int) }
+func (cfg MapConfig) GetString(key string) string { return cfg[key].(string) }
+func (cfg MapConfig) GetStringMap(key string) map[string]interface{} {
+ return cfg[key].(map[string]interface{})
+}
+func (cfg MapConfig) GetStringMapString(key string) map[string]string {
+ return cfg[key].(map[string]string)
+}
+func (cfg MapConfig) GetStringSlice(key string) []string { return cfg[key].([]string) }
+func (cfg MapConfig) GetTime(key string) time.Time { return cfg[key].(time.Time) }
+func (cfg MapConfig) IsSet(key string) bool { _, ok := cfg[key]; return ok }
+func (cfg MapConfig) Set(key string, value interface{}) { cfg[key] = value }
+func (cfg MapConfig) SetDefault(key string, value interface{}) {
+ if cfg.IsSet(key) {
+ return
+ }
+ cfg[key] = value
+}
+
+//--------------------------------------------------------------------------------
+// A little convenient hack to notify listeners upon config changes.
+
+type Configurable func(Config)
+
+var mtx sync.Mutex
+var globalConfig Config
+var confs []Configurable
+
+func OnConfig(conf func(Config)) {
+ mtx.Lock()
+ defer mtx.Unlock()
+
+ confs = append(confs, conf)
+ if globalConfig != nil {
+ conf(globalConfig)
+ }
+}
+
+func ApplyConfig(config Config) {
+ mtx.Lock()
+ globalConfig = config
+ confsCopy := make([]Configurable, len(confs))
+ copy(confsCopy, confs)
+ mtx.Unlock()
+
+ for _, conf := range confsCopy {
+ conf(config)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/config/log.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/config/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..8057015d1d6e47774d521a53d98226bf7cad7ee7
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/config/log.go
@@ -0,0 +1,9 @@
+package config
+
+import (
+ // We can't use github.com/tendermint/tendermint/logger
+ // because that would create a dependency cycle.
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
+)
+
+var log = log15.New("module", "config")
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint/config.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..b207135c0d42b15f3c5b9f5a52224dbb1611e11b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint/config.go
@@ -0,0 +1,181 @@
+package tendermint
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/naoina/toml"
+ "os"
+ "path"
+ "strings"
+
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ cfg "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config"
+)
+
+func getTMRoot(rootDir string) string {
+ if rootDir == "" {
+ rootDir = os.Getenv("TMROOT")
+ }
+ if rootDir == "" {
+ rootDir = os.Getenv("HOME") + "/.tendermint"
+ }
+ return rootDir
+}
+
+func initTMRoot(rootDir string) {
+ rootDir = getTMRoot(rootDir)
+ EnsureDir(rootDir)
+
+ configFilePath := path.Join(rootDir, "config.toml")
+ genesisFilePath := path.Join(rootDir, "genesis.json")
+
+ // Write default config file if missing.
+ if !FileExists(configFilePath) {
+ // Ask user for moniker
+ moniker := cfg.Prompt("Type hostname: ", "anonymous")
+ MustWriteFile(configFilePath, []byte(defaultConfig(moniker)))
+ }
+ if !FileExists(genesisFilePath) {
+ MustWriteFile(genesisFilePath, []byte(defaultGenesis))
+ }
+}
+
+func GetConfig(rootDir string) cfg.Config {
+ rootDir = getTMRoot(rootDir)
+ initTMRoot(rootDir)
+
+ var mapConfig = cfg.MapConfig(make(map[string]interface{}))
+ configFilePath := path.Join(rootDir, "config.toml")
+ configFileBytes := MustReadFile(configFilePath)
+ err := toml.Unmarshal(configFileBytes, mapConfig)
+ if err != nil {
+ Exit(Fmt("Could not read config: %v", err))
+ }
+
+ // Set defaults or panic
+ if mapConfig.IsSet("chain_id") {
+ Exit("Cannot set 'chain_id' via config.toml")
+ }
+ if mapConfig.IsSet("version") {
+ Exit("Cannot set 'version' via config.toml")
+ }
+ mapConfig.SetDefault("chain_id", "tendermint_testnet_5")
+ mapConfig.SetDefault("version", "0.3.0") // JAE: changed merkle tree persistence format for merkle proofs.
+ mapConfig.SetDefault("genesis_file", rootDir+"/genesis.json")
+ mapConfig.SetDefault("moniker", "anonymous")
+ mapConfig.SetDefault("node_laddr", "0.0.0.0:46656")
+ // mapConfig.SetDefault("seeds", "goldenalchemist.chaintest.net:46656")
+ mapConfig.SetDefault("fast_sync", true)
+ mapConfig.SetDefault("addrbook_file", rootDir+"/addrbook.json")
+ mapConfig.SetDefault("priv_validator_file", rootDir+"/priv_validator.json")
+ mapConfig.SetDefault("db_backend", "leveldb")
+ mapConfig.SetDefault("db_dir", rootDir+"/data")
+ mapConfig.SetDefault("log_level", "info")
+ mapConfig.SetDefault("rpc_laddr", "0.0.0.0:46657")
+ return mapConfig
+}
+
+func ensureDefault(mapConfig cfg.MapConfig, key string, value interface{}) {
+ if !mapConfig.IsSet(key) {
+ mapConfig[key] = value
+ }
+}
+
+var defaultConfigTmpl = `# This is a TOML config file.
+# For more information, see https://github.com/toml-lang/toml
+
+moniker = "__MONIKER__"
+node_laddr = "0.0.0.0:46656"
+seeds = "goldenalchemist.chaintest.net:46656"
+fast_sync = true
+db_backend = "leveldb"
+log_level = "debug"
+rpc_laddr = "0.0.0.0:46657"
+`
+
+func defaultConfig(moniker string) (defaultConfig string) {
+ defaultConfig = strings.Replace(defaultConfigTmpl, "__MONIKER__", moniker, -1)
+ return
+}
+
+var defaultGenesis = `{
+ "chain_id": "tendermint_testnet_5",
+ "accounts": [
+ {
+ "address": "F81CB9ED0A868BD961C4F5BBC0E39B763B89FCB6",
+ "amount": 690000000000
+ },
+ {
+ "address": "0000000000000000000000000000000000000002",
+ "amount": 565000000000
+ },
+ {
+ "address": "9E54C9ECA9A3FD5D4496696818DA17A9E17F69DA",
+ "amount": 525000000000
+ },
+ {
+ "address": "0000000000000000000000000000000000000004",
+ "amount": 110000000000
+ }
+ ],
+ "validators": [
+ {
+ "pub_key": [1, "178EC6008A4364508979C70CBF100BD4BCBAA12DDE6251F5F486B4FD09014F06"],
+ "amount": 5000000000,
+ "unbond_to": [
+ {
+ "address": "93E243AC8A01F723DE353A4FA1ED911529CCB6E5",
+ "amount": 5000000000
+ }
+ ]
+ },
+ {
+ "pub_key": [1, "2A77777CC51467DE42350D4A8F34720D527734189BE64C7A930DD169E1FED3C6"],
+ "amount": 5000000000,
+ "unbond_to": [
+ {
+ "address": "93E243AC8A01F723DE353A4FA1ED911529CCB6E5",
+ "amount": 5000000000
+ }
+ ]
+ },
+ {
+ "pub_key": [1, "3718E69D09B11B3AD3FA31AEF07EC416D2AEED241CACE7B0F30AE9803FFB0F08"],
+ "amount": 5000000000,
+ "unbond_to": [
+ {
+ "address": "93E243AC8A01F723DE353A4FA1ED911529CCB6E5",
+ "amount": 5000000000
+ }
+ ]
+ },
+ {
+ "pub_key": [1, "C6B0440DEACD1E4CF1C736CEB8E38E788B700BA2B2045A55CB657A455CF5F889"],
+ "amount": 5000000000,
+ "unbond_to": [
+ {
+ "address": "93E243AC8A01F723DE353A4FA1ED911529CCB6E5",
+ "amount": 5000000000
+ }
+ ]
+ },
+ {
+ "pub_key": [1, "3BA1190D54F91EFBF8B0125F7EC116AD4BA2894B6EE38564A5D5FD3230D91F7B"],
+ "amount": 5000000000,
+ "unbond_to": [
+ {
+ "address": "93E243AC8A01F723DE353A4FA1ED911529CCB6E5",
+ "amount": 5000000000
+ }
+ ]
+ },
+ {
+ "pub_key": [1, "E56663353D01C58A1D4CDB4D14B70C2E3335BE1EBB6C3F697AF7882C03837962"],
+ "amount": 5000000000,
+ "unbond_to": [
+ {
+ "address": "9E54C9ECA9A3FD5D4496696818DA17A9E17F69DA",
+ "amount": 5000000000
+ }
+ ]
+ }
+ ]
+}`
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint_test/config.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint_test/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..770e1e332efbf863a8f6713ecb06a0d845a7e953
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint_test/config.go
@@ -0,0 +1,153 @@
+// Import this in all *_test.go files to initialize ~/.tendermint_test.
+
+package tendermint_test
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/naoina/toml"
+ "os"
+ "path"
+ "strings"
+
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ cfg "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config"
+)
+
+func init() {
+ // Creates ~/.tendermint_test/*
+ config := GetConfig("")
+ cfg.ApplyConfig(config)
+}
+
+func getTMRoot(rootDir string) string {
+ if rootDir == "" {
+ rootDir = os.Getenv("HOME") + "/.tendermint_test"
+ }
+ return rootDir
+}
+
+func initTMRoot(rootDir string) {
+ rootDir = getTMRoot(rootDir)
+ EnsureDir(rootDir)
+
+ configFilePath := path.Join(rootDir, "config.toml")
+ genesisFilePath := path.Join(rootDir, "genesis.json")
+ privValFilePath := path.Join(rootDir, "priv_validator.json")
+
+ // Write default config file if missing.
+ if !FileExists(configFilePath) {
+ // Ask user for moniker
+ moniker := cfg.Prompt("Type hostname: ", "anonymous")
+ MustWriteFile(configFilePath, []byte(defaultConfig(moniker)))
+ }
+ if !FileExists(genesisFilePath) {
+ MustWriteFile(genesisFilePath, []byte(defaultGenesis))
+ }
+ if !FileExists(privValFilePath) {
+ MustWriteFile(privValFilePath, []byte(privValFilePath))
+ }
+}
+
+func GetConfig(rootDir string) cfg.Config {
+ rootDir = getTMRoot(rootDir)
+ initTMRoot(rootDir)
+
+ var mapConfig = cfg.MapConfig(make(map[string]interface{}))
+ configFilePath := path.Join(rootDir, "config.toml")
+ configFileBytes := MustReadFile(configFilePath)
+ err := toml.Unmarshal(configFileBytes, mapConfig)
+ if err != nil {
+ Exit(Fmt("Could not read config: %v", err))
+ }
+
+ // Set defaults or panic
+ if mapConfig.IsSet("chain_id") {
+ Exit("Cannot set 'chain_id' via config.toml")
+ }
+ if mapConfig.IsSet("version") {
+ Exit("Cannot set 'version' via config.toml")
+ }
+ mapConfig.SetDefault("chain_id", "tendermint_test")
+ mapConfig.SetDefault("version", "0.3.0")
+ mapConfig.SetDefault("genesis_file", rootDir+"/genesis.json")
+ mapConfig.SetDefault("moniker", "anonymous")
+ mapConfig.SetDefault("node_laddr", "0.0.0.0:36656")
+ mapConfig.SetDefault("fast_sync", false)
+ mapConfig.SetDefault("addrbook_file", rootDir+"/addrbook.json")
+ mapConfig.SetDefault("priv_validator_file", rootDir+"/priv_validator.json")
+ mapConfig.SetDefault("db_backend", "memdb")
+ mapConfig.SetDefault("db_dir", rootDir+"/data")
+ mapConfig.SetDefault("log_level", "debug")
+ mapConfig.SetDefault("rpc_laddr", "0.0.0.0:36657")
+ return mapConfig
+}
+
+func ensureDefault(mapConfig cfg.MapConfig, key string, value interface{}) {
+ if !mapConfig.IsSet(key) {
+ mapConfig[key] = value
+ }
+}
+
+var defaultConfigTmpl = `# This is a TOML config file.
+# For more information, see https://github.com/toml-lang/toml
+
+moniker = "__MONIKER__"
+node_laddr = "0.0.0.0:36656"
+seeds = ""
+fast_sync = false
+db_backend = "memdb"
+log_level = "debug"
+rpc_laddr = "0.0.0.0:36657"
+`
+
+func defaultConfig(moniker string) (defaultConfig string) {
+ defaultConfig = strings.Replace(defaultConfigTmpl, "__MONIKER__", moniker, -1)
+ return
+}
+
+// priv keys generated deterministically eg rpc/tests/helpers.go
+var defaultGenesis = `{
+ "chain_id" : "tendermint_test",
+ "accounts": [
+ {
+ "address": "E9B5D87313356465FAE33C406CE2C2979DE60BCB",
+ "amount": 200000000
+ },
+ {
+ "address": "DFE4AFFA4CEE17CD01CB9E061D77C3ECED29BD88",
+ "amount": 200000000
+ },
+ {
+ "address": "F60D30722E7B497FA532FB3207C3FB29C31B1992",
+ "amount": 200000000
+ },
+ {
+ "address": "336CB40A5EB92E496E19B74FDFF2BA017C877FD6",
+ "amount": 200000000
+ },
+ {
+ "address": "D218F0F439BF0384F6F5EF8D0F8B398D941BD1DC",
+ "amount": 200000000
+ }
+ ],
+ "validators": [
+ {
+ "pub_key": [1, "583779C3BFA3F6C7E23C7D830A9C3D023A216B55079AD38BFED1207B94A19548"],
+ "amount": 1000000,
+ "unbond_to": [
+ {
+ "address": "E9B5D87313356465FAE33C406CE2C2979DE60BCB",
+ "amount": 100000
+ }
+ ]
+ }
+ ]
+}`
+
+var defaultPrivValidator = `{
+ "address": "1D7A91CB32F758A02EBB9BE1FB6F8DEE56F90D42",
+ "pub_key": [1,"06FBAC4E285285D1D91FCBC7E91C780ADA11516F67462340B3980CE2B94940E8"],
+ "priv_key": [1,"C453604BD6480D5538B4C6FD2E3E314B5BCE518D75ADE4DA3DA85AB8ADFD819606FBAC4E285285D1D91FCBC7E91C780ADA11516F67462340B3980CE2B94940E8"],
+ "last_height":0,
+ "last_round":0,
+ "last_step":0
+}`
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/README.md b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..46d33032f88df18aead5b4891c94b3ce102fb264
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/README.md
@@ -0,0 +1,4 @@
+The core consensus algorithm.
+
+* state.go - The state machine as detailed in the whitepaper
+* reactor.go - A reactor that connects the state machine to the gossip network
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/config.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..a9f0e602e3812fe9dd8315354bc68eddec41ccd0
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/config.go
@@ -0,0 +1,13 @@
+package consensus
+
+import (
+ cfg "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config"
+)
+
+var config cfg.Config = nil
+
+func init() {
+ cfg.OnConfig(func(newConfig cfg.Config) {
+ config = newConfig
+ })
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/log.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..12a5b9153d8d04bc5a6c7791ae65343be78670f5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/log.go
@@ -0,0 +1,7 @@
+package consensus
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/logger"
+)
+
+var log = logger.New("module", "consensus")
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/pol.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/pol.go
new file mode 100644
index 0000000000000000000000000000000000000000..176aa9d66bd7316d85d4532e1cf353e822939ddc
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/pol.go
@@ -0,0 +1,101 @@
+package consensus
+
+import (
+ "fmt"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ sm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+// Each signature of a POL (proof-of-lock, see whitepaper) is
+// either a prevote or a commit.
+// Commits require an additional round which is strictly less than
+// the POL round. Prevote rounds are equal to the POL round.
+type POLVoteSignature struct {
+ Round uint `json:"round"`
+ Signature account.SignatureEd25519 `json:"signature"`
+}
+
+// Proof of lock.
+// +2/3 of validators' prevotes for a given blockhash (or nil)
+type POL struct {
+ Height uint `json:"height"`
+ Round uint `json:"round"`
+ BlockHash []byte `json:"block_hash"` // Could be nil, which makes this a proof of unlock.
+ BlockParts types.PartSetHeader `json:"block_parts"` // When BlockHash is nil, this is zero.
+ Votes []POLVoteSignature `json:"votes"` // Prevote and commit signatures in ValidatorSet order.
+}
+
+// Returns whether +2/3 have prevoted/committed for BlockHash.
+func (pol *POL) Verify(valSet *sm.ValidatorSet) error {
+
+ if uint(len(pol.Votes)) != valSet.Size() {
+ return fmt.Errorf("Invalid POL votes count: Expected %v, got %v",
+ valSet.Size(), len(pol.Votes))
+ }
+
+ talliedVotingPower := uint64(0)
+ prevoteDoc := account.SignBytes(config.GetString("chain_id"), &types.Vote{
+ Height: pol.Height, Round: pol.Round, Type: types.VoteTypePrevote,
+ BlockHash: pol.BlockHash,
+ BlockParts: pol.BlockParts,
+ })
+ seenValidators := map[string]struct{}{}
+
+ for idx, vote := range pol.Votes {
+ // vote may be zero, in which case skip.
+ if vote.Signature.IsZero() {
+ continue
+ }
+ voteDoc := prevoteDoc
+ _, val := valSet.GetByIndex(uint(idx))
+
+ // Commit vote?
+ if vote.Round < pol.Round {
+ voteDoc = account.SignBytes(config.GetString("chain_id"), &types.Vote{
+ Height: pol.Height, Round: vote.Round, Type: types.VoteTypeCommit,
+ BlockHash: pol.BlockHash,
+ BlockParts: pol.BlockParts,
+ })
+ } else if vote.Round > pol.Round {
+ return fmt.Errorf("Invalid commit round %v for POL %v", vote.Round, pol)
+ }
+
+ // Validate
+ if _, seen := seenValidators[string(val.Address)]; seen {
+ return fmt.Errorf("Duplicate validator for vote %v for POL %v", vote, pol)
+ }
+
+ if !val.PubKey.VerifyBytes(voteDoc, vote.Signature) {
+ return fmt.Errorf("Invalid signature for vote %v for POL %v", vote, pol)
+ }
+
+ // Tally
+ seenValidators[string(val.Address)] = struct{}{}
+ talliedVotingPower += val.VotingPower
+ }
+
+ if talliedVotingPower > valSet.TotalVotingPower()*2/3 {
+ return nil
+ } else {
+ return fmt.Errorf("Invalid POL, insufficient voting power %v, needed %v",
+ talliedVotingPower, (valSet.TotalVotingPower()*2/3 + 1))
+ }
+
+}
+
+func (pol *POL) StringShort() string {
+ if pol == nil {
+ return "nil-POL"
+ } else {
+ return fmt.Sprintf("POL{H:%v R:%v BH:%X}", pol.Height, pol.Round,
+ Fingerprint(pol.BlockHash), pol.BlockParts)
+ }
+}
+
+func (pol *POL) MakePartSet() *types.PartSet {
+ return types.NewPartSetFromData(binary.BinaryBytes(pol))
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/pol_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/pol_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..52ce3ae634b0b5230c082707e0c53d49774ad360
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/pol_test.go
@@ -0,0 +1,213 @@
+package consensus
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ _ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint_test"
+ sm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+
+ "bytes"
+ "testing"
+)
+
+// NOTE: see consensus/test.go for common test methods.
+
+// Convenience method.
+// Signs the vote and sets the POL's vote at the desired index
+// Returns the POLVoteSignature pointer, so you can modify it afterwards.
+func signAddPOLVoteSignature(val *sm.PrivValidator, valSet *sm.ValidatorSet, vote *types.Vote, pol *POL) *POLVoteSignature {
+ vote = vote.Copy()
+ err := val.SignVote(config.GetString("chain_id"), vote)
+ if err != nil {
+ panic(err)
+ }
+ idx, _ := valSet.GetByAddress(val.Address) // now we have the index
+ pol.Votes[idx] = POLVoteSignature{vote.Round, vote.Signature}
+ return &pol.Votes[idx]
+}
+
+func TestVerifyVotes(t *testing.T) {
+ height, round := uint(1), uint(0)
+ _, valSet, privValidators := randVoteSet(height, round, types.VoteTypePrevote, 10, 1)
+
+ // Make a POL with -2/3 votes.
+ blockHash := RandBytes(32)
+ pol := &POL{
+ Height: height, Round: round, BlockHash: blockHash,
+ Votes: make([]POLVoteSignature, valSet.Size()),
+ }
+ voteProto := &types.Vote{
+ Height: height, Round: round, Type: types.VoteTypePrevote, BlockHash: blockHash,
+ }
+ for i := 0; i < 6; i++ {
+ signAddPOLVoteSignature(privValidators[i], valSet, voteProto, pol)
+ }
+
+ // Check that validation fails.
+ if err := pol.Verify(valSet); err == nil {
+ t.Errorf("Expected POL.Verify() to fail, not enough votes.")
+ }
+
+ // Insert another vote to make +2/3
+ signAddPOLVoteSignature(privValidators[7], valSet, voteProto, pol)
+
+ // Check that validation succeeds.
+ if err := pol.Verify(valSet); err != nil {
+ t.Errorf("POL.Verify() failed: %v", err)
+ }
+}
+
+func TestVerifyInvalidVote(t *testing.T) {
+ height, round := uint(1), uint(0)
+ _, valSet, privValidators := randVoteSet(height, round, types.VoteTypePrevote, 10, 1)
+
+ // Make a POL with +2/3 votes with the wrong signature.
+ blockHash := RandBytes(32)
+ pol := &POL{
+ Height: height, Round: round, BlockHash: blockHash,
+ Votes: make([]POLVoteSignature, valSet.Size()),
+ }
+ voteProto := &types.Vote{
+ Height: height, Round: round, Type: types.VoteTypePrevote, BlockHash: blockHash,
+ }
+ for i := 0; i < 7; i++ {
+ polVoteSig := signAddPOLVoteSignature(privValidators[i], valSet, voteProto, pol)
+ polVoteSig.Signature[0] += byte(0x01) // mutated!
+ }
+
+ // Check that validation fails.
+ if err := pol.Verify(valSet); err == nil {
+ t.Errorf("Expected POL.Verify() to fail, wrong signatures.")
+ }
+}
+
+func TestVerifyCommits(t *testing.T) {
+ height, round := uint(1), uint(2)
+ _, valSet, privValidators := randVoteSet(height, round, types.VoteTypePrevote, 10, 1)
+
+ // Make a POL with +2/3 votes.
+ blockHash := RandBytes(32)
+ pol := &POL{
+ Height: height, Round: round, BlockHash: blockHash,
+ Votes: make([]POLVoteSignature, valSet.Size()),
+ }
+ voteProto := &types.Vote{
+ Height: height, Round: round - 1, Type: types.VoteTypeCommit, BlockHash: blockHash,
+ }
+ for i := 0; i < 7; i++ {
+ signAddPOLVoteSignature(privValidators[i], valSet, voteProto, pol)
+ }
+
+ // Check that validation succeeds.
+ if err := pol.Verify(valSet); err != nil {
+ t.Errorf("POL.Verify() failed: %v", err)
+ }
+}
+
+func TestVerifyInvalidCommits(t *testing.T) {
+ height, round := uint(1), uint(2)
+ _, valSet, privValidators := randVoteSet(height, round, types.VoteTypePrevote, 10, 1)
+
+ // Make a POL with +2/3 votes with the wrong signature.
+ blockHash := RandBytes(32)
+ pol := &POL{
+ Height: height, Round: round, BlockHash: blockHash,
+ Votes: make([]POLVoteSignature, valSet.Size()),
+ }
+ voteProto := &types.Vote{
+ Height: height, Round: round - 1, Type: types.VoteTypeCommit, BlockHash: blockHash,
+ }
+ for i := 0; i < 7; i++ {
+ polVoteSig := signAddPOLVoteSignature(privValidators[i], valSet, voteProto, pol)
+ polVoteSig.Signature[0] += byte(0x01)
+ }
+
+ // Check that validation fails.
+ if err := pol.Verify(valSet); err == nil {
+ t.Errorf("Expected POL.Verify() to fail, wrong signatures.")
+ }
+}
+
+func TestVerifyInvalidCommitRounds(t *testing.T) {
+ height, round := uint(1), uint(2)
+ _, valSet, privValidators := randVoteSet(height, round, types.VoteTypePrevote, 10, 1)
+
+ // Make a POL with +2/3 commits for the current round.
+ blockHash := RandBytes(32)
+ pol := &POL{
+ Height: height, Round: round, BlockHash: blockHash,
+ Votes: make([]POLVoteSignature, valSet.Size()),
+ }
+ voteProto := &types.Vote{
+ Height: height, Round: round, Type: types.VoteTypeCommit, BlockHash: blockHash,
+ }
+ for i := 0; i < 7; i++ {
+ signAddPOLVoteSignature(privValidators[i], valSet, voteProto, pol)
+ }
+
+ // Check that validation fails.
+ if err := pol.Verify(valSet); err == nil {
+ t.Errorf("Expected POL.Verify() to fail, same round.")
+ }
+}
+
+func TestVerifyInvalidCommitRounds2(t *testing.T) {
+ height, round := uint(1), uint(2)
+ _, valSet, privValidators := randVoteSet(height, round, types.VoteTypePrevote, 10, 1)
+
+ // Make a POL with +2/3 commits for future round.
+ blockHash := RandBytes(32)
+ pol := &POL{
+ Height: height, Round: round, BlockHash: blockHash,
+ Votes: make([]POLVoteSignature, valSet.Size()),
+ }
+ voteProto := &types.Vote{
+ Height: height, Round: round + 1, Type: types.VoteTypeCommit, BlockHash: blockHash,
+ }
+ for i := 0; i < 7; i++ {
+ polVoteSig := signAddPOLVoteSignature(privValidators[i], valSet, voteProto, pol)
+ polVoteSig.Round += 1 // mutate round
+ }
+
+ // Check that validation fails.
+ if err := pol.Verify(valSet); err == nil {
+ t.Errorf("Expected POL.Verify() to fail, future round.")
+ }
+}
+
+func TestReadWrite(t *testing.T) {
+ height, round := uint(1), uint(2)
+ _, valSet, privValidators := randVoteSet(height, round, types.VoteTypePrevote, 10, 1)
+
+ // Make a POL with +2/3 votes.
+ blockHash := RandBytes(32)
+ pol := &POL{
+ Height: height, Round: round, BlockHash: blockHash,
+ Votes: make([]POLVoteSignature, valSet.Size()),
+ }
+ voteProto := &types.Vote{
+ Height: height, Round: round, Type: types.VoteTypePrevote, BlockHash: blockHash,
+ }
+ for i := 0; i < 7; i++ {
+ signAddPOLVoteSignature(privValidators[i], valSet, voteProto, pol)
+ }
+
+ // Write it to a buffer.
+ buf, n, err := new(bytes.Buffer), new(int64), new(error)
+ binary.WriteBinary(pol, buf, n, err)
+ if *err != nil {
+ t.Fatalf("Failed to write POL: %v", *err)
+ }
+
+ // Read from buffer.
+ pol2 := binary.ReadBinary(&POL{}, buf, n, err).(*POL)
+ if *err != nil {
+ t.Fatalf("Failed to read POL: %v", *err)
+ }
+
+ // Check that validation succeeds.
+ if err := pol2.Verify(valSet); err != nil {
+ t.Errorf("POL.Verify() failed: %v", err)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/reactor.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/reactor.go
new file mode 100644
index 0000000000000000000000000000000000000000..c2589ee1ab1b99131ea1bf4da6f2b2582b359069
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/reactor.go
@@ -0,0 +1,915 @@
+package consensus
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "reflect"
+ "sync"
+ "sync/atomic"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ bc "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/types"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/events"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p"
+ sm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+const (
+ StateChannel = byte(0x20)
+ DataChannel = byte(0x21)
+ VoteChannel = byte(0x22)
+
+ PeerStateKey = "ConsensusReactor.peerState"
+
+ peerGossipSleepDuration = 100 * time.Millisecond // Time to sleep if there's nothing to send.
+)
+
+//-----------------------------------------------------------------------------
+
+// The reactor's underlying ConsensusState may change state at any time.
+// We atomically copy the RoundState struct before using it.
+type ConsensusReactor struct {
+ sw *p2p.Switch
+ running uint32
+ quit chan struct{}
+
+ blockStore *bc.BlockStore
+ conS *ConsensusState
+
+ // if fast sync is running we don't really do anything
+ sync bool
+
+ evsw events.Fireable
+}
+
+func NewConsensusReactor(consensusState *ConsensusState, blockStore *bc.BlockStore, sync bool) *ConsensusReactor {
+ conR := &ConsensusReactor{
+ blockStore: blockStore,
+ quit: make(chan struct{}),
+ conS: consensusState,
+ sync: sync,
+ }
+ return conR
+}
+
+// Implements Reactor
+func (conR *ConsensusReactor) Start(sw *p2p.Switch) {
+ if atomic.CompareAndSwapUint32(&conR.running, 0, 1) {
+ log.Info("Starting ConsensusReactor")
+ conR.sw = sw
+ if !conR.sync {
+ conR.conS.Start()
+ }
+ go conR.broadcastNewRoundStepRoutine()
+ }
+}
+
+// Implements Reactor
+func (conR *ConsensusReactor) Stop() {
+ if atomic.CompareAndSwapUint32(&conR.running, 1, 0) {
+ log.Info("Stopping ConsensusReactor")
+ conR.conS.Stop()
+ close(conR.quit)
+ }
+}
+
+func (conR *ConsensusReactor) IsRunning() bool {
+ return atomic.LoadUint32(&conR.running) == 1
+}
+
+// Implements Reactor
+func (conR *ConsensusReactor) GetChannels() []*p2p.ChannelDescriptor {
+ // TODO optimize
+ return []*p2p.ChannelDescriptor{
+ &p2p.ChannelDescriptor{
+ Id: StateChannel,
+ Priority: 5,
+ SendQueueCapacity: 100,
+ },
+ &p2p.ChannelDescriptor{
+ Id: DataChannel,
+ Priority: 5,
+ SendQueueCapacity: 2,
+ },
+ &p2p.ChannelDescriptor{
+ Id: VoteChannel,
+ Priority: 5,
+ SendQueueCapacity: 40,
+ },
+ }
+}
+
+// Implements Reactor
+func (conR *ConsensusReactor) AddPeer(peer *p2p.Peer) {
+ if !conR.IsRunning() {
+ return
+ }
+
+ // Create peerState for peer
+ peerState := NewPeerState(peer)
+ peer.Data.Set(PeerStateKey, peerState)
+
+ // Begin gossip routines for this peer.
+ go conR.gossipDataRoutine(peer, peerState)
+ go conR.gossipVotesRoutine(peer, peerState)
+
+ // Send our state to peer.
+ conR.sendNewRoundStep(peer)
+}
+
+// Implements Reactor
+func (conR *ConsensusReactor) RemovePeer(peer *p2p.Peer, reason interface{}) {
+ if !conR.IsRunning() {
+ return
+ }
+ //peer.Data.Get(PeerStateKey).(*PeerState).Disconnect()
+}
+
+// Implements Reactor
+func (conR *ConsensusReactor) Receive(chId byte, peer *p2p.Peer, msgBytes []byte) {
+ if conR.sync || !conR.IsRunning() {
+ return
+ }
+
+ // Get round state
+ rs := conR.conS.GetRoundState()
+ ps := peer.Data.Get(PeerStateKey).(*PeerState)
+ _, msg_, err := DecodeMessage(msgBytes)
+ if err != nil {
+ log.Warn("Error decoding message", "channel", chId, "peer", peer, "msg", msg_, "error", err, "bytes", msgBytes)
+ return
+ }
+ log.Debug("Receive", "channel", chId, "peer", peer, "msg", msg_) //, "bytes", msgBytes)
+
+ switch chId {
+ case StateChannel:
+ switch msg := msg_.(type) {
+ case *NewRoundStepMessage:
+ ps.ApplyNewRoundStepMessage(msg, rs)
+ case *CommitStepMessage:
+ ps.ApplyCommitStepMessage(msg)
+ case *HasVoteMessage:
+ ps.ApplyHasVoteMessage(msg)
+ default:
+ log.Warn(Fmt("Unknown message type %v", reflect.TypeOf(msg)))
+ }
+
+ case DataChannel:
+ switch msg := msg_.(type) {
+ case *ProposalMessage:
+ ps.SetHasProposal(msg.Proposal)
+ err = conR.conS.SetProposal(msg.Proposal)
+
+ case *PartMessage:
+ if msg.Type == partTypeProposalBlock {
+ ps.SetHasProposalBlockPart(msg.Height, msg.Round, msg.Part.Index)
+ _, err = conR.conS.AddProposalBlockPart(msg.Height, msg.Round, msg.Part)
+ } else if msg.Type == partTypeProposalPOL {
+ ps.SetHasProposalPOLPart(msg.Height, msg.Round, msg.Part.Index)
+ _, err = conR.conS.AddProposalPOLPart(msg.Height, msg.Round, msg.Part)
+ } else {
+ log.Warn(Fmt("Unknown part type %v", msg.Type))
+ }
+
+ default:
+ log.Warn(Fmt("Unknown message type %v", reflect.TypeOf(msg)))
+ }
+
+ case VoteChannel:
+ switch msg := msg_.(type) {
+ case *VoteMessage:
+ vote := msg.Vote
+ if rs.Height != vote.Height {
+ if rs.Height == vote.Height+1 {
+ if rs.Step == RoundStepNewHeight && vote.Type == types.VoteTypeCommit {
+ goto VOTE_PASS // *ducks*
+ }
+ }
+ return // Wrong height. Not necessarily a bad peer.
+ }
+ VOTE_PASS:
+ validatorIndex := msg.ValidatorIndex
+ address, _ := rs.Validators.GetByIndex(validatorIndex)
+ added, index, err := conR.conS.AddVote(address, vote)
+ if err != nil {
+ // If conflicting sig, broadcast evidence tx for slashing. Else punish peer.
+ if errDupe, ok := err.(*types.ErrVoteConflictingSignature); ok {
+ log.Warn("Found conflicting vote. Publish evidence")
+ evidenceTx := &types.DupeoutTx{
+ Address: address,
+ VoteA: *errDupe.VoteA,
+ VoteB: *errDupe.VoteB,
+ }
+ conR.conS.mempoolReactor.BroadcastTx(evidenceTx) // shouldn't need to check returned err
+ } else {
+ // Probably an invalid signature. Bad peer.
+ log.Warn("Error attempting to add vote", "error", err)
+
+ // TODO: punish peer
+ }
+ }
+ // Initialize Prevotes/Precommits/Commits if needed
+ ps.EnsureVoteBitArrays(rs.Height, rs.Validators.Size())
+ ps.SetHasVote(vote, index)
+ if added {
+ msg := &HasVoteMessage{
+ Height: vote.Height,
+ Round: vote.Round,
+ Type: vote.Type,
+ Index: index,
+ }
+ conR.sw.Broadcast(StateChannel, msg)
+ }
+
+ default:
+ log.Warn(Fmt("Unknown message type %v", reflect.TypeOf(msg)))
+ }
+ default:
+ log.Warn(Fmt("Unknown channel %X", chId))
+ }
+
+ if err != nil {
+ log.Warn("Error in Receive()", "error", err)
+ }
+}
+
+// Sets our private validator account for signing votes.
+func (conR *ConsensusReactor) SetPrivValidator(priv *sm.PrivValidator) {
+ conR.conS.SetPrivValidator(priv)
+}
+
+// Switch from the fast sync to the consensus:
+// reset the state, turn off fast sync, start the consensus-state-machine
+func (conR *ConsensusReactor) SwitchToConsensus(state *sm.State) {
+ conR.conS.updateToState(state, false)
+ conR.conS.newStepCh <- conR.conS.getRoundState()
+ conR.sync = false
+ conR.conS.Start()
+}
+
+// implements events.Eventable
+func (conR *ConsensusReactor) SetFireable(evsw events.Fireable) {
+ conR.evsw = evsw
+ conR.conS.SetFireable(evsw)
+}
+
+//--------------------------------------
+
+func makeRoundStepMessages(rs *RoundState) (nrsMsg *NewRoundStepMessage, csMsg *CommitStepMessage) {
+ // Get seconds since beginning of height.
+ timeElapsed := time.Now().Sub(rs.StartTime)
+
+ // Broadcast NewRoundStepMessage
+ nrsMsg = &NewRoundStepMessage{
+ Height: rs.Height,
+ Round: rs.Round,
+ Step: rs.Step,
+ SecondsSinceStartTime: uint(timeElapsed.Seconds()),
+ }
+
+ // If the step is commit, then also broadcast a CommitStepMessage.
+ if rs.Step == RoundStepCommit {
+ csMsg = &CommitStepMessage{
+ Height: rs.Height,
+ BlockParts: rs.ProposalBlockParts.Header(),
+ BlockBitArray: rs.ProposalBlockParts.BitArray(),
+ }
+ }
+
+ return
+}
+
+// Listens for changes to the ConsensusState.Step by pulling
+// on conR.conS.NewStepCh().
+func (conR *ConsensusReactor) broadcastNewRoundStepRoutine() {
+ for {
+ // Get RoundState with new Step or quit.
+ var rs *RoundState
+ select {
+ case rs = <-conR.conS.NewStepCh():
+ case <-conR.quit:
+ return
+ }
+
+ nrsMsg, csMsg := makeRoundStepMessages(rs)
+ if nrsMsg != nil {
+ conR.sw.Broadcast(StateChannel, nrsMsg)
+ }
+ if csMsg != nil {
+ conR.sw.Broadcast(StateChannel, csMsg)
+ }
+ }
+}
+
+func (conR *ConsensusReactor) sendNewRoundStep(peer *p2p.Peer) {
+ rs := conR.conS.GetRoundState()
+ nrsMsg, csMsg := makeRoundStepMessages(rs)
+ if nrsMsg != nil {
+ peer.Send(StateChannel, nrsMsg)
+ }
+ if csMsg != nil {
+ peer.Send(StateChannel, csMsg)
+ }
+}
+
+func (conR *ConsensusReactor) gossipDataRoutine(peer *p2p.Peer, ps *PeerState) {
+
+OUTER_LOOP:
+ for {
+ // Manage disconnects from self or peer.
+ if !peer.IsRunning() || !conR.IsRunning() {
+ log.Info(Fmt("Stopping gossipDataRoutine for %v.", peer))
+ return
+ }
+ rs := conR.conS.GetRoundState()
+ prs := ps.GetRoundState()
+
+ // Send proposal Block parts?
+ // NOTE: if we or peer is at RoundStepCommit*, the round
+ // won't necessarily match, but that's OK.
+ if rs.ProposalBlockParts.HasHeader(prs.ProposalBlockParts) {
+ //log.Debug("ProposalBlockParts matched", "blockParts", prs.ProposalBlockParts)
+ if index, ok := rs.ProposalBlockParts.BitArray().Sub(prs.ProposalBlockBitArray.Copy()).PickRandom(); ok {
+ part := rs.ProposalBlockParts.GetPart(index)
+ msg := &PartMessage{
+ Height: rs.Height,
+ Round: rs.Round,
+ Type: partTypeProposalBlock,
+ Part: part,
+ }
+ peer.Send(DataChannel, msg)
+ ps.SetHasProposalBlockPart(rs.Height, rs.Round, index)
+ continue OUTER_LOOP
+ }
+ }
+
+ // If the peer is on a previous height, help catch up.
+ if 0 < prs.Height && prs.Height < rs.Height {
+ //log.Debug("Data catchup", "height", rs.Height, "peerHeight", prs.Height, "peerProposalBlockBitArray", prs.ProposalBlockBitArray)
+ if index, ok := prs.ProposalBlockBitArray.Not().PickRandom(); ok {
+ // Ensure that the peer's PartSetHeader is correct
+ blockMeta := conR.blockStore.LoadBlockMeta(prs.Height)
+ if !blockMeta.Parts.Equals(prs.ProposalBlockParts) {
+ log.Debug("Peer ProposalBlockParts mismatch, sleeping",
+ "peerHeight", prs.Height, "blockParts", blockMeta.Parts, "peerBlockParts", prs.ProposalBlockParts)
+ time.Sleep(peerGossipSleepDuration)
+ continue OUTER_LOOP
+ }
+ // Load the part
+ part := conR.blockStore.LoadBlockPart(prs.Height, index)
+ if part == nil {
+ log.Warn("Could not load part", "index", index,
+ "peerHeight", prs.Height, "blockParts", blockMeta.Parts, "peerBlockParts", prs.ProposalBlockParts)
+ time.Sleep(peerGossipSleepDuration)
+ continue OUTER_LOOP
+ }
+ // Send the part
+ msg := &PartMessage{
+ Height: prs.Height,
+ Round: prs.Round,
+ Type: partTypeProposalBlock,
+ Part: part,
+ }
+ peer.Send(DataChannel, msg)
+ ps.SetHasProposalBlockPart(prs.Height, prs.Round, index)
+ continue OUTER_LOOP
+ } else {
+ //log.Debug("No parts to send in catch-up, sleeping")
+ time.Sleep(peerGossipSleepDuration)
+ continue OUTER_LOOP
+ }
+ }
+
+ // If height and round don't match, sleep.
+ if rs.Height != prs.Height || rs.Round != prs.Round {
+ //log.Debug("Peer Height|Round mismatch, sleeping", "peerHeight", prs.Height, "peerRound", prs.Round, "peer", peer)
+ time.Sleep(peerGossipSleepDuration)
+ continue OUTER_LOOP
+ }
+
+ // Send proposal?
+ if rs.Proposal != nil && !prs.Proposal {
+ msg := &ProposalMessage{Proposal: rs.Proposal}
+ peer.Send(DataChannel, msg)
+ ps.SetHasProposal(rs.Proposal)
+ continue OUTER_LOOP
+ }
+
+ // Send proposal POL parts?
+ if rs.ProposalPOLParts.HasHeader(prs.ProposalPOLParts) {
+ if index, ok := rs.ProposalPOLParts.BitArray().Sub(prs.ProposalPOLBitArray.Copy()).PickRandom(); ok {
+ msg := &PartMessage{
+ Height: rs.Height,
+ Round: rs.Round,
+ Type: partTypeProposalPOL,
+ Part: rs.ProposalPOLParts.GetPart(index),
+ }
+ peer.Send(DataChannel, msg)
+ ps.SetHasProposalPOLPart(rs.Height, rs.Round, index)
+ continue OUTER_LOOP
+ }
+ }
+
+ // Nothing to do. Sleep.
+ time.Sleep(peerGossipSleepDuration)
+ continue OUTER_LOOP
+ }
+}
+
+func (conR *ConsensusReactor) gossipVotesRoutine(peer *p2p.Peer, ps *PeerState) {
+
+ // Simple hack to throttle logs upon sleep.
+ var sleeping = 0
+
+OUTER_LOOP:
+ for {
+ // Manage disconnects from self or peer.
+ if !peer.IsRunning() || !conR.IsRunning() {
+ log.Info(Fmt("Stopping gossipVotesRoutine for %v.", peer))
+ return
+ }
+ rs := conR.conS.GetRoundState()
+ prs := ps.GetRoundState()
+
+ switch sleeping {
+ case 1: // First sleep
+ sleeping = 2
+ case 2: // No more sleep
+ sleeping = 0
+ }
+
+ // Returns true when useful work was done.
+ trySendVote := func(height uint, voteSet *VoteSet, peerVoteSet *BitArray) (sent bool) {
+ if voteSet == nil {
+ return false
+ } else if peerVoteSet == nil {
+ ps.EnsureVoteBitArrays(height, voteSet.Size())
+ return true
+ }
+ // TODO: give priority to our vote.
+ if index, ok := voteSet.BitArray().Sub(peerVoteSet.Copy()).PickRandom(); ok {
+ vote := voteSet.GetByIndex(index)
+ // NOTE: vote may be a commit.
+ msg := &VoteMessage{index, vote}
+ peer.Send(VoteChannel, msg)
+ ps.SetHasVote(vote, index)
+ return true
+ }
+ return false
+ }
+
+ // Returns true when useful work was done.
+ trySendCommitFromValidation := func(blockMeta *types.BlockMeta, validation *types.Validation, peerVoteSet *BitArray) (sent bool) {
+ if validation == nil {
+ return false
+ } else if peerVoteSet == nil {
+ ps.EnsureVoteBitArrays(blockMeta.Header.Height, uint(len(validation.Commits)))
+ return true
+ }
+ if index, ok := validation.BitArray().Sub(prs.Commits.Copy()).PickRandom(); ok {
+ commit := validation.Commits[index]
+ log.Debug("Picked commit to send", "index", index, "commit", commit)
+ // Reconstruct vote.
+ vote := &types.Vote{
+ Height: prs.Height,
+ Round: commit.Round,
+ Type: types.VoteTypeCommit,
+ BlockHash: blockMeta.Hash,
+ BlockParts: blockMeta.Parts,
+ Signature: commit.Signature,
+ }
+ msg := &VoteMessage{index, vote}
+ peer.Send(VoteChannel, msg)
+ ps.SetHasVote(vote, index)
+ return true
+ }
+ return false
+ }
+
+ // If height matches, then send LastCommits, Prevotes, Precommits, or Commits.
+ if rs.Height == prs.Height {
+
+ // If there are lastcommits to send...
+ if prs.Round == 0 && prs.Step == RoundStepNewHeight {
+ if trySendVote(rs.Height-1, rs.LastCommits, prs.LastCommits) {
+ continue OUTER_LOOP
+ }
+ }
+
+ // If there are prevotes to send...
+ if rs.Round == prs.Round && prs.Step <= RoundStepPrevote {
+ if trySendVote(rs.Height, rs.Prevotes, prs.Prevotes) {
+ continue OUTER_LOOP
+ }
+ }
+
+ // If there are precommits to send...
+ if rs.Round == prs.Round && prs.Step <= RoundStepPrecommit {
+ if trySendVote(rs.Height, rs.Precommits, prs.Precommits) {
+ continue OUTER_LOOP
+ }
+ }
+
+ // If there are any commits to send...
+ if trySendVote(rs.Height, rs.Commits, prs.Commits) {
+ continue OUTER_LOOP
+ }
+ }
+
+ // Catchup logic
+ if prs.Height != 0 && !prs.HasAllCatchupCommits {
+
+ // If peer is lagging by height 1, match our LastCommits or SeenValidation to peer's Commits.
+ if rs.Height == prs.Height+1 && rs.LastCommits.Size() > 0 {
+ // If there are lastcommits to send...
+ if trySendVote(prs.Height, rs.LastCommits, prs.Commits) {
+ continue OUTER_LOOP
+ } else {
+ ps.SetHasAllCatchupCommits(prs.Height)
+ }
+ }
+
+ // Or, if peer is lagging by 1 and we don't have LastCommits, send SeenValidation.
+ if rs.Height == prs.Height+1 && rs.LastCommits.Size() == 0 {
+ // Load the blockMeta for block at prs.Height
+ blockMeta := conR.blockStore.LoadBlockMeta(prs.Height)
+ // Load the seen validation for prs.Height
+ validation := conR.blockStore.LoadSeenValidation(prs.Height)
+ log.Debug("Loaded SeenValidation for catch-up", "height", prs.Height, "blockMeta", blockMeta, "validation", validation)
+
+ if trySendCommitFromValidation(blockMeta, validation, prs.Commits) {
+ continue OUTER_LOOP
+ } else {
+ ps.SetHasAllCatchupCommits(prs.Height)
+ }
+ }
+
+ // If peer is lagging by more than 1, send Validation.
+ if rs.Height >= prs.Height+2 {
+ // Load the blockMeta for block at prs.Height
+ blockMeta := conR.blockStore.LoadBlockMeta(prs.Height)
+ // Load the block validation for prs.Height+1,
+ // which contains commit signatures for prs.Height.
+ validation := conR.blockStore.LoadBlockValidation(prs.Height + 1)
+ log.Debug("Loaded BlockValidation for catch-up", "height", prs.Height+1, "blockMeta", blockMeta, "validation", validation)
+
+ if trySendCommitFromValidation(blockMeta, validation, prs.Commits) {
+ continue OUTER_LOOP
+ } else {
+ ps.SetHasAllCatchupCommits(prs.Height)
+ }
+ }
+ }
+
+ if sleeping == 0 {
+ // We sent nothing. Sleep...
+ sleeping = 1
+ log.Debug("No votes to send, sleeping", "peer", peer,
+ "localPV", rs.Prevotes.BitArray(), "peerPV", prs.Prevotes,
+ "localPC", rs.Precommits.BitArray(), "peerPC", prs.Precommits,
+ "localCM", rs.Commits.BitArray(), "peerCM", prs.Commits)
+ } else if sleeping == 2 {
+ // Continued sleep...
+ sleeping = 1
+ }
+
+ time.Sleep(peerGossipSleepDuration)
+ continue OUTER_LOOP
+ }
+}
+
+//-----------------------------------------------------------------------------
+
+// Read only when returned by PeerState.GetRoundState().
+type PeerRoundState struct {
+ Height uint // Height peer is at
+ Round uint // Round peer is at
+ Step RoundStepType // Step peer is at
+ StartTime time.Time // Estimated start of round 0 at this height
+ Proposal bool // True if peer has proposal for this round
+ ProposalBlockParts types.PartSetHeader //
+ ProposalBlockBitArray *BitArray // True bit -> has part
+ ProposalPOLParts types.PartSetHeader //
+ ProposalPOLBitArray *BitArray // True bit -> has part
+ Prevotes *BitArray // All votes peer has for this round
+ Precommits *BitArray // All precommits peer has for this round
+ Commits *BitArray // All commits peer has for this height
+ LastCommits *BitArray // All commits peer has for last height
+ HasAllCatchupCommits bool // Used for catch-up
+}
+
+//-----------------------------------------------------------------------------
+
+var (
+ ErrPeerStateHeightRegression = errors.New("Error peer state height regression")
+ ErrPeerStateInvalidStartTime = errors.New("Error peer state invalid startTime")
+)
+
+type PeerState struct {
+ Key string
+
+ mtx sync.Mutex
+ PeerRoundState
+}
+
+func NewPeerState(peer *p2p.Peer) *PeerState {
+ return &PeerState{Key: peer.Key}
+}
+
+// Returns an atomic snapshot of the PeerRoundState.
+// There's no point in mutating it since it won't change PeerState.
+func (ps *PeerState) GetRoundState() *PeerRoundState {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+
+ prs := ps.PeerRoundState // copy
+ return &prs
+}
+
+func (ps *PeerState) SetHasProposal(proposal *Proposal) {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+
+ if ps.Height != proposal.Height || ps.Round != proposal.Round {
+ return
+ }
+ if ps.Proposal {
+ return
+ }
+
+ ps.Proposal = true
+ ps.ProposalBlockParts = proposal.BlockParts
+ ps.ProposalBlockBitArray = NewBitArray(uint(proposal.BlockParts.Total))
+ ps.ProposalPOLParts = proposal.POLParts
+ ps.ProposalPOLBitArray = NewBitArray(uint(proposal.POLParts.Total))
+}
+
+func (ps *PeerState) SetHasProposalBlockPart(height uint, round uint, index uint) {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+
+ if ps.Height != height || ps.Round != round {
+ return
+ }
+
+ ps.ProposalBlockBitArray.SetIndex(uint(index), true)
+}
+
+func (ps *PeerState) SetHasProposalPOLPart(height uint, round uint, index uint) {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+
+ if ps.Height != height || ps.Round != round {
+ return
+ }
+
+ ps.ProposalPOLBitArray.SetIndex(uint(index), true)
+}
+
+func (ps *PeerState) EnsureVoteBitArrays(height uint, numValidators uint) {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+
+ if ps.Height == height {
+ if ps.Prevotes == nil {
+ ps.Prevotes = NewBitArray(numValidators)
+ }
+ if ps.Precommits == nil {
+ ps.Precommits = NewBitArray(numValidators)
+ }
+ if ps.Commits == nil {
+ ps.Commits = NewBitArray(numValidators)
+ }
+ } else if ps.Height == height+1 {
+ if ps.LastCommits == nil {
+ ps.LastCommits = NewBitArray(numValidators)
+ }
+ }
+}
+
+func (ps *PeerState) SetHasVote(vote *types.Vote, index uint) {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+
+ ps.setHasVote(vote.Height, vote.Round, vote.Type, index)
+}
+
+func (ps *PeerState) setHasVote(height uint, round uint, type_ byte, index uint) {
+ if ps.Height == height+1 && type_ == types.VoteTypeCommit {
+ // Special case for LastCommits.
+ ps.LastCommits.SetIndex(index, true)
+ log.Debug("SetHasVote", "lastCommits", ps.LastCommits, "index", index)
+ return
+ } else if ps.Height != height {
+ // Does not apply.
+ return
+ }
+
+ switch type_ {
+ case types.VoteTypePrevote:
+ ps.Prevotes.SetIndex(index, true)
+ log.Debug("SetHasVote", "peer", ps.Key, "prevotes", ps.Prevotes, "index", index)
+ case types.VoteTypePrecommit:
+ ps.Precommits.SetIndex(index, true)
+ log.Debug("SetHasVote", "peer", ps.Key, "precommits", ps.Precommits, "index", index)
+ case types.VoteTypeCommit:
+ if round < ps.Round {
+ ps.Prevotes.SetIndex(index, true)
+ ps.Precommits.SetIndex(index, true)
+ }
+ ps.Commits.SetIndex(index, true)
+ log.Debug("SetHasVote", "peer", ps.Key, "commits", ps.Commits, "index", index)
+ default:
+ panic("Invalid vote type")
+ }
+}
+
+// When catching up, this helps keep track of whether
+// we should send more commit votes from the block (validation) store
+func (ps *PeerState) SetHasAllCatchupCommits(height uint) {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+
+ if ps.Height == height {
+ ps.HasAllCatchupCommits = true
+ }
+}
+
+func (ps *PeerState) ApplyNewRoundStepMessage(msg *NewRoundStepMessage, rs *RoundState) {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+
+ // Just remember these values.
+ psHeight := ps.Height
+ psRound := ps.Round
+ //psStep := ps.Step
+
+ startTime := time.Now().Add(-1 * time.Duration(msg.SecondsSinceStartTime) * time.Second)
+ ps.Height = msg.Height
+ ps.Round = msg.Round
+ ps.Step = msg.Step
+ ps.StartTime = startTime
+ if psHeight != msg.Height || psRound != msg.Round {
+ ps.Proposal = false
+ ps.ProposalBlockParts = types.PartSetHeader{}
+ ps.ProposalBlockBitArray = nil
+ ps.ProposalPOLParts = types.PartSetHeader{}
+ ps.ProposalPOLBitArray = nil
+ // We'll update the BitArray capacity later.
+ ps.Prevotes = nil
+ ps.Precommits = nil
+ }
+ if psHeight != msg.Height {
+ // Shift Commits to LastCommits
+ if psHeight+1 == msg.Height {
+ ps.LastCommits = ps.Commits
+ } else {
+ ps.LastCommits = nil
+ }
+ // We'll update the BitArray capacity later.
+ ps.Commits = nil
+ ps.HasAllCatchupCommits = false
+ }
+}
+
+func (ps *PeerState) ApplyCommitStepMessage(msg *CommitStepMessage) {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+
+ if ps.Height != msg.Height {
+ return
+ }
+
+ ps.ProposalBlockParts = msg.BlockParts
+ ps.ProposalBlockBitArray = msg.BlockBitArray
+}
+
+func (ps *PeerState) ApplyHasVoteMessage(msg *HasVoteMessage) {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+
+ // Special case for LastCommits
+ if ps.Height == msg.Height+1 && msg.Type == types.VoteTypeCommit {
+ ps.LastCommits.SetIndex(msg.Index, true)
+ return
+ } else if ps.Height != msg.Height {
+ return
+ }
+
+ ps.setHasVote(msg.Height, msg.Round, msg.Type, msg.Index)
+}
+
+//-----------------------------------------------------------------------------
+// Messages
+
+const (
+ msgTypeNewRoundStep = byte(0x01)
+ msgTypeCommitStep = byte(0x02)
+ msgTypeProposal = byte(0x11)
+ msgTypePart = byte(0x12) // both block & POL
+ msgTypeVote = byte(0x13)
+ msgTypeHasVote = byte(0x14)
+)
+
+type ConsensusMessage interface{}
+
+var _ = binary.RegisterInterface(
+ struct{ ConsensusMessage }{},
+ binary.ConcreteType{&NewRoundStepMessage{}, msgTypeNewRoundStep},
+ binary.ConcreteType{&CommitStepMessage{}, msgTypeCommitStep},
+ binary.ConcreteType{&ProposalMessage{}, msgTypeProposal},
+ binary.ConcreteType{&PartMessage{}, msgTypePart},
+ binary.ConcreteType{&VoteMessage{}, msgTypeVote},
+ binary.ConcreteType{&HasVoteMessage{}, msgTypeHasVote},
+)
+
+// TODO: check for unnecessary extra bytes at the end.
+func DecodeMessage(bz []byte) (msgType byte, msg ConsensusMessage, err error) {
+ msgType = bz[0]
+ n := new(int64)
+ r := bytes.NewReader(bz)
+ msg = binary.ReadBinary(struct{ ConsensusMessage }{}, r, n, &err).(struct{ ConsensusMessage }).ConsensusMessage
+ return
+}
+
+//-------------------------------------
+
+type NewRoundStepMessage struct {
+ Height uint
+ Round uint
+ Step RoundStepType
+ SecondsSinceStartTime uint
+}
+
+func (m *NewRoundStepMessage) String() string {
+ return fmt.Sprintf("[NewRoundStep H:%v R:%v S:%v]", m.Height, m.Round, m.Step)
+}
+
+//-------------------------------------
+
+type CommitStepMessage struct {
+ Height uint
+ BlockParts types.PartSetHeader
+ BlockBitArray *BitArray
+}
+
+func (m *CommitStepMessage) String() string {
+ return fmt.Sprintf("[CommitStep H:%v BP:%v BA:%v]", m.Height, m.BlockParts, m.BlockBitArray)
+}
+
+//-------------------------------------
+
+type ProposalMessage struct {
+ Proposal *Proposal
+}
+
+func (m *ProposalMessage) String() string {
+ return fmt.Sprintf("[Proposal %v]", m.Proposal)
+}
+
+//-------------------------------------
+
+const (
+ partTypeProposalBlock = byte(0x01)
+ partTypeProposalPOL = byte(0x02)
+)
+
+type PartMessage struct {
+ Height uint
+ Round uint
+ Type byte
+ Part *types.Part
+}
+
+func (m *PartMessage) String() string {
+ return fmt.Sprintf("[Part H:%v R:%v T:%X P:%v]", m.Height, m.Round, m.Type, m.Part)
+}
+
+//-------------------------------------
+
+type VoteMessage struct {
+ ValidatorIndex uint
+ Vote *types.Vote
+}
+
+func (m *VoteMessage) String() string {
+ return fmt.Sprintf("[Vote VI:%v V:%v VI:%v]", m.ValidatorIndex, m.Vote, m.ValidatorIndex)
+}
+
+//-------------------------------------
+
+type HasVoteMessage struct {
+ Height uint
+ Round uint
+ Type byte
+ Index uint
+}
+
+func (m *HasVoteMessage) String() string {
+ return fmt.Sprintf("[HasVote VI:%v V:{%v/%02d/%v} VI:%v]", m.Index, m.Height, m.Round, m.Type, m.Index)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/state.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/state.go
new file mode 100644
index 0000000000000000000000000000000000000000..eb98d74501d304560785c324b12da3b769d59c76
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/state.go
@@ -0,0 +1,1229 @@
+/*
+
+Consensus State Machine Overview:
+
+* Propose, Prevote, Precommit represent state machine stages. (aka RoundStep, or step).
+ Each take a predetermined amount of time depending on the round number.
+* The Commit step can be entered by two means:
+ 1. After the Precommit step, +2/3 Precommits were found
+ 2. At any time, +2/3 Commits were found
+* Once in the Commit stage, two conditions must both be satisfied
+ before proceeding to the next height NewHeight.
+* The Propose step of the next height does not begin until
+ at least Delta duration *after* +2/3 Commits were found.
+ The step stays at NewHeight until this timeout occurs before
+ proceeding to Propose.
+* The NewHeight is a transition period after the height is incremented,
+ where the node still receives late commits before potentially proposing.
+ The height should be incremented because a block had been
+ "committed by the network", and clients should see that
+ reflected as a new height.
+
+ +-------------------------------------+
+ | |
+ v |(Wait til CommitTime + Delta)
+ +-----------+ +-----+-----+
+ +----------> | Propose +--------------+ | NewHeight |
+ | +-----------+ | +-----------+
+ | | ^
+ | | |
+ | | |
+ |(Else) v |
+ +-----+-----+ +-----------+ |
+ | Precommit | <------------------------+ Prevote | |
+ +-----+-----+ +-----------+ |
+ |(If +2/3 Precommits found) |
+ | |
+ | + (When +2/3 Commits found) |
+ | | |
+ v v |
+ +------------------------------------------------------------------------------+
+ | Commit | |
+ | | |
+ | +----------------+ * Save Block | |
+ | |Get Block Parts |---> * Stage Block +--+ + |
+ | +----------------+ * Broadcast Commit | * Setup New Height |
+ | | * Move Commits set to |
+ | +--> LastCommits to continue |
+ | | collecting commits |
+ | +-----------------+ | * Broadcast New State |
+ | |Get +2/3 Commits |--> * Set CommitTime +--+ |
+ | +-----------------+ |
+ | |
+ +------------------------------------------------------------------------------+
+
+*/
+
+package consensus
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "math"
+ "sync"
+ "sync/atomic"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ bc "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/types"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/events"
+ mempl "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool"
+ sm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+const (
+ roundDeadlinePrevote = float64(1.0 / 3.0) // When the prevote is due.
+ roundDeadlinePrecommit = float64(2.0 / 3.0) // When the precommit vote is due.
+)
+
+var (
+ RoundDuration0 = 10 * time.Second // The first round is 60 seconds long.
+ RoundDurationDelta = 3 * time.Second // Each successive round lasts 15 seconds longer.
+ newHeightDelta = RoundDuration0 / 3 // The time to wait between commitTime and startTime of next consensus rounds.
+)
+
+var (
+ ErrInvalidProposalSignature = errors.New("Error invalid proposal signature")
+)
+
+//-----------------------------------------------------------------------------
+// RoundStepType enum type
+
+type RoundStepType uint8 // These must be numeric, ordered.
+
+const (
+ RoundStepNewHeight = RoundStepType(0x01) // Round0 for new height started, wait til CommitTime + Delta
+ RoundStepNewRound = RoundStepType(0x02) // Pseudostep, immediately goes to RoundStepPropose
+ RoundStepPropose = RoundStepType(0x03) // Did propose, gossip proposal
+ RoundStepPrevote = RoundStepType(0x04) // Did prevote, gossip prevotes
+ RoundStepPrecommit = RoundStepType(0x05) // Did precommit, gossip precommits
+ RoundStepCommit = RoundStepType(0x06) // Entered commit state machine
+)
+
+func (rs RoundStepType) String() string {
+ switch rs {
+ case RoundStepNewHeight:
+ return "RoundStepNewHeight"
+ case RoundStepNewRound:
+ return "RoundStepNewRound"
+ case RoundStepPropose:
+ return "RoundStepPropose"
+ case RoundStepPrevote:
+ return "RoundStepPrevote"
+ case RoundStepPrecommit:
+ return "RoundStepPrecommit"
+ case RoundStepCommit:
+ return "RoundStepCommit"
+ default:
+ panic(Fmt("Unknown RoundStep %X", rs))
+ }
+}
+
+//-----------------------------------------------------------------------------
+// RoundAction enum type
+
+type RoundActionType string
+
+const (
+ RoundActionPropose = RoundActionType("PR") // Propose and goto RoundStepPropose
+ RoundActionPrevote = RoundActionType("PV") // Prevote and goto RoundStepPrevote
+ RoundActionPrecommit = RoundActionType("PC") // Precommit and goto RoundStepPrecommit
+ RoundActionTryCommit = RoundActionType("TC") // Goto RoundStepCommit, or RoundStepPropose for next round.
+ RoundActionCommit = RoundActionType("CM") // Goto RoundStepCommit upon +2/3 commits
+ RoundActionTryFinalize = RoundActionType("TF") // Maybe goto RoundStepPropose for next round.
+)
+
+func (rat RoundActionType) String() string {
+ switch rat {
+ case RoundActionPropose:
+ return "RoundActionPropose"
+ case RoundActionPrevote:
+ return "RoundActionPrevote"
+ case RoundActionPrecommit:
+ return "RoundActionPrecommit"
+ case RoundActionTryCommit:
+ return "RoundActionTryCommit"
+ case RoundActionCommit:
+ return "RoundActionCommit"
+ case RoundActionTryFinalize:
+ return "RoundActionTryFinalize"
+ default:
+ panic(Fmt("Unknown RoundAction %X", rat))
+ }
+}
+
+//-----------------------------------------------------------------------------
+
+type RoundAction struct {
+ Height uint // The block height for which consensus is reaching for.
+ Round uint // The round number at given height.
+ Action RoundActionType // Action to perform.
+}
+
+func (ra RoundAction) String() string {
+ return Fmt("RoundAction{H:%v R:%v A:%v}", ra.Height, ra.Round, ra.Action)
+}
+
+//-----------------------------------------------------------------------------
+
+// Immutable when returned from ConsensusState.GetRoundState()
+type RoundState struct {
+ Height uint // Height we are working on
+ Round uint
+ Step RoundStepType
+ StartTime time.Time
+ CommitTime time.Time // Time when +2/3 commits were found
+ Validators *sm.ValidatorSet
+ Proposal *Proposal
+ ProposalBlock *types.Block
+ ProposalBlockParts *types.PartSet
+ ProposalPOL *POL
+ ProposalPOLParts *types.PartSet
+ LockedBlock *types.Block
+ LockedBlockParts *types.PartSet
+ LockedPOL *POL // Rarely needed, so no LockedPOLParts.
+ Prevotes *VoteSet
+ Precommits *VoteSet
+ Commits *VoteSet
+ LastCommits *VoteSet
+}
+
+func (rs *RoundState) String() string {
+ return rs.StringIndented("")
+}
+
+func (rs *RoundState) StringIndented(indent string) string {
+ return fmt.Sprintf(`RoundState{
+%s H:%v R:%v S:%v
+%s StartTime: %v
+%s CommitTime: %v
+%s Validators: %v
+%s Proposal: %v
+%s ProposalBlock: %v %v
+%s ProposalPOL: %v %v
+%s LockedBlock: %v %v
+%s LockedPOL: %v
+%s Prevotes: %v
+%s Precommits: %v
+%s Commits: %v
+%s LastCommits: %v
+%s}`,
+ indent, rs.Height, rs.Round, rs.Step,
+ indent, rs.StartTime,
+ indent, rs.CommitTime,
+ indent, rs.Validators.StringIndented(indent+" "),
+ indent, rs.Proposal,
+ indent, rs.ProposalBlockParts.StringShort(), rs.ProposalBlock.StringShort(),
+ indent, rs.ProposalPOLParts.StringShort(), rs.ProposalPOL.StringShort(),
+ indent, rs.LockedBlockParts.StringShort(), rs.LockedBlock.StringShort(),
+ indent, rs.LockedPOL.StringShort(),
+ indent, rs.Prevotes.StringIndented(indent+" "),
+ indent, rs.Precommits.StringIndented(indent+" "),
+ indent, rs.Commits.StringIndented(indent+" "),
+ indent, rs.LastCommits.StringShort(),
+ indent)
+}
+
+func (rs *RoundState) StringShort() string {
+ return fmt.Sprintf(`RoundState{H:%v R:%v S:%v ST:%v}`,
+ rs.Height, rs.Round, rs.Step, rs.StartTime)
+}
+
+//-----------------------------------------------------------------------------
+
+// Tracks consensus state across block heights and rounds.
+type ConsensusState struct {
+ started uint32
+ stopped uint32
+ quit chan struct{}
+
+ blockStore *bc.BlockStore
+ mempoolReactor *mempl.MempoolReactor
+ privValidator *sm.PrivValidator
+ runActionCh chan RoundAction
+ newStepCh chan *RoundState
+
+ mtx sync.Mutex
+ RoundState
+ state *sm.State // State until height-1.
+ stagedBlock *types.Block // Cache last staged block.
+ stagedState *sm.State // Cache result of staged block.
+ lastCommitVoteHeight uint // Last called commitVoteBlock() or saveCommitVoteBlock() on.
+
+ evsw events.Fireable
+ evc *events.EventCache // set in stageBlock and passed into state
+}
+
+func NewConsensusState(state *sm.State, blockStore *bc.BlockStore, mempoolReactor *mempl.MempoolReactor) *ConsensusState {
+ cs := &ConsensusState{
+ quit: make(chan struct{}),
+ blockStore: blockStore,
+ mempoolReactor: mempoolReactor,
+ runActionCh: make(chan RoundAction, 1),
+ newStepCh: make(chan *RoundState, 1),
+ }
+ cs.updateToState(state, true)
+ return cs
+}
+
+func (cs *ConsensusState) GetState() *sm.State {
+ cs.mtx.Lock()
+ defer cs.mtx.Unlock()
+ return cs.state.Copy()
+}
+
+func (cs *ConsensusState) GetRoundState() *RoundState {
+ cs.mtx.Lock()
+ defer cs.mtx.Unlock()
+ return cs.getRoundState()
+}
+
+func (cs *ConsensusState) getRoundState() *RoundState {
+ rs := cs.RoundState // copy
+ return &rs
+}
+
+func (cs *ConsensusState) NewStepCh() chan *RoundState {
+ return cs.newStepCh
+}
+
+func (cs *ConsensusState) Start() {
+ if atomic.CompareAndSwapUint32(&cs.started, 0, 1) {
+ log.Info("Starting ConsensusState")
+ go cs.stepTransitionRoutine()
+ }
+}
+
+func (cs *ConsensusState) Stop() {
+ if atomic.CompareAndSwapUint32(&cs.stopped, 0, 1) {
+ log.Info("Stopping ConsensusState")
+ close(cs.quit)
+ }
+}
+
+func (cs *ConsensusState) IsStopped() bool {
+ return atomic.LoadUint32(&cs.stopped) == 1
+}
+
+func (cs *ConsensusState) queueAction(ra RoundAction) {
+ go func() {
+ cs.runActionCh <- ra
+ }()
+}
+
+// Source of all round state transitions (and votes).
+func (cs *ConsensusState) stepTransitionRoutine() {
+
+ // For clarity, all state transitions that happen after some timeout are here.
+ // Schedule the next action by pushing a RoundAction{} to cs.runActionCh.
+ scheduleNextAction := func() {
+ // NOTE: rs must be fetched in the same callstack as the caller.
+ rs := cs.getRoundState()
+ go func() {
+ // NOTE: We can push directly to runActionCh because
+ // we're running in a separate goroutine, which avoids deadlocks.
+ round, roundStartTime, RoundDuration, _, elapsedRatio := calcRoundInfo(rs.StartTime)
+ log.Debug("Scheduling next action", "height", rs.Height, "round", round, "step", rs.Step, "roundStartTime", roundStartTime, "elapsedRatio", elapsedRatio)
+ switch rs.Step {
+ case RoundStepNewHeight:
+ // We should run RoundActionPropose when rs.StartTime passes.
+ if elapsedRatio < 0 {
+ // startTime is in the future.
+ time.Sleep(time.Duration((-1.0 * elapsedRatio) * float64(RoundDuration)))
+ }
+ cs.runActionCh <- RoundAction{rs.Height, rs.Round, RoundActionPropose}
+ case RoundStepNewRound:
+ // Pseudostep: Immediately goto propose.
+ cs.runActionCh <- RoundAction{rs.Height, rs.Round, RoundActionPropose}
+ case RoundStepPropose:
+ // Wake up when it's time to vote.
+ time.Sleep(time.Duration((roundDeadlinePrevote - elapsedRatio) * float64(RoundDuration)))
+ cs.runActionCh <- RoundAction{rs.Height, rs.Round, RoundActionPrevote}
+ case RoundStepPrevote:
+ // Wake up when it's time to precommit.
+ time.Sleep(time.Duration((roundDeadlinePrecommit - elapsedRatio) * float64(RoundDuration)))
+ cs.runActionCh <- RoundAction{rs.Height, rs.Round, RoundActionPrecommit}
+ case RoundStepPrecommit:
+ // Wake up when the round is over.
+ time.Sleep(time.Duration((1.0 - elapsedRatio) * float64(RoundDuration)))
+ cs.runActionCh <- RoundAction{rs.Height, rs.Round, RoundActionTryCommit}
+ case RoundStepCommit:
+ // There's nothing to scheudle, we're waiting for
+ // ProposalBlockParts.IsComplete() &&
+ // Commits.HasTwoThirdsMajority()
+ panic("The next action from RoundStepCommit is not scheduled by time")
+ default:
+ panic("Should not happen")
+ }
+ }()
+ }
+
+ if cs.getRoundState().Step < RoundStepCommit {
+ scheduleNextAction()
+ } else {
+ // Race condition with receipt of commits, maybe.
+ // We shouldn't have to schedule anything.
+ }
+
+ // NOTE: All ConsensusState.RunAction*() calls come from here.
+ // Since only one routine calls them, it is safe to assume that
+ // the RoundState Height/Round/Step won't change concurrently.
+ // However, other fields like Proposal could change concurrent
+ // due to gossip routines.
+ACTION_LOOP:
+ for {
+ var roundAction RoundAction
+ select {
+ case roundAction = <-cs.runActionCh:
+ case <-cs.quit:
+ return
+ }
+
+ height, round, action := roundAction.Height, roundAction.Round, roundAction.Action
+ rs := cs.GetRoundState()
+
+ // Continue if action is not relevant
+ if height != rs.Height {
+ log.Debug("Discarding round action: Height mismatch", "height", rs.Height, "roundAction", roundAction)
+ continue
+ }
+ // If action <= RoundActionPrecommit, the round must match too.
+ if action <= RoundActionPrecommit && round != rs.Round {
+ log.Debug("Discarding round action: Round mismatch", "round", rs.Round, "roundAction", roundAction)
+ continue
+ }
+
+ log.Info("Running round action", "height", rs.Height, "round", rs.Round, "step", rs.Step, "roundAction", roundAction, "startTime", rs.StartTime)
+
+ // Run action
+ switch action {
+ case RoundActionPropose:
+ if rs.Step != RoundStepNewHeight && rs.Step != RoundStepNewRound {
+ continue ACTION_LOOP
+ }
+ cs.RunActionPropose(rs.Height, rs.Round)
+ scheduleNextAction()
+ continue ACTION_LOOP
+
+ case RoundActionPrevote:
+ if rs.Step >= RoundStepPrevote {
+ continue ACTION_LOOP
+ }
+ cs.RunActionPrevote(rs.Height, rs.Round)
+ scheduleNextAction()
+ continue ACTION_LOOP
+
+ case RoundActionPrecommit:
+ if rs.Step >= RoundStepPrecommit {
+ continue ACTION_LOOP
+ }
+ cs.RunActionPrecommit(rs.Height, rs.Round)
+ scheduleNextAction()
+ continue ACTION_LOOP
+
+ case RoundActionTryCommit:
+ if rs.Step >= RoundStepCommit {
+ continue ACTION_LOOP
+ }
+ if rs.Precommits.HasTwoThirdsMajority() {
+ // Enter RoundStepCommit and commit.
+ cs.RunActionCommit(rs.Height)
+ continue ACTION_LOOP
+ } else {
+ // Could not commit, move onto next round.
+ cs.SetupNewRound(rs.Height, rs.Round+1)
+ // cs.Step is now at RoundStepNewRound
+ scheduleNextAction()
+ continue ACTION_LOOP
+ }
+
+ case RoundActionCommit:
+ if rs.Step >= RoundStepCommit {
+ continue ACTION_LOOP
+ }
+ // Enter RoundStepCommit and commit.
+ cs.RunActionCommit(rs.Height)
+ continue ACTION_LOOP
+
+ case RoundActionTryFinalize:
+ if cs.TryFinalizeCommit(rs.Height) {
+ // Now at new height
+ // cs.Step is at RoundStepNewHeight or RoundStepNewRound.
+ // fire some events!
+ go func() {
+ newBlock := cs.blockStore.LoadBlock(cs.state.LastBlockHeight)
+ cs.evsw.FireEvent(types.EventStringNewBlock(), newBlock)
+ cs.evc.Flush()
+ }()
+ scheduleNextAction()
+ continue ACTION_LOOP
+ } else {
+ // do not schedule next action.
+ continue ACTION_LOOP
+ }
+
+ default:
+ panic("Unknown action")
+ }
+
+ // For clarity, ensure that all switch cases call "continue"
+ panic("Should not happen.")
+ }
+}
+
+// Updates ConsensusState and increments height to match that of state.
+// If calculated round is greater than 0 (based on BlockTime or calculated StartTime)
+// then also sets up the appropriate round, and cs.Step becomes RoundStepNewRound.
+// Otherwise the round is 0 and cs.Step becomes RoundStepNewHeight.
+func (cs *ConsensusState) updateToState(state *sm.State, contiguous bool) {
+ // Sanity check state.
+ if contiguous && cs.Height > 0 && cs.Height != state.LastBlockHeight {
+ panic(Fmt("updateToState() expected state height of %v but found %v",
+ cs.Height, state.LastBlockHeight))
+ }
+
+ // Reset fields based on state.
+ validators := state.BondedValidators
+ height := state.LastBlockHeight + 1 // next desired block height
+
+ // RoundState fields
+ cs.Height = height
+ cs.Round = 0
+ cs.Step = RoundStepNewHeight
+ if cs.CommitTime.IsZero() {
+ // "Now" makes it easier to sync up dev nodes.
+ // We add newHeightDelta to allow transactions
+ // to be gathered for the first block.
+ // And alternative solution that relies on clocks:
+ // cs.StartTime = state.LastBlockTime.Add(newHeightDelta)
+ cs.StartTime = time.Now().Add(newHeightDelta)
+ } else {
+ cs.StartTime = cs.CommitTime.Add(newHeightDelta)
+ }
+ cs.CommitTime = time.Time{}
+ cs.Validators = validators
+ cs.Proposal = nil
+ cs.ProposalBlock = nil
+ cs.ProposalBlockParts = nil
+ cs.ProposalPOL = nil
+ cs.ProposalPOLParts = nil
+ cs.LockedBlock = nil
+ cs.LockedBlockParts = nil
+ cs.LockedPOL = nil
+ cs.Prevotes = NewVoteSet(height, 0, types.VoteTypePrevote, validators)
+ cs.Precommits = NewVoteSet(height, 0, types.VoteTypePrecommit, validators)
+ cs.LastCommits = cs.Commits
+ cs.Commits = NewVoteSet(height, 0, types.VoteTypeCommit, validators)
+
+ cs.state = state
+ cs.stagedBlock = nil
+ cs.stagedState = nil
+
+ // Update the round if we need to.
+ round := calcRound(cs.StartTime)
+ if round > 0 {
+ cs.setupNewRound(round)
+ }
+
+ // If we've timed out, then send rebond tx.
+ if cs.privValidator != nil && cs.state.UnbondingValidators.HasAddress(cs.privValidator.Address) {
+ rebondTx := &types.RebondTx{
+ Address: cs.privValidator.Address,
+ Height: cs.Height,
+ }
+ err := cs.privValidator.SignRebondTx(cs.state.ChainID, rebondTx)
+ if err == nil {
+ err := cs.mempoolReactor.BroadcastTx(rebondTx)
+ if err != nil {
+ log.Error("Failed to broadcast RebondTx",
+ "height", cs.Height, "round", cs.Round, "tx", rebondTx, "error", err)
+ } else {
+ log.Info("Signed and broadcast RebondTx",
+ "height", cs.Height, "round", cs.Round, "tx", rebondTx)
+ }
+ } else {
+ log.Warn("Error signing RebondTx", "height", cs.Height, "round", cs.Round, "tx", rebondTx, "error", err)
+ }
+ }
+}
+
+// After the call cs.Step becomes RoundStepNewRound.
+func (cs *ConsensusState) setupNewRound(round uint) {
+ // Sanity check
+ if round == 0 {
+ panic("setupNewRound() should never be called for round 0")
+ }
+
+ // Increment all the way to round.
+ validators := cs.Validators.Copy()
+ validators.IncrementAccum(round - cs.Round)
+
+ cs.Round = round
+ cs.Step = RoundStepNewRound
+ cs.Validators = validators
+ cs.Proposal = nil
+ cs.ProposalBlock = nil
+ cs.ProposalBlockParts = nil
+ cs.ProposalPOL = nil
+ cs.ProposalPOLParts = nil
+ cs.Prevotes = NewVoteSet(cs.Height, round, types.VoteTypePrevote, validators)
+ cs.Prevotes.AddFromCommits(cs.Commits)
+ cs.Precommits = NewVoteSet(cs.Height, round, types.VoteTypePrecommit, validators)
+ cs.Precommits.AddFromCommits(cs.Commits)
+}
+
+func (cs *ConsensusState) SetPrivValidator(priv *sm.PrivValidator) {
+ cs.mtx.Lock()
+ defer cs.mtx.Unlock()
+ cs.privValidator = priv
+}
+
+//-----------------------------------------------------------------------------
+
+// Set up the round to desired round and set step to RoundStepNewRound
+func (cs *ConsensusState) SetupNewRound(height uint, desiredRound uint) bool {
+ cs.mtx.Lock()
+ defer cs.mtx.Unlock()
+ if cs.Height != height {
+ return false
+ }
+ if desiredRound <= cs.Round {
+ return false
+ }
+ cs.setupNewRound(desiredRound)
+ // c.Step is now RoundStepNewRound
+ cs.newStepCh <- cs.getRoundState()
+ return true
+}
+
+func (cs *ConsensusState) RunActionPropose(height uint, round uint) {
+ cs.mtx.Lock()
+ defer cs.mtx.Unlock()
+ if cs.Height != height || cs.Round != round {
+ return
+ }
+ defer func() {
+ cs.Step = RoundStepPropose
+ cs.newStepCh <- cs.getRoundState()
+ }()
+
+ // Nothing to do if it's not our turn.
+ if cs.privValidator == nil {
+ return
+ }
+ if !bytes.Equal(cs.Validators.Proposer().Address, cs.privValidator.Address) {
+ log.Debug("Not our turn to propose", "proposer", cs.Validators.Proposer().Address, "privValidator", cs.privValidator)
+ return
+ } else {
+ log.Debug("Our turn to propose", "proposer", cs.Validators.Proposer().Address, "privValidator", cs.privValidator)
+ }
+
+ var block *types.Block
+ var blockParts *types.PartSet
+ var pol *POL
+ var polParts *types.PartSet
+
+ // Decide on block and POL
+ if cs.LockedBlock != nil {
+ // If we're locked onto a block, just choose that.
+ block = cs.LockedBlock
+ blockParts = cs.LockedBlockParts
+ pol = cs.LockedPOL
+ } else {
+ // Otherwise we should create a new proposal.
+ var validation *types.Validation
+ if cs.Height == 1 {
+ // We're creating a proposal for the first block.
+ // The validation is empty.
+ validation = &types.Validation{}
+ } else if cs.LastCommits.HasTwoThirdsMajority() {
+ // Make the validation from LastCommits
+ validation = cs.LastCommits.MakeValidation()
+ } else {
+ // Upon reboot, we may have to use SeenValidation
+ validation = cs.blockStore.LoadSeenValidation(height - 1)
+ if validation == nil {
+ // We just don't have any validation for the previous block
+ log.Debug("Cannot propose anything: No validation for the previous block.")
+ return
+ }
+ }
+ txs := cs.mempoolReactor.Mempool.GetProposalTxs()
+ block = &types.Block{
+ Header: &types.Header{
+ ChainID: cs.state.ChainID,
+ Height: cs.Height,
+ Time: time.Now(),
+ Fees: 0, // TODO fees
+ NumTxs: uint(len(txs)),
+ LastBlockHash: cs.state.LastBlockHash,
+ LastBlockParts: cs.state.LastBlockParts,
+ StateHash: nil, // Will set afterwards.
+ },
+ Validation: validation,
+ Data: &types.Data{
+ Txs: txs,
+ },
+ }
+
+ // Set the types.Header.StateHash.
+ err := cs.state.SetBlockStateHash(block)
+ if err != nil {
+ log.Error("Error setting state hash", "error", err)
+ return
+ }
+
+ blockParts = block.MakePartSet()
+ pol = cs.LockedPOL // If exists, is a PoUnlock.
+ }
+
+ if pol != nil {
+ polParts = pol.MakePartSet()
+ }
+
+ // Make proposal
+ proposal := NewProposal(cs.Height, cs.Round, blockParts.Header(), polParts.Header())
+ err := cs.privValidator.SignProposal(cs.state.ChainID, proposal)
+ if err == nil {
+ log.Info("Signed and set proposal", "height", cs.Height, "round", cs.Round, "proposal", proposal)
+ log.Debug(Fmt("Signed and set proposal block: %v", block))
+ // Set fields
+ cs.Proposal = proposal
+ cs.ProposalBlock = block
+ cs.ProposalBlockParts = blockParts
+ cs.ProposalPOL = pol
+ cs.ProposalPOLParts = polParts
+ } else {
+ log.Warn("Error signing proposal", "height", cs.Height, "round", cs.Round, "error", err)
+ }
+}
+
+// Prevote for LockedBlock if we're locked, or ProposealBlock if valid.
+// Otherwise vote nil.
+func (cs *ConsensusState) RunActionPrevote(height uint, round uint) {
+ cs.mtx.Lock()
+ defer cs.mtx.Unlock()
+ if cs.Height != height || cs.Round != round {
+ panic(Fmt("RunActionPrevote(%v/%v), expected %v/%v", height, round, cs.Height, cs.Round))
+ }
+ defer func() {
+ cs.Step = RoundStepPrevote
+ cs.newStepCh <- cs.getRoundState()
+ }()
+
+ // If a block is locked, prevote that.
+ if cs.LockedBlock != nil {
+ log.Debug("Block was locked")
+ cs.signAddVote(types.VoteTypePrevote, cs.LockedBlock.Hash(), cs.LockedBlockParts.Header())
+ return
+ }
+
+ // If ProposalBlock is nil, prevote nil.
+ if cs.ProposalBlock == nil {
+ log.Warn("ProposalBlock is nil")
+ cs.signAddVote(types.VoteTypePrevote, nil, types.PartSetHeader{})
+ return
+ }
+
+ // Try staging cs.ProposalBlock
+ err := cs.stageBlock(cs.ProposalBlock, cs.ProposalBlockParts)
+ if err != nil {
+ // ProposalBlock is invalid, prevote nil.
+ log.Warn("ProposalBlock is invalid", "error", err)
+ cs.signAddVote(types.VoteTypePrevote, nil, types.PartSetHeader{})
+ return
+ }
+
+ // Prevote cs.ProposalBlock
+ cs.signAddVote(types.VoteTypePrevote, cs.ProposalBlock.Hash(), cs.ProposalBlockParts.Header())
+ return
+}
+
+// Lock & Precommit the ProposalBlock if we have enough prevotes for it,
+// or unlock an existing lock if +2/3 of prevotes were nil.
+func (cs *ConsensusState) RunActionPrecommit(height uint, round uint) {
+ cs.mtx.Lock()
+ defer cs.mtx.Unlock()
+ if cs.Height != height || cs.Round != round {
+ panic(Fmt("RunActionPrecommit(%v/%v), expected %v/%v", height, round, cs.Height, cs.Round))
+ }
+ defer func() {
+ cs.Step = RoundStepPrecommit
+ cs.newStepCh <- cs.getRoundState()
+ }()
+
+ hash, partsHeader, ok := cs.Prevotes.TwoThirdsMajority()
+ if !ok {
+ // If we don't have two thirds of prevotes,
+ // don't do anything at all.
+ log.Info("Insufficient prevotes for precommit")
+ return
+ }
+
+ // Remember this POL. (hash may be nil)
+ cs.LockedPOL = cs.Prevotes.MakePOL()
+
+ // If +2/3 prevoted nil. Just unlock.
+ if len(hash) == 0 {
+ if cs.LockedBlock == nil {
+ log.Info("+2/3 prevoted for nil.")
+ } else {
+ log.Info("+2/3 prevoted for nil. Unlocking")
+ cs.LockedBlock = nil
+ cs.LockedBlockParts = nil
+ }
+ return
+ }
+
+ // If +2/3 prevoted for already locked block, precommit it.
+ if cs.LockedBlock.HashesTo(hash) {
+ log.Info("+2/3 prevoted locked block.")
+ cs.signAddVote(types.VoteTypePrecommit, hash, partsHeader)
+ return
+ }
+
+ // If +2/3 prevoted for cs.ProposalBlock, lock it and precommit it.
+ if !cs.ProposalBlock.HashesTo(hash) {
+ log.Warn("Proposal does not hash to +2/3 prevotes")
+ // We don't have the block that validators prevoted.
+ // Unlock if we're locked.
+ cs.LockedBlock = nil
+ cs.LockedBlockParts = nil
+ return
+ }
+
+ // Validate the block.
+ if err := cs.stageBlock(cs.ProposalBlock, cs.ProposalBlockParts); err != nil {
+ // Prevent zombies.
+ log.Warn("+2/3 prevoted for an invalid block", "error", err)
+ return
+ }
+
+ cs.LockedBlock = cs.ProposalBlock
+ cs.LockedBlockParts = cs.ProposalBlockParts
+ cs.signAddVote(types.VoteTypePrecommit, hash, partsHeader)
+ return
+}
+
+// Enter commit step. See the diagram for details.
+// There are two ways to enter this step:
+// * After the Precommit step with +2/3 precommits, or,
+// * Upon +2/3 commits regardless of current step
+// Either way this action is run at most once per round.
+func (cs *ConsensusState) RunActionCommit(height uint) {
+ cs.mtx.Lock()
+ defer cs.mtx.Unlock()
+ if cs.Height != height {
+ panic(Fmt("RunActionCommit(%v), expected %v", height, cs.Height))
+ }
+ defer func() {
+ cs.Step = RoundStepCommit
+ cs.newStepCh <- cs.getRoundState()
+ }()
+
+ // Sanity check.
+ // There are two ways to enter:
+ // 1. +2/3 precommits at the end of RoundStepPrecommit
+ // 2. +2/3 commits at any time
+ hash, partsHeader, ok := cs.Precommits.TwoThirdsMajority()
+ if !ok {
+ hash, partsHeader, ok = cs.Commits.TwoThirdsMajority()
+ if !ok {
+ panic("RunActionCommit() expects +2/3 precommits or commits")
+ }
+ }
+
+ // Clear the Locked* fields and use cs.Proposed*
+ if cs.LockedBlock.HashesTo(hash) {
+ cs.ProposalBlock = cs.LockedBlock
+ cs.ProposalBlockParts = cs.LockedBlockParts
+ cs.LockedBlock = nil
+ cs.LockedBlockParts = nil
+ cs.LockedPOL = nil
+ }
+
+ // If we don't have the block being committed, set up to get it.
+ if !cs.ProposalBlock.HashesTo(hash) {
+ if !cs.ProposalBlockParts.HasHeader(partsHeader) {
+ // We're getting the wrong block.
+ // Set up ProposalBlockParts and keep waiting.
+ cs.ProposalBlock = nil
+ cs.ProposalBlockParts = types.NewPartSetFromHeader(partsHeader)
+
+ } else {
+ // We just need to keep waiting.
+ }
+ } else {
+ // We have the block, so sign a Commit-vote.
+ cs.commitVoteBlock(cs.ProposalBlock, cs.ProposalBlockParts)
+ }
+
+ // If we have the block AND +2/3 commits, queue RoundActionTryFinalize.
+ // Round will immediately become finalized.
+ if cs.ProposalBlock.HashesTo(hash) && cs.Commits.HasTwoThirdsMajority() {
+ cs.queueAction(RoundAction{cs.Height, cs.Round, RoundActionTryFinalize})
+ }
+
+}
+
+// Returns true if Finalize happened, which increments height && sets
+// the step to RoundStepNewHeight (or RoundStepNewRound, but probably not).
+func (cs *ConsensusState) TryFinalizeCommit(height uint) bool {
+ cs.mtx.Lock()
+ defer cs.mtx.Unlock()
+
+ if cs.Height != height {
+ panic(Fmt("TryFinalizeCommit(%v), expected %v", height, cs.Height))
+ }
+
+ if cs.Step == RoundStepCommit &&
+ cs.Commits.HasTwoThirdsMajority() &&
+ cs.ProposalBlockParts.IsComplete() {
+
+ // Sanity check
+ if cs.ProposalBlock == nil {
+ panic(Fmt("Expected ProposalBlock to exist"))
+ }
+ hash, header, _ := cs.Commits.TwoThirdsMajority()
+ if !cs.ProposalBlock.HashesTo(hash) {
+ // XXX See: https://github.com/tendermint/tendermint/issues/44
+ panic(Fmt("Expected ProposalBlock to hash to commit hash. Expected %X, got %X", hash, cs.ProposalBlock.Hash()))
+ }
+ if !cs.ProposalBlockParts.HasHeader(header) {
+ panic(Fmt("Expected ProposalBlockParts header to be commit header"))
+ }
+
+ err := cs.stageBlock(cs.ProposalBlock, cs.ProposalBlockParts)
+ if err == nil {
+ log.Debug(Fmt("Finalizing commit of block: %v", cs.ProposalBlock))
+ // We have the block, so save/stage/sign-commit-vote.
+ cs.saveCommitVoteBlock(cs.ProposalBlock, cs.ProposalBlockParts, cs.Commits)
+ // Increment height.
+ cs.updateToState(cs.stagedState, true)
+ // cs.Step is now RoundStepNewHeight or RoundStepNewRound
+ cs.newStepCh <- cs.getRoundState()
+ return true
+ } else {
+ // Prevent zombies.
+ // TODO: Does this ever happen?
+ panic(Fmt("+2/3 committed an invalid block: %v", err))
+ }
+ }
+ return false
+}
+
+//-----------------------------------------------------------------------------
+
+func (cs *ConsensusState) SetProposal(proposal *Proposal) error {
+ cs.mtx.Lock()
+ defer cs.mtx.Unlock()
+
+ // Already have one
+ if cs.Proposal != nil {
+ return nil
+ }
+
+ // Does not apply
+ if proposal.Height != cs.Height || proposal.Round != cs.Round {
+ return nil
+ }
+
+ // We don't care about the proposal if we're already in RoundStepCommit.
+ if cs.Step == RoundStepCommit {
+ return nil
+ }
+
+ // Verify signature
+ if !cs.Validators.Proposer().PubKey.VerifyBytes(account.SignBytes(cs.state.ChainID, proposal), proposal.Signature) {
+ return ErrInvalidProposalSignature
+ }
+
+ cs.Proposal = proposal
+ cs.ProposalBlockParts = types.NewPartSetFromHeader(proposal.BlockParts)
+ cs.ProposalPOLParts = types.NewPartSetFromHeader(proposal.POLParts)
+ return nil
+}
+
+// NOTE: block is not necessarily valid.
+// NOTE: This function may increment the height.
+func (cs *ConsensusState) AddProposalBlockPart(height uint, round uint, part *types.Part) (added bool, err error) {
+ cs.mtx.Lock()
+ defer cs.mtx.Unlock()
+
+ // Blocks might be reused, so round mismatch is OK
+ if cs.Height != height {
+ return false, nil
+ }
+
+ // We're not expecting a block part.
+ if cs.ProposalBlockParts == nil {
+ return false, nil // TODO: bad peer? Return error?
+ }
+
+ added, err = cs.ProposalBlockParts.AddPart(part)
+ if err != nil {
+ return added, err
+ }
+ if added && cs.ProposalBlockParts.IsComplete() {
+ var n int64
+ var err error
+ cs.ProposalBlock = binary.ReadBinary(&types.Block{}, cs.ProposalBlockParts.GetReader(), &n, &err).(*types.Block)
+ log.Debug("Received complete proposal", "hash", cs.ProposalBlock.Hash())
+ // If we're already in the commit step, try to finalize round.
+ if cs.Step == RoundStepCommit {
+ cs.queueAction(RoundAction{cs.Height, cs.Round, RoundActionTryFinalize})
+ }
+ // XXX If POL is valid, consider unlocking.
+ return true, err
+ }
+ return true, nil
+}
+
+// NOTE: POL is not necessarily valid.
+func (cs *ConsensusState) AddProposalPOLPart(height uint, round uint, part *types.Part) (added bool, err error) {
+ cs.mtx.Lock()
+ defer cs.mtx.Unlock()
+
+ if cs.Height != height || cs.Round != round {
+ return false, nil
+ }
+
+ // We're not expecting a POL part.
+ if cs.ProposalPOLParts == nil {
+ return false, nil // TODO: bad peer? Return error?
+ }
+
+ added, err = cs.ProposalPOLParts.AddPart(part)
+ if err != nil {
+ return added, err
+ }
+ if added && cs.ProposalPOLParts.IsComplete() {
+ var n int64
+ var err error
+ cs.ProposalPOL = binary.ReadBinary(&POL{}, cs.ProposalPOLParts.GetReader(), &n, &err).(*POL)
+ return true, err
+ }
+ return true, nil
+}
+
+func (cs *ConsensusState) AddVote(address []byte, vote *types.Vote) (added bool, index uint, err error) {
+ cs.mtx.Lock()
+ defer cs.mtx.Unlock()
+
+ return cs.addVote(address, vote)
+}
+
+//-----------------------------------------------------------------------------
+
+func (cs *ConsensusState) addVote(address []byte, vote *types.Vote) (added bool, index uint, err error) {
+ switch vote.Type {
+ case types.VoteTypePrevote:
+ // Prevotes checks for height+round match.
+ added, index, err = cs.Prevotes.Add(address, vote)
+ if added {
+ log.Debug(Fmt("Added prevote: %v", cs.Prevotes.StringShort()))
+ }
+ return
+ case types.VoteTypePrecommit:
+ // Precommits checks for height+round match.
+ added, index, err = cs.Precommits.Add(address, vote)
+ if added {
+ log.Debug(Fmt("Added precommit: %v", cs.Precommits.StringShort()))
+ }
+ return
+ case types.VoteTypeCommit:
+ if vote.Height == cs.Height {
+ // No need to check if vote.Round < cs.Round ...
+ // Prevotes && Precommits already checks that.
+ cs.Prevotes.Add(address, vote)
+ cs.Precommits.Add(address, vote)
+ added, index, err = cs.Commits.Add(address, vote)
+ if added && cs.Commits.HasTwoThirdsMajority() && cs.CommitTime.IsZero() {
+ cs.CommitTime = time.Now()
+ log.Debug(Fmt("Set CommitTime to %v", cs.CommitTime))
+ if cs.Step < RoundStepCommit {
+ cs.queueAction(RoundAction{cs.Height, cs.Round, RoundActionCommit})
+ } else {
+ cs.queueAction(RoundAction{cs.Height, cs.Round, RoundActionTryFinalize})
+ }
+ }
+ if added {
+ log.Debug(Fmt("Added commit: %v\nprecommits: %v\nprevotes: %v",
+ cs.Commits.StringShort(),
+ cs.Precommits.StringShort(),
+ cs.Prevotes.StringShort()))
+ }
+ return
+ }
+ if vote.Height+1 == cs.Height {
+ added, index, err = cs.LastCommits.Add(address, vote)
+ log.Debug(Fmt("Added lastCommits: %v", cs.LastCommits.StringShort()))
+ return
+ }
+ return false, 0, nil
+ default:
+ panic("Unknown vote type")
+ }
+}
+
+func (cs *ConsensusState) stageBlock(block *types.Block, blockParts *types.PartSet) error {
+ if block == nil {
+ panic("Cannot stage nil block")
+ }
+
+ // Already staged?
+ blockHash := block.Hash()
+ if cs.stagedBlock != nil && len(blockHash) != 0 && bytes.Equal(cs.stagedBlock.Hash(), blockHash) {
+ return nil
+ }
+
+ // Create a copy of the state for staging
+ stateCopy := cs.state.Copy()
+ // reset the event cache and pass it into the state
+ cs.evc = events.NewEventCache(cs.evsw)
+ stateCopy.SetFireable(cs.evc)
+
+ // Commit block onto the copied state.
+ // NOTE: Basic validation is done in state.AppendBlock().
+ err := sm.ExecBlock(stateCopy, block, blockParts.Header())
+ if err != nil {
+ return err
+ } else {
+ cs.stagedBlock = block
+ cs.stagedState = stateCopy
+ return nil
+ }
+}
+
+func (cs *ConsensusState) signAddVote(type_ byte, hash []byte, header types.PartSetHeader) *types.Vote {
+ if cs.privValidator == nil || !cs.Validators.HasAddress(cs.privValidator.Address) {
+ return nil
+ }
+ vote := &types.Vote{
+ Height: cs.Height,
+ Round: cs.Round,
+ Type: type_,
+ BlockHash: hash,
+ BlockParts: header,
+ }
+ err := cs.privValidator.SignVote(cs.state.ChainID, vote)
+ if err == nil {
+ log.Info("Signed and added vote", "height", cs.Height, "round", cs.Round, "vote", vote)
+ cs.addVote(cs.privValidator.Address, vote)
+ return vote
+ } else {
+ log.Warn("Error signing vote", "height", cs.Height, "round", cs.Round, "vote", vote, "error", err)
+ return nil
+ }
+}
+
+// sign a Commit-Vote
+func (cs *ConsensusState) commitVoteBlock(block *types.Block, blockParts *types.PartSet) {
+
+ // The proposal must be valid.
+ if err := cs.stageBlock(block, blockParts); err != nil {
+ // Prevent zombies.
+ log.Warn("commitVoteBlock() an invalid block", "error", err)
+ return
+ }
+
+ // Commit-vote.
+ if cs.lastCommitVoteHeight < block.Height {
+ cs.signAddVote(types.VoteTypeCommit, block.Hash(), blockParts.Header())
+ cs.lastCommitVoteHeight = block.Height
+ } else {
+ log.Error("Duplicate commitVoteBlock() attempt", "lastCommitVoteHeight", cs.lastCommitVoteHeight, "types.Height", block.Height)
+ }
+}
+
+// Save Block, save the +2/3 Commits we've seen,
+// and sign a Commit-Vote if we haven't already
+func (cs *ConsensusState) saveCommitVoteBlock(block *types.Block, blockParts *types.PartSet, commits *VoteSet) {
+
+ // The proposal must be valid.
+ if err := cs.stageBlock(block, blockParts); err != nil {
+ // Prevent zombies.
+ log.Warn("saveCommitVoteBlock() an invalid block", "error", err)
+ return
+ }
+
+ // Save to blockStore.
+ if cs.blockStore.Height() < block.Height {
+ seenValidation := commits.MakeValidation()
+ cs.blockStore.SaveBlock(block, blockParts, seenValidation)
+ }
+
+ // Save the state.
+ cs.stagedState.Save()
+
+ // Update mempool.
+ cs.mempoolReactor.Mempool.ResetForBlockAndState(block, cs.stagedState)
+
+ // Commit-vote if we haven't already.
+ if cs.lastCommitVoteHeight < block.Height {
+ cs.signAddVote(types.VoteTypeCommit, block.Hash(), blockParts.Header())
+ cs.lastCommitVoteHeight = block.Height
+ }
+}
+
+// implements events.Eventable
+func (cs *ConsensusState) SetFireable(evsw events.Fireable) {
+ cs.evsw = evsw
+}
+
+//-----------------------------------------------------------------------------
+
+// total duration of given round
+func calcRoundDuration(round uint) time.Duration {
+ return RoundDuration0 + RoundDurationDelta*time.Duration(round)
+}
+
+// startTime is when round zero started.
+func calcRoundStartTime(round uint, startTime time.Time) time.Time {
+ return startTime.Add(RoundDuration0*time.Duration(round) +
+ RoundDurationDelta*(time.Duration((int64(round)*int64(round)-int64(round))/2)))
+}
+
+// calculates the current round given startTime of round zero.
+// NOTE: round is zero if startTime is in the future.
+func calcRound(startTime time.Time) uint {
+ now := time.Now()
+ if now.Before(startTime) {
+ return 0
+ }
+ // Start + D_0 * R + D_delta * (R^2 - R)/2 <= Now; find largest integer R.
+ // D_delta * R^2 + (2D_0 - D_delta) * R + 2(Start - Now) <= 0.
+ // AR^2 + BR + C <= 0; A = D_delta, B = (2_D0 - D_delta), C = 2(Start - Now).
+ // R = Floor((-B + Sqrt(B^2 - 4AC))/2A)
+ A := float64(RoundDurationDelta)
+ B := 2.0*float64(RoundDuration0) - float64(RoundDurationDelta)
+ C := 2.0 * float64(startTime.Sub(now))
+ R := math.Floor((-B + math.Sqrt(B*B-4.0*A*C)) / (2 * A))
+ if math.IsNaN(R) {
+ panic("Could not calc round, should not happen")
+ }
+ if R > math.MaxInt32 {
+ panic(Fmt("Could not calc round, round overflow: %v", R))
+ }
+ if R < 0 {
+ return 0
+ }
+ return uint(R)
+}
+
+// convenience
+// NOTE: elapsedRatio can be negative if startTime is in the future.
+func calcRoundInfo(startTime time.Time) (round uint, roundStartTime time.Time, RoundDuration time.Duration,
+ roundElapsed time.Duration, elapsedRatio float64) {
+ round = calcRound(startTime)
+ roundStartTime = calcRoundStartTime(round, startTime)
+ RoundDuration = calcRoundDuration(round)
+ roundElapsed = time.Now().Sub(roundStartTime)
+ elapsedRatio = float64(roundElapsed) / float64(RoundDuration)
+ return
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/state_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/state_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..b85ecad9a953e57811e4969a040c959585963109
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/state_test.go
@@ -0,0 +1,209 @@
+package consensus
+
+import (
+ "bytes"
+ "testing"
+
+ _ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint_test"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+func TestSetupRound(t *testing.T) {
+ cs, privValidators := randConsensusState()
+ val0 := privValidators[0]
+
+ // Add a vote, precommit, and commit by val0.
+ voteTypes := []byte{types.VoteTypePrevote, types.VoteTypePrecommit, types.VoteTypeCommit}
+ for _, voteType := range voteTypes {
+ vote := &types.Vote{Height: 1, Round: 0, Type: voteType} // nil vote
+ err := val0.SignVote(cs.state.ChainID, vote)
+ if err != nil {
+ t.Error("Error signing vote: %v", err)
+ }
+ cs.AddVote(val0.Address, vote)
+ }
+
+ // Ensure that vote appears in RoundState.
+ rs0 := cs.GetRoundState()
+ if vote := rs0.Prevotes.GetByAddress(val0.Address); vote == nil || vote.Type != types.VoteTypePrevote {
+ t.Errorf("Expected to find prevote but got %v", vote)
+ }
+ if vote := rs0.Precommits.GetByAddress(val0.Address); vote == nil || vote.Type != types.VoteTypePrecommit {
+ t.Errorf("Expected to find precommit but got %v", vote)
+ }
+ if vote := rs0.Commits.GetByAddress(val0.Address); vote == nil || vote.Type != types.VoteTypeCommit {
+ t.Errorf("Expected to find commit but got %v", vote)
+ }
+
+ // Setup round 1 (next round)
+ cs.SetupNewRound(1, 1)
+ <-cs.NewStepCh()
+
+ // Now the commit should be copied over to prevotes and precommits.
+ rs1 := cs.GetRoundState()
+ if vote := rs1.Prevotes.GetByAddress(val0.Address); vote == nil || vote.Type != types.VoteTypeCommit {
+ t.Errorf("Expected to find commit but got %v", vote)
+ }
+ if vote := rs1.Precommits.GetByAddress(val0.Address); vote == nil || vote.Type != types.VoteTypeCommit {
+ t.Errorf("Expected to find commit but got %v", vote)
+ }
+ if vote := rs1.Commits.GetByAddress(val0.Address); vote == nil || vote.Type != types.VoteTypeCommit {
+ t.Errorf("Expected to find commit but got %v", vote)
+ }
+
+}
+
+func TestRunActionProposeNoPrivValidator(t *testing.T) {
+ cs, _ := randConsensusState()
+ cs.RunActionPropose(1, 0)
+ rs := cs.GetRoundState()
+ if rs.Proposal != nil {
+ t.Error("Expected to make no proposal, since no privValidator")
+ }
+}
+
+func TestRunActionPropose(t *testing.T) {
+ cs, privValidators := randConsensusState()
+ val0 := privValidators[0]
+ cs.SetPrivValidator(val0)
+
+ cs.RunActionPropose(1, 0)
+ rs := cs.GetRoundState()
+
+ // Check that Proposal, ProposalBlock, ProposalBlockParts are set.
+ if rs.Proposal == nil {
+ t.Error("rs.Proposal should be set")
+ }
+ if rs.ProposalBlock == nil {
+ t.Error("rs.ProposalBlock should be set")
+ }
+ if rs.ProposalBlockParts.Total() == 0 {
+ t.Error("rs.ProposalBlockParts should be set")
+ }
+}
+
+func checkRoundState(t *testing.T, rs *RoundState,
+ height uint, round uint, step RoundStepType) {
+ if rs.Height != height {
+ t.Errorf("rs.Height should be %v, got %v", height, rs.Height)
+ }
+ if rs.Round != round {
+ t.Errorf("rs.Round should be %v, got %v", round, rs.Round)
+ }
+ if rs.Step != step {
+ t.Errorf("rs.Step should be %v, got %v", step, rs.Step)
+ }
+}
+
+func TestRunActionPrecommitCommitFinalize(t *testing.T) {
+ cs, privValidators := randConsensusState()
+ val0 := privValidators[0]
+ cs.SetPrivValidator(val0)
+
+ cs.RunActionPrecommit(1, 0)
+ <-cs.NewStepCh() // TODO: test this value too.
+ if cs.Precommits.GetByAddress(val0.Address) != nil {
+ t.Errorf("RunActionPrecommit should return nil without a proposal")
+ }
+
+ cs.RunActionPropose(1, 0)
+ <-cs.NewStepCh() // TODO: test this value too.
+
+ cs.RunActionPrecommit(1, 0)
+ <-cs.NewStepCh() // TODO: test this value too.
+ if cs.Precommits.GetByAddress(val0.Address) != nil {
+ t.Errorf("RunActionPrecommit should return nil, not enough prevotes")
+ }
+
+ // Add at least +2/3 prevotes.
+ for i := 0; i < 7; i++ {
+ vote := &types.Vote{
+ Height: 1,
+ Round: 0,
+ Type: types.VoteTypePrevote,
+ BlockHash: cs.ProposalBlock.Hash(),
+ BlockParts: cs.ProposalBlockParts.Header(),
+ }
+ err := privValidators[i].SignVote(cs.state.ChainID, vote)
+ if err != nil {
+ t.Error("Error signing vote: %v", err)
+ }
+ cs.AddVote(privValidators[i].Address, vote)
+ }
+
+ // Test RunActionPrecommit success:
+ cs.RunActionPrecommit(1, 0)
+ <-cs.NewStepCh() // TODO: test this value too.
+ if cs.Precommits.GetByAddress(val0.Address) == nil {
+ t.Errorf("RunActionPrecommit should have succeeded")
+ }
+ checkRoundState(t, cs.GetRoundState(), 1, 0, RoundStepPrecommit)
+
+ // Add at least +2/3 precommits.
+ for i := 0; i < 7; i++ {
+ if bytes.Equal(privValidators[i].Address, val0.Address) {
+ if cs.Precommits.GetByAddress(val0.Address) == nil {
+ t.Errorf("Proposer should already have signed a precommit vote")
+ }
+ continue
+ }
+ vote := &types.Vote{
+ Height: 1,
+ Round: 0,
+ Type: types.VoteTypePrecommit,
+ BlockHash: cs.ProposalBlock.Hash(),
+ BlockParts: cs.ProposalBlockParts.Header(),
+ }
+ err := privValidators[i].SignVote(cs.state.ChainID, vote)
+ if err != nil {
+ t.Error("Error signing vote: %v", err)
+ }
+ added, _, err := cs.AddVote(privValidators[i].Address, vote)
+ if !added || err != nil {
+ t.Errorf("Error adding precommit: %v", err)
+ }
+ }
+
+ // Test RunActionCommit success:
+ cs.RunActionCommit(1)
+ <-cs.NewStepCh() // TODO: test this value too.
+ if cs.Commits.GetByAddress(val0.Address) == nil {
+ t.Errorf("RunActionCommit should have succeeded")
+ }
+ checkRoundState(t, cs.GetRoundState(), 1, 0, RoundStepCommit)
+
+ // cs.CommitTime should still be zero
+ if !cs.CommitTime.IsZero() {
+ t.Errorf("Expected CommitTime to yet be zero")
+ }
+
+ // Add at least +2/3 commits.
+ for i := 0; i < 7; i++ {
+ if bytes.Equal(privValidators[i].Address, val0.Address) {
+ if cs.Commits.GetByAddress(val0.Address) == nil {
+ t.Errorf("Proposer should already have signed a commit vote")
+ }
+ continue
+ }
+ vote := &types.Vote{
+ Height: 1,
+ Round: uint(i), // Doesn't matter what round
+ Type: types.VoteTypeCommit,
+ BlockHash: cs.ProposalBlock.Hash(),
+ BlockParts: cs.ProposalBlockParts.Header(),
+ }
+ err := privValidators[i].SignVote(cs.state.ChainID, vote)
+ if err != nil {
+ t.Error("Error signing vote: %v", err)
+ }
+ added, _, err := cs.AddVote(privValidators[i].Address, vote)
+ if !added || err != nil {
+ t.Errorf("Error adding commit: %v", err)
+ }
+ }
+
+ // Test TryFinalizeCommit:
+ cs.TryFinalizeCommit(1)
+ <-cs.NewStepCh() // TODO: test this value too.
+ checkRoundState(t, cs.GetRoundState(), 2, 0, RoundStepNewHeight)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/test.go
new file mode 100644
index 0000000000000000000000000000000000000000..4ddf544b6b5819ca2c45a2fb8989b463f103e0d3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/test.go
@@ -0,0 +1,32 @@
+package consensus
+
+import (
+ "sort"
+
+ bc "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain"
+ dbm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/db"
+ mempl "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool"
+ sm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+)
+
+func randConsensusState() (*ConsensusState, []*sm.PrivValidator) {
+ state, _, privValidators := sm.RandGenesisState(20, false, 1000, 10, false, 1000)
+ blockStore := bc.NewBlockStore(dbm.NewMemDB())
+ mempool := mempl.NewMempool(state)
+ mempoolReactor := mempl.NewMempoolReactor(mempool)
+ cs := NewConsensusState(state, blockStore, mempoolReactor)
+ return cs, privValidators
+}
+
+func randVoteSet(height uint, round uint, type_ byte, numValidators int, votingPower uint64) (*VoteSet, *sm.ValidatorSet, []*sm.PrivValidator) {
+ vals := make([]*sm.Validator, numValidators)
+ privValidators := make([]*sm.PrivValidator, numValidators)
+ for i := 0; i < numValidators; i++ {
+ _, val, privValidator := sm.RandValidator(false, votingPower)
+ vals[i] = val
+ privValidators[i] = privValidator
+ }
+ valSet := sm.NewValidatorSet(vals)
+ sort.Sort(sm.PrivValidatorsByAddress(privValidators))
+ return NewVoteSet(height, round, type_, valSet), valSet, privValidators
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/types/config.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/types/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..a9f0e602e3812fe9dd8315354bc68eddec41ccd0
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/types/config.go
@@ -0,0 +1,13 @@
+package consensus
+
+import (
+ cfg "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config"
+)
+
+var config cfg.Config = nil
+
+func init() {
+ cfg.OnConfig(func(newConfig cfg.Config) {
+ config = newConfig
+ })
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/types/proposal.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/types/proposal.go
new file mode 100644
index 0000000000000000000000000000000000000000..2d5ab7e6d5cb2b6141cde0fae9879ed2b44d00ff
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/types/proposal.go
@@ -0,0 +1,48 @@
+package consensus
+
+import (
+ "errors"
+ "fmt"
+ "io"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+var (
+ ErrInvalidBlockPartSignature = errors.New("Error invalid block part signature")
+ ErrInvalidBlockPartHash = errors.New("Error invalid block part hash")
+)
+
+type Proposal struct {
+ Height uint `json:"height"`
+ Round uint `json:"round"`
+ BlockParts types.PartSetHeader `json:"block_parts"`
+ POLParts types.PartSetHeader `json:"pol_parts"`
+ Signature account.SignatureEd25519 `json:"signature"`
+}
+
+func NewProposal(height uint, round uint, blockParts, polParts types.PartSetHeader) *Proposal {
+ return &Proposal{
+ Height: height,
+ Round: round,
+ BlockParts: blockParts,
+ POLParts: polParts,
+ }
+}
+
+func (p *Proposal) String() string {
+ return fmt.Sprintf("Proposal{%v/%v %v %v %v}", p.Height, p.Round,
+ p.BlockParts, p.POLParts, p.Signature)
+}
+
+func (p *Proposal) WriteSignBytes(chainID string, w io.Writer, n *int64, err *error) {
+ binary.WriteTo([]byte(Fmt(`{"chain_id":"%s"`, chainID)), w, n, err)
+ binary.WriteTo([]byte(`,"proposal":{"block_parts":`), w, n, err)
+ p.BlockParts.WriteSignBytes(w, n, err)
+ binary.WriteTo([]byte(Fmt(`,"height":%v,"pol_parts":`, p.Height)), w, n, err)
+ p.POLParts.WriteSignBytes(w, n, err)
+ binary.WriteTo([]byte(Fmt(`,"round":%v}}`, p.Round)), w, n, err)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/types/proposal_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/types/proposal_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..314349659f0e2a612da7ad2ac54efc0e1980af88
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/types/proposal_test.go
@@ -0,0 +1,27 @@
+package consensus
+
+import (
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ _ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint_test"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+func TestProposalSignable(t *testing.T) {
+ proposal := &Proposal{
+ Height: 12345,
+ Round: 23456,
+ BlockParts: types.PartSetHeader{111, []byte("blockparts")},
+ POLParts: types.PartSetHeader{222, []byte("polparts")},
+ Signature: nil,
+ }
+ signBytes := account.SignBytes(config.GetString("chain_id"), proposal)
+ signStr := string(signBytes)
+ expected := Fmt(`{"chain_id":"%s","proposal":{"block_parts":{"hash":"626C6F636B7061727473","total":111},"height":12345,"pol_parts":{"hash":"706F6C7061727473","total":222},"round":23456}}`,
+ config.GetString("chain_id"))
+ if signStr != expected {
+ t.Errorf("Got unexpected sign string for SendTx. Expected:\n%v\nGot:\n%v", expected, signStr)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/vote_set.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/vote_set.go
new file mode 100644
index 0000000000000000000000000000000000000000..5fc76115895c988c1512b5dbc6c87f6ce778615c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/vote_set.go
@@ -0,0 +1,293 @@
+package consensus
+
+import (
+ "bytes"
+ "fmt"
+ "strings"
+ "sync"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ sm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+// VoteSet helps collect signatures from validators at each height+round
+// for a predefined vote type.
+// Note that there three kinds of votes: prevotes, precommits, and commits.
+// A commit of prior rounds can be added added in lieu of votes/precommits.
+// NOTE: Assumes that the sum total of voting power does not exceed MaxUInt64.
+type VoteSet struct {
+ height uint
+ round uint
+ type_ byte
+
+ mtx sync.Mutex
+ valSet *sm.ValidatorSet
+ votes []*types.Vote // validator index -> vote
+ votesBitArray *BitArray // validator index -> has vote?
+ votesByBlock map[string]uint64 // string(blockHash)+string(blockParts) -> vote sum.
+ totalVotes uint64
+ maj23Hash []byte
+ maj23Parts types.PartSetHeader
+ maj23Exists bool
+}
+
+// Constructs a new VoteSet struct used to accumulate votes for given height/round.
+func NewVoteSet(height uint, round uint, type_ byte, valSet *sm.ValidatorSet) *VoteSet {
+ if height == 0 {
+ panic("Cannot make VoteSet for height == 0, doesn't make sense.")
+ }
+ if type_ == types.VoteTypeCommit && round != 0 {
+ panic("Expected round 0 for commit vote set")
+ }
+ return &VoteSet{
+ height: height,
+ round: round,
+ type_: type_,
+ valSet: valSet,
+ votes: make([]*types.Vote, valSet.Size()),
+ votesBitArray: NewBitArray(valSet.Size()),
+ votesByBlock: make(map[string]uint64),
+ totalVotes: 0,
+ }
+}
+
+func (voteSet *VoteSet) Height() uint {
+ if voteSet == nil {
+ return 0
+ } else {
+ return voteSet.height
+ }
+}
+
+func (voteSet *VoteSet) Size() uint {
+ if voteSet == nil {
+ return 0
+ } else {
+ return voteSet.valSet.Size()
+ }
+}
+
+// True if added, false if not.
+// Returns ErrVote[UnexpectedStep|InvalidAccount|InvalidSignature|InvalidBlockHash|ConflictingSignature]
+// NOTE: vote should not be mutated after adding.
+// Returns the validator index of the vote unless error is set.
+func (voteSet *VoteSet) Add(address []byte, vote *types.Vote) (bool, uint, error) {
+ voteSet.mtx.Lock()
+ defer voteSet.mtx.Unlock()
+
+ // Make sure the step matches. (or that vote is commit && round < voteSet.round)
+ if vote.Height != voteSet.height ||
+ (vote.Type != types.VoteTypeCommit && vote.Round != voteSet.round) ||
+ (vote.Type != types.VoteTypeCommit && vote.Type != voteSet.type_) ||
+ (vote.Type == types.VoteTypeCommit && voteSet.type_ != types.VoteTypeCommit && vote.Round >= voteSet.round) {
+ return false, 0, types.ErrVoteUnexpectedStep
+ }
+
+ // Ensure that signer is a validator.
+ valIndex, val := voteSet.valSet.GetByAddress(address)
+ if val == nil {
+ return false, 0, types.ErrVoteInvalidAccount
+ }
+
+ // Check signature.
+ if !val.PubKey.VerifyBytes(account.SignBytes(config.GetString("chain_id"), vote), vote.Signature) {
+ // Bad signature.
+ return false, 0, types.ErrVoteInvalidSignature
+ }
+
+ return voteSet.addVote(valIndex, vote)
+}
+
+func (voteSet *VoteSet) addVote(valIndex uint, vote *types.Vote) (bool, uint, error) {
+ // If vote already exists, return false.
+ if existingVote := voteSet.votes[valIndex]; existingVote != nil {
+ if bytes.Equal(existingVote.BlockHash, vote.BlockHash) {
+ return false, valIndex, nil
+ } else {
+ return false, valIndex, &types.ErrVoteConflictingSignature{
+ VoteA: existingVote,
+ VoteB: vote,
+ }
+ }
+ }
+
+ // Add vote.
+ _, val := voteSet.valSet.GetByIndex(valIndex)
+ if val == nil {
+ panic(fmt.Sprintf("Missing validator for index %v", valIndex))
+ }
+ voteSet.votes[valIndex] = vote
+ voteSet.votesBitArray.SetIndex(valIndex, true)
+ blockKey := string(vote.BlockHash) + string(binary.BinaryBytes(vote.BlockParts))
+ totalBlockHashVotes := voteSet.votesByBlock[blockKey] + val.VotingPower
+ voteSet.votesByBlock[blockKey] = totalBlockHashVotes
+ voteSet.totalVotes += val.VotingPower
+
+ // If we just nudged it up to two thirds majority, add it.
+ if totalBlockHashVotes > voteSet.valSet.TotalVotingPower()*2/3 &&
+ (totalBlockHashVotes-val.VotingPower) <= voteSet.valSet.TotalVotingPower()*2/3 {
+ voteSet.maj23Hash = vote.BlockHash
+ voteSet.maj23Parts = vote.BlockParts
+ voteSet.maj23Exists = true
+ }
+
+ return true, valIndex, nil
+}
+
+// Assumes that commits VoteSet is valid.
+func (voteSet *VoteSet) AddFromCommits(commits *VoteSet) {
+ for valIndex, commit := range commits.votes {
+ if commit == nil {
+ continue
+ }
+ if commit.Round < voteSet.round {
+ voteSet.addVote(uint(valIndex), commit)
+ }
+ }
+}
+
+func (voteSet *VoteSet) BitArray() *BitArray {
+ if voteSet == nil {
+ return nil
+ }
+ voteSet.mtx.Lock()
+ defer voteSet.mtx.Unlock()
+ return voteSet.votesBitArray.Copy()
+}
+
+func (voteSet *VoteSet) GetByIndex(valIndex uint) *types.Vote {
+ voteSet.mtx.Lock()
+ defer voteSet.mtx.Unlock()
+ return voteSet.votes[valIndex]
+}
+
+func (voteSet *VoteSet) GetByAddress(address []byte) *types.Vote {
+ voteSet.mtx.Lock()
+ defer voteSet.mtx.Unlock()
+ valIndex, val := voteSet.valSet.GetByAddress(address)
+ if val == nil {
+ panic("GetByAddress(address) returned nil")
+ }
+ return voteSet.votes[valIndex]
+}
+
+func (voteSet *VoteSet) HasTwoThirdsMajority() bool {
+ if voteSet == nil {
+ return false
+ }
+ voteSet.mtx.Lock()
+ defer voteSet.mtx.Unlock()
+ return voteSet.maj23Exists
+}
+
+// Returns either a blockhash (or nil) that received +2/3 majority.
+// If there exists no such majority, returns (nil, false).
+func (voteSet *VoteSet) TwoThirdsMajority() (hash []byte, parts types.PartSetHeader, ok bool) {
+ voteSet.mtx.Lock()
+ defer voteSet.mtx.Unlock()
+ if voteSet.maj23Exists {
+ return voteSet.maj23Hash, voteSet.maj23Parts, true
+ } else {
+ return nil, types.PartSetHeader{}, false
+ }
+}
+
+func (voteSet *VoteSet) MakePOL() *POL {
+ if voteSet.type_ != types.VoteTypePrevote {
+ panic("Cannot MakePOL() unless VoteSet.Type is types.VoteTypePrevote")
+ }
+ voteSet.mtx.Lock()
+ defer voteSet.mtx.Unlock()
+ if !voteSet.maj23Exists {
+ return nil
+ }
+ pol := &POL{
+ Height: voteSet.height,
+ Round: voteSet.round,
+ BlockHash: voteSet.maj23Hash,
+ BlockParts: voteSet.maj23Parts,
+ Votes: make([]POLVoteSignature, voteSet.valSet.Size()),
+ }
+ for valIndex, vote := range voteSet.votes {
+ if vote == nil {
+ continue
+ }
+ if !bytes.Equal(vote.BlockHash, voteSet.maj23Hash) {
+ continue
+ }
+ if !vote.BlockParts.Equals(voteSet.maj23Parts) {
+ continue
+ }
+ pol.Votes[valIndex] = POLVoteSignature{
+ Round: vote.Round,
+ Signature: vote.Signature,
+ }
+ }
+ return pol
+}
+
+func (voteSet *VoteSet) MakeValidation() *types.Validation {
+ if voteSet.type_ != types.VoteTypeCommit {
+ panic("Cannot MakeValidation() unless VoteSet.Type is types.VoteTypeCommit")
+ }
+ voteSet.mtx.Lock()
+ defer voteSet.mtx.Unlock()
+ if len(voteSet.maj23Hash) == 0 {
+ panic("Cannot MakeValidation() unless a blockhash has +2/3")
+ }
+ commits := make([]types.Commit, voteSet.valSet.Size())
+ voteSet.valSet.Iterate(func(valIndex uint, val *sm.Validator) bool {
+ vote := voteSet.votes[valIndex]
+ if vote == nil {
+ return false
+ }
+ if !bytes.Equal(vote.BlockHash, voteSet.maj23Hash) {
+ return false
+ }
+ if !vote.BlockParts.Equals(voteSet.maj23Parts) {
+ return false
+ }
+ commits[valIndex] = types.Commit{val.Address, vote.Round, vote.Signature}
+ return false
+ })
+ return &types.Validation{
+ Commits: commits,
+ }
+}
+
+func (voteSet *VoteSet) String() string {
+ return voteSet.StringIndented("")
+}
+
+func (voteSet *VoteSet) StringIndented(indent string) string {
+ voteStrings := make([]string, len(voteSet.votes))
+ for i, vote := range voteSet.votes {
+ if vote == nil {
+ voteStrings[i] = "nil-Vote"
+ } else {
+ voteStrings[i] = vote.String()
+ }
+ }
+ return fmt.Sprintf(`VoteSet{
+%s H:%v R:%v T:%v
+%s %v
+%s %v
+%s}`,
+ indent, voteSet.height, voteSet.round, voteSet.type_,
+ indent, strings.Join(voteStrings, "\n"+indent+" "),
+ indent, voteSet.votesBitArray,
+ indent)
+}
+
+func (voteSet *VoteSet) StringShort() string {
+ if voteSet == nil {
+ return "nil-VoteSet"
+ }
+ voteSet.mtx.Lock()
+ defer voteSet.mtx.Unlock()
+ return fmt.Sprintf(`VoteSet{H:%v R:%v T:%v +2/3:%v %v}`,
+ voteSet.height, voteSet.round, voteSet.type_, voteSet.maj23Exists, voteSet.votesBitArray)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/vote_set_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/vote_set_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..07915f9e01bc7e8ee694812edd0b1ad74c813388
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/vote_set_test.go
@@ -0,0 +1,325 @@
+package consensus
+
+import (
+ "bytes"
+
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common/test"
+ _ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint_test"
+ sm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+
+ "testing"
+)
+
+// NOTE: see consensus/test.go for common test methods.
+
+// Convenience: Return new vote with different height
+func withHeight(vote *types.Vote, height uint) *types.Vote {
+ vote = vote.Copy()
+ vote.Height = height
+ return vote
+}
+
+// Convenience: Return new vote with different round
+func withRound(vote *types.Vote, round uint) *types.Vote {
+ vote = vote.Copy()
+ vote.Round = round
+ return vote
+}
+
+// Convenience: Return new vote with different type
+func withType(vote *types.Vote, type_ byte) *types.Vote {
+ vote = vote.Copy()
+ vote.Type = type_
+ return vote
+}
+
+// Convenience: Return new vote with different blockHash
+func withBlockHash(vote *types.Vote, blockHash []byte) *types.Vote {
+ vote = vote.Copy()
+ vote.BlockHash = blockHash
+ return vote
+}
+
+// Convenience: Return new vote with different blockParts
+func withBlockParts(vote *types.Vote, blockParts types.PartSetHeader) *types.Vote {
+ vote = vote.Copy()
+ vote.BlockParts = blockParts
+ return vote
+}
+
+func signAddVote(privVal *sm.PrivValidator, vote *types.Vote, voteSet *VoteSet) (bool, error) {
+ privVal.SignVoteUnsafe(config.GetString("chain_id"), vote)
+ added, _, err := voteSet.Add(privVal.Address, vote)
+ return added, err
+}
+
+func TestAddVote(t *testing.T) {
+ height, round := uint(1), uint(0)
+ voteSet, _, privValidators := randVoteSet(height, round, types.VoteTypePrevote, 10, 1)
+ val0 := privValidators[0]
+
+ // t.Logf(">> %v", voteSet)
+
+ if voteSet.GetByAddress(val0.Address) != nil {
+ t.Errorf("Expected GetByAddress(val0.Address) to be nil")
+ }
+ if voteSet.BitArray().GetIndex(0) {
+ t.Errorf("Expected BitArray.GetIndex(0) to be false")
+ }
+ hash, header, ok := voteSet.TwoThirdsMajority()
+ if hash != nil || !header.IsZero() || ok {
+ t.Errorf("There should be no 2/3 majority")
+ }
+
+ vote := &types.Vote{Height: height, Round: round, Type: types.VoteTypePrevote, BlockHash: nil}
+ signAddVote(val0, vote, voteSet)
+
+ if voteSet.GetByAddress(val0.Address) == nil {
+ t.Errorf("Expected GetByAddress(val0.Address) to be present")
+ }
+ if !voteSet.BitArray().GetIndex(0) {
+ t.Errorf("Expected BitArray.GetIndex(0) to be true")
+ }
+ hash, header, ok = voteSet.TwoThirdsMajority()
+ if hash != nil || !header.IsZero() || ok {
+ t.Errorf("There should be no 2/3 majority")
+ }
+}
+
+func Test2_3Majority(t *testing.T) {
+ height, round := uint(1), uint(0)
+ voteSet, _, privValidators := randVoteSet(height, round, types.VoteTypePrevote, 10, 1)
+
+ vote := &types.Vote{Height: height, Round: round, Type: types.VoteTypePrevote, BlockHash: nil}
+
+ // 6 out of 10 voted for nil.
+ for i := 0; i < 6; i++ {
+ signAddVote(privValidators[i], vote, voteSet)
+ }
+ hash, header, ok := voteSet.TwoThirdsMajority()
+ if hash != nil || !header.IsZero() || ok {
+ t.Errorf("There should be no 2/3 majority")
+ }
+
+ // 7th validator voted for some blockhash
+ {
+ signAddVote(privValidators[6], withBlockHash(vote, RandBytes(32)), voteSet)
+ hash, header, ok = voteSet.TwoThirdsMajority()
+ if hash != nil || !header.IsZero() || ok {
+ t.Errorf("There should be no 2/3 majority")
+ }
+ }
+
+ // 8th validator voted for nil.
+ {
+ signAddVote(privValidators[7], vote, voteSet)
+ hash, header, ok = voteSet.TwoThirdsMajority()
+ if hash != nil || !header.IsZero() || !ok {
+ t.Errorf("There should be 2/3 majority for nil")
+ }
+ }
+}
+
+func Test2_3MajorityRedux(t *testing.T) {
+ height, round := uint(1), uint(0)
+ voteSet, _, privValidators := randVoteSet(height, round, types.VoteTypePrevote, 100, 1)
+
+ blockHash := CRandBytes(32)
+ blockPartsTotal := uint(123)
+ blockParts := types.PartSetHeader{blockPartsTotal, CRandBytes(32)}
+
+ vote := &types.Vote{Height: height, Round: round, Type: types.VoteTypePrevote, BlockHash: blockHash, BlockParts: blockParts}
+
+ // 66 out of 100 voted for nil.
+ for i := 0; i < 66; i++ {
+ signAddVote(privValidators[i], vote, voteSet)
+ }
+ hash, header, ok := voteSet.TwoThirdsMajority()
+ if hash != nil || !header.IsZero() || ok {
+ t.Errorf("There should be no 2/3 majority")
+ }
+
+ // 67th validator voted for nil
+ {
+ signAddVote(privValidators[66], withBlockHash(vote, nil), voteSet)
+ hash, header, ok = voteSet.TwoThirdsMajority()
+ if hash != nil || !header.IsZero() || ok {
+ t.Errorf("There should be no 2/3 majority: last vote added was nil")
+ }
+ }
+
+ // 68th validator voted for a different BlockParts PartSetHeader
+ {
+ blockParts := types.PartSetHeader{blockPartsTotal, CRandBytes(32)}
+ signAddVote(privValidators[67], withBlockParts(vote, blockParts), voteSet)
+ hash, header, ok = voteSet.TwoThirdsMajority()
+ if hash != nil || !header.IsZero() || ok {
+ t.Errorf("There should be no 2/3 majority: last vote added had different PartSetHeader Hash")
+ }
+ }
+
+ // 69th validator voted for different BlockParts Total
+ {
+ blockParts := types.PartSetHeader{blockPartsTotal + 1, blockParts.Hash}
+ signAddVote(privValidators[68], withBlockParts(vote, blockParts), voteSet)
+ hash, header, ok = voteSet.TwoThirdsMajority()
+ if hash != nil || !header.IsZero() || ok {
+ t.Errorf("There should be no 2/3 majority: last vote added had different PartSetHeader Total")
+ }
+ }
+
+ // 70th validator voted for different BlockHash
+ {
+ signAddVote(privValidators[69], withBlockHash(vote, RandBytes(32)), voteSet)
+ hash, header, ok = voteSet.TwoThirdsMajority()
+ if hash != nil || !header.IsZero() || ok {
+ t.Errorf("There should be no 2/3 majority: last vote added had different BlockHash")
+ }
+ }
+
+ // 71st validator voted for the right BlockHash & BlockParts
+ {
+ signAddVote(privValidators[70], vote, voteSet)
+ hash, header, ok = voteSet.TwoThirdsMajority()
+ if !bytes.Equal(hash, blockHash) || !header.Equals(blockParts) || !ok {
+ t.Errorf("There should be 2/3 majority")
+ }
+ }
+}
+
+func TestBadVotes(t *testing.T) {
+ height, round := uint(1), uint(0)
+ voteSet, _, privValidators := randVoteSet(height, round, types.VoteTypePrevote, 10, 1)
+
+ // val0 votes for nil.
+ vote := &types.Vote{Height: height, Round: round, Type: types.VoteTypePrevote, BlockHash: nil}
+ added, err := signAddVote(privValidators[0], vote, voteSet)
+ if !added || err != nil {
+ t.Errorf("Expected Add() to succeed")
+ }
+
+ // val0 votes again for some block.
+ added, err = signAddVote(privValidators[0], withBlockHash(vote, RandBytes(32)), voteSet)
+ if added || err == nil {
+ t.Errorf("Expected Add() to fail, dupeout.")
+ }
+
+ // val1 votes on another height
+ added, err = signAddVote(privValidators[1], withHeight(vote, height+1), voteSet)
+ if added {
+ t.Errorf("Expected Add() to fail, wrong height")
+ }
+
+ // val2 votes on another round
+ added, err = signAddVote(privValidators[2], withRound(vote, round+1), voteSet)
+ if added {
+ t.Errorf("Expected Add() to fail, wrong round")
+ }
+
+ // val3 votes of another type.
+ added, err = signAddVote(privValidators[3], withType(vote, types.VoteTypePrecommit), voteSet)
+ if added {
+ t.Errorf("Expected Add() to fail, wrong type")
+ }
+}
+
+func TestAddCommitsToPrevoteVotes(t *testing.T) {
+ height, round := uint(2), uint(5)
+ voteSet, _, privValidators := randVoteSet(height, round, types.VoteTypePrevote, 10, 1)
+
+ // val0, val1, val2, val3, val4, val5 vote for nil.
+ vote := &types.Vote{Height: height, Round: round, Type: types.VoteTypePrevote, BlockHash: nil}
+ for i := 0; i < 6; i++ {
+ signAddVote(privValidators[i], vote, voteSet)
+ }
+ hash, header, ok := voteSet.TwoThirdsMajority()
+ if hash != nil || !header.IsZero() || ok {
+ t.Errorf("There should be no 2/3 majority")
+ }
+
+ // Attempt to add a commit from val6 at a previous height
+ vote = &types.Vote{Height: height - 1, Round: round, Type: types.VoteTypeCommit, BlockHash: nil}
+ added, _ := signAddVote(privValidators[6], vote, voteSet)
+ if added {
+ t.Errorf("Expected Add() to fail, wrong height.")
+ }
+
+ // Attempt to add a commit from val6 at a later round
+ vote = &types.Vote{Height: height, Round: round + 1, Type: types.VoteTypeCommit, BlockHash: nil}
+ added, _ = signAddVote(privValidators[6], vote, voteSet)
+ if added {
+ t.Errorf("Expected Add() to fail, cannot add future round vote.")
+ }
+
+ // Attempt to add a commit from val6 for currrent height/round.
+ vote = &types.Vote{Height: height, Round: round, Type: types.VoteTypeCommit, BlockHash: nil}
+ added, err := signAddVote(privValidators[6], vote, voteSet)
+ if added || err == nil {
+ t.Errorf("Expected Add() to fail, only prior round commits can be added.")
+ }
+
+ // Add commit from val6 at a previous round
+ vote = &types.Vote{Height: height, Round: round - 1, Type: types.VoteTypeCommit, BlockHash: nil}
+ added, err = signAddVote(privValidators[6], vote, voteSet)
+ if !added || err != nil {
+ t.Errorf("Expected Add() to succeed, commit for prior rounds are relevant.")
+ }
+
+ // Also add commit from val7 for previous round.
+ vote = &types.Vote{Height: height, Round: round - 2, Type: types.VoteTypeCommit, BlockHash: nil}
+ added, err = signAddVote(privValidators[7], vote, voteSet)
+ if !added || err != nil {
+ t.Errorf("Expected Add() to succeed. err: %v", err)
+ }
+
+ // We should have 2/3 majority
+ hash, header, ok = voteSet.TwoThirdsMajority()
+ if hash != nil || !header.IsZero() || !ok {
+ t.Errorf("There should be 2/3 majority for nil")
+ }
+
+}
+
+func TestMakeValidation(t *testing.T) {
+ height, round := uint(1), uint(0)
+ voteSet, _, privValidators := randVoteSet(height, round, types.VoteTypeCommit, 10, 1)
+ blockHash, blockParts := CRandBytes(32), types.PartSetHeader{123, CRandBytes(32)}
+
+ vote := &types.Vote{Height: height, Round: round, Type: types.VoteTypeCommit,
+ BlockHash: blockHash, BlockParts: blockParts}
+
+ // 6 out of 10 voted for some block.
+ for i := 0; i < 6; i++ {
+ signAddVote(privValidators[i], vote, voteSet)
+ }
+
+ // MakeValidation should fail.
+ AssertPanics(t, "Doesn't have +2/3 majority", func() { voteSet.MakeValidation() })
+
+ // 7th voted for some other block.
+ {
+ vote := withBlockHash(vote, RandBytes(32))
+ vote = withBlockParts(vote, types.PartSetHeader{123, RandBytes(32)})
+ signAddVote(privValidators[6], vote, voteSet)
+ }
+
+ // The 8th voted like everyone else.
+ {
+ signAddVote(privValidators[7], vote, voteSet)
+ }
+
+ validation := voteSet.MakeValidation()
+
+ // Validation should have 10 elements
+ if len(validation.Commits) != 10 {
+ t.Errorf("Validation Commits should have the same number of commits as validators")
+ }
+
+ // Ensure that Validation commits are ordered.
+ if err := validation.ValidateBasic(); err != nil {
+ t.Errorf("Error in Validation.ValidateBasic(): %v", err)
+ }
+
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/db/config.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/db/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..2a2934ffca193e66f13cf87f8036a55a1637cea9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/db/config.go
@@ -0,0 +1,13 @@
+package db
+
+import (
+ cfg "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config"
+)
+
+var config cfg.Config = nil
+
+func init() {
+ cfg.OnConfig(func(newConfig cfg.Config) {
+ config = newConfig
+ })
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/db/db.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/db/db.go
new file mode 100644
index 0000000000000000000000000000000000000000..f27e4c21eb74a8de5b318259f56c95db647e0905
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/db/db.go
@@ -0,0 +1,49 @@
+package db
+
+import (
+ "path"
+
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+type DB interface {
+ Get([]byte) []byte
+ Set([]byte, []byte)
+ SetSync([]byte, []byte)
+ Delete([]byte)
+ DeleteSync([]byte)
+ Close()
+
+ // For debugging
+ Print()
+}
+
+//-----------------------------------------------------------------------------
+
+// Database types
+const DBBackendMemDB = "memdb"
+const DBBackendLevelDB = "leveldb"
+
+var dbs = NewCMap()
+
+func GetDB(name string) DB {
+ db := dbs.Get(name)
+ if db != nil {
+ return db.(DB)
+ }
+ switch config.GetString("db_backend") {
+ case DBBackendMemDB:
+ db := NewMemDB()
+ dbs.Set(name, db)
+ return db
+ case DBBackendLevelDB:
+ db, err := NewLevelDB(path.Join(config.GetString("db_dir"), name+".db"))
+ if err != nil {
+ panic(err)
+ }
+ dbs.Set(name, db)
+ return db
+ default:
+ panic(Fmt("Unknown DB backend: %v", config.GetString("db_backend")))
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/db/level_db.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/db/level_db.go
new file mode 100644
index 0000000000000000000000000000000000000000..0bf65f42549e7fd32e4b920326059a30cc70c0b0
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/db/level_db.go
@@ -0,0 +1,80 @@
+package db
+
+import (
+ "fmt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
+ "path"
+)
+
+type LevelDB struct {
+ db *leveldb.DB
+}
+
+func NewLevelDB(name string) (*LevelDB, error) {
+ dbPath := path.Join(name)
+ db, err := leveldb.OpenFile(dbPath, nil)
+ if err != nil {
+ return nil, err
+ }
+ database := &LevelDB{db: db}
+ return database, nil
+}
+
+func (db *LevelDB) Get(key []byte) []byte {
+ res, err := db.db.Get(key, nil)
+ if err != nil {
+ if err == errors.ErrNotFound {
+ return nil
+ } else {
+ panic(err)
+ }
+ }
+ return res
+}
+
+func (db *LevelDB) Set(key []byte, value []byte) {
+ err := db.db.Put(key, value, nil)
+ if err != nil {
+ panic(err)
+ }
+}
+
+func (db *LevelDB) SetSync(key []byte, value []byte) {
+ err := db.db.Put(key, value, &opt.WriteOptions{Sync: true})
+ if err != nil {
+ panic(err)
+ }
+}
+
+func (db *LevelDB) Delete(key []byte) {
+ err := db.db.Delete(key, nil)
+ if err != nil {
+ panic(err)
+ }
+}
+
+func (db *LevelDB) DeleteSync(key []byte) {
+ err := db.db.Delete(key, &opt.WriteOptions{Sync: true})
+ if err != nil {
+ panic(err)
+ }
+}
+
+func (db *LevelDB) DB() *leveldb.DB {
+ return db.db
+}
+
+func (db *LevelDB) Close() {
+ db.db.Close()
+}
+
+func (db *LevelDB) Print() {
+ iter := db.db.NewIterator(nil, nil)
+ for iter.Next() {
+ key := iter.Key()
+ value := iter.Value()
+ fmt.Printf("[%X]:\t[%X]\n", key, value)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/db/mem_db.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/db/mem_db.go
new file mode 100644
index 0000000000000000000000000000000000000000..b7d8918d4ca3c72687044f2dcd006699a43d5bae
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/db/mem_db.go
@@ -0,0 +1,44 @@
+package db
+
+import (
+ "fmt"
+)
+
+type MemDB struct {
+ db map[string][]byte
+}
+
+func NewMemDB() *MemDB {
+ database := &MemDB{db: make(map[string][]byte)}
+ return database
+}
+
+func (db *MemDB) Get(key []byte) []byte {
+ return db.db[string(key)]
+}
+
+func (db *MemDB) Set(key []byte, value []byte) {
+ db.db[string(key)] = value
+}
+
+func (db *MemDB) SetSync(key []byte, value []byte) {
+ db.db[string(key)] = value
+}
+
+func (db *MemDB) Delete(key []byte) {
+ delete(db.db, string(key))
+}
+
+func (db *MemDB) DeleteSync(key []byte) {
+ delete(db.db, string(key))
+}
+
+func (db *MemDB) Close() {
+ db = nil
+}
+
+func (db *MemDB) Print() {
+ for key, value := range db.db {
+ fmt.Printf("[%X]:\t[%X]\n", []byte(key), value)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/events/event_cache.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/events/event_cache.go
new file mode 100644
index 0000000000000000000000000000000000000000..3231fe0d41006b77d8476689f022925643ee1124
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/events/event_cache.go
@@ -0,0 +1,41 @@
+package events
+
+const (
+ eventsBufferSize = 1000
+)
+
+// An EventCache buffers events for a Fireable
+// All events are cached. Filtering happens on Flush
+type EventCache struct {
+ evsw Fireable
+ events []eventInfo
+}
+
+// Create a new EventCache with an EventSwitch as backend
+func NewEventCache(evsw Fireable) *EventCache {
+ return &EventCache{
+ evsw: evsw,
+ events: make([]eventInfo, eventsBufferSize),
+ }
+}
+
+// a cached event
+type eventInfo struct {
+ event string
+ msg interface{}
+}
+
+// Cache an event to be fired upon finality.
+func (evc *EventCache) FireEvent(event string, msg interface{}) {
+ // append to list
+ evc.events = append(evc.events, eventInfo{event, msg})
+}
+
+// Fire events by running evsw.FireEvent on all cached events. Blocks.
+// Clears cached events
+func (evc *EventCache) Flush() {
+ for _, ei := range evc.events {
+ evc.evsw.FireEvent(ei.event, ei.msg)
+ }
+ evc.events = make([]eventInfo, eventsBufferSize)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/events/events.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/events/events.go
new file mode 100644
index 0000000000000000000000000000000000000000..13aca2dac8e26184893f7c8444a6f98c8bd0733e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/events/events.go
@@ -0,0 +1,200 @@
+package events
+
+import (
+ "sync"
+ "sync/atomic"
+)
+
+// reactors and other modules should export
+// this interface to become eventable
+type Eventable interface {
+ SetFireable(Fireable)
+}
+
+// an event switch or cache implements fireable
+type Fireable interface {
+ FireEvent(event string, msg interface{})
+}
+
+type EventSwitch struct {
+ mtx sync.RWMutex
+ eventCells map[string]*eventCell
+ listeners map[string]*eventListener
+ running uint32
+ quit chan struct{}
+}
+
+func (evsw *EventSwitch) Start() {
+ if atomic.CompareAndSwapUint32(&evsw.running, 0, 1) {
+ evsw.eventCells = make(map[string]*eventCell)
+ evsw.listeners = make(map[string]*eventListener)
+ evsw.quit = make(chan struct{})
+ }
+}
+
+func (evsw *EventSwitch) Stop() {
+ if atomic.CompareAndSwapUint32(&evsw.running, 1, 0) {
+ evsw.eventCells = nil
+ evsw.listeners = nil
+ close(evsw.quit)
+ }
+}
+
+func (evsw *EventSwitch) AddListenerForEvent(listenerId, event string, cb eventCallback) {
+ // Get/Create eventCell and listener
+ evsw.mtx.Lock()
+ eventCell := evsw.eventCells[event]
+ if eventCell == nil {
+ eventCell = newEventCell()
+ evsw.eventCells[event] = eventCell
+ }
+ listener := evsw.listeners[listenerId]
+ if listener == nil {
+ listener = newEventListener(listenerId)
+ evsw.listeners[listenerId] = listener
+ }
+ evsw.mtx.Unlock()
+
+ // Add event and listener
+ eventCell.AddListener(listenerId, cb)
+ listener.AddEvent(event)
+}
+
+func (evsw *EventSwitch) RemoveListener(listenerId string) {
+ // Get and remove listener
+ evsw.mtx.RLock()
+ listener := evsw.listeners[listenerId]
+ delete(evsw.listeners, listenerId)
+ evsw.mtx.RUnlock()
+
+ if listener == nil {
+ return
+ }
+
+ // Remove callback for each event.
+ listener.SetRemoved()
+ for _, event := range listener.GetEvents() {
+ evsw.RemoveListenerForEvent(event, listenerId)
+ }
+}
+
+func (evsw *EventSwitch) RemoveListenerForEvent(event string, listenerId string) {
+ // Get eventCell
+ evsw.mtx.Lock()
+ eventCell := evsw.eventCells[event]
+ evsw.mtx.Unlock()
+
+ if eventCell == nil {
+ return
+ }
+
+ // Remove listenerId from eventCell
+ numListeners := eventCell.RemoveListener(listenerId)
+
+ // Maybe garbage collect eventCell.
+ if numListeners == 0 {
+ // Lock again and double check.
+ evsw.mtx.Lock() // OUTER LOCK
+ eventCell.mtx.Lock() // INNER LOCK
+ if len(eventCell.listeners) == 0 {
+ delete(evsw.eventCells, event)
+ }
+ eventCell.mtx.Unlock() // INNER LOCK
+ evsw.mtx.Unlock() // OUTER LOCK
+ }
+}
+
+func (evsw *EventSwitch) FireEvent(event string, msg interface{}) {
+ // Get the eventCell
+ evsw.mtx.RLock()
+ eventCell := evsw.eventCells[event]
+ evsw.mtx.RUnlock()
+
+ if eventCell == nil {
+ return
+ }
+
+ // Fire event for all listeners in eventCell
+ eventCell.FireEvent(msg)
+}
+
+//-----------------------------------------------------------------------------
+
+// eventCell handles keeping track of listener callbacks for a given event.
+type eventCell struct {
+ mtx sync.RWMutex
+ listeners map[string]eventCallback
+}
+
+func newEventCell() *eventCell {
+ return &eventCell{
+ listeners: make(map[string]eventCallback),
+ }
+}
+
+func (cell *eventCell) AddListener(listenerId string, cb eventCallback) {
+ cell.mtx.Lock()
+ cell.listeners[listenerId] = cb
+ cell.mtx.Unlock()
+}
+
+func (cell *eventCell) RemoveListener(listenerId string) int {
+ cell.mtx.Lock()
+ delete(cell.listeners, listenerId)
+ numListeners := len(cell.listeners)
+ cell.mtx.Unlock()
+ return numListeners
+}
+
+func (cell *eventCell) FireEvent(msg interface{}) {
+ cell.mtx.RLock()
+ for _, listener := range cell.listeners {
+ listener(msg)
+ }
+ cell.mtx.RUnlock()
+}
+
+//-----------------------------------------------------------------------------
+
+type eventCallback func(msg interface{})
+
+type eventListener struct {
+ id string
+
+ mtx sync.RWMutex
+ removed bool
+ events []string
+}
+
+func newEventListener(id string) *eventListener {
+ return &eventListener{
+ id: id,
+ removed: false,
+ events: nil,
+ }
+}
+
+func (evl *eventListener) AddEvent(event string) {
+ evl.mtx.Lock()
+ defer evl.mtx.Unlock()
+
+ if evl.removed {
+ return
+ }
+ evl.events = append(evl.events, event)
+}
+
+func (evl *eventListener) GetEvents() []string {
+ evl.mtx.RLock()
+ defer evl.mtx.RUnlock()
+
+ events := make([]string, len(evl.events))
+ copy(events, evl.events)
+ return events
+}
+
+func (evl *eventListener) SetRemoved() {
+ evl.mtx.Lock()
+ defer evl.mtx.Unlock()
+ evl.removed = true
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/logger/config.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/logger/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..e5c5fdada143c0a6584de201aba2e5f8a89ccb6a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/logger/config.go
@@ -0,0 +1,14 @@
+package logger
+
+import (
+ cfg "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config"
+)
+
+var config cfg.Config = nil
+
+func init() {
+ cfg.OnConfig(func(newConfig cfg.Config) {
+ config = newConfig
+ Reset() // reset log root upon config change.
+ })
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/logger/log.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/logger/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..f93b21abfea32c8f07d083ccd54f65c3c881e456
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/logger/log.go
@@ -0,0 +1,55 @@
+package logger
+
+import (
+ "os"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+var rootHandler log15.Handler
+
+func init() {
+ Reset()
+}
+
+// You might want to call this after resetting tendermint/config.
+func Reset() {
+
+ var logLevel string = "debug"
+ if config != nil {
+ logLevel = config.GetString("log_level")
+ }
+
+ // stdout handler
+ //handlers := []log15.Handler{}
+ stdoutHandler := log15.LvlFilterHandler(
+ getLevel(logLevel),
+ log15.StreamHandler(os.Stdout, log15.TerminalFormat()),
+ )
+ //handlers = append(handlers, stdoutHandler)
+
+ // Set rootHandler.
+ //rootHandler = log15.MultiHandler(handlers...)
+ rootHandler = stdoutHandler
+
+ // By setting handlers on the root, we handle events from all loggers.
+ log15.Root().SetHandler(rootHandler)
+}
+
+// See binary/log for an example of usage.
+func RootHandler() log15.Handler {
+ return rootHandler
+}
+
+func New(ctx ...interface{}) log15.Logger {
+ return log15.Root().New(ctx...)
+}
+
+func getLevel(lvlString string) log15.Lvl {
+ lvl, err := log15.LvlFromString(lvlString)
+ if err != nil {
+ Exit(Fmt("Invalid log level %v: %v", lvlString, err))
+ }
+ return lvl
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool/log.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..724a9a3668bf9a167ed9a5baabafe6fbd412f34b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool/log.go
@@ -0,0 +1,7 @@
+package mempool
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/logger"
+)
+
+var log = logger.New("module", "mempool")
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool/mempool.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool/mempool.go
new file mode 100644
index 0000000000000000000000000000000000000000..32c9edce75c19474f7bf25a48e5fcec8032f3e45
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool/mempool.go
@@ -0,0 +1,109 @@
+/*
+Mempool receives new transactions and applies them to the latest committed state.
+If the transaction is acceptable, then it broadcasts the tx to peers.
+
+When this node happens to be the next proposer, it simply uses the recently
+modified state (and the associated transactions) to construct a proposal.
+*/
+
+package mempool
+
+import (
+ "sync"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ sm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+type Mempool struct {
+ mtx sync.Mutex
+ state *sm.State
+ cache *sm.BlockCache
+ txs []types.Tx
+}
+
+func NewMempool(state *sm.State) *Mempool {
+ return &Mempool{
+ state: state,
+ cache: sm.NewBlockCache(state),
+ }
+}
+
+func (mem *Mempool) GetState() *sm.State {
+ return mem.state
+}
+
+func (mem *Mempool) GetCache() *sm.BlockCache {
+ return mem.cache
+}
+
+// Apply tx to the state and remember it.
+func (mem *Mempool) AddTx(tx types.Tx) (err error) {
+ mem.mtx.Lock()
+ defer mem.mtx.Unlock()
+ err = sm.ExecTx(mem.cache, tx, false, nil)
+ if err != nil {
+ log.Debug("AddTx() error", "tx", tx, "error", err)
+ return err
+ } else {
+ log.Debug("AddTx() success", "tx", tx)
+ mem.txs = append(mem.txs, tx)
+ return nil
+ }
+}
+
+func (mem *Mempool) GetProposalTxs() []types.Tx {
+ mem.mtx.Lock()
+ defer mem.mtx.Unlock()
+ log.Debug("GetProposalTxs:", "txs", mem.txs)
+ return mem.txs
+}
+
+// "block" is the new block being committed.
+// "state" is the result of state.AppendBlock("block").
+// Txs that are present in "block" are discarded from mempool.
+// Txs that have become invalid in the new "state" are also discarded.
+func (mem *Mempool) ResetForBlockAndState(block *types.Block, state *sm.State) {
+ mem.mtx.Lock()
+ defer mem.mtx.Unlock()
+ mem.state = state.Copy()
+ mem.cache = sm.NewBlockCache(mem.state)
+
+ // First, create a lookup map of txns in new block.
+ blockTxsMap := make(map[string]struct{})
+ for _, tx := range block.Data.Txs {
+ txHash := binary.BinarySha256(tx)
+ blockTxsMap[string(txHash)] = struct{}{}
+ }
+
+ // Next, filter all txs from mem.txs that are in blockTxsMap
+ txs := []types.Tx{}
+ for _, tx := range mem.txs {
+ txHash := binary.BinarySha256(tx)
+ if _, ok := blockTxsMap[string(txHash)]; ok {
+ log.Debug("Filter out, already committed", "tx", tx, "txHash", txHash)
+ continue
+ } else {
+ log.Debug("Filter in, still new", "tx", tx, "txHash", txHash)
+ txs = append(txs, tx)
+ }
+ }
+
+ // Next, filter all txs that aren't valid given new state.
+ validTxs := []types.Tx{}
+ for _, tx := range txs {
+ err := sm.ExecTx(mem.cache, tx, false, nil)
+ if err == nil {
+ log.Debug("Filter in, valid", "tx", tx)
+ validTxs = append(validTxs, tx)
+ } else {
+ // tx is no longer valid.
+ log.Debug("Filter out, no longer valid", "tx", tx, "error", err)
+ }
+ }
+
+ // We're done!
+ log.Debug("New txs", "txs", validTxs, "oldTxs", mem.txs)
+ mem.txs = validTxs
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool/reactor.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool/reactor.go
new file mode 100644
index 0000000000000000000000000000000000000000..dc9dcb32c0cae63a1d877b3f9bc9517fb05186f5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool/reactor.go
@@ -0,0 +1,153 @@
+package mempool
+
+import (
+ "bytes"
+ "fmt"
+ "reflect"
+ "sync/atomic"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/events"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+var (
+ MempoolChannel = byte(0x30)
+)
+
+// MempoolReactor handles mempool tx broadcasting amongst peers.
+type MempoolReactor struct {
+ sw *p2p.Switch
+ quit chan struct{}
+ started uint32
+ stopped uint32
+
+ Mempool *Mempool
+
+ evsw events.Fireable
+}
+
+func NewMempoolReactor(mempool *Mempool) *MempoolReactor {
+ memR := &MempoolReactor{
+ quit: make(chan struct{}),
+ Mempool: mempool,
+ }
+ return memR
+}
+
+// Implements Reactor
+func (memR *MempoolReactor) Start(sw *p2p.Switch) {
+ if atomic.CompareAndSwapUint32(&memR.started, 0, 1) {
+ memR.sw = sw
+ log.Info("Starting MempoolReactor")
+ }
+}
+
+// Implements Reactor
+func (memR *MempoolReactor) Stop() {
+ if atomic.CompareAndSwapUint32(&memR.stopped, 0, 1) {
+ log.Info("Stopping MempoolReactor")
+ close(memR.quit)
+ }
+}
+
+// Implements Reactor
+func (memR *MempoolReactor) GetChannels() []*p2p.ChannelDescriptor {
+ return []*p2p.ChannelDescriptor{
+ &p2p.ChannelDescriptor{
+ Id: MempoolChannel,
+ Priority: 5,
+ },
+ }
+}
+
+// Implements Reactor
+func (pexR *MempoolReactor) AddPeer(peer *p2p.Peer) {
+}
+
+// Implements Reactor
+func (pexR *MempoolReactor) RemovePeer(peer *p2p.Peer, reason interface{}) {
+}
+
+// Implements Reactor
+func (memR *MempoolReactor) Receive(chId byte, src *p2p.Peer, msgBytes []byte) {
+ _, msg_, err := DecodeMessage(msgBytes)
+ if err != nil {
+ log.Warn("Error decoding message", "error", err)
+ return
+ }
+ log.Info("MempoolReactor received message", "msg", msg_)
+
+ switch msg := msg_.(type) {
+ case *TxMessage:
+ err := memR.Mempool.AddTx(msg.Tx)
+ if err != nil {
+ // Bad, seen, or conflicting tx.
+ log.Debug("Could not add tx", "tx", msg.Tx)
+ return
+ } else {
+ log.Debug("Added valid tx", "tx", msg.Tx)
+ }
+ // Share tx.
+ // We use a simple shotgun approach for now.
+ // TODO: improve efficiency
+ for _, peer := range memR.sw.Peers().List() {
+ if peer.Key == src.Key {
+ continue
+ }
+ peer.TrySend(MempoolChannel, msg)
+ }
+
+ default:
+ log.Warn(Fmt("Unknown message type %v", reflect.TypeOf(msg)))
+ }
+}
+
+func (memR *MempoolReactor) BroadcastTx(tx types.Tx) error {
+ err := memR.Mempool.AddTx(tx)
+ if err != nil {
+ return err
+ }
+ msg := &TxMessage{Tx: tx}
+ memR.sw.Broadcast(MempoolChannel, msg)
+ return nil
+}
+
+// implements events.Eventable
+func (memR *MempoolReactor) SetFireable(evsw events.Fireable) {
+ memR.evsw = evsw
+}
+
+//-----------------------------------------------------------------------------
+// Messages
+
+const (
+ msgTypeTx = byte(0x01)
+)
+
+type MempoolMessage interface{}
+
+var _ = binary.RegisterInterface(
+ struct{ MempoolMessage }{},
+ binary.ConcreteType{&TxMessage{}, msgTypeTx},
+)
+
+func DecodeMessage(bz []byte) (msgType byte, msg MempoolMessage, err error) {
+ msgType = bz[0]
+ n := new(int64)
+ r := bytes.NewReader(bz)
+ msg = binary.ReadBinary(struct{ MempoolMessage }{}, r, n, &err).(struct{ MempoolMessage }).MempoolMessage
+ return
+}
+
+//-------------------------------------
+
+type TxMessage struct {
+ Tx types.Tx
+}
+
+func (m *TxMessage) String() string {
+ return fmt.Sprintf("[TxMessage %v]", m.Tx)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/README.md b/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..f7ae879f1c8943552912cc2d952ab5eb60d04c26
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/README.md
@@ -0,0 +1,18 @@
+There are two types of merkle trees in this module.
+
+* IAVL+ Tree: A snapshottable (immutable) AVL+ tree for persistent data
+* A simple merkle tree for static data
+
+## IAVL+ Tree
+
+The purpose of this data structure is to provide persistent storage for key-value pairs (say to store account balances) such that a deterministic merkle root hash can be computed. The tree is balanced using a variant of the [AVL algortihm](http://en.wikipedia.org/wiki/AVL_tree) so all operations are O(log(n)).
+
+Nodes of this tree are immutable and indexed by its hash. Thus any node serves as an immutable snapshot which lets us stage uncommitted transactions from the mempool cheaply, and we can instantly roll back to the last committed state to process transactions of a newly committed block (which may not be the same set of transactions as those from the mempool).
+
+In an AVL tree, the heights of the two child subtrees of any node differ by at most one. Whenever this condition is violated upon an update, the tree is rebalanced by creating O(log(n)) new nodes that point to unmodified nodes of the old tree. In the original AVL algorithm, inner nodes can also hold key-value pairs. The AVL+ algorithm (note the plus) modifies the AVL algorithm to keep all values on leaf nodes, while only using branch-nodes to store keys. This simplifies the algorithm while keeping the merkle hash trail short.
+
+In Ethereum, the analog is [Patricia tries](http://en.wikipedia.org/wiki/Radix_tree). There are tradeoffs. Keys do not need to be hashed prior to insertion in IAVL+ trees, so this provides faster iteration in the key space which may benefit some applications. The logic is simpler to implement, requiring only two types of nodes -- inner nodes and leaf nodes. On the other hand, while IAVL+ trees provide a deterministic merkle root hash, it depends on the order of transactions. In practice this shouldn't be a problem, since you can efficiently encode the tree structure when serializing the tree contents.
+
+## Simple Merkle Tree
+
+For smaller static data structures that don't require immutable snapshots or mutability, use the functions provided in `simple_tree.go`. The transactions and validation signatures of a block are hashed using this simple merkle tree logic.
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/iavl_node.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/iavl_node.go
new file mode 100644
index 0000000000000000000000000000000000000000..3d6f79320f95ad1b6672a6cd55969c149bc95102
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/iavl_node.go
@@ -0,0 +1,460 @@
+package merkle
+
+import (
+ "bytes"
+ "crypto/sha256"
+ "io"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+)
+
+// Node
+
+type IAVLNode struct {
+ key interface{}
+ value interface{}
+ height uint8
+ size uint
+ hash []byte
+ leftHash []byte
+ leftNode *IAVLNode
+ rightHash []byte
+ rightNode *IAVLNode
+ persisted bool
+}
+
+func NewIAVLNode(key interface{}, value interface{}) *IAVLNode {
+ return &IAVLNode{
+ key: key,
+ value: value,
+ height: 0,
+ size: 1,
+ }
+}
+
+// NOTE: The hash is not saved or set. The caller should set the hash afterwards.
+// (Presumably the caller already has the hash)
+func ReadIAVLNode(t *IAVLTree, r io.Reader, n *int64, err *error) *IAVLNode {
+ node := &IAVLNode{}
+
+ // node header
+ node.height = binary.ReadUint8(r, n, err)
+ node.size = binary.ReadUvarint(r, n, err)
+ node.key = decodeByteSlice(t.keyCodec, r, n, err)
+
+ if node.height == 0 {
+ // value
+ node.value = decodeByteSlice(t.valueCodec, r, n, err)
+ } else {
+ // children
+ node.leftHash = binary.ReadByteSlice(r, n, err)
+ node.rightHash = binary.ReadByteSlice(r, n, err)
+ }
+ if *err != nil {
+ panic(*err)
+ }
+ return node
+}
+
+func (node *IAVLNode) _copy() *IAVLNode {
+ if node.height == 0 {
+ panic("Why are you copying a value node?")
+ }
+ return &IAVLNode{
+ key: node.key,
+ height: node.height,
+ size: node.size,
+ hash: nil, // Going to be mutated anyways.
+ leftHash: node.leftHash,
+ leftNode: node.leftNode,
+ rightHash: node.rightHash,
+ rightNode: node.rightNode,
+ persisted: false, // Going to be mutated, so it can't already be persisted.
+ }
+}
+
+func (node *IAVLNode) has(t *IAVLTree, key interface{}) (has bool) {
+ if t.keyCodec.Compare(node.key, key) == 0 {
+ return true
+ }
+ if node.height == 0 {
+ return false
+ } else {
+ if t.keyCodec.Compare(key, node.key) < 0 {
+ return node.getLeftNode(t).has(t, key)
+ } else {
+ return node.getRightNode(t).has(t, key)
+ }
+ }
+}
+
+func (node *IAVLNode) get(t *IAVLTree, key interface{}) (index uint, value interface{}) {
+ if node.height == 0 {
+ if t.keyCodec.Compare(node.key, key) == 0 {
+ return 0, node.value
+ } else {
+ return 0, nil
+ }
+ } else {
+ if t.keyCodec.Compare(key, node.key) < 0 {
+ return node.getLeftNode(t).get(t, key)
+ } else {
+ rightNode := node.getRightNode(t)
+ index, value = rightNode.get(t, key)
+ index += node.size - rightNode.size
+ return index, value
+ }
+ }
+}
+
+func (node *IAVLNode) getByIndex(t *IAVLTree, index uint) (key interface{}, value interface{}) {
+ if node.height == 0 {
+ if index == 0 {
+ return node.key, node.value
+ } else {
+ panic("getByIndex asked for invalid index")
+ }
+ } else {
+ // TODO: could improve this by storing the
+ // sizes as well as left/right hash.
+ leftNode := node.getLeftNode(t)
+ if index < leftNode.size {
+ return leftNode.getByIndex(t, index)
+ } else {
+ return node.getRightNode(t).getByIndex(t, index-leftNode.size)
+ }
+ }
+}
+
+// NOTE: sets hashes recursively
+func (node *IAVLNode) hashWithCount(t *IAVLTree) ([]byte, uint) {
+ if node.hash != nil {
+ return node.hash, 0
+ }
+
+ hasher := sha256.New()
+ buf := new(bytes.Buffer)
+ _, hashCount, err := node.writeHashBytes(t, buf)
+ if err != nil {
+ panic(err)
+ }
+ // fmt.Printf("Wrote IAVL hash bytes: %X\n", buf.Bytes())
+ hasher.Write(buf.Bytes())
+ node.hash = hasher.Sum(nil)
+ // fmt.Printf("Write IAVL hash: %X\n", node.hash)
+
+ return node.hash, hashCount + 1
+}
+
+// NOTE: sets hashes recursively
+func (node *IAVLNode) writeHashBytes(t *IAVLTree, w io.Writer) (n int64, hashCount uint, err error) {
+ // height & size
+ binary.WriteUint8(node.height, w, &n, &err)
+ binary.WriteUvarint(node.size, w, &n, &err)
+ // key is not written for inner nodes, unlike writePersistBytes
+
+ if node.height == 0 {
+ // key & value
+ encodeByteSlice(node.key, t.keyCodec, w, &n, &err)
+ encodeByteSlice(node.value, t.valueCodec, w, &n, &err)
+ } else {
+ // left
+ if node.leftNode != nil {
+ leftHash, leftCount := node.leftNode.hashWithCount(t)
+ node.leftHash = leftHash
+ hashCount += leftCount
+ }
+ if node.leftHash == nil {
+ panic("node.leftHash was nil in writeHashBytes")
+ }
+ binary.WriteByteSlice(node.leftHash, w, &n, &err)
+ // right
+ if node.rightNode != nil {
+ rightHash, rightCount := node.rightNode.hashWithCount(t)
+ node.rightHash = rightHash
+ hashCount += rightCount
+ }
+ if node.rightHash == nil {
+ panic("node.rightHash was nil in writeHashBytes")
+ }
+ binary.WriteByteSlice(node.rightHash, w, &n, &err)
+ }
+ return
+}
+
+// NOTE: sets hashes recursively
+// NOTE: clears leftNode/rightNode recursively
+func (node *IAVLNode) save(t *IAVLTree) []byte {
+ if node.hash == nil {
+ node.hash, _ = node.hashWithCount(t)
+ }
+ if node.persisted {
+ return node.hash
+ }
+
+ // save children
+ if node.leftNode != nil {
+ node.leftHash = node.leftNode.save(t)
+ node.leftNode = nil
+ }
+ if node.rightNode != nil {
+ node.rightHash = node.rightNode.save(t)
+ node.rightNode = nil
+ }
+
+ // save node
+ t.ndb.SaveNode(t, node)
+ return node.hash
+}
+
+// NOTE: sets hashes recursively
+func (node *IAVLNode) writePersistBytes(t *IAVLTree, w io.Writer) (n int64, err error) {
+ // node header
+ binary.WriteUint8(node.height, w, &n, &err)
+ binary.WriteUvarint(node.size, w, &n, &err)
+ // key (unlike writeHashBytes, key is written for inner nodes)
+ encodeByteSlice(node.key, t.keyCodec, w, &n, &err)
+
+ if node.height == 0 {
+ // value
+ encodeByteSlice(node.value, t.valueCodec, w, &n, &err)
+ } else {
+ // left
+ if node.leftHash == nil {
+ panic("node.leftHash was nil in writePersistBytes")
+ }
+ binary.WriteByteSlice(node.leftHash, w, &n, &err)
+ // right
+ if node.rightHash == nil {
+ panic("node.rightHash was nil in writePersistBytes")
+ }
+ binary.WriteByteSlice(node.rightHash, w, &n, &err)
+ }
+ return
+}
+
+func (node *IAVLNode) set(t *IAVLTree, key interface{}, value interface{}) (newSelf *IAVLNode, updated bool) {
+ if node.height == 0 {
+ cmp := t.keyCodec.Compare(key, node.key)
+ if cmp < 0 {
+ return &IAVLNode{
+ key: node.key,
+ height: 1,
+ size: 2,
+ leftNode: NewIAVLNode(key, value),
+ rightNode: node,
+ }, false
+ } else if cmp == 0 {
+ return NewIAVLNode(key, value), true
+ } else {
+ return &IAVLNode{
+ key: key,
+ height: 1,
+ size: 2,
+ leftNode: node,
+ rightNode: NewIAVLNode(key, value),
+ }, false
+ }
+ } else {
+ node = node._copy()
+ if t.keyCodec.Compare(key, node.key) < 0 {
+ node.leftNode, updated = node.getLeftNode(t).set(t, key, value)
+ node.leftHash = nil
+ } else {
+ node.rightNode, updated = node.getRightNode(t).set(t, key, value)
+ node.rightHash = nil
+ }
+ if updated {
+ return node, updated
+ } else {
+ node.calcHeightAndSize(t)
+ return node.balance(t), updated
+ }
+ }
+}
+
+// newHash/newNode: The new hash or node to replace node after remove.
+// newKey: new leftmost leaf key for tree after successfully removing 'key' if changed.
+// value: removed value.
+func (node *IAVLNode) remove(t *IAVLTree, key interface{}) (
+ newHash []byte, newNode *IAVLNode, newKey interface{}, value interface{}, removed bool) {
+ if node.height == 0 {
+ if t.keyCodec.Compare(key, node.key) == 0 {
+ return nil, nil, nil, node.value, true
+ } else {
+ return nil, node, nil, nil, false
+ }
+ } else {
+ if t.keyCodec.Compare(key, node.key) < 0 {
+ var newLeftHash []byte
+ var newLeftNode *IAVLNode
+ newLeftHash, newLeftNode, newKey, value, removed = node.getLeftNode(t).remove(t, key)
+ if !removed {
+ return nil, node, nil, value, false
+ } else if newLeftHash == nil && newLeftNode == nil { // left node held value, was removed
+ return node.rightHash, node.rightNode, node.key, value, true
+ }
+ node = node._copy()
+ node.leftHash, node.leftNode = newLeftHash, newLeftNode
+ node.calcHeightAndSize(t)
+ return nil, node.balance(t), newKey, value, true
+ } else {
+ var newRightHash []byte
+ var newRightNode *IAVLNode
+ newRightHash, newRightNode, newKey, value, removed = node.getRightNode(t).remove(t, key)
+ if !removed {
+ return nil, node, nil, value, false
+ } else if newRightHash == nil && newRightNode == nil { // right node held value, was removed
+ return node.leftHash, node.leftNode, nil, value, true
+ }
+ node = node._copy()
+ node.rightHash, node.rightNode = newRightHash, newRightNode
+ if newKey != nil {
+ node.key = newKey
+ newKey = nil
+ }
+ node.calcHeightAndSize(t)
+ return nil, node.balance(t), newKey, value, true
+ }
+ }
+}
+
+func (node *IAVLNode) getLeftNode(t *IAVLTree) *IAVLNode {
+ if node.leftNode != nil {
+ return node.leftNode
+ } else {
+ return t.ndb.GetNode(t, node.leftHash)
+ }
+}
+
+func (node *IAVLNode) getRightNode(t *IAVLTree) *IAVLNode {
+ if node.rightNode != nil {
+ return node.rightNode
+ } else {
+ return t.ndb.GetNode(t, node.rightHash)
+ }
+}
+
+func (node *IAVLNode) rotateRight(t *IAVLTree) *IAVLNode {
+ node = node._copy()
+ sl := node.getLeftNode(t)._copy()
+
+ slrHash, slrCached := sl.rightHash, sl.rightNode
+ sl.rightHash, sl.rightNode = nil, node
+ node.leftHash, node.leftNode = slrHash, slrCached
+
+ node.calcHeightAndSize(t)
+ sl.calcHeightAndSize(t)
+
+ return sl
+}
+
+func (node *IAVLNode) rotateLeft(t *IAVLTree) *IAVLNode {
+ node = node._copy()
+ sr := node.getRightNode(t)._copy()
+
+ srlHash, srlCached := sr.leftHash, sr.leftNode
+ sr.leftHash, sr.leftNode = nil, node
+ node.rightHash, node.rightNode = srlHash, srlCached
+
+ node.calcHeightAndSize(t)
+ sr.calcHeightAndSize(t)
+
+ return sr
+}
+
+// NOTE: mutates height and size
+func (node *IAVLNode) calcHeightAndSize(t *IAVLTree) {
+ node.height = maxUint8(node.getLeftNode(t).height, node.getRightNode(t).height) + 1
+ node.size = node.getLeftNode(t).size + node.getRightNode(t).size
+}
+
+func (node *IAVLNode) calcBalance(t *IAVLTree) int {
+ return int(node.getLeftNode(t).height) - int(node.getRightNode(t).height)
+}
+
+func (node *IAVLNode) balance(t *IAVLTree) (newSelf *IAVLNode) {
+ balance := node.calcBalance(t)
+ if balance > 1 {
+ if node.getLeftNode(t).calcBalance(t) >= 0 {
+ // Left Left Case
+ return node.rotateRight(t)
+ } else {
+ // Left Right Case
+ node = node._copy()
+ node.leftHash, node.leftNode = nil, node.getLeftNode(t).rotateLeft(t)
+ //node.calcHeightAndSize()
+ return node.rotateRight(t)
+ }
+ }
+ if balance < -1 {
+ if node.getRightNode(t).calcBalance(t) <= 0 {
+ // Right Right Case
+ return node.rotateLeft(t)
+ } else {
+ // Right Left Case
+ node = node._copy()
+ node.rightHash, node.rightNode = nil, node.getRightNode(t).rotateRight(t)
+ //node.calcHeightAndSize()
+ return node.rotateLeft(t)
+ }
+ }
+ // Nothing changed
+ return node
+}
+
+func (node *IAVLNode) traverse(t *IAVLTree, cb func(*IAVLNode) bool) bool {
+ stop := cb(node)
+ if stop {
+ return stop
+ }
+ if node.height > 0 {
+ stop = node.getLeftNode(t).traverse(t, cb)
+ if stop {
+ return stop
+ }
+ stop = node.getRightNode(t).traverse(t, cb)
+ if stop {
+ return stop
+ }
+ }
+ return false
+}
+
+// Only used in testing...
+func (node *IAVLNode) lmd(t *IAVLTree) *IAVLNode {
+ if node.height == 0 {
+ return node
+ }
+ return node.getLeftNode(t).lmd(t)
+}
+
+// Only used in testing...
+func (node *IAVLNode) rmd(t *IAVLTree) *IAVLNode {
+ if node.height == 0 {
+ return node
+ }
+ return node.getRightNode(t).rmd(t)
+}
+
+//--------------------------------------------------------------------------------
+
+// Read a (length prefixed) byteslice then decode the object using the codec
+func decodeByteSlice(codec binary.Codec, r io.Reader, n *int64, err *error) interface{} {
+ bytez := binary.ReadByteSlice(r, n, err)
+ if *err != nil {
+ return nil
+ }
+ n_ := new(int64)
+ return codec.Decode(bytes.NewBuffer(bytez), n_, err)
+}
+
+// Encode object using codec, then write a (length prefixed) byteslice.
+func encodeByteSlice(o interface{}, codec binary.Codec, w io.Writer, n *int64, err *error) {
+ buf, n_ := new(bytes.Buffer), new(int64)
+ codec.Encode(o, buf, n_, err)
+ if *err != nil {
+ return
+ }
+ binary.WriteByteSlice(buf.Bytes(), w, n, err)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/iavl_proof.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/iavl_proof.go
new file mode 100644
index 0000000000000000000000000000000000000000..7c0b2acacc89032d82bc38ca322a90398442183c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/iavl_proof.go
@@ -0,0 +1,137 @@
+package merkle
+
+import (
+ "bytes"
+ "crypto/sha256"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+type IAVLProof struct {
+ Root []byte
+ Branches []IAVLProofBranch
+ Leaf IAVLProofLeaf
+}
+
+func (proof *IAVLProof) Verify() bool {
+ hash := proof.Leaf.Hash()
+ // fmt.Printf("leaf hash: %X\n", hash)
+ for i := len(proof.Branches) - 1; 0 <= i; i-- {
+ hash = proof.Branches[i].Hash(hash)
+ // fmt.Printf("branch hash: %X\n", hash)
+ }
+ // fmt.Printf("root: %X, computed: %X\n", proof.Root, hash)
+ return bytes.Equal(proof.Root, hash)
+}
+
+type IAVLProofBranch struct {
+ Height uint8
+ Size uint
+ Left []byte
+ Right []byte
+}
+
+func (branch IAVLProofBranch) Hash(childHash []byte) []byte {
+ hasher := sha256.New()
+ buf := new(bytes.Buffer)
+ n, err := int64(0), error(nil)
+ binary.WriteUint8(branch.Height, buf, &n, &err)
+ binary.WriteUvarint(branch.Size, buf, &n, &err)
+ if branch.Left == nil {
+ binary.WriteByteSlice(childHash, buf, &n, &err)
+ binary.WriteByteSlice(branch.Right, buf, &n, &err)
+ } else {
+ binary.WriteByteSlice(branch.Left, buf, &n, &err)
+ binary.WriteByteSlice(childHash, buf, &n, &err)
+ }
+ if err != nil {
+ panic(Fmt("Failed to hash IAVLProofBranch: %v", err))
+ }
+ // fmt.Printf("Branch hash bytes: %X\n", buf.Bytes())
+ hasher.Write(buf.Bytes())
+ return hasher.Sum(nil)
+}
+
+type IAVLProofLeaf struct {
+ KeyBytes []byte
+ ValueBytes []byte
+}
+
+func (leaf IAVLProofLeaf) Hash() []byte {
+ hasher := sha256.New()
+ buf := new(bytes.Buffer)
+ n, err := int64(0), error(nil)
+ binary.WriteUint8(0, buf, &n, &err)
+ binary.WriteUvarint(1, buf, &n, &err)
+ binary.WriteByteSlice(leaf.KeyBytes, buf, &n, &err)
+ binary.WriteByteSlice(leaf.ValueBytes, buf, &n, &err)
+ if err != nil {
+ panic(Fmt("Failed to hash IAVLProofLeaf: %v", err))
+ }
+ // fmt.Printf("Leaf hash bytes: %X\n", buf.Bytes())
+ hasher.Write(buf.Bytes())
+ return hasher.Sum(nil)
+}
+
+func (node *IAVLNode) constructProof(t *IAVLTree, key interface{}, proof *IAVLProof) (exists bool) {
+ if node.height == 0 {
+ if t.keyCodec.Compare(node.key, key) == 0 {
+ keyBuf, valueBuf := new(bytes.Buffer), new(bytes.Buffer)
+ n, err := int64(0), error(nil)
+ t.keyCodec.Encode(node.key, keyBuf, &n, &err)
+ if err != nil {
+ panic(Fmt("Failed to encode node.key: %v", err))
+ }
+ t.valueCodec.Encode(node.value, valueBuf, &n, &err)
+ if err != nil {
+ panic(Fmt("Failed to encode node.value: %v", err))
+ }
+ leaf := IAVLProofLeaf{
+ KeyBytes: keyBuf.Bytes(),
+ ValueBytes: valueBuf.Bytes(),
+ }
+ proof.Leaf = leaf
+ return true
+ } else {
+ return false
+ }
+ } else {
+ if t.keyCodec.Compare(key, node.key) < 0 {
+ branch := IAVLProofBranch{
+ Height: node.height,
+ Size: node.size,
+ Left: nil,
+ Right: node.getRightNode(t).hash,
+ }
+ if node.getRightNode(t).hash == nil {
+ // fmt.Println(node.getRightNode(t))
+ panic("WTF")
+ }
+ proof.Branches = append(proof.Branches, branch)
+ return node.getLeftNode(t).constructProof(t, key, proof)
+ } else {
+ branch := IAVLProofBranch{
+ Height: node.height,
+ Size: node.size,
+ Left: node.getLeftNode(t).hash,
+ Right: nil,
+ }
+ proof.Branches = append(proof.Branches, branch)
+ return node.getRightNode(t).constructProof(t, key, proof)
+ }
+ }
+}
+
+// Returns nil if key is not in tree.
+func (t *IAVLTree) ConstructProof(key interface{}) *IAVLProof {
+ if t.root == nil {
+ return nil
+ }
+ t.root.hashWithCount(t) // Ensure that all hashes are calculated.
+ proof := &IAVLProof{
+ Root: t.root.hash,
+ }
+ t.root.constructProof(t, key, proof)
+ return proof
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/iavl_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/iavl_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..d3b294c155b9b6cbd709643ac470bac00c3b010a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/iavl_test.go
@@ -0,0 +1,326 @@
+package merkle
+
+import (
+ "bytes"
+ "fmt"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common/test"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/db"
+
+ "runtime"
+ "testing"
+)
+
+func randstr(length int) string {
+ return RandStr(length)
+}
+
+// Convenience for a new node
+func N(l, r interface{}) *IAVLNode {
+ var left, right *IAVLNode
+ if _, ok := l.(*IAVLNode); ok {
+ left = l.(*IAVLNode)
+ } else {
+ left = NewIAVLNode(l, "")
+ }
+ if _, ok := r.(*IAVLNode); ok {
+ right = r.(*IAVLNode)
+ } else {
+ right = NewIAVLNode(r, "")
+ }
+
+ n := &IAVLNode{
+ key: right.lmd(nil).key,
+ value: "",
+ leftNode: left,
+ rightNode: right,
+ }
+ n.calcHeightAndSize(nil)
+ return n
+}
+
+// Setup a deep node
+func T(n *IAVLNode) *IAVLTree {
+ t := NewIAVLTree(binary.BasicCodec, binary.BasicCodec, 0, nil)
+ n.hashWithCount(t)
+ t.root = n
+ return t
+}
+
+// Convenience for simple printing of keys & tree structure
+func P(n *IAVLNode) string {
+ if n.height == 0 {
+ return fmt.Sprintf("%v", n.key)
+ } else {
+ return fmt.Sprintf("(%v %v)", P(n.leftNode), P(n.rightNode))
+ }
+}
+
+func TestUnit(t *testing.T) {
+
+ expectHash := func(tree *IAVLTree, hashCount uint) {
+ // ensure number of new hash calculations is as expected.
+ hash, count := tree.HashWithCount()
+ if count != hashCount {
+ t.Fatalf("Expected %v new hashes, got %v", hashCount, count)
+ }
+ // nuke hashes and reconstruct hash, ensure it's the same.
+ tree.root.traverse(tree, func(node *IAVLNode) bool {
+ node.hash = nil
+ return false
+ })
+ // ensure that the new hash after nuking is the same as the old.
+ newHash, _ := tree.HashWithCount()
+ if bytes.Compare(hash, newHash) != 0 {
+ t.Fatalf("Expected hash %v but got %v after nuking", hash, newHash)
+ }
+ }
+
+ expectSet := func(tree *IAVLTree, i int, repr string, hashCount uint) {
+ origNode := tree.root
+ updated := tree.Set(i, "")
+ // ensure node was added & structure is as expected.
+ if updated == true || P(tree.root) != repr {
+ t.Fatalf("Adding %v to %v:\nExpected %v\nUnexpectedly got %v updated:%v",
+ i, P(origNode), repr, P(tree.root), updated)
+ }
+ // ensure hash calculation requirements
+ expectHash(tree, hashCount)
+ tree.root = origNode
+ }
+
+ expectRemove := func(tree *IAVLTree, i int, repr string, hashCount uint) {
+ origNode := tree.root
+ value, removed := tree.Remove(i)
+ // ensure node was added & structure is as expected.
+ if value != "" || !removed || P(tree.root) != repr {
+ t.Fatalf("Removing %v from %v:\nExpected %v\nUnexpectedly got %v value:%v removed:%v",
+ i, P(origNode), repr, P(tree.root), value, removed)
+ }
+ // ensure hash calculation requirements
+ expectHash(tree, hashCount)
+ tree.root = origNode
+ }
+
+ //////// Test Set cases:
+
+ // Case 1:
+ t1 := T(N(4, 20))
+
+ expectSet(t1, 8, "((4 8) 20)", 3)
+ expectSet(t1, 25, "(4 (20 25))", 3)
+
+ t2 := T(N(4, N(20, 25)))
+
+ expectSet(t2, 8, "((4 8) (20 25))", 3)
+ expectSet(t2, 30, "((4 20) (25 30))", 4)
+
+ t3 := T(N(N(1, 2), 6))
+
+ expectSet(t3, 4, "((1 2) (4 6))", 4)
+ expectSet(t3, 8, "((1 2) (6 8))", 3)
+
+ t4 := T(N(N(1, 2), N(N(5, 6), N(7, 9))))
+
+ expectSet(t4, 8, "(((1 2) (5 6)) ((7 8) 9))", 5)
+ expectSet(t4, 10, "(((1 2) (5 6)) (7 (9 10)))", 5)
+
+ //////// Test Remove cases:
+
+ t10 := T(N(N(1, 2), 3))
+
+ expectRemove(t10, 2, "(1 3)", 1)
+ expectRemove(t10, 3, "(1 2)", 0)
+
+ t11 := T(N(N(N(1, 2), 3), N(4, 5)))
+
+ expectRemove(t11, 4, "((1 2) (3 5))", 2)
+ expectRemove(t11, 3, "((1 2) (4 5))", 1)
+
+}
+
+func TestIntegration(t *testing.T) {
+
+ type record struct {
+ key string
+ value string
+ }
+
+ records := make([]*record, 400)
+ var tree *IAVLTree = NewIAVLTree(binary.BasicCodec, binary.BasicCodec, 0, nil)
+
+ randomRecord := func() *record {
+ return &record{randstr(20), randstr(20)}
+ }
+
+ for i := range records {
+ r := randomRecord()
+ records[i] = r
+ //t.Log("New record", r)
+ //PrintIAVLNode(tree.root)
+ updated := tree.Set(r.key, "")
+ if updated {
+ t.Error("should have not been updated")
+ }
+ updated = tree.Set(r.key, r.value)
+ if !updated {
+ t.Error("should have been updated")
+ }
+ if tree.Size() != uint(i+1) {
+ t.Error("size was wrong", tree.Size(), i+1)
+ }
+ }
+
+ for _, r := range records {
+ if has := tree.Has(r.key); !has {
+ t.Error("Missing key", r.key)
+ }
+ if has := tree.Has(randstr(12)); has {
+ t.Error("Table has extra key")
+ }
+ if _, val := tree.Get(r.key); val.(string) != r.value {
+ t.Error("wrong value")
+ }
+ }
+
+ for i, x := range records {
+ if val, removed := tree.Remove(x.key); !removed {
+ t.Error("Wasn't removed")
+ } else if val != x.value {
+ t.Error("Wrong value")
+ }
+ for _, r := range records[i+1:] {
+ if has := tree.Has(r.key); !has {
+ t.Error("Missing key", r.key)
+ }
+ if has := tree.Has(randstr(12)); has {
+ t.Error("Table has extra key")
+ }
+ _, val := tree.Get(r.key)
+ if val != r.value {
+ t.Error("wrong value")
+ }
+ }
+ if tree.Size() != uint(len(records)-(i+1)) {
+ t.Error("size was wrong", tree.Size(), (len(records) - (i + 1)))
+ }
+ }
+}
+
+func TestPersistence(t *testing.T) {
+ db := db.NewMemDB()
+
+ // Create some random key value pairs
+ records := make(map[string]string)
+ for i := 0; i < 10000; i++ {
+ records[randstr(20)] = randstr(20)
+ }
+
+ // Construct some tree and save it
+ t1 := NewIAVLTree(binary.BasicCodec, binary.BasicCodec, 0, db)
+ for key, value := range records {
+ t1.Set(key, value)
+ }
+ t1.Save()
+
+ hash, _ := t1.HashWithCount()
+
+ // Load a tree
+ t2 := NewIAVLTree(binary.BasicCodec, binary.BasicCodec, 0, db)
+ t2.Load(hash)
+ for key, value := range records {
+ _, t2value := t2.Get(key)
+ if t2value != value {
+ t.Fatalf("Invalid value. Expected %v, got %v", value, t2value)
+ }
+ }
+}
+
+func testProof(t *testing.T, proof *IAVLProof) {
+ // Proof must verify.
+ if !proof.Verify() {
+ t.Errorf("Invalid proof. Verification failed.")
+ return
+ }
+ // Write/Read then verify.
+ proofBytes := binary.BinaryBytes(proof)
+ n, err := int64(0), error(nil)
+ proof2 := binary.ReadBinary(&IAVLProof{}, bytes.NewBuffer(proofBytes), &n, &err).(*IAVLProof)
+ if err != nil {
+ t.Errorf("Failed to read IAVLProof from bytes: %v", err)
+ return
+ }
+ if !proof2.Verify() {
+ t.Errorf("Invalid proof after write/read. Verification failed.")
+ return
+ }
+ // Random mutations must not verify
+ for i := 0; i < 3; i++ {
+ badProofBytes := MutateByteSlice(proofBytes)
+ n, err := int64(0), error(nil)
+ badProof := binary.ReadBinary(&IAVLProof{}, bytes.NewBuffer(badProofBytes), &n, &err).(*IAVLProof)
+ if err != nil {
+ continue // This is fine.
+ }
+ if badProof.Verify() {
+ t.Errorf("Proof was still valid after a random mutation:\n%X\n%X", proofBytes, badProofBytes)
+ }
+ }
+}
+
+func TestConstructProof(t *testing.T) {
+ // Construct some random tree
+ db := db.NewMemDB()
+ var tree *IAVLTree = NewIAVLTree(binary.BasicCodec, binary.BasicCodec, 100, db)
+ for i := 0; i < 1000; i++ {
+ key, value := randstr(20), randstr(20)
+ tree.Set(key, value)
+ }
+
+ // Persist the items so far
+ tree.Save()
+
+ // Add more items so it's not all persisted
+ for i := 0; i < 100; i++ {
+ key, value := randstr(20), randstr(20)
+ tree.Set(key, value)
+ }
+
+ // Now for each item, construct a proof and verify
+ tree.Iterate(func(key interface{}, value interface{}) bool {
+ proof := tree.ConstructProof(key)
+ if !bytes.Equal(proof.Root, tree.Hash()) {
+ t.Errorf("Invalid proof. Expected root %X, got %X", tree.Hash(), proof.Root)
+ }
+ if !proof.Verify() {
+ t.Errorf("Invalid proof. Verification failed.")
+ }
+ testProof(t, proof)
+ return false
+ })
+
+}
+
+func BenchmarkImmutableAvlTree(b *testing.B) {
+ b.StopTimer()
+
+ t := NewIAVLTree(binary.BasicCodec, binary.BasicCodec, 0, nil)
+ // 23000ns/op, 43000ops/s
+ // for i := 0; i < 10000000; i++ {
+ for i := 0; i < 1000000; i++ {
+ t.Set(RandUint64(), "")
+ }
+
+ fmt.Println("ok, starting")
+
+ runtime.GC()
+
+ b.StartTimer()
+ for i := 0; i < b.N; i++ {
+ ri := RandUint64()
+ t.Set(ri, "")
+ t.Remove(ri)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/iavl_tree.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/iavl_tree.go
new file mode 100644
index 0000000000000000000000000000000000000000..87ae71564a8c8f9683b50c5514a4c75985a528c9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/iavl_tree.go
@@ -0,0 +1,262 @@
+package merkle
+
+import (
+ "bytes"
+ "container/list"
+ "sync"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ dbm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/db"
+)
+
+/*
+Immutable AVL Tree (wraps the Node root)
+This tree is not goroutine safe.
+*/
+type IAVLTree struct {
+ keyCodec binary.Codec
+ valueCodec binary.Codec
+ root *IAVLNode
+ ndb *nodeDB
+}
+
+func NewIAVLTree(keyCodec, valueCodec binary.Codec, cacheSize int, db dbm.DB) *IAVLTree {
+ if db == nil {
+ // In-memory IAVLTree
+ return &IAVLTree{
+ keyCodec: keyCodec,
+ valueCodec: valueCodec,
+ }
+ } else {
+ // Persistent IAVLTree
+ return &IAVLTree{
+ keyCodec: keyCodec,
+ valueCodec: valueCodec,
+ ndb: newNodeDB(cacheSize, db),
+ }
+ }
+}
+
+// The returned tree and the original tree are goroutine independent.
+// That is, they can each run in their own goroutine.
+func (t *IAVLTree) Copy() Tree {
+ if t.root == nil {
+ return &IAVLTree{
+ keyCodec: t.keyCodec,
+ valueCodec: t.valueCodec,
+ root: nil,
+ ndb: t.ndb,
+ }
+ }
+ if t.ndb != nil && !t.root.persisted {
+ // Saving a tree finalizes all the nodes.
+ // It sets all the hashes recursively,
+ // clears all the leftNode/rightNode values recursively,
+ // and all the .persisted flags get set.
+ panic("It is unsafe to Copy() an unpersisted tree.")
+ } else if t.ndb == nil && t.root.hash == nil {
+ // An in-memory IAVLTree is finalized when the hashes are
+ // calculated.
+ t.root.hashWithCount(t)
+ }
+ return &IAVLTree{
+ keyCodec: t.keyCodec,
+ valueCodec: t.valueCodec,
+ root: t.root,
+ ndb: t.ndb,
+ }
+}
+
+func (t *IAVLTree) Size() uint {
+ if t.root == nil {
+ return 0
+ }
+ return t.root.size
+}
+
+func (t *IAVLTree) Height() uint8 {
+ if t.root == nil {
+ return 0
+ }
+ return t.root.height
+}
+
+func (t *IAVLTree) Has(key interface{}) bool {
+ if t.root == nil {
+ return false
+ }
+ return t.root.has(t, key)
+}
+
+func (t *IAVLTree) Set(key interface{}, value interface{}) (updated bool) {
+ if t.root == nil {
+ t.root = NewIAVLNode(key, value)
+ return false
+ }
+ t.root, updated = t.root.set(t, key, value)
+ return updated
+}
+
+func (t *IAVLTree) Hash() []byte {
+ if t.root == nil {
+ return nil
+ }
+ hash, _ := t.root.hashWithCount(t)
+ return hash
+}
+
+func (t *IAVLTree) HashWithCount() ([]byte, uint) {
+ if t.root == nil {
+ return nil, 0
+ }
+ return t.root.hashWithCount(t)
+}
+
+func (t *IAVLTree) Save() []byte {
+ if t.root == nil {
+ return nil
+ }
+ return t.root.save(t)
+}
+
+// Sets the root node by reading from db.
+// If the hash is empty, then sets root to nil.
+func (t *IAVLTree) Load(hash []byte) {
+ if len(hash) == 0 {
+ t.root = nil
+ } else {
+ t.root = t.ndb.GetNode(t, hash)
+ }
+}
+
+func (t *IAVLTree) Get(key interface{}) (index uint, value interface{}) {
+ if t.root == nil {
+ return 0, nil
+ }
+ return t.root.get(t, key)
+}
+
+func (t *IAVLTree) GetByIndex(index uint) (key interface{}, value interface{}) {
+ if t.root == nil {
+ return nil, nil
+ }
+ return t.root.getByIndex(t, index)
+}
+
+func (t *IAVLTree) Remove(key interface{}) (value interface{}, removed bool) {
+ if t.root == nil {
+ return nil, false
+ }
+ newRootHash, newRoot, _, value, removed := t.root.remove(t, key)
+ if !removed {
+ return nil, false
+ }
+ if newRoot == nil && newRootHash != nil {
+ t.root = t.ndb.GetNode(t, newRootHash)
+ } else {
+ t.root = newRoot
+ }
+ return value, true
+}
+
+func (t *IAVLTree) Iterate(fn func(key interface{}, value interface{}) bool) (stopped bool) {
+ if t.root == nil {
+ return false
+ }
+ return t.root.traverse(t, func(node *IAVLNode) bool {
+ if node.height == 0 {
+ return fn(node.key, node.value)
+ } else {
+ return false
+ }
+ })
+}
+
+//-----------------------------------------------------------------------------
+
+type nodeElement struct {
+ node *IAVLNode
+ elem *list.Element
+}
+
+type nodeDB struct {
+ mtx sync.Mutex
+ cache map[string]nodeElement
+ cacheSize int
+ cacheQueue *list.List
+ db dbm.DB
+}
+
+func newNodeDB(cacheSize int, db dbm.DB) *nodeDB {
+ return &nodeDB{
+ cache: make(map[string]nodeElement),
+ cacheSize: cacheSize,
+ cacheQueue: list.New(),
+ db: db,
+ }
+}
+
+func (ndb *nodeDB) GetNode(t *IAVLTree, hash []byte) *IAVLNode {
+ ndb.mtx.Lock()
+ defer ndb.mtx.Unlock()
+ // Check the cache.
+ nodeElem, ok := ndb.cache[string(hash)]
+ if ok {
+ // Already exists. Move to back of cacheQueue.
+ ndb.cacheQueue.MoveToBack(nodeElem.elem)
+ return nodeElem.node
+ } else {
+ // Doesn't exist, load.
+ buf := ndb.db.Get(hash)
+ if len(buf) == 0 {
+ ndb.db.(*dbm.LevelDB).Print()
+ panic(Fmt("Value missing for key %X", hash))
+ }
+ r := bytes.NewReader(buf)
+ var n int64
+ var err error
+ node := ReadIAVLNode(t, r, &n, &err)
+ if err != nil {
+ panic(Fmt("Error reading IAVLNode. bytes: %X error: %v", buf, err))
+ }
+ node.hash = hash
+ node.persisted = true
+ ndb.cacheNode(node)
+ return node
+ }
+}
+
+func (ndb *nodeDB) SaveNode(t *IAVLTree, node *IAVLNode) {
+ ndb.mtx.Lock()
+ defer ndb.mtx.Unlock()
+ if node.hash == nil {
+ panic("Expected to find node.hash, but none found.")
+ }
+ if node.persisted {
+ panic("Shouldn't be calling save on an already persisted node.")
+ }
+ /*if _, ok := ndb.cache[string(node.hash)]; ok {
+ panic("Shouldn't be calling save on an already cached node.")
+ }*/
+ // Save node bytes to db
+ buf := bytes.NewBuffer(nil)
+ _, err := node.writePersistBytes(t, buf)
+ if err != nil {
+ panic(err)
+ }
+ ndb.db.Set(node.hash, buf.Bytes())
+ node.persisted = true
+ ndb.cacheNode(node)
+}
+
+func (ndb *nodeDB) cacheNode(node *IAVLNode) {
+ // Create entry in cache and append to cacheQueue.
+ elem := ndb.cacheQueue.PushBack(node.hash)
+ ndb.cache[string(node.hash)] = nodeElement{node, elem}
+ // Maybe expire an item.
+ if ndb.cacheQueue.Len() > ndb.cacheSize {
+ hash := ndb.cacheQueue.Remove(ndb.cacheQueue.Front()).([]byte)
+ delete(ndb.cache, string(hash))
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/simple_tree.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/simple_tree.go
new file mode 100644
index 0000000000000000000000000000000000000000..79def4561ce46c044c367ce17794cd71b723352d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/simple_tree.go
@@ -0,0 +1,178 @@
+/*
+Computes a deterministic minimal height merkle tree hash.
+If the number of items is not a power of two, some leaves
+will be at different levels. Tries to keep both sides of
+the tree the same size, but the left may be one greater.
+
+Use this for short deterministic trees, such as the validator list.
+For larger datasets, use IAVLTree.
+
+ *
+ / \
+ / \
+ / \
+ / \
+ * *
+ / \ / \
+ / \ / \
+ / \ / \
+ * * * h6
+ / \ / \ / \
+ h0 h1 h2 h3 h4 h5
+
+*/
+
+package merkle
+
+import (
+ "bytes"
+ "crypto/sha256"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+)
+
+func HashFromTwoHashes(left []byte, right []byte) []byte {
+ var n int64
+ var err error
+ var hasher = sha256.New()
+ binary.WriteByteSlice(left, hasher, &n, &err)
+ binary.WriteByteSlice(right, hasher, &n, &err)
+ if err != nil {
+ panic(err)
+ }
+ return hasher.Sum(nil)
+}
+
+func HashFromHashes(hashes [][]byte) []byte {
+ // Recursive impl.
+ switch len(hashes) {
+ case 0:
+ return nil
+ case 1:
+ return hashes[0]
+ default:
+ left := HashFromHashes(hashes[:(len(hashes)+1)/2])
+ right := HashFromHashes(hashes[(len(hashes)+1)/2:])
+ return HashFromTwoHashes(left, right)
+ }
+}
+
+// Convenience for HashFromHashes.
+func HashFromBinaries(items []interface{}) []byte {
+ hashes := [][]byte{}
+ for _, item := range items {
+ hashes = append(hashes, HashFromBinary(item))
+ }
+ return HashFromHashes(hashes)
+}
+
+// General Convenience
+func HashFromBinary(item interface{}) []byte {
+ hasher, n, err := sha256.New(), new(int64), new(error)
+ binary.WriteBinary(item, hasher, n, err)
+ if *err != nil {
+ panic(err)
+ }
+ return hasher.Sum(nil)
+}
+
+// Convenience for HashFromHashes.
+func HashFromHashables(items []Hashable) []byte {
+ hashes := [][]byte{}
+ for _, item := range items {
+ hash := item.Hash()
+ hashes = append(hashes, hash)
+ }
+ return HashFromHashes(hashes)
+}
+
+type HashTrail struct {
+ Hash []byte
+ Parent *HashTrail
+ Left *HashTrail
+ Right *HashTrail
+}
+
+func (ht *HashTrail) Flatten() [][]byte {
+ // Nonrecursive impl.
+ trail := [][]byte{}
+ for ht != nil {
+ if ht.Left != nil {
+ trail = append(trail, ht.Left.Hash)
+ } else if ht.Right != nil {
+ trail = append(trail, ht.Right.Hash)
+ } else {
+ break
+ }
+ ht = ht.Parent
+ }
+ return trail
+}
+
+// returned trails[0].Hash is the leaf hash.
+// trails[0].Parent.Hash is the hash above that, etc.
+func HashTrailsFromHashables(items []Hashable) (trails []*HashTrail, root *HashTrail) {
+ // Recursive impl.
+ switch len(items) {
+ case 0:
+ return nil, nil
+ case 1:
+ trail := &HashTrail{items[0].Hash(), nil, nil, nil}
+ return []*HashTrail{trail}, trail
+ default:
+ lefts, leftRoot := HashTrailsFromHashables(items[:(len(items)+1)/2])
+ rights, rightRoot := HashTrailsFromHashables(items[(len(items)+1)/2:])
+ rootHash := HashFromTwoHashes(leftRoot.Hash, rightRoot.Hash)
+ root := &HashTrail{rootHash, nil, nil, nil}
+ leftRoot.Parent = root
+ leftRoot.Right = rightRoot
+ rightRoot.Parent = root
+ rightRoot.Left = leftRoot
+ return append(lefts, rights...), root
+ }
+}
+
+// Ensures that leafHash is part of rootHash.
+func VerifyHashTrail(index uint, total uint, leafHash []byte, trail [][]byte, rootHash []byte) bool {
+ computedRoot := ComputeRootFromTrail(index, total, leafHash, trail)
+ if computedRoot == nil {
+ return false
+ }
+ return bytes.Equal(computedRoot, rootHash)
+}
+
+// Use the leafHash and trail to get the root merkle hash.
+// If the length of the trail slice isn't exactly correct, the result is nil.
+func ComputeRootFromTrail(index uint, total uint, leafHash []byte, trail [][]byte) []byte {
+ // Recursive impl.
+ if index >= total {
+ return nil
+ }
+ switch total {
+ case 0:
+ panic("Cannot call ComputeRootFromTrail() with 0 total")
+ case 1:
+ if len(trail) != 0 {
+ return nil
+ }
+ return leafHash
+ default:
+ if len(trail) == 0 {
+ return nil
+ }
+ numLeft := (total + 1) / 2
+ if index < numLeft {
+ leftRoot := ComputeRootFromTrail(index, numLeft, leafHash, trail[:len(trail)-1])
+ if leftRoot == nil {
+ return nil
+ }
+ return HashFromTwoHashes(leftRoot, trail[len(trail)-1])
+ } else {
+ rightRoot := ComputeRootFromTrail(index-numLeft, total-numLeft, leafHash, trail[:len(trail)-1])
+ if rightRoot == nil {
+ return nil
+ }
+ return HashFromTwoHashes(trail[len(trail)-1], rightRoot)
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/simple_tree_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/simple_tree_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..9d9b36b790fce331e463a1569d4ce0496bfe42f8
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/simple_tree_test.go
@@ -0,0 +1,74 @@
+package merkle
+
+import (
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+
+ "bytes"
+ "testing"
+)
+
+type testItem []byte
+
+func (tI testItem) Hash() []byte {
+ return []byte(tI)
+}
+
+func TestMerkleTrails(t *testing.T) {
+
+ numItems := uint(100)
+
+ items := make([]Hashable, numItems)
+ for i := uint(0); i < numItems; i++ {
+ items[i] = testItem(RandBytes(32))
+ }
+
+ root := HashFromHashables(items)
+
+ trails, rootTrail := HashTrailsFromHashables(items)
+
+ // Assert that HashFromHashables and HashTrailsFromHashables are compatible.
+ if !bytes.Equal(root, rootTrail.Hash) {
+ t.Errorf("Root mismatch:\n%X vs\n%X", root, rootTrail.Hash)
+ }
+
+ // For each item, check the trail.
+ for i, item := range items {
+ itemHash := item.Hash()
+ flatTrail := trails[i].Flatten()
+
+ // Verify success
+ ok := VerifyHashTrail(uint(i), numItems, itemHash, flatTrail, root)
+ if !ok {
+ t.Errorf("Verification failed for index %v.", i)
+ }
+
+ // Wrong item index should make it fail
+ ok = VerifyHashTrail(uint(i)+1, numItems, itemHash, flatTrail, root)
+ if ok {
+ t.Errorf("Expected verification to fail for wrong index %v.", i)
+ }
+
+ // Trail too long should make it fail
+ trail2 := append(flatTrail, RandBytes(32))
+ ok = VerifyHashTrail(uint(i), numItems, itemHash, trail2, root)
+ if ok {
+ t.Errorf("Expected verification to fail for wrong trail length.")
+ }
+
+ // Trail too short should make it fail
+ trail2 = flatTrail[:len(flatTrail)-1]
+ ok = VerifyHashTrail(uint(i), numItems, itemHash, trail2, root)
+ if ok {
+ t.Errorf("Expected verification to fail for wrong trail length.")
+ }
+
+ // Mutating the itemHash should make it fail.
+ itemHash2 := make([]byte, len(itemHash))
+ copy(itemHash2, itemHash)
+ itemHash2[0] += byte(0x01)
+ ok = VerifyHashTrail(uint(i), numItems, itemHash2, flatTrail, root)
+ if ok {
+ t.Errorf("Expected verification to fail for mutated leaf hash")
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/types.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..68a461310c30b91aa805b4ff849d895456a95fc5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/types.go
@@ -0,0 +1,21 @@
+package merkle
+
+type Tree interface {
+ Size() (size uint)
+ Height() (height uint8)
+ Has(key interface{}) (has bool)
+ Get(key interface{}) (index uint, value interface{})
+ GetByIndex(index uint) (key interface{}, value interface{})
+ Set(key interface{}, value interface{}) (updated bool)
+ Remove(key interface{}) (value interface{}, removed bool)
+ HashWithCount() (hash []byte, count uint)
+ Hash() (hash []byte)
+ Save() (hash []byte)
+ Load(hash []byte)
+ Copy() Tree
+ Iterate(func(key interface{}, value interface{}) (stop bool)) (stopped bool)
+}
+
+type Hashable interface {
+ Hash() []byte
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/util.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..edc3fbf74941e20ffee25c880e773d5b7b8bb168
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle/util.go
@@ -0,0 +1,43 @@
+package merkle
+
+import (
+ "fmt"
+)
+
+// Prints the in-memory children recursively.
+func PrintIAVLNode(node *IAVLNode) {
+ fmt.Println("==== NODE")
+ if node != nil {
+ printIAVLNode(node, 0)
+ }
+ fmt.Println("==== END")
+}
+
+func printIAVLNode(node *IAVLNode, indent int) {
+ indentPrefix := ""
+ for i := 0; i < indent; i++ {
+ indentPrefix += " "
+ }
+
+ if node.rightNode != nil {
+ printIAVLNode(node.rightNode, indent+1)
+ } else if node.rightHash != nil {
+ fmt.Printf("%s %X\n", indentPrefix, node.rightHash)
+ }
+
+ fmt.Printf("%s%v:%v\n", indentPrefix, node.key, node.height)
+
+ if node.leftNode != nil {
+ printIAVLNode(node.leftNode, indent+1)
+ } else if node.leftHash != nil {
+ fmt.Printf("%s %X\n", indentPrefix, node.leftHash)
+ }
+
+}
+
+func maxUint8(a, b uint8) uint8 {
+ if a > b {
+ return a
+ }
+ return b
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/node/config.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/node/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..67e802981239b922996aa717ebba2b1301ca106e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/node/config.go
@@ -0,0 +1,13 @@
+package node
+
+import (
+ cfg "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config"
+)
+
+var config cfg.Config = nil
+
+func init() {
+ cfg.OnConfig(func(newConfig cfg.Config) {
+ config = newConfig
+ })
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/node/id.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/node/id.go
new file mode 100644
index 0000000000000000000000000000000000000000..23c75f3451e5f42367d745937b1bcc254242c6f9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/node/id.go
@@ -0,0 +1,34 @@
+package node
+
+import (
+ acm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "time"
+)
+
+type NodeID struct {
+ Name string
+ PubKey acm.PubKey
+}
+
+type PrivNodeID struct {
+ NodeID
+ PrivKey acm.PrivKey
+}
+
+type NodeGreeting struct {
+ NodeID
+ Version string
+ ChainID string
+ Message string
+ Time time.Time
+}
+
+type SignedNodeGreeting struct {
+ NodeGreeting
+ Signature acm.Signature
+}
+
+func (pnid *PrivNodeID) SignGreeting() *SignedNodeGreeting {
+ //greeting := NodeGreeting{}
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/node/log.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/node/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..73ac43eb67340eb8cafb11a0ae041f3d87b9dde3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/node/log.go
@@ -0,0 +1,7 @@
+package node
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/logger"
+)
+
+var log = logger.New("module", "node")
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/node/node.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/node/node.go
new file mode 100644
index 0000000000000000000000000000000000000000..d94b01df401acfbec8f650f2667d773aa5d48a6e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/node/node.go
@@ -0,0 +1,265 @@
+package node
+
+import (
+ "fmt"
+ "math/rand"
+ "net"
+ "net/http"
+ "os"
+ "strconv"
+ "strings"
+ "time"
+
+ bc "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus"
+ dbm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/db"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/events"
+ mempl "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/server"
+ sm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+import _ "net/http/pprof"
+
+func init() {
+ go func() {
+ fmt.Println(http.ListenAndServe("0.0.0.0:6060", nil))
+ }()
+}
+
+type Node struct {
+ sw *p2p.Switch
+ evsw *events.EventSwitch
+ book *p2p.AddrBook
+ blockStore *bc.BlockStore
+ pexReactor *p2p.PEXReactor
+ bcReactor *bc.BlockchainReactor
+ mempoolReactor *mempl.MempoolReactor
+ consensusState *consensus.ConsensusState
+ consensusReactor *consensus.ConsensusReactor
+ privValidator *sm.PrivValidator
+}
+
+func NewNode() *Node {
+ // Get BlockStore
+ blockStoreDB := dbm.GetDB("blockstore")
+ blockStore := bc.NewBlockStore(blockStoreDB)
+
+ // Get State
+ stateDB := dbm.GetDB("state")
+ state := sm.LoadState(stateDB)
+ if state == nil {
+ state = sm.MakeGenesisStateFromFile(stateDB, config.GetString("genesis_file"))
+ state.Save()
+ }
+ // add the chainid to the global config
+ config.Set("chain_id", state.ChainID)
+
+ // Get PrivValidator
+ var privValidator *sm.PrivValidator
+ privValidatorFile := config.GetString("priv_validator_file")
+ if _, err := os.Stat(privValidatorFile); err == nil {
+ privValidator = sm.LoadPrivValidator(privValidatorFile)
+ log.Info("Loaded PrivValidator",
+ "file", privValidatorFile, "privValidator", privValidator)
+ } else {
+ privValidator = sm.GenPrivValidator()
+ privValidator.SetFile(privValidatorFile)
+ privValidator.Save()
+ log.Info("Generated PrivValidator", "file", privValidatorFile)
+ }
+
+ eventSwitch := new(events.EventSwitch)
+ eventSwitch.Start()
+
+ // Get PEXReactor
+ book := p2p.NewAddrBook(config.GetString("addrbook_file"))
+ pexReactor := p2p.NewPEXReactor(book)
+
+ // Get BlockchainReactor
+ bcReactor := bc.NewBlockchainReactor(state, blockStore, config.GetBool("fast_sync"))
+
+ // Get MempoolReactor
+ mempool := mempl.NewMempool(state.Copy())
+ mempoolReactor := mempl.NewMempoolReactor(mempool)
+
+ // Get ConsensusReactor
+ consensusState := consensus.NewConsensusState(state, blockStore, mempoolReactor)
+ consensusReactor := consensus.NewConsensusReactor(consensusState, blockStore, config.GetBool("fast_sync"))
+ if privValidator != nil {
+ consensusReactor.SetPrivValidator(privValidator)
+ }
+
+ sw := p2p.NewSwitch()
+ sw.AddReactor("PEX", pexReactor)
+ sw.AddReactor("MEMPOOL", mempoolReactor)
+ sw.AddReactor("BLOCKCHAIN", bcReactor)
+ sw.AddReactor("CONSENSUS", consensusReactor)
+
+ // add the event switch to all services
+ // they should all satisfy events.Eventable
+ SetFireable(eventSwitch, pexReactor, bcReactor, mempoolReactor, consensusReactor)
+
+ return &Node{
+ sw: sw,
+ evsw: eventSwitch,
+ book: book,
+ blockStore: blockStore,
+ pexReactor: pexReactor,
+ bcReactor: bcReactor,
+ mempoolReactor: mempoolReactor,
+ consensusState: consensusState,
+ consensusReactor: consensusReactor,
+ privValidator: privValidator,
+ }
+}
+
+// Call Start() after adding the listeners.
+func (n *Node) Start() {
+ log.Info("Starting Node")
+ n.book.Start()
+ nodeInfo := makeNodeInfo(n.sw)
+ n.sw.SetNodeInfo(nodeInfo)
+ n.sw.Start()
+}
+
+func (n *Node) Stop() {
+ log.Info("Stopping Node")
+ // TODO: gracefully disconnect from peers.
+ n.sw.Stop()
+ n.book.Stop()
+}
+
+// Add the event switch to reactors, mempool, etc.
+func SetFireable(evsw *events.EventSwitch, eventables ...events.Eventable) {
+ for _, e := range eventables {
+ e.SetFireable(evsw)
+ }
+}
+
+// Add a Listener to accept inbound peer connections.
+// Add listeners before starting the Node.
+// The first listener is the primary listener (in NodeInfo)
+func (n *Node) AddListener(l p2p.Listener) {
+ log.Info(Fmt("Added %v", l))
+ n.sw.AddListener(l)
+ n.book.AddOurAddress(l.ExternalAddress())
+}
+
+// NOTE: Blocking
+func (n *Node) DialSeed() {
+ // permute the list, dial them in random order.
+ seeds := strings.Split(config.GetString("seeds"), ",")
+ perm := rand.Perm(len(seeds))
+ for i := 0; i < len(perm); i++ {
+ go func(i int) {
+ time.Sleep(time.Duration(rand.Int63n(3000)) * time.Millisecond)
+ j := perm[i]
+ addr := p2p.NewNetAddressString(seeds[j])
+ n.dialSeed(addr)
+ }(i)
+ }
+}
+
+func (n *Node) dialSeed(addr *p2p.NetAddress) {
+ peer, err := n.sw.DialPeerWithAddress(addr)
+ if err != nil {
+ log.Error("Error dialing seed", "error", err)
+ //n.book.MarkAttempt(addr)
+ return
+ } else {
+ log.Info("Connected to seed", "peer", peer)
+ n.book.AddAddress(addr, addr)
+ }
+}
+
+func (n *Node) StartRPC() {
+ core.SetBlockStore(n.blockStore)
+ core.SetConsensusState(n.consensusState)
+ core.SetConsensusReactor(n.consensusReactor)
+ core.SetMempoolReactor(n.mempoolReactor)
+ core.SetSwitch(n.sw)
+ core.SetPrivValidator(n.privValidator)
+
+ listenAddr := config.GetString("rpc_laddr")
+ mux := http.NewServeMux()
+ rpcserver.RegisterEventsHandler(mux, n.evsw)
+ rpcserver.RegisterRPCFuncs(mux, core.Routes)
+ rpcserver.StartHTTPServer(listenAddr, mux)
+}
+
+func (n *Node) Switch() *p2p.Switch {
+ return n.sw
+}
+
+func (n *Node) BlockStore() *bc.BlockStore {
+ return n.blockStore
+}
+
+func (n *Node) ConsensusState() *consensus.ConsensusState {
+ return n.consensusState
+}
+
+func (n *Node) MempoolReactor() *mempl.MempoolReactor {
+ return n.mempoolReactor
+}
+
+func (n *Node) EventSwitch() *events.EventSwitch {
+ return n.evsw
+}
+
+func makeNodeInfo(sw *p2p.Switch) *types.NodeInfo {
+ nodeInfo := &types.NodeInfo{
+ ChainID: config.GetString("chain_id"),
+ Moniker: config.GetString("moniker"),
+ Version: config.GetString("version"),
+ }
+ if !sw.IsListening() {
+ return nodeInfo
+ }
+ p2pListener := sw.Listeners()[0]
+ p2pHost := p2pListener.ExternalAddress().IP.String()
+ p2pPort := p2pListener.ExternalAddress().Port
+ rpcListenAddr := config.GetString("rpc_laddr")
+ _, rpcPortStr, _ := net.SplitHostPort(rpcListenAddr)
+ rpcPort, err := strconv.Atoi(rpcPortStr)
+ if err != nil {
+ panic(Fmt("Expected numeric RPC.ListenAddr port but got %v", rpcPortStr))
+ }
+
+ // We assume that the rpcListener has the same ExternalAddress.
+ // This is probably true because both P2P and RPC listeners use UPnP.
+ nodeInfo.Host = p2pHost
+ nodeInfo.P2PPort = p2pPort
+ nodeInfo.RPCPort = uint16(rpcPort)
+ return nodeInfo
+}
+
+//------------------------------------------------------------------------------
+
+func RunNode() {
+ // Create & start node
+ n := NewNode()
+ l := p2p.NewDefaultListener("tcp", config.GetString("node_laddr"), false)
+ n.AddListener(l)
+ n.Start()
+
+ // If seedNode is provided by config, dial out.
+ if len(config.GetString("seeds")) > 0 {
+ n.DialSeed()
+ }
+
+ // Run the RPC server.
+ if config.GetString("rpc_laddr") != "" {
+ n.StartRPC()
+ }
+
+ // Sleep forever and then...
+ TrapSignal(func() {
+ n.Stop()
+ })
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/README.md b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..cfbbf5c7d492ad9088acdafeb82c64f218d0a764
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/README.md
@@ -0,0 +1,77 @@
+# `tendermint/p2p`
+
+`tendermint/p2p` provides an abstraction around peer-to-peer communication.<br/>
+
+## Peer/MConnection/Channel
+
+Each peer has one `MConnection` (multiplex connection) instance.
+
+__multiplex__ *noun* a system or signal involving simultaneous transmission of
+several messages along a single channel of communication.
+
+Each `MConnection` handles message transmission on multiple abstract communication
+`Channel`s. Each channel has a globally unique byte id.
+The byte id and the relative priorities of each `Channel` are configured upon
+initialization of the connection.
+
+There are two methods for sending messages:
+```go
+func (m MConnection) Send(chId byte, msg interface{}) bool {}
+func (m MConnection) TrySend(chId byte, msg interface{}) bool {}
+```
+
+`Send(chId, msg)` is a blocking call that waits until `msg` is successfully queued
+for the channel with the given id byte `chId`. The message `msg` is serialized
+using the `tendermint/binary` submodule's `WriteBinary()` reflection routine.
+
+`TrySend(chId, msg)` is a nonblocking call that returns false if the channel's
+queue is full.
+
+`Send()` and `TrySend()` are also exposed for each `Peer`.
+
+## Switch/Reactor
+
+The `Switch` handles peer connections and exposes an API to receive incoming messages
+on `Reactors`. Each `Reactor` is responsible for handling incoming messages of one
+or more `Channels`. So while sending outgoing messages is typically performed on the peer,
+incoming messages are received on the reactor.
+
+```go
+// Declare a MyReactor reactor that handles messages on MyChannelId.
+type MyReactor struct{}
+
+func (reactor MyReactor) GetChannels() []*ChannelDescriptor {
+ return []*ChannelDescriptor{ChannelDescriptor{Id:MyChannelId, Priority: 1}}
+}
+
+func (reactor MyReactor) Receive(chId byte, peer *Peer, msgBytes []byte) {
+ r, n, err := bytes.NewBuffer(msgBytes), new(int64), new(error)
+ msgString := ReadString(r, n, err)
+ fmt.Println(msgString)
+}
+
+// Other Reactor methods omitted for brevity
+...
+
+switch := NewSwitch([]Reactor{MyReactor{}})
+
+...
+
+// Send a random message to all outbound connections
+for _, peer := range switch.Peers().List() {
+ if peer.IsOutbound() {
+ peer.Send(MyChannelId, "Here's a random message")
+ }
+}
+```
+
+### PexReactor/AddrBook
+
+A `PEXReactor` reactor implementation is provided to automate peer discovery.
+
+```go
+book := p2p.NewAddrBook(config.App.GetString("AddrBookFile"))
+pexReactor := p2p.NewPEXReactor(book)
+...
+switch := NewSwitch([]Reactor{pexReactor, myReactor, ...})
+```
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/addrbook.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/addrbook.go
new file mode 100644
index 0000000000000000000000000000000000000000..c72276af827a2861104870c91a5cb13bbafd6510
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/addrbook.go
@@ -0,0 +1,818 @@
+// Modified for Tendermint
+// Originally Copyright (c) 2013-2014 Conformal Systems LLC.
+// https://github.com/conformal/btcd/blob/master/LICENSE
+
+package p2p
+
+import (
+ "encoding/binary"
+ "encoding/json"
+ "math"
+ "math/rand"
+ "net"
+ "os"
+ "sync"
+ "sync/atomic"
+ "time"
+
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+const (
+ // addresses under which the address manager will claim to need more addresses.
+ needAddressThreshold = 1000
+
+ // interval used to dump the address cache to disk for future use.
+ dumpAddressInterval = time.Minute * 2
+
+ // max addresses in each old address bucket.
+ oldBucketSize = 64
+
+ // buckets we split old addresses over.
+ oldBucketCount = 64
+
+ // max addresses in each new address bucket.
+ newBucketSize = 64
+
+ // buckets that we spread new addresses over.
+ newBucketCount = 256
+
+ // old buckets over which an address group will be spread.
+ oldBucketsPerGroup = 4
+
+ // new buckets over which an source address group will be spread.
+ newBucketsPerGroup = 32
+
+ // buckets a frequently seen new address may end up in.
+ maxNewBucketsPerAddress = 4
+
+ // days before which we assume an address has vanished
+ // if we have not seen it announced in that long.
+ numMissingDays = 30
+
+ // tries without a single success before we assume an address is bad.
+ numRetries = 3
+
+ // max failures we will accept without a success before considering an address bad.
+ maxFailures = 10
+
+ // days since the last success before we will consider evicting an address.
+ minBadDays = 7
+
+ // % of total addresses known returned by GetSelection.
+ getSelectionPercent = 23
+
+ // min addresses that must be returned by GetSelection. Useful for bootstrapping.
+ minGetSelection = 32
+
+ // max addresses returned by GetSelection
+ maxGetSelection = 2500
+
+ // current version of the on-disk format.
+ serializationVersion = 1
+)
+
+/* AddrBook - concurrency safe peer address manager */
+type AddrBook struct {
+ filePath string
+
+ mtx sync.Mutex
+ rand *rand.Rand
+ key string
+ ourAddrs map[string]*NetAddress
+ addrLookup map[string]*knownAddress // new & old
+ addrNew []map[string]*knownAddress
+ addrOld []map[string]*knownAddress
+ started uint32
+ stopped uint32
+ wg sync.WaitGroup
+ quit chan struct{}
+ nOld int
+ nNew int
+}
+
+const (
+ bucketTypeNew = 0x01
+ bucketTypeOld = 0x02
+)
+
+// Use Start to begin processing asynchronous address updates.
+func NewAddrBook(filePath string) *AddrBook {
+ am := AddrBook{
+ rand: rand.New(rand.NewSource(time.Now().UnixNano())),
+ ourAddrs: make(map[string]*NetAddress),
+ addrLookup: make(map[string]*knownAddress),
+ quit: make(chan struct{}),
+ filePath: filePath,
+ }
+ am.init()
+ return &am
+}
+
+// When modifying this, don't forget to update loadFromFile()
+func (a *AddrBook) init() {
+ a.key = CRandHex(24) // 24/2 * 8 = 96 bits
+ // New addr buckets
+ a.addrNew = make([]map[string]*knownAddress, newBucketCount)
+ for i := range a.addrNew {
+ a.addrNew[i] = make(map[string]*knownAddress)
+ }
+ // Old addr buckets
+ a.addrOld = make([]map[string]*knownAddress, oldBucketCount)
+ for i := range a.addrOld {
+ a.addrOld[i] = make(map[string]*knownAddress)
+ }
+}
+
+func (a *AddrBook) Start() {
+ if atomic.CompareAndSwapUint32(&a.started, 0, 1) {
+ log.Info("Starting AddrBook")
+ a.loadFromFile(a.filePath)
+ a.wg.Add(1)
+ go a.saveRoutine()
+ }
+}
+
+func (a *AddrBook) Stop() {
+ if atomic.CompareAndSwapUint32(&a.stopped, 0, 1) {
+ log.Info("Stopping AddrBook")
+ close(a.quit)
+ a.wg.Wait()
+ }
+}
+
+func (a *AddrBook) AddOurAddress(addr *NetAddress) {
+ a.mtx.Lock()
+ defer a.mtx.Unlock()
+ log.Debug("Add our address to book", "addr", addr)
+ a.ourAddrs[addr.String()] = addr
+}
+
+func (a *AddrBook) OurAddresses() []*NetAddress {
+ addrs := []*NetAddress{}
+ for _, addr := range a.ourAddrs {
+ addrs = append(addrs, addr)
+ }
+ return addrs
+}
+
+func (a *AddrBook) AddAddress(addr *NetAddress, src *NetAddress) {
+ a.mtx.Lock()
+ defer a.mtx.Unlock()
+ log.Debug("Add address to book", "addr", addr, "src", src)
+ a.addAddress(addr, src)
+}
+
+func (a *AddrBook) NeedMoreAddrs() bool {
+ return a.Size() < needAddressThreshold
+}
+
+func (a *AddrBook) Size() int {
+ a.mtx.Lock()
+ defer a.mtx.Unlock()
+ return a.size()
+}
+
+func (a *AddrBook) size() int {
+ return a.nNew + a.nOld
+}
+
+// Pick an address to connect to with new/old bias.
+func (a *AddrBook) PickAddress(newBias int) *NetAddress {
+ a.mtx.Lock()
+ defer a.mtx.Unlock()
+
+ if a.size() == 0 {
+ return nil
+ }
+ if newBias > 100 {
+ newBias = 100
+ }
+ if newBias < 0 {
+ newBias = 0
+ }
+
+ // Bias between new and old addresses.
+ oldCorrelation := math.Sqrt(float64(a.nOld)) * (100.0 - float64(newBias))
+ newCorrelation := math.Sqrt(float64(a.nNew)) * float64(newBias)
+
+ if (newCorrelation+oldCorrelation)*a.rand.Float64() < oldCorrelation {
+ // pick random Old bucket.
+ var bucket map[string]*knownAddress = nil
+ for len(bucket) == 0 {
+ bucket = a.addrOld[a.rand.Intn(len(a.addrOld))]
+ }
+ // pick a random ka from bucket.
+ randIndex := a.rand.Intn(len(bucket))
+ for _, ka := range bucket {
+ if randIndex == 0 {
+ return ka.Addr
+ }
+ randIndex--
+ }
+ panic("Should not happen")
+ } else {
+ // pick random New bucket.
+ var bucket map[string]*knownAddress = nil
+ for len(bucket) == 0 {
+ bucket = a.addrNew[a.rand.Intn(len(a.addrNew))]
+ }
+ // pick a random ka from bucket.
+ randIndex := a.rand.Intn(len(bucket))
+ for _, ka := range bucket {
+ if randIndex == 0 {
+ return ka.Addr
+ }
+ randIndex--
+ }
+ panic("Should not happen")
+ }
+ return nil
+}
+
+func (a *AddrBook) MarkGood(addr *NetAddress) {
+ a.mtx.Lock()
+ defer a.mtx.Unlock()
+ ka := a.addrLookup[addr.String()]
+ if ka == nil {
+ return
+ }
+ ka.markGood()
+ if ka.isNew() {
+ a.moveToOld(ka)
+ }
+}
+
+func (a *AddrBook) MarkAttempt(addr *NetAddress) {
+ a.mtx.Lock()
+ defer a.mtx.Unlock()
+ ka := a.addrLookup[addr.String()]
+ if ka == nil {
+ return
+ }
+ ka.markAttempt()
+}
+
+func (a *AddrBook) MarkBad(addr *NetAddress) {
+ a.mtx.Lock()
+ defer a.mtx.Unlock()
+ ka := a.addrLookup[addr.String()]
+ if ka == nil {
+ return
+ }
+ // We currently just eject the address.
+ // In the future, consider blacklisting.
+ a.removeFromAllBuckets(ka)
+}
+
+/* Peer exchange */
+
+// GetSelection randomly selects some addresses (old & new). Suitable for peer-exchange protocols.
+func (a *AddrBook) GetSelection() []*NetAddress {
+ a.mtx.Lock()
+ defer a.mtx.Unlock()
+
+ if a.size() == 0 {
+ return nil
+ }
+
+ allAddr := make([]*NetAddress, a.size())
+ i := 0
+ for _, v := range a.addrLookup {
+ allAddr[i] = v.Addr
+ i++
+ }
+
+ numAddresses := MaxInt(
+ MinInt(minGetSelection, len(allAddr)),
+ len(allAddr)*getSelectionPercent/100)
+ numAddresses = MinInt(maxGetSelection, numAddresses)
+
+ // Fisher-Yates shuffle the array. We only need to do the first
+ // `numAddresses' since we are throwing the rest.
+ for i := 0; i < numAddresses; i++ {
+ // pick a number between current index and the end
+ j := rand.Intn(len(allAddr)-i) + i
+ allAddr[i], allAddr[j] = allAddr[j], allAddr[i]
+ }
+
+ // slice off the limit we are willing to share.
+ return allAddr[:numAddresses]
+}
+
+/* Loading & Saving */
+
+type addrBookJSON struct {
+ Key string
+ Addrs []*knownAddress
+}
+
+func (a *AddrBook) saveToFile(filePath string) {
+ // Compile Addrs
+ addrs := []*knownAddress{}
+ for _, ka := range a.addrLookup {
+ addrs = append(addrs, ka)
+ }
+
+ aJSON := &addrBookJSON{
+ Key: a.key,
+ Addrs: addrs,
+ }
+
+ jsonBytes, err := json.MarshalIndent(aJSON, "", "\t")
+ if err != nil {
+ log.Error("Failed to save AddrBook to file", "err", err)
+ return
+ }
+ err = WriteFileAtomic(filePath, jsonBytes)
+ if err != nil {
+ log.Error("Failed to save AddrBook to file", "file", filePath, "error", err)
+ }
+}
+
+// Returns false if file does not exist.
+// Panics if file is corrupt.
+func (a *AddrBook) loadFromFile(filePath string) bool {
+ // If doesn't exist, do nothing.
+ _, err := os.Stat(filePath)
+ if os.IsNotExist(err) {
+ return false
+ }
+
+ // Load addrBookJSON{}
+ r, err := os.Open(filePath)
+ if err != nil {
+ panic(Fmt("Error opening file %s: %v", filePath, err))
+ }
+ defer r.Close()
+ aJSON := &addrBookJSON{}
+ dec := json.NewDecoder(r)
+ err = dec.Decode(aJSON)
+ if err != nil {
+ panic(Fmt("Error reading file %s: %v", filePath, err))
+ }
+
+ // Restore all the fields...
+ // Restore the key
+ a.key = aJSON.Key
+ // Restore .addrNew & .addrOld
+ for _, ka := range aJSON.Addrs {
+ for _, bucketIndex := range ka.Buckets {
+ bucket := a.getBucket(ka.BucketType, bucketIndex)
+ bucket[ka.Addr.String()] = ka
+ }
+ a.addrLookup[ka.Addr.String()] = ka
+ if ka.BucketType == bucketTypeNew {
+ a.nNew++
+ } else {
+ a.nOld++
+ }
+ }
+ return true
+}
+
+/* Private methods */
+
+func (a *AddrBook) saveRoutine() {
+ dumpAddressTicker := time.NewTicker(dumpAddressInterval)
+out:
+ for {
+ select {
+ case <-dumpAddressTicker.C:
+ log.Debug("Saving AddrBook to file", "size", a.Size())
+ a.saveToFile(a.filePath)
+ case <-a.quit:
+ break out
+ }
+ }
+ dumpAddressTicker.Stop()
+ a.saveToFile(a.filePath)
+ a.wg.Done()
+ log.Info("Address handler done")
+}
+
+func (a *AddrBook) getBucket(bucketType byte, bucketIdx int) map[string]*knownAddress {
+ switch bucketType {
+ case bucketTypeNew:
+ return a.addrNew[bucketIdx]
+ case bucketTypeOld:
+ return a.addrOld[bucketIdx]
+ default:
+ panic("Should not happen")
+ }
+}
+
+// Adds ka to new bucket. Returns false if it couldn't do it cuz buckets full.
+// NOTE: currently it always returns true.
+func (a *AddrBook) addToNewBucket(ka *knownAddress, bucketIdx int) bool {
+ // Sanity check
+ if ka.isOld() {
+ log.Warn(Fmt("Cannot add address already in old bucket to a new bucket: %v", ka))
+ return false
+ }
+
+ addrStr := ka.Addr.String()
+ bucket := a.getBucket(bucketTypeNew, bucketIdx)
+
+ // Already exists?
+ if _, ok := bucket[addrStr]; ok {
+ return true
+ }
+
+ // Enforce max addresses.
+ if len(bucket) > newBucketSize {
+ log.Info("new bucket is full, expiring old ")
+ a.expireNew(bucketIdx)
+ }
+
+ // Add to bucket.
+ bucket[addrStr] = ka
+ if ka.addBucketRef(bucketIdx) == 1 {
+ a.nNew++
+ }
+
+ // Ensure in addrLookup
+ a.addrLookup[addrStr] = ka
+
+ return true
+}
+
+// Adds ka to old bucket. Returns false if it couldn't do it cuz buckets full.
+func (a *AddrBook) addToOldBucket(ka *knownAddress, bucketIdx int) bool {
+ // Sanity check
+ if ka.isNew() {
+ log.Warn(Fmt("Cannot add new address to old bucket: %v", ka))
+ return false
+ }
+ if len(ka.Buckets) != 0 {
+ log.Warn(Fmt("Cannot add already old address to another old bucket: %v", ka))
+ return false
+ }
+
+ addrStr := ka.Addr.String()
+ bucket := a.getBucket(bucketTypeNew, bucketIdx)
+
+ // Already exists?
+ if _, ok := bucket[addrStr]; ok {
+ return true
+ }
+
+ // Enforce max addresses.
+ if len(bucket) > oldBucketSize {
+ return false
+ }
+
+ // Add to bucket.
+ bucket[addrStr] = ka
+ if ka.addBucketRef(bucketIdx) == 1 {
+ a.nOld++
+ }
+
+ // Ensure in addrLookup
+ a.addrLookup[addrStr] = ka
+
+ return true
+}
+
+func (a *AddrBook) removeFromBucket(ka *knownAddress, bucketType byte, bucketIdx int) {
+ if ka.BucketType != bucketType {
+ log.Warn(Fmt("Bucket type mismatch: %v", ka))
+ return
+ }
+ bucket := a.getBucket(bucketType, bucketIdx)
+ delete(bucket, ka.Addr.String())
+ if ka.removeBucketRef(bucketIdx) == 0 {
+ if bucketType == bucketTypeNew {
+ a.nNew--
+ } else {
+ a.nOld--
+ }
+ delete(a.addrLookup, ka.Addr.String())
+ }
+}
+
+func (a *AddrBook) removeFromAllBuckets(ka *knownAddress) {
+ for _, bucketIdx := range ka.Buckets {
+ bucket := a.getBucket(ka.BucketType, bucketIdx)
+ delete(bucket, ka.Addr.String())
+ }
+ ka.Buckets = nil
+ if ka.BucketType == bucketTypeNew {
+ a.nNew--
+ } else {
+ a.nOld--
+ }
+ delete(a.addrLookup, ka.Addr.String())
+}
+
+func (a *AddrBook) pickOldest(bucketType byte, bucketIdx int) *knownAddress {
+ bucket := a.getBucket(bucketType, bucketIdx)
+ var oldest *knownAddress
+ for _, ka := range bucket {
+ if oldest == nil || ka.LastAttempt.Before(oldest.LastAttempt) {
+ oldest = ka
+ }
+ }
+ return oldest
+}
+
+func (a *AddrBook) addAddress(addr, src *NetAddress) {
+ if !addr.Routable() {
+ log.Warn(Fmt("Cannot add non-routable address %v", addr))
+ return
+ }
+ if _, ok := a.ourAddrs[addr.String()]; ok {
+ // Ignore our own listener address.
+ return
+ }
+
+ ka := a.addrLookup[addr.String()]
+
+ if ka != nil {
+ // Already old.
+ if ka.isOld() {
+ return
+ }
+ // Already in max new buckets.
+ if len(ka.Buckets) == maxNewBucketsPerAddress {
+ return
+ }
+ // The more entries we have, the less likely we are to add more.
+ factor := int32(2 * len(ka.Buckets))
+ if a.rand.Int31n(factor) != 0 {
+ return
+ }
+ } else {
+ ka = newKnownAddress(addr, src)
+ }
+
+ bucket := a.calcNewBucket(addr, src)
+ a.addToNewBucket(ka, bucket)
+
+ log.Info("Added new address", "address", addr, "total", a.size())
+}
+
+// Make space in the new buckets by expiring the really bad entries.
+// If no bad entries are available we remove the oldest.
+func (a *AddrBook) expireNew(bucketIdx int) {
+ for addrStr, ka := range a.addrNew[bucketIdx] {
+ // If an entry is bad, throw it away
+ if ka.isBad() {
+ log.Info(Fmt("expiring bad address %v", addrStr))
+ a.removeFromBucket(ka, bucketTypeNew, bucketIdx)
+ return
+ }
+ }
+
+ // If we haven't thrown out a bad entry, throw out the oldest entry
+ oldest := a.pickOldest(bucketTypeNew, bucketIdx)
+ a.removeFromBucket(oldest, bucketTypeNew, bucketIdx)
+}
+
+// Promotes an address from new to old.
+// TODO: Move to old probabilistically.
+// The better a node is, the less likely it should be evicted from an old bucket.
+func (a *AddrBook) moveToOld(ka *knownAddress) {
+ // Sanity check
+ if ka.isOld() {
+ log.Warn(Fmt("Cannot promote address that is already old %v", ka))
+ return
+ }
+ if len(ka.Buckets) == 0 {
+ log.Warn(Fmt("Cannot promote address that isn't in any new buckets %v", ka))
+ return
+ }
+
+ // Remember one of the buckets in which ka is in.
+ freedBucket := ka.Buckets[0]
+ // Remove from all (new) buckets.
+ a.removeFromAllBuckets(ka)
+ // It's officially old now.
+ ka.BucketType = bucketTypeOld
+
+ // Try to add it to its oldBucket destination.
+ oldBucketIdx := a.calcOldBucket(ka.Addr)
+ added := a.addToOldBucket(ka, oldBucketIdx)
+ if !added {
+ // No room, must evict something
+ oldest := a.pickOldest(bucketTypeOld, oldBucketIdx)
+ a.removeFromBucket(oldest, bucketTypeOld, oldBucketIdx)
+ // Find new bucket to put oldest in
+ newBucketIdx := a.calcNewBucket(oldest.Addr, oldest.Src)
+ added := a.addToNewBucket(oldest, newBucketIdx)
+ // No space in newBucket either, just put it in freedBucket from above.
+ if !added {
+ added := a.addToNewBucket(oldest, freedBucket)
+ if !added {
+ log.Warn(Fmt("Could not migrate oldest %v to freedBucket %v", oldest, freedBucket))
+ }
+ }
+ // Finally, add to bucket again.
+ added = a.addToOldBucket(ka, oldBucketIdx)
+ if !added {
+ log.Warn(Fmt("Could not re-add ka %v to oldBucketIdx %v", ka, oldBucketIdx))
+ }
+ }
+}
+
+// doublesha256(key + sourcegroup +
+// int64(doublesha256(key + group + sourcegroup))%bucket_per_source_group) % num_new_buckes
+func (a *AddrBook) calcNewBucket(addr, src *NetAddress) int {
+ data1 := []byte{}
+ data1 = append(data1, []byte(a.key)...)
+ data1 = append(data1, []byte(groupKey(addr))...)
+ data1 = append(data1, []byte(groupKey(src))...)
+ hash1 := doubleSha256(data1)
+ hash64 := binary.BigEndian.Uint64(hash1)
+ hash64 %= newBucketsPerGroup
+ var hashbuf [8]byte
+ binary.BigEndian.PutUint64(hashbuf[:], hash64)
+ data2 := []byte{}
+ data2 = append(data2, []byte(a.key)...)
+ data2 = append(data2, groupKey(src)...)
+ data2 = append(data2, hashbuf[:]...)
+
+ hash2 := doubleSha256(data2)
+ return int(binary.BigEndian.Uint64(hash2) % newBucketCount)
+}
+
+// doublesha256(key + group + truncate_to_64bits(doublesha256(key + addr))%buckets_per_group) % num_buckets
+func (a *AddrBook) calcOldBucket(addr *NetAddress) int {
+ data1 := []byte{}
+ data1 = append(data1, []byte(a.key)...)
+ data1 = append(data1, []byte(addr.String())...)
+ hash1 := doubleSha256(data1)
+ hash64 := binary.BigEndian.Uint64(hash1)
+ hash64 %= oldBucketsPerGroup
+ var hashbuf [8]byte
+ binary.BigEndian.PutUint64(hashbuf[:], hash64)
+ data2 := []byte{}
+ data2 = append(data2, []byte(a.key)...)
+ data2 = append(data2, groupKey(addr)...)
+ data2 = append(data2, hashbuf[:]...)
+
+ hash2 := doubleSha256(data2)
+ return int(binary.BigEndian.Uint64(hash2) % oldBucketCount)
+}
+
+// Return a string representing the network group of this address.
+// This is the /16 for IPv6, the /32 (/36 for he.net) for IPv6, the string
+// "local" for a local address and the string "unroutable for an unroutable
+// address.
+func groupKey(na *NetAddress) string {
+ if na.Local() {
+ return "local"
+ }
+ if !na.Routable() {
+ return "unroutable"
+ }
+
+ if ipv4 := na.IP.To4(); ipv4 != nil {
+ return (&net.IPNet{IP: na.IP, Mask: net.CIDRMask(16, 32)}).String()
+ }
+ if na.RFC6145() || na.RFC6052() {
+ // last four bytes are the ip address
+ ip := net.IP(na.IP[12:16])
+ return (&net.IPNet{IP: ip, Mask: net.CIDRMask(16, 32)}).String()
+ }
+
+ if na.RFC3964() {
+ ip := net.IP(na.IP[2:7])
+ return (&net.IPNet{IP: ip, Mask: net.CIDRMask(16, 32)}).String()
+
+ }
+ if na.RFC4380() {
+ // teredo tunnels have the last 4 bytes as the v4 address XOR
+ // 0xff.
+ ip := net.IP(make([]byte, 4))
+ for i, byte := range na.IP[12:16] {
+ ip[i] = byte ^ 0xff
+ }
+ return (&net.IPNet{IP: ip, Mask: net.CIDRMask(16, 32)}).String()
+ }
+
+ // OK, so now we know ourselves to be a IPv6 address.
+ // bitcoind uses /32 for everything, except for Hurricane Electric's
+ // (he.net) IP range, which it uses /36 for.
+ bits := 32
+ heNet := &net.IPNet{IP: net.ParseIP("2001:470::"),
+ Mask: net.CIDRMask(32, 128)}
+ if heNet.Contains(na.IP) {
+ bits = 36
+ }
+
+ return (&net.IPNet{IP: na.IP, Mask: net.CIDRMask(bits, 128)}).String()
+}
+
+//-----------------------------------------------------------------------------
+
+/*
+ knownAddress
+
+ tracks information about a known network address that is used
+ to determine how viable an address is.
+*/
+type knownAddress struct {
+ Addr *NetAddress
+ Src *NetAddress
+ Attempts uint32
+ LastAttempt time.Time
+ LastSuccess time.Time
+ BucketType byte
+ Buckets []int
+}
+
+func newKnownAddress(addr *NetAddress, src *NetAddress) *knownAddress {
+ return &knownAddress{
+ Addr: addr,
+ Src: src,
+ Attempts: 0,
+ LastAttempt: time.Now(),
+ BucketType: bucketTypeNew,
+ Buckets: nil,
+ }
+}
+
+func (ka *knownAddress) isOld() bool {
+ return ka.BucketType == bucketTypeOld
+}
+
+func (ka *knownAddress) isNew() bool {
+ return ka.BucketType == bucketTypeNew
+}
+
+func (ka *knownAddress) markAttempt() {
+ now := time.Now()
+ ka.LastAttempt = now
+ ka.Attempts += 1
+}
+
+func (ka *knownAddress) markGood() {
+ now := time.Now()
+ ka.LastAttempt = now
+ ka.Attempts = 0
+ ka.LastSuccess = now
+}
+
+func (ka *knownAddress) addBucketRef(bucketIdx int) int {
+ for _, bucket := range ka.Buckets {
+ if bucket == bucketIdx {
+ log.Warn(Fmt("Bucket already exists in ka.Buckets: %v", ka))
+ return -1
+ }
+ }
+ ka.Buckets = append(ka.Buckets, bucketIdx)
+ return len(ka.Buckets)
+}
+
+func (ka *knownAddress) removeBucketRef(bucketIdx int) int {
+ buckets := []int{}
+ for _, bucket := range ka.Buckets {
+ if bucket != bucketIdx {
+ buckets = append(buckets, bucket)
+ }
+ }
+ if len(buckets) != len(ka.Buckets)-1 {
+ log.Warn(Fmt("bucketIdx not found in ka.Buckets: %v", ka))
+ return -1
+ }
+ ka.Buckets = buckets
+ return len(ka.Buckets)
+}
+
+/*
+ An address is bad if the address in question has not been tried in the last
+ minute and meets one of the following criteria:
+
+ 1) It claims to be from the future
+ 2) It hasn't been seen in over a month
+ 3) It has failed at least three times and never succeeded
+ 4) It has failed ten times in the last week
+
+ All addresses that meet these criteria are assumed to be worthless and not
+ worth keeping hold of.
+*/
+func (ka *knownAddress) isBad() bool {
+ // Has been attempted in the last minute --> good
+ if ka.LastAttempt.Before(time.Now().Add(-1 * time.Minute)) {
+ return false
+ }
+
+ // Over a month old?
+ if ka.LastAttempt.After(time.Now().Add(-1 * numMissingDays * time.Hour * 24)) {
+ return true
+ }
+
+ // Never succeeded?
+ if ka.LastSuccess.IsZero() && ka.Attempts >= numRetries {
+ return true
+ }
+
+ // Hasn't succeeded in too long?
+ if ka.LastSuccess.Before(time.Now().Add(-1*minBadDays*time.Hour*24)) &&
+ ka.Attempts >= maxFailures {
+ return true
+ }
+
+ return false
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/addrbook_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/addrbook_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..50986452eeb6942bb98f90f7b59871f1844bebf1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/addrbook_test.go
@@ -0,0 +1,161 @@
+package p2p
+
+import (
+ "fmt"
+ "io/ioutil"
+ "math/rand"
+ "testing"
+)
+
+func createTempFileName(prefix string) string {
+ f, err := ioutil.TempFile("", prefix)
+ if err != nil {
+ panic(err)
+ }
+ fname := f.Name()
+ err = f.Close()
+ if err != nil {
+ panic(err)
+ }
+ return fname
+}
+
+func TestEmpty(t *testing.T) {
+ fname := createTempFileName("addrbook_test")
+ // t.Logf("New tempfile name: %v", fname)
+
+ // Save an empty book & load it
+ book := NewAddrBook(fname)
+ book.saveToFile(fname)
+
+ book = NewAddrBook(fname)
+ book.loadFromFile(fname)
+
+ if book.Size() != 0 {
+ t.Errorf("Expected 0 addresses, found %v", book.Size())
+ }
+}
+
+func randIPv4Address() *NetAddress {
+ for {
+ ip := fmt.Sprintf("%v.%v.%v.%v",
+ rand.Intn(254)+1,
+ rand.Intn(255),
+ rand.Intn(255),
+ rand.Intn(255),
+ )
+ port := rand.Intn(65535-1) + 1
+ addr := NewNetAddressString(fmt.Sprintf("%v:%v", ip, port))
+ if addr.Routable() {
+ return addr
+ }
+ }
+}
+
+func TestSaveAddresses(t *testing.T) {
+ fname := createTempFileName("addrbook_test")
+ //t.Logf("New tempfile name: %v", fname)
+
+ // Create some random addresses
+ randAddrs := []struct {
+ addr *NetAddress
+ src *NetAddress
+ }{}
+ for i := 0; i < 100; i++ {
+ addr := randIPv4Address()
+ src := randIPv4Address()
+ randAddrs = append(randAddrs, struct {
+ addr *NetAddress
+ src *NetAddress
+ }{
+ addr: addr,
+ src: src,
+ })
+ }
+
+ // Create the book & populate & save
+ book := NewAddrBook(fname)
+ for _, addrSrc := range randAddrs {
+ book.AddAddress(addrSrc.addr, addrSrc.src)
+ }
+ if book.Size() != 100 {
+ t.Errorf("Expected 100 addresses, found %v", book.Size())
+ }
+ book.saveToFile(fname)
+
+ // Reload the book
+ book = NewAddrBook(fname)
+ book.loadFromFile(fname)
+
+ // Test ...
+
+ if book.Size() != 100 {
+ t.Errorf("Expected 100 addresses, found %v", book.Size())
+ }
+
+ for _, addrSrc := range randAddrs {
+ addr := addrSrc.addr
+ src := addrSrc.src
+ ka := book.addrLookup[addr.String()]
+ if ka == nil {
+ t.Fatalf("Expected to find KnownAddress %v but wasn't there.", addr)
+ }
+ if !(ka.Addr.Equals(addr) && ka.Src.Equals(src)) {
+ t.Fatalf("KnownAddress doesn't match addr & src")
+ }
+ }
+}
+
+func TestPromoteToOld(t *testing.T) {
+ fname := createTempFileName("addrbook_test")
+ t.Logf("New tempfile name: %v", fname)
+
+ // Create some random addresses
+ randAddrs := []struct {
+ addr *NetAddress
+ src *NetAddress
+ }{}
+ for i := 0; i < 100; i++ {
+ addr := randIPv4Address()
+ src := randIPv4Address()
+ randAddrs = append(randAddrs, struct {
+ addr *NetAddress
+ src *NetAddress
+ }{
+ addr: addr,
+ src: src,
+ })
+ }
+
+ // Create the book & populate & save
+ book := NewAddrBook(fname)
+ for _, addrSrc := range randAddrs {
+ book.AddAddress(addrSrc.addr, addrSrc.src)
+ }
+ // Attempt all addresses.
+ for _, addrSrc := range randAddrs {
+ book.MarkAttempt(addrSrc.addr)
+ }
+ // Promote half of them
+ for i, addrSrc := range randAddrs {
+ if i%2 == 0 {
+ book.MarkGood(addrSrc.addr)
+ }
+ }
+ book.saveToFile(fname)
+
+ // Reload the book
+ book = NewAddrBook(fname)
+ book.loadFromFile(fname)
+
+ // Test ...
+
+ if book.Size() != 100 {
+ t.Errorf("Expected 100 addresses, found %v", book.Size())
+ }
+
+ // TODO: do more testing :)
+
+ selection := book.GetSelection()
+ t.Logf("selection: %v", selection)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/connection.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/connection.go
new file mode 100644
index 0000000000000000000000000000000000000000..d6119b361836bf880d57532ee914d4939ed07eda
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/connection.go
@@ -0,0 +1,620 @@
+package p2p
+
+import (
+ "bufio"
+ "fmt"
+ "io"
+ "math"
+ "net"
+ "runtime/debug"
+ "sync/atomic"
+ "time"
+
+ flow "github.com/eris-ltd/eris-db/Godeps/_workspace/src/code.google.com/p/mxk/go1/flowcontrol"
+ //"github.com/tendermint/log15"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+const (
+ numBatchMsgPackets = 10
+ minReadBufferSize = 1024
+ minWriteBufferSize = 1024
+ flushThrottleMS = 50
+ idleTimeoutMinutes = 5
+ updateStatsSeconds = 2
+ pingTimeoutMinutes = 2
+ defaultSendRate = 51200 // 5Kb/s
+ defaultRecvRate = 51200 // 5Kb/s
+ defaultSendQueueCapacity = 1
+ defaultRecvBufferCapacity = 4096
+ defaultSendTimeoutSeconds = 10
+)
+
+type receiveCbFunc func(chId byte, msgBytes []byte)
+type errorCbFunc func(interface{})
+
+/*
+Each peer has one `MConnection` (multiplex connection) instance.
+
+__multiplex__ *noun* a system or signal involving simultaneous transmission of
+several messages along a single channel of communication.
+
+Each `MConnection` handles message transmission on multiple abstract communication
+`Channel`s. Each channel has a globally unique byte id.
+The byte id and the relative priorities of each `Channel` are configured upon
+initialization of the connection.
+
+There are two methods for sending messages:
+ func (m MConnection) Send(chId byte, msg interface{}) bool {}
+ func (m MConnection) TrySend(chId byte, msg interface{}) bool {}
+
+`Send(chId, msg)` is a blocking call that waits until `msg` is successfully queued
+for the channel with the given id byte `chId`, or until the request times out.
+The message `msg` is serialized using the `tendermint/binary` submodule's
+`WriteBinary()` reflection routine.
+
+`TrySend(chId, msg)` is a nonblocking call that returns false if the channel's
+queue is full.
+
+Inbound message bytes are handled with an onReceive callback function.
+*/
+type MConnection struct {
+ conn net.Conn
+ bufReader *bufio.Reader
+ bufWriter *bufio.Writer
+ sendMonitor *flow.Monitor
+ recvMonitor *flow.Monitor
+ sendRate int64
+ recvRate int64
+ flushTimer *ThrottleTimer // flush writes as necessary but throttled.
+ send chan struct{}
+ quit chan struct{}
+ pingTimer *RepeatTimer // send pings periodically
+ pong chan struct{}
+ chStatsTimer *RepeatTimer // update channel stats periodically
+ channels []*Channel
+ channelsIdx map[byte]*Channel
+ onReceive receiveCbFunc
+ onError errorCbFunc
+ started uint32
+ stopped uint32
+ errored uint32
+
+ LocalAddress *NetAddress
+ RemoteAddress *NetAddress
+}
+
+func NewMConnection(conn net.Conn, chDescs []*ChannelDescriptor, onReceive receiveCbFunc, onError errorCbFunc) *MConnection {
+
+ mconn := &MConnection{
+ conn: conn,
+ bufReader: bufio.NewReaderSize(conn, minReadBufferSize),
+ bufWriter: bufio.NewWriterSize(conn, minWriteBufferSize),
+ sendMonitor: flow.New(0, 0),
+ recvMonitor: flow.New(0, 0),
+ sendRate: defaultSendRate,
+ recvRate: defaultRecvRate,
+ flushTimer: NewThrottleTimer("flush", flushThrottleMS*time.Millisecond),
+ send: make(chan struct{}, 1),
+ quit: make(chan struct{}),
+ pingTimer: NewRepeatTimer("ping", pingTimeoutMinutes*time.Minute),
+ pong: make(chan struct{}),
+ chStatsTimer: NewRepeatTimer("chStats", updateStatsSeconds*time.Second),
+ onReceive: onReceive,
+ onError: onError,
+ LocalAddress: NewNetAddress(conn.LocalAddr()),
+ RemoteAddress: NewNetAddress(conn.RemoteAddr()),
+ }
+
+ // Create channels
+ var channelsIdx = map[byte]*Channel{}
+ var channels = []*Channel{}
+
+ for _, desc := range chDescs {
+ channel := newChannel(mconn, desc)
+ channelsIdx[channel.id] = channel
+ channels = append(channels, channel)
+ }
+ mconn.channels = channels
+ mconn.channelsIdx = channelsIdx
+
+ return mconn
+}
+
+// .Start() begins multiplexing packets to and from "channels".
+func (c *MConnection) Start() {
+ if atomic.CompareAndSwapUint32(&c.started, 0, 1) {
+ log.Debug("Starting MConnection", "connection", c)
+ go c.sendRoutine()
+ go c.recvRoutine()
+ }
+}
+
+func (c *MConnection) Stop() {
+ if atomic.CompareAndSwapUint32(&c.stopped, 0, 1) {
+ log.Debug("Stopping MConnection", "connection", c)
+ close(c.quit)
+ c.conn.Close()
+ c.flushTimer.Stop()
+ c.chStatsTimer.Stop()
+ c.pingTimer.Stop()
+ // We can't close pong safely here because
+ // recvRoutine may write to it after we've stopped.
+ // Though it doesn't need to get closed at all,
+ // we close it @ recvRoutine.
+ // close(c.pong)
+ }
+}
+
+func (c *MConnection) String() string {
+ return fmt.Sprintf("MConn{%v}", c.conn.RemoteAddr())
+}
+
+func (c *MConnection) flush() {
+ err := c.bufWriter.Flush()
+ if err != nil {
+ log.Warn("MConnection flush failed", "error", err)
+ }
+}
+
+// Catch panics, usually caused by remote disconnects.
+func (c *MConnection) _recover() {
+ if r := recover(); r != nil {
+ stack := debug.Stack()
+ err := StackError{r, stack}
+ c.stopForError(err)
+ }
+}
+
+func (c *MConnection) stopForError(r interface{}) {
+ c.Stop()
+ if atomic.CompareAndSwapUint32(&c.errored, 0, 1) {
+ if c.onError != nil {
+ c.onError(r)
+ }
+ }
+}
+
+// Queues a message to be sent to channel.
+func (c *MConnection) Send(chId byte, msg interface{}) bool {
+ if atomic.LoadUint32(&c.stopped) == 1 {
+ return false
+ }
+
+ log.Debug("Send", "channel", chId, "connection", c, "msg", msg) //, "bytes", binary.BinaryBytes(msg))
+
+ // Send message to channel.
+ channel, ok := c.channelsIdx[chId]
+ if !ok {
+ log.Error(Fmt("Cannot send bytes, unknown channel %X", chId))
+ return false
+ }
+
+ success := channel.sendBytes(binary.BinaryBytes(msg))
+ if success {
+ // Wake up sendRoutine if necessary
+ select {
+ case c.send <- struct{}{}:
+ default:
+ }
+ } else {
+ log.Warn("Send failed", "channel", chId, "connection", c, "msg", msg)
+ }
+ return success
+}
+
+// Queues a message to be sent to channel.
+// Nonblocking, returns true if successful.
+func (c *MConnection) TrySend(chId byte, msg interface{}) bool {
+ if atomic.LoadUint32(&c.stopped) == 1 {
+ return false
+ }
+
+ log.Debug("TrySend", "channel", chId, "connection", c, "msg", msg)
+
+ // Send message to channel.
+ channel, ok := c.channelsIdx[chId]
+ if !ok {
+ log.Error(Fmt("Cannot send bytes, unknown channel %X", chId))
+ return false
+ }
+
+ ok = channel.trySendBytes(binary.BinaryBytes(msg))
+ if ok {
+ // Wake up sendRoutine if necessary
+ select {
+ case c.send <- struct{}{}:
+ default:
+ }
+ }
+
+ return ok
+}
+
+func (c *MConnection) CanSend(chId byte) bool {
+ if atomic.LoadUint32(&c.stopped) == 1 {
+ return false
+ }
+
+ channel, ok := c.channelsIdx[chId]
+ if !ok {
+ log.Error(Fmt("Unknown channel %X", chId))
+ return false
+ }
+ return channel.canSend()
+}
+
+// sendRoutine polls for packets to send from channels.
+func (c *MConnection) sendRoutine() {
+ defer c._recover()
+
+FOR_LOOP:
+ for {
+ var n int64
+ var err error
+ select {
+ case <-c.flushTimer.Ch:
+ // NOTE: flushTimer.Set() must be called every time
+ // something is written to .bufWriter.
+ c.flush()
+ case <-c.chStatsTimer.Ch:
+ for _, channel := range c.channels {
+ channel.updateStats()
+ }
+ case <-c.pingTimer.Ch:
+ log.Debug("Send Ping")
+ binary.WriteByte(packetTypePing, c.bufWriter, &n, &err)
+ c.sendMonitor.Update(int(n))
+ c.flush()
+ case <-c.pong:
+ log.Debug("Send Pong")
+ binary.WriteByte(packetTypePong, c.bufWriter, &n, &err)
+ c.sendMonitor.Update(int(n))
+ c.flush()
+ case <-c.quit:
+ break FOR_LOOP
+ case <-c.send:
+ // Send some msgPackets
+ eof := c.sendSomeMsgPackets()
+ if !eof {
+ // Keep sendRoutine awake.
+ select {
+ case c.send <- struct{}{}:
+ default:
+ }
+ }
+ }
+
+ if atomic.LoadUint32(&c.stopped) == 1 {
+ break FOR_LOOP
+ }
+ if err != nil {
+ log.Warn("Connection failed @ sendRoutine", "connection", c, "error", err)
+ c.stopForError(err)
+ break FOR_LOOP
+ }
+ }
+
+ // Cleanup
+}
+
+// Returns true if messages from channels were exhausted.
+// Blocks in accordance to .sendMonitor throttling.
+func (c *MConnection) sendSomeMsgPackets() bool {
+ // Block until .sendMonitor says we can write.
+ // Once we're ready we send more than we asked for,
+ // but amortized it should even out.
+ c.sendMonitor.Limit(maxMsgPacketSize, atomic.LoadInt64(&c.sendRate), true)
+
+ // Now send some msgPackets.
+ for i := 0; i < numBatchMsgPackets; i++ {
+ if c.sendMsgPacket() {
+ return true
+ }
+ }
+ return false
+}
+
+// Returns true if messages from channels were exhausted.
+func (c *MConnection) sendMsgPacket() bool {
+ // Choose a channel to create a msgPacket from.
+ // The chosen channel will be the one whose recentlySent/priority is the least.
+ var leastRatio float32 = math.MaxFloat32
+ var leastChannel *Channel
+ for _, channel := range c.channels {
+ // If nothing to send, skip this channel
+ if !channel.isSendPending() {
+ continue
+ }
+ // Get ratio, and keep track of lowest ratio.
+ ratio := float32(channel.recentlySent) / float32(channel.priority)
+ if ratio < leastRatio {
+ leastRatio = ratio
+ leastChannel = channel
+ }
+ }
+
+ // Nothing to send?
+ if leastChannel == nil {
+ return true
+ } else {
+ // log.Debug("Found a msgPacket to send")
+ }
+
+ // Make & send a msgPacket from this channel
+ n, err := leastChannel.writeMsgPacketTo(c.bufWriter)
+ if err != nil {
+ log.Warn("Failed to write msgPacket", "error", err)
+ c.stopForError(err)
+ return true
+ }
+ c.sendMonitor.Update(int(n))
+ c.flushTimer.Set()
+ return false
+}
+
+// recvRoutine reads msgPackets and reconstructs the message using the channels' "recving" buffer.
+// After a whole message has been assembled, it's pushed to onReceive().
+// Blocks depending on how the connection is throttled.
+func (c *MConnection) recvRoutine() {
+ defer c._recover()
+
+FOR_LOOP:
+ for {
+ // Block until .recvMonitor says we can read.
+ c.recvMonitor.Limit(maxMsgPacketSize, atomic.LoadInt64(&c.recvRate), true)
+
+ /*
+ // Peek into bufReader for debugging
+ if numBytes := c.bufReader.Buffered(); numBytes > 0 {
+ log.Debug("Peek connection buffer", "numBytes", numBytes, "bytes", log15.Lazy{func() []byte {
+ bytes, err := c.bufReader.Peek(MinInt(numBytes, 100))
+ if err == nil {
+ return bytes
+ } else {
+ log.Warn("Error peeking connection buffer", "error", err)
+ return nil
+ }
+ }})
+ }
+ */
+
+ // Read packet type
+ var n int64
+ var err error
+ pktType := binary.ReadByte(c.bufReader, &n, &err)
+ c.recvMonitor.Update(int(n))
+ if err != nil {
+ if atomic.LoadUint32(&c.stopped) != 1 {
+ log.Warn("Connection failed @ recvRoutine (reading byte)", "connection", c, "error", err)
+ c.stopForError(err)
+ }
+ break FOR_LOOP
+ }
+
+ // Read more depending on packet type.
+ switch pktType {
+ case packetTypePing:
+ // TODO: prevent abuse, as they cause flush()'s.
+ log.Debug("Receive Ping")
+ c.pong <- struct{}{}
+ case packetTypePong:
+ // do nothing
+ log.Debug("Receive Pong")
+ case packetTypeMsg:
+ pkt, n, err := msgPacket{}, new(int64), new(error)
+ binary.ReadBinary(&pkt, c.bufReader, n, err)
+ c.recvMonitor.Update(int(*n))
+ if *err != nil {
+ if atomic.LoadUint32(&c.stopped) != 1 {
+ log.Warn("Connection failed @ recvRoutine", "connection", c, "error", *err)
+ c.stopForError(*err)
+ }
+ break FOR_LOOP
+ }
+ channel, ok := c.channelsIdx[pkt.ChannelId]
+ if !ok || channel == nil {
+ panic(Fmt("Unknown channel %X", pkt.ChannelId))
+ }
+ msgBytes := channel.recvMsgPacket(pkt)
+ if msgBytes != nil {
+ //log.Debug("Received bytes", "chId", pkt.ChannelId, "msgBytes", msgBytes)
+ c.onReceive(pkt.ChannelId, msgBytes)
+ }
+ default:
+ panic(Fmt("Unknown message type %X", pktType))
+ }
+
+ // TODO: shouldn't this go in the sendRoutine?
+ // Better to send a ping packet when *we* haven't sent anything for a while.
+ c.pingTimer.Reset()
+ }
+
+ // Cleanup
+ close(c.pong)
+ for _ = range c.pong {
+ // Drain
+ }
+}
+
+//-----------------------------------------------------------------------------
+
+type ChannelDescriptor struct {
+ Id byte
+ Priority uint
+ SendQueueCapacity uint
+ RecvBufferCapacity uint
+}
+
+func (chDesc *ChannelDescriptor) FillDefaults() {
+ if chDesc.SendQueueCapacity == 0 {
+ chDesc.SendQueueCapacity = defaultSendQueueCapacity
+ }
+ if chDesc.RecvBufferCapacity == 0 {
+ chDesc.RecvBufferCapacity = defaultRecvBufferCapacity
+ }
+}
+
+// TODO: lowercase.
+// NOTE: not goroutine-safe.
+type Channel struct {
+ conn *MConnection
+ desc *ChannelDescriptor
+ id byte
+ sendQueue chan []byte
+ sendQueueSize uint32 // atomic.
+ recving []byte
+ sending []byte
+ priority uint
+ recentlySent int64 // exponential moving average
+}
+
+func newChannel(conn *MConnection, desc *ChannelDescriptor) *Channel {
+ desc.FillDefaults()
+ if desc.Priority <= 0 {
+ panic("Channel default priority must be a postive integer")
+ }
+ return &Channel{
+ conn: conn,
+ desc: desc,
+ id: desc.Id,
+ sendQueue: make(chan []byte, desc.SendQueueCapacity),
+ recving: make([]byte, 0, desc.RecvBufferCapacity),
+ priority: desc.Priority,
+ }
+}
+
+// Queues message to send to this channel.
+// Goroutine-safe
+// Times out (and returns false) after defaultSendTimeoutSeconds
+func (ch *Channel) sendBytes(bytes []byte) bool {
+ timeout := time.NewTimer(defaultSendTimeoutSeconds * time.Second)
+ select {
+ case <-timeout.C:
+ // timeout
+ return false
+ case ch.sendQueue <- bytes:
+ atomic.AddUint32(&ch.sendQueueSize, 1)
+ return true
+ }
+}
+
+// Queues message to send to this channel.
+// Nonblocking, returns true if successful.
+// Goroutine-safe
+func (ch *Channel) trySendBytes(bytes []byte) bool {
+ select {
+ case ch.sendQueue <- bytes:
+ atomic.AddUint32(&ch.sendQueueSize, 1)
+ return true
+ default:
+ return false
+ }
+}
+
+// Goroutine-safe
+func (ch *Channel) loadSendQueueSize() (size int) {
+ return int(atomic.LoadUint32(&ch.sendQueueSize))
+}
+
+// Goroutine-safe
+// Use only as a heuristic.
+func (ch *Channel) canSend() bool {
+ return ch.loadSendQueueSize() < defaultSendQueueCapacity
+}
+
+// Returns true if any msgPackets are pending to be sent.
+// Call before calling nextMsgPacket()
+// Goroutine-safe
+func (ch *Channel) isSendPending() bool {
+ if len(ch.sending) == 0 {
+ if len(ch.sendQueue) == 0 {
+ return false
+ }
+ ch.sending = <-ch.sendQueue
+ }
+ return true
+}
+
+// Creates a new msgPacket to send.
+// Not goroutine-safe
+func (ch *Channel) nextMsgPacket() msgPacket {
+ packet := msgPacket{}
+ packet.ChannelId = byte(ch.id)
+ packet.Bytes = ch.sending[:MinInt(maxMsgPacketSize, len(ch.sending))]
+ if len(ch.sending) <= maxMsgPacketSize {
+ packet.EOF = byte(0x01)
+ ch.sending = nil
+ atomic.AddUint32(&ch.sendQueueSize, ^uint32(0)) // decrement sendQueueSize
+ } else {
+ packet.EOF = byte(0x00)
+ ch.sending = ch.sending[MinInt(maxMsgPacketSize, len(ch.sending)):]
+ }
+ return packet
+}
+
+// Writes next msgPacket to w.
+// Not goroutine-safe
+func (ch *Channel) writeMsgPacketTo(w io.Writer) (n int64, err error) {
+ packet := ch.nextMsgPacket()
+ binary.WriteByte(packetTypeMsg, w, &n, &err)
+ binary.WriteBinary(packet, w, &n, &err)
+ if err != nil {
+ ch.recentlySent += n
+ }
+ return
+}
+
+// Handles incoming msgPackets. Returns a msg bytes if msg is complete.
+// Not goroutine-safe
+func (ch *Channel) recvMsgPacket(pkt msgPacket) []byte {
+ ch.recving = append(ch.recving, pkt.Bytes...)
+ if pkt.EOF == byte(0x01) {
+ msgBytes := ch.recving
+ ch.recving = make([]byte, 0, defaultRecvBufferCapacity)
+ return msgBytes
+ }
+ return nil
+}
+
+// Call this periodically to update stats for throttling purposes.
+// Not goroutine-safe
+func (ch *Channel) updateStats() {
+ // Exponential decay of stats.
+ // TODO: optimize.
+ ch.recentlySent = int64(float64(ch.recentlySent) * 0.5)
+}
+
+//-----------------------------------------------------------------------------
+
+const (
+ maxMsgPacketSize = 1024
+ packetTypePing = byte(0x01)
+ packetTypePong = byte(0x02)
+ packetTypeMsg = byte(0x03)
+)
+
+// Messages in channels are chopped into smaller msgPackets for multiplexing.
+type msgPacket struct {
+ ChannelId byte
+ EOF byte // 1 means message ends here.
+ Bytes []byte
+}
+
+func (p msgPacket) String() string {
+ return fmt.Sprintf("MsgPacket{%X:%X}", p.ChannelId, p.Bytes)
+}
+
+//-----------------------------------------------------------------------------
+
+// Convenience struct for writing typed messages.
+// Reading requires a custom decoder that switches on the first type byte of a byteslice.
+type TypedMessage struct {
+ Type byte
+ Msg interface{}
+}
+
+func (tm TypedMessage) String() string {
+ return fmt.Sprintf("TMsg{%X:%v}", tm.Type, tm.Msg)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/listener.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/listener.go
new file mode 100644
index 0000000000000000000000000000000000000000..62f83dec7ba907e034a39c79adb7c6a53f5ca1b7
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/listener.go
@@ -0,0 +1,207 @@
+package p2p
+
+import (
+ "fmt"
+ "net"
+ "strconv"
+ "sync/atomic"
+
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/upnp"
+)
+
+type Listener interface {
+ Connections() <-chan net.Conn
+ InternalAddress() *NetAddress
+ ExternalAddress() *NetAddress
+ String() string
+ Stop()
+}
+
+// Implements Listener
+type DefaultListener struct {
+ listener net.Listener
+ intAddr *NetAddress
+ extAddr *NetAddress
+ connections chan net.Conn
+ stopped uint32
+}
+
+const (
+ numBufferedConnections = 10
+ defaultExternalPort = 8770
+)
+
+func splitHostPort(addr string) (host string, port int) {
+ host, portStr, err := net.SplitHostPort(addr)
+ if err != nil {
+ panic(err)
+ }
+ port, err = strconv.Atoi(portStr)
+ if err != nil {
+ panic(err)
+ }
+ return host, port
+}
+
+func NewDefaultListener(protocol string, lAddr string, requireUPNPHairpin bool) Listener {
+ // Local listen IP & port
+ lAddrIP, lAddrPort := splitHostPort(lAddr)
+
+ // Create listener
+ listener, err := net.Listen(protocol, lAddr)
+ if err != nil {
+ panic(err)
+ }
+ // Actual listener local IP & port
+ listenerIP, listenerPort := splitHostPort(listener.Addr().String())
+ log.Debug("Local listener", "ip", listenerIP, "port", listenerPort)
+
+ // Determine internal address...
+ var intAddr *NetAddress = NewNetAddressString(lAddr)
+
+ // Determine external address...
+ var extAddr *NetAddress
+ // If the lAddrIP is INADDR_ANY, try UPnP
+ if lAddrIP == "" || lAddrIP == "0.0.0.0" {
+ if requireUPNPHairpin {
+ upnpCapabilities, err := upnp.Probe()
+ if err != nil {
+ log.Warn("Failed to probe UPNP", "error", err)
+ goto SKIP_UPNP
+ }
+ if !upnpCapabilities.Hairpin {
+ goto SKIP_UPNP
+ }
+ }
+ extAddr = getUPNPExternalAddress(lAddrPort, listenerPort)
+ }
+SKIP_UPNP:
+
+ // Otherwise just use the local address...
+ if extAddr == nil {
+ extAddr = getNaiveExternalAddress(listenerPort)
+ }
+ if extAddr == nil {
+ panic("Could not determine external address!")
+ }
+
+ dl := &DefaultListener{
+ listener: listener,
+ intAddr: intAddr,
+ extAddr: extAddr,
+ connections: make(chan net.Conn, numBufferedConnections),
+ }
+
+ go dl.listenRoutine()
+
+ return dl
+}
+
+// TODO: prevent abuse, esp a bunch of connections coming from the same IP range.
+func (l *DefaultListener) listenRoutine() {
+ for {
+ conn, err := l.listener.Accept()
+
+ if atomic.LoadUint32(&l.stopped) == 1 {
+ break // Go to cleanup
+ }
+
+ // listener wasn't stopped,
+ // yet we encountered an error.
+ if err != nil {
+ panic(err)
+ }
+
+ l.connections <- conn
+ }
+
+ // Cleanup
+ close(l.connections)
+ for _ = range l.connections {
+ // Drain
+ }
+}
+
+// A channel of inbound connections.
+// It gets closed when the listener closes.
+func (l *DefaultListener) Connections() <-chan net.Conn {
+ return l.connections
+}
+
+func (l *DefaultListener) InternalAddress() *NetAddress {
+ return l.intAddr
+}
+
+func (l *DefaultListener) ExternalAddress() *NetAddress {
+ return l.extAddr
+}
+
+// NOTE: The returned listener is already Accept()'ing.
+// So it's not suitable to pass into http.Serve().
+func (l *DefaultListener) NetListener() net.Listener {
+ return l.listener
+}
+
+func (l *DefaultListener) Stop() {
+ if atomic.CompareAndSwapUint32(&l.stopped, 0, 1) {
+ l.listener.Close()
+ }
+}
+
+func (l *DefaultListener) String() string {
+ return fmt.Sprintf("Listener(@%v)", l.extAddr)
+}
+
+/* external address helpers */
+
+// UPNP external address discovery & port mapping
+func getUPNPExternalAddress(externalPort, internalPort int) *NetAddress {
+ log.Debug("Getting UPNP external address")
+ nat, err := upnp.Discover()
+ if err != nil {
+ log.Debug("Could not get UPNP extrernal address", "error", err)
+ return nil
+ }
+
+ ext, err := nat.GetExternalAddress()
+ if err != nil {
+ log.Debug("Could not get UPNP external address", "error", err)
+ return nil
+ }
+
+ // UPnP can't seem to get the external port, so let's just be explicit.
+ if externalPort == 0 {
+ externalPort = defaultExternalPort
+ }
+
+ externalPort, err = nat.AddPortMapping("tcp", externalPort, internalPort, "tendermint", 0)
+ if err != nil {
+ log.Debug("Could not get UPNP external address", "error", err)
+ return nil
+ }
+
+ log.Debug("Got UPNP external address", "address", ext)
+ return NewNetAddressIPPort(ext, uint16(externalPort))
+}
+
+// TODO: use syscalls: http://pastebin.com/9exZG4rh
+func getNaiveExternalAddress(port int) *NetAddress {
+ addrs, err := net.InterfaceAddrs()
+ if err != nil {
+ panic(Fmt("Could not fetch interface addresses: %v", err))
+ }
+
+ for _, a := range addrs {
+ ipnet, ok := a.(*net.IPNet)
+ if !ok {
+ continue
+ }
+ v4 := ipnet.IP.To4()
+ if v4 == nil || v4[0] == 127 {
+ continue
+ } // loopback
+ return NewNetAddressIPPort(ipnet.IP, uint16(port))
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/log.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..319af3567266e3b809a517c9a07b10497130d8c9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/log.go
@@ -0,0 +1,7 @@
+package p2p
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/logger"
+)
+
+var log = logger.New("module", "p2p")
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/netaddress.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/netaddress.go
new file mode 100644
index 0000000000000000000000000000000000000000..39979fdcdaacf74955528b495eb939c489c3c43a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/netaddress.go
@@ -0,0 +1,210 @@
+// Modified for Tendermint
+// Originally Copyright (c) 2013-2014 Conformal Systems LLC.
+// https://github.com/conformal/btcd/blob/master/LICENSE
+
+package p2p
+
+import (
+ "fmt"
+ "net"
+ "strconv"
+ "time"
+)
+
+type NetAddress struct {
+ IP net.IP
+ Port uint16
+ str string
+}
+
+// TODO: socks proxies?
+func NewNetAddress(addr net.Addr) *NetAddress {
+ tcpAddr, ok := addr.(*net.TCPAddr)
+ if !ok {
+ panic(fmt.Sprintf("Only TCPAddrs are supported. Got: %v", addr))
+ }
+ ip := tcpAddr.IP
+ port := uint16(tcpAddr.Port)
+ return NewNetAddressIPPort(ip, port)
+}
+
+// Also resolves the host if host is not an IP.
+func NewNetAddressString(addr string) *NetAddress {
+ host, portStr, err := net.SplitHostPort(addr)
+ if err != nil {
+ panic(err)
+ }
+ ip := net.ParseIP(host)
+ if ip == nil {
+ if len(host) > 0 {
+ ips, err := net.LookupIP(host)
+ if err != nil {
+ panic(err)
+ }
+ ip = ips[0]
+ }
+ }
+ port, err := strconv.ParseUint(portStr, 10, 16)
+ if err != nil {
+ panic(err)
+ }
+ na := NewNetAddressIPPort(ip, uint16(port))
+ return na
+}
+
+func NewNetAddressIPPort(ip net.IP, port uint16) *NetAddress {
+ na := &NetAddress{
+ IP: ip,
+ Port: port,
+ str: net.JoinHostPort(
+ ip.String(),
+ strconv.FormatUint(uint64(port), 10),
+ ),
+ }
+ return na
+}
+
+func (na *NetAddress) Equals(other interface{}) bool {
+ if o, ok := other.(*NetAddress); ok {
+ return na.String() == o.String()
+ } else {
+ return false
+ }
+}
+
+func (na *NetAddress) Less(other interface{}) bool {
+ if o, ok := other.(*NetAddress); ok {
+ return na.String() < o.String()
+ } else {
+ panic("Cannot compare unequal types")
+ }
+}
+
+func (na *NetAddress) String() string {
+ if na.str == "" {
+ na.str = net.JoinHostPort(
+ na.IP.String(),
+ strconv.FormatUint(uint64(na.Port), 10),
+ )
+ }
+ return na.str
+}
+
+func (na *NetAddress) Dial() (net.Conn, error) {
+ conn, err := net.Dial("tcp", na.String())
+ if err != nil {
+ return nil, err
+ }
+ return conn, nil
+}
+
+func (na *NetAddress) DialTimeout(timeout time.Duration) (net.Conn, error) {
+ conn, err := net.DialTimeout("tcp", na.String(), timeout)
+ if err != nil {
+ return nil, err
+ }
+ return conn, nil
+}
+
+func (na *NetAddress) Routable() bool {
+ // TODO(oga) bitcoind doesn't include RFC3849 here, but should we?
+ return na.Valid() && !(na.RFC1918() || na.RFC3927() || na.RFC4862() ||
+ na.RFC4193() || na.RFC4843() || na.Local())
+}
+
+// For IPv4 these are either a 0 or all bits set address. For IPv6 a zero
+// address or one that matches the RFC3849 documentation address format.
+func (na *NetAddress) Valid() bool {
+ return na.IP != nil && !(na.IP.IsUnspecified() || na.RFC3849() ||
+ na.IP.Equal(net.IPv4bcast))
+}
+
+func (na *NetAddress) Local() bool {
+ return na.IP.IsLoopback() || zero4.Contains(na.IP)
+}
+
+func (na *NetAddress) ReachabilityTo(o *NetAddress) int {
+ const (
+ Unreachable = 0
+ Default = iota
+ Teredo
+ Ipv6_weak
+ Ipv4
+ Ipv6_strong
+ Private
+ )
+ if !na.Routable() {
+ return Unreachable
+ } else if na.RFC4380() {
+ if !o.Routable() {
+ return Default
+ } else if o.RFC4380() {
+ return Teredo
+ } else if o.IP.To4() != nil {
+ return Ipv4
+ } else { // ipv6
+ return Ipv6_weak
+ }
+ } else if na.IP.To4() != nil {
+ if o.Routable() && o.IP.To4() != nil {
+ return Ipv4
+ }
+ return Default
+ } else /* ipv6 */ {
+ var tunnelled bool
+ // Is our v6 is tunnelled?
+ if o.RFC3964() || o.RFC6052() || o.RFC6145() {
+ tunnelled = true
+ }
+ if !o.Routable() {
+ return Default
+ } else if o.RFC4380() {
+ return Teredo
+ } else if o.IP.To4() != nil {
+ return Ipv4
+ } else if tunnelled {
+ // only prioritise ipv6 if we aren't tunnelling it.
+ return Ipv6_weak
+ }
+ return Ipv6_strong
+ }
+}
+
+// RFC1918: IPv4 Private networks (10.0.0.0/8, 192.168.0.0/16, 172.16.0.0/12)
+// RFC3849: IPv6 Documentation address (2001:0DB8::/32)
+// RFC3927: IPv4 Autoconfig (169.254.0.0/16)
+// RFC3964: IPv6 6to4 (2002::/16)
+// RFC4193: IPv6 unique local (FC00::/7)
+// RFC4380: IPv6 Teredo tunneling (2001::/32)
+// RFC4843: IPv6 ORCHID: (2001:10::/28)
+// RFC4862: IPv6 Autoconfig (FE80::/64)
+// RFC6052: IPv6 well known prefix (64:FF9B::/96)
+// RFC6145: IPv6 IPv4 translated address ::FFFF:0:0:0/96
+var rfc1918_10 = net.IPNet{IP: net.ParseIP("10.0.0.0"), Mask: net.CIDRMask(8, 32)}
+var rfc1918_192 = net.IPNet{IP: net.ParseIP("192.168.0.0"), Mask: net.CIDRMask(16, 32)}
+var rfc1918_172 = net.IPNet{IP: net.ParseIP("172.16.0.0"), Mask: net.CIDRMask(12, 32)}
+var rfc3849 = net.IPNet{IP: net.ParseIP("2001:0DB8::"), Mask: net.CIDRMask(32, 128)}
+var rfc3927 = net.IPNet{IP: net.ParseIP("169.254.0.0"), Mask: net.CIDRMask(16, 32)}
+var rfc3964 = net.IPNet{IP: net.ParseIP("2002::"), Mask: net.CIDRMask(16, 128)}
+var rfc4193 = net.IPNet{IP: net.ParseIP("FC00::"), Mask: net.CIDRMask(7, 128)}
+var rfc4380 = net.IPNet{IP: net.ParseIP("2001::"), Mask: net.CIDRMask(32, 128)}
+var rfc4843 = net.IPNet{IP: net.ParseIP("2001:10::"), Mask: net.CIDRMask(28, 128)}
+var rfc4862 = net.IPNet{IP: net.ParseIP("FE80::"), Mask: net.CIDRMask(64, 128)}
+var rfc6052 = net.IPNet{IP: net.ParseIP("64:FF9B::"), Mask: net.CIDRMask(96, 128)}
+var rfc6145 = net.IPNet{IP: net.ParseIP("::FFFF:0:0:0"), Mask: net.CIDRMask(96, 128)}
+var zero4 = net.IPNet{IP: net.ParseIP("0.0.0.0"), Mask: net.CIDRMask(8, 32)}
+
+func (na *NetAddress) RFC1918() bool {
+ return rfc1918_10.Contains(na.IP) ||
+ rfc1918_192.Contains(na.IP) ||
+ rfc1918_172.Contains(na.IP)
+}
+func (na *NetAddress) RFC3849() bool { return rfc3849.Contains(na.IP) }
+func (na *NetAddress) RFC3927() bool { return rfc3927.Contains(na.IP) }
+func (na *NetAddress) RFC3964() bool { return rfc3964.Contains(na.IP) }
+func (na *NetAddress) RFC4193() bool { return rfc4193.Contains(na.IP) }
+func (na *NetAddress) RFC4380() bool { return rfc4380.Contains(na.IP) }
+func (na *NetAddress) RFC4843() bool { return rfc4843.Contains(na.IP) }
+func (na *NetAddress) RFC4862() bool { return rfc4862.Contains(na.IP) }
+func (na *NetAddress) RFC6052() bool { return rfc6052.Contains(na.IP) }
+func (na *NetAddress) RFC6145() bool { return rfc6145.Contains(na.IP) }
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/peer.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/peer.go
new file mode 100644
index 0000000000000000000000000000000000000000..49bcd280854b7e090e6222003638d75c03fde7e5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/peer.go
@@ -0,0 +1,139 @@
+package p2p
+
+import (
+ "fmt"
+ "io"
+ "net"
+ "sync"
+ "sync/atomic"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+type Peer struct {
+ outbound bool
+ mconn *MConnection
+ running uint32
+
+ *types.NodeInfo
+ Key string
+ Data *CMap // User data.
+}
+
+func peerHandshake(conn net.Conn, ourNodeInfo *types.NodeInfo) (*types.NodeInfo, error) {
+ var peerNodeInfo = new(types.NodeInfo)
+ var wg sync.WaitGroup
+ var err1 error
+ var err2 error
+ wg.Add(2)
+ go func() {
+ var n int64
+ binary.WriteBinary(ourNodeInfo, conn, &n, &err1)
+ wg.Done()
+ }()
+ go func() {
+ var n int64
+ binary.ReadBinary(peerNodeInfo, conn, &n, &err2)
+ log.Info("Peer handshake", "peerNodeInfo", peerNodeInfo)
+ wg.Done()
+ }()
+ wg.Wait()
+ if err1 != nil {
+ return nil, err1
+ }
+ if err2 != nil {
+ return nil, err2
+ }
+ return peerNodeInfo, nil
+}
+
+func newPeer(conn net.Conn, peerNodeInfo *types.NodeInfo, outbound bool, reactorsByCh map[byte]Reactor, chDescs []*ChannelDescriptor, onPeerError func(*Peer, interface{})) *Peer {
+ var p *Peer
+ onReceive := func(chId byte, msgBytes []byte) {
+ reactor := reactorsByCh[chId]
+ if reactor == nil {
+ panic(Fmt("Unknown channel %X", chId))
+ }
+ reactor.Receive(chId, p, msgBytes)
+ }
+ onError := func(r interface{}) {
+ p.stop()
+ onPeerError(p, r)
+ }
+ mconn := NewMConnection(conn, chDescs, onReceive, onError)
+ p = &Peer{
+ outbound: outbound,
+ mconn: mconn,
+ running: 0,
+ NodeInfo: peerNodeInfo,
+ Key: mconn.RemoteAddress.IP.String(),
+ Data: NewCMap(),
+ }
+ return p
+}
+
+func (p *Peer) start() {
+ if atomic.CompareAndSwapUint32(&p.running, 0, 1) {
+ log.Debug("Starting Peer", "peer", p)
+ p.mconn.Start()
+ }
+}
+
+func (p *Peer) stop() {
+ if atomic.CompareAndSwapUint32(&p.running, 1, 0) {
+ log.Debug("Stopping Peer", "peer", p)
+ p.mconn.Stop()
+ }
+}
+
+func (p *Peer) IsRunning() bool {
+ return atomic.LoadUint32(&p.running) == 1
+}
+
+func (p *Peer) Connection() *MConnection {
+ return p.mconn
+}
+
+func (p *Peer) IsOutbound() bool {
+ return p.outbound
+}
+
+func (p *Peer) Send(chId byte, msg interface{}) bool {
+ if atomic.LoadUint32(&p.running) == 0 {
+ return false
+ }
+ return p.mconn.Send(chId, msg)
+}
+
+func (p *Peer) TrySend(chId byte, msg interface{}) bool {
+ if atomic.LoadUint32(&p.running) == 0 {
+ return false
+ }
+ return p.mconn.TrySend(chId, msg)
+}
+
+func (p *Peer) CanSend(chId byte) bool {
+ if atomic.LoadUint32(&p.running) == 0 {
+ return false
+ }
+ return p.mconn.CanSend(chId)
+}
+
+func (p *Peer) WriteTo(w io.Writer) (n int64, err error) {
+ binary.WriteString(p.Key, w, &n, &err)
+ return
+}
+
+func (p *Peer) String() string {
+ if p.outbound {
+ return fmt.Sprintf("Peer{->%v}", p.mconn)
+ } else {
+ return fmt.Sprintf("Peer{%v->}", p.mconn)
+ }
+}
+
+func (p *Peer) Equals(other *Peer) bool {
+ return p.Key == other.Key
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/peer_set.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/peer_set.go
new file mode 100644
index 0000000000000000000000000000000000000000..effad6dccc5a57faeac0796ef804c827328c17ab
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/peer_set.go
@@ -0,0 +1,109 @@
+package p2p
+
+import (
+ "sync"
+)
+
+// IPeerSet has a (immutable) subset of the methods of PeerSet.
+type IPeerSet interface {
+ Has(key string) bool
+ Get(key string) *Peer
+ List() []*Peer
+ Size() int
+}
+
+//-----------------------------------------------------------------------------
+
+// PeerSet is a special structure for keeping a table of peers.
+// Iteration over the peers is super fast and thread-safe.
+type PeerSet struct {
+ mtx sync.Mutex
+ lookup map[string]*peerSetItem
+ list []*Peer
+}
+
+type peerSetItem struct {
+ peer *Peer
+ index int
+}
+
+func NewPeerSet() *PeerSet {
+ return &PeerSet{
+ lookup: make(map[string]*peerSetItem),
+ list: make([]*Peer, 0, 256),
+ }
+}
+
+// Returns false if peer with key (address) is already in set.
+func (ps *PeerSet) Add(peer *Peer) bool {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+ if ps.lookup[peer.Key] != nil {
+ return false
+ }
+ index := len(ps.list)
+ // Appending is safe even with other goroutines
+ // iterating over the ps.list slice.
+ ps.list = append(ps.list, peer)
+ ps.lookup[peer.Key] = &peerSetItem{peer, index}
+ return true
+}
+
+func (ps *PeerSet) Has(peerKey string) bool {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+ _, ok := ps.lookup[peerKey]
+ return ok
+}
+
+func (ps *PeerSet) Get(peerKey string) *Peer {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+ item, ok := ps.lookup[peerKey]
+ if ok {
+ return item.peer
+ } else {
+ return nil
+ }
+}
+
+func (ps *PeerSet) Remove(peer *Peer) {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+ item := ps.lookup[peer.Key]
+ if item == nil {
+ return
+ }
+ index := item.index
+ // Copy the list but without the last element.
+ // (we must copy because we're mutating the list)
+ newList := make([]*Peer, len(ps.list)-1)
+ copy(newList, ps.list)
+ // If it's the last peer, that's an easy special case.
+ if index == len(ps.list)-1 {
+ ps.list = newList
+ delete(ps.lookup, peer.Key)
+ return
+ }
+ // Move the last item from ps.list to "index" in list.
+ lastPeer := ps.list[len(ps.list)-1]
+ lastPeerKey := lastPeer.Key
+ lastPeerItem := ps.lookup[lastPeerKey]
+ newList[index] = lastPeer
+ lastPeerItem.index = index
+ ps.list = newList
+ delete(ps.lookup, peer.Key)
+}
+
+func (ps *PeerSet) Size() int {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+ return len(ps.list)
+}
+
+// threadsafe list of peers.
+func (ps *PeerSet) List() []*Peer {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+ return ps.list
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/peer_set_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/peer_set_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..dfdcb174c77fa721a357026b26f2a98b3d309d9e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/peer_set_test.go
@@ -0,0 +1,63 @@
+package p2p
+
+import (
+ "math/rand"
+ "testing"
+
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+// Returns an empty dummy peer
+func randPeer() *Peer {
+ return &Peer{
+ Key: Fmt("%v.%v.%v.%v:%v", rand.Int()%256, rand.Int()%256, rand.Int()%256, rand.Int()%256, rand.Int()%10000+80),
+ }
+}
+
+func TestAddRemoveOne(t *testing.T) {
+ peerSet := NewPeerSet()
+
+ peer := randPeer()
+ added := peerSet.Add(peer)
+ if !added {
+ t.Errorf("Failed to add new peer")
+ }
+ if peerSet.Size() != 1 {
+ t.Errorf("Failed to add new peer and increment size")
+ }
+
+ peerSet.Remove(peer)
+ if peerSet.Has(peer.Key) {
+ t.Errorf("Failed to remove peer")
+ }
+ if peerSet.Size() != 0 {
+ t.Errorf("Failed to remove peer and decrement size")
+ }
+}
+
+func TestAddRemoveMany(t *testing.T) {
+ peerSet := NewPeerSet()
+
+ peers := []*Peer{}
+ for i := 0; i < 100; i++ {
+ peer := randPeer()
+ added := peerSet.Add(peer)
+ if !added {
+ t.Errorf("Failed to add new peer")
+ }
+ if peerSet.Size() != i+1 {
+ t.Errorf("Failed to add new peer and increment size")
+ }
+ peers = append(peers, peer)
+ }
+
+ for i, peer := range peers {
+ peerSet.Remove(peer)
+ if peerSet.Has(peer.Key) {
+ t.Errorf("Failed to remove peer")
+ }
+ if peerSet.Size() != len(peers)-i-1 {
+ t.Errorf("Failed to remove peer and decrement size")
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/pex_reactor.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/pex_reactor.go
new file mode 100644
index 0000000000000000000000000000000000000000..d1329021c2367c75b9b599a3876ac45303ef1d31
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/pex_reactor.go
@@ -0,0 +1,259 @@
+package p2p
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "math/rand"
+ "reflect"
+ "sync/atomic"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/events"
+)
+
+var pexErrInvalidMessage = errors.New("Invalid PEX message")
+
+const (
+ PexChannel = byte(0x00)
+ ensurePeersPeriodSeconds = 30
+ minNumOutboundPeers = 10
+ maxNumPeers = 50
+)
+
+/*
+PEXReactor handles PEX (peer exchange) and ensures that an
+adequate number of peers are connected to the switch.
+*/
+type PEXReactor struct {
+ sw *Switch
+ quit chan struct{}
+ started uint32
+ stopped uint32
+
+ book *AddrBook
+
+ evsw events.Fireable
+}
+
+func NewPEXReactor(book *AddrBook) *PEXReactor {
+ pexR := &PEXReactor{
+ quit: make(chan struct{}),
+ book: book,
+ }
+ return pexR
+}
+
+// Implements Reactor
+func (pexR *PEXReactor) Start(sw *Switch) {
+ if atomic.CompareAndSwapUint32(&pexR.started, 0, 1) {
+ log.Info("Starting PEXReactor")
+ pexR.sw = sw
+ go pexR.ensurePeersRoutine()
+ }
+}
+
+// Implements Reactor
+func (pexR *PEXReactor) Stop() {
+ if atomic.CompareAndSwapUint32(&pexR.stopped, 0, 1) {
+ log.Info("Stopping PEXReactor")
+ close(pexR.quit)
+ }
+}
+
+// Implements Reactor
+func (pexR *PEXReactor) GetChannels() []*ChannelDescriptor {
+ return []*ChannelDescriptor{
+ &ChannelDescriptor{
+ Id: PexChannel,
+ Priority: 1,
+ SendQueueCapacity: 10,
+ },
+ }
+}
+
+// Implements Reactor
+func (pexR *PEXReactor) AddPeer(peer *Peer) {
+ if peer.IsOutbound() {
+ pexR.SendAddrs(peer, pexR.book.OurAddresses())
+ if pexR.book.NeedMoreAddrs() {
+ pexR.RequestPEX(peer)
+ }
+ }
+}
+
+// Implements Reactor
+func (pexR *PEXReactor) RemovePeer(peer *Peer, reason interface{}) {
+ // TODO
+}
+
+// Implements Reactor
+// Handles incoming PEX messages.
+func (pexR *PEXReactor) Receive(chId byte, src *Peer, msgBytes []byte) {
+
+ // decode message
+ _, msg, err := DecodeMessage(msgBytes)
+ if err != nil {
+ log.Warn("Error decoding message", "error", err)
+ return
+ }
+ log.Info("Received message", "msg", msg)
+
+ switch msg.(type) {
+ case *pexRequestMessage:
+ // src requested some peers.
+ // TODO: prevent abuse.
+ pexR.SendAddrs(src, pexR.book.GetSelection())
+ case *pexAddrsMessage:
+ // We received some peer addresses from src.
+ // TODO: prevent abuse.
+ // (We don't want to get spammed with bad peers)
+ srcAddr := src.Connection().RemoteAddress
+ for _, addr := range msg.(*pexAddrsMessage).Addrs {
+ pexR.book.AddAddress(addr, srcAddr)
+ }
+ default:
+ log.Warn(Fmt("Unknown message type %v", reflect.TypeOf(msg)))
+ }
+
+}
+
+// Asks peer for more addresses.
+func (pexR *PEXReactor) RequestPEX(peer *Peer) {
+ peer.Send(PexChannel, &pexRequestMessage{})
+}
+
+func (pexR *PEXReactor) SendAddrs(peer *Peer, addrs []*NetAddress) {
+ peer.Send(PexChannel, &pexAddrsMessage{Addrs: addrs})
+}
+
+// Ensures that sufficient peers are connected. (continuous)
+func (pexR *PEXReactor) ensurePeersRoutine() {
+ // Randomize when routine starts
+ time.Sleep(time.Duration(rand.Int63n(500*ensurePeersPeriodSeconds)) * time.Millisecond)
+
+ // fire once immediately.
+ pexR.ensurePeers()
+ // fire periodically
+ timer := NewRepeatTimer("pex", ensurePeersPeriodSeconds*time.Second)
+FOR_LOOP:
+ for {
+ select {
+ case <-timer.Ch:
+ pexR.ensurePeers()
+ case <-pexR.quit:
+ break FOR_LOOP
+ }
+ }
+
+ // Cleanup
+ timer.Stop()
+}
+
+// Ensures that sufficient peers are connected. (once)
+func (pexR *PEXReactor) ensurePeers() {
+ numOutPeers, _, numDialing := pexR.sw.NumPeers()
+ numToDial := minNumOutboundPeers - (numOutPeers + numDialing)
+ log.Debug("Ensure peers", "numOutPeers", numOutPeers, "numDialing", numDialing, "numToDial", numToDial)
+ if numToDial <= 0 {
+ return
+ }
+ toDial := NewCMap()
+
+ // Try to pick numToDial addresses to dial.
+ // TODO: improve logic.
+ for i := 0; i < numToDial; i++ {
+ newBias := MinInt(numOutPeers, 8)*10 + 10
+ var picked *NetAddress
+ // Try to fetch a new peer 3 times.
+ // This caps the maximum number of tries to 3 * numToDial.
+ for j := 0; j < 3; j++ {
+ try := pexR.book.PickAddress(newBias)
+ if try == nil {
+ break
+ }
+ alreadySelected := toDial.Has(try.IP.String())
+ alreadyDialing := pexR.sw.IsDialing(try)
+ alreadyConnected := pexR.sw.Peers().Has(try.IP.String())
+ if alreadySelected || alreadyDialing || alreadyConnected {
+ /*
+ log.Debug("Cannot dial address", "addr", try,
+ "alreadySelected", alreadySelected,
+ "alreadyDialing", alreadyDialing,
+ "alreadyConnected", alreadyConnected)
+ */
+ continue
+ } else {
+ log.Debug("Will dial address", "addr", try)
+ picked = try
+ break
+ }
+ }
+ if picked == nil {
+ continue
+ }
+ toDial.Set(picked.IP.String(), picked)
+ }
+
+ // Dial picked addresses
+ for _, item := range toDial.Values() {
+ go func(picked *NetAddress) {
+ _, err := pexR.sw.DialPeerWithAddress(picked)
+ if err != nil {
+ pexR.book.MarkAttempt(picked)
+ }
+ }(item.(*NetAddress))
+ }
+}
+
+// implements events.Eventable
+func (pexR *PEXReactor) SetFireable(evsw events.Fireable) {
+ pexR.evsw = evsw
+}
+
+//-----------------------------------------------------------------------------
+// Messages
+
+const (
+ msgTypeRequest = byte(0x01)
+ msgTypeAddrs = byte(0x02)
+)
+
+type PexMessage interface{}
+
+var _ = binary.RegisterInterface(
+ struct{ PexMessage }{},
+ binary.ConcreteType{&pexRequestMessage{}, msgTypeRequest},
+ binary.ConcreteType{&pexAddrsMessage{}, msgTypeAddrs},
+)
+
+func DecodeMessage(bz []byte) (msgType byte, msg PexMessage, err error) {
+ msgType = bz[0]
+ n := new(int64)
+ r := bytes.NewReader(bz)
+ msg = binary.ReadBinary(struct{ PexMessage }{}, r, n, &err).(struct{ PexMessage }).PexMessage
+ return
+}
+
+/*
+A pexRequestMessage requests additional peer addresses.
+*/
+type pexRequestMessage struct {
+}
+
+func (m *pexRequestMessage) String() string {
+ return "[pexRequest]"
+}
+
+/*
+A message with announced peer addresses.
+*/
+type pexAddrsMessage struct {
+ Addrs []*NetAddress
+}
+
+func (m *pexAddrsMessage) String() string {
+ return fmt.Sprintf("[pexAddrs %v]", m.Addrs)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/switch.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/switch.go
new file mode 100644
index 0000000000000000000000000000000000000000..3755151c0ad8b4c993159454656ef93b5fcfc216
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/switch.go
@@ -0,0 +1,304 @@
+package p2p
+
+import (
+ "errors"
+ "fmt"
+ "net"
+ "sync/atomic"
+ "time"
+
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+type Reactor interface {
+ Start(sw *Switch)
+ Stop()
+ GetChannels() []*ChannelDescriptor
+ AddPeer(peer *Peer)
+ RemovePeer(peer *Peer, reason interface{})
+ Receive(chId byte, peer *Peer, msgBytes []byte)
+}
+
+//--------------------------------------
+
+type BaseReactor struct{}
+
+func (_ BaseReactor) Start(sw *Switch) {}
+func (_ BaseReactor) Stop() {}
+func (_ BaseReactor) GetChannels() []*ChannelDescriptor { return nil }
+func (_ BaseReactor) AddPeer(peer *Peer) {}
+func (_ BaseReactor) RemovePeer(peer *Peer, reason interface{}) {}
+func (_ BaseReactor) Receive(chId byte, peer *Peer, msgBytes []byte) {}
+
+//-----------------------------------------------------------------------------
+
+/*
+The `Switch` handles peer connections and exposes an API to receive incoming messages
+on `Reactors`. Each `Reactor` is responsible for handling incoming messages of one
+or more `Channels`. So while sending outgoing messages is typically performed on the peer,
+incoming messages are received on the reactor.
+*/
+type Switch struct {
+ listeners []Listener
+ reactors map[string]Reactor
+ chDescs []*ChannelDescriptor
+ reactorsByCh map[byte]Reactor
+ peers *PeerSet
+ dialing *CMap
+ running uint32
+ nodeInfo *types.NodeInfo // our node info
+}
+
+var (
+ ErrSwitchDuplicatePeer = errors.New("Duplicate peer")
+)
+
+const (
+ peerDialTimeoutSeconds = 3
+)
+
+func NewSwitch() *Switch {
+ sw := &Switch{
+ reactors: make(map[string]Reactor),
+ chDescs: make([]*ChannelDescriptor, 0),
+ reactorsByCh: make(map[byte]Reactor),
+ peers: NewPeerSet(),
+ dialing: NewCMap(),
+ running: 0,
+ nodeInfo: nil,
+ }
+ return sw
+}
+
+// Not goroutine safe.
+func (sw *Switch) AddReactor(name string, reactor Reactor) Reactor {
+ // Validate the reactor.
+ // No two reactors can share the same channel.
+ reactorChannels := reactor.GetChannels()
+ for _, chDesc := range reactorChannels {
+ chId := chDesc.Id
+ if sw.reactorsByCh[chId] != nil {
+ panic(fmt.Sprintf("Channel %X has multiple reactors %v & %v", chId, sw.reactorsByCh[chId], reactor))
+ }
+ sw.chDescs = append(sw.chDescs, chDesc)
+ sw.reactorsByCh[chId] = reactor
+ }
+ sw.reactors[name] = reactor
+ return reactor
+}
+
+// Not goroutine safe.
+func (sw *Switch) Reactors() map[string]Reactor {
+ return sw.reactors
+}
+
+// Not goroutine safe.
+func (sw *Switch) Reactor(name string) Reactor {
+ return sw.reactors[name]
+}
+
+// Not goroutine safe.
+func (sw *Switch) AddListener(l Listener) {
+ sw.listeners = append(sw.listeners, l)
+}
+
+// Not goroutine safe.
+func (sw *Switch) Listeners() []Listener {
+ return sw.listeners
+}
+
+// Not goroutine safe.
+func (sw *Switch) IsListening() bool {
+ return len(sw.listeners) > 0
+}
+
+// Not goroutine safe.
+func (sw *Switch) SetNodeInfo(nodeInfo *types.NodeInfo) {
+ sw.nodeInfo = nodeInfo
+}
+
+func (sw *Switch) Start() {
+ if atomic.CompareAndSwapUint32(&sw.running, 0, 1) {
+ // Start reactors
+ for _, reactor := range sw.reactors {
+ reactor.Start(sw)
+ }
+ // Start peers
+ for _, peer := range sw.peers.List() {
+ sw.startInitPeer(peer)
+ }
+ // Start listeners
+ for _, listener := range sw.listeners {
+ go sw.listenerRoutine(listener)
+ }
+ }
+}
+
+func (sw *Switch) Stop() {
+ if atomic.CompareAndSwapUint32(&sw.running, 1, 0) {
+ // Stop listeners
+ for _, listener := range sw.listeners {
+ listener.Stop()
+ }
+ sw.listeners = nil
+ // Stop peers
+ for _, peer := range sw.peers.List() {
+ peer.stop()
+ }
+ sw.peers = NewPeerSet()
+ // Stop reactors
+ for _, reactor := range sw.reactors {
+ reactor.Stop()
+ }
+ }
+}
+
+// NOTE: This performs a blocking handshake before the peer is added.
+func (sw *Switch) AddPeerWithConnection(conn net.Conn, outbound bool) (*Peer, error) {
+ // First, perform handshake
+ peerNodeInfo, err := peerHandshake(conn, sw.nodeInfo)
+ if err != nil {
+ return nil, err
+ }
+ if err := sw.nodeInfo.CompatibleWith(peerNodeInfo); err != nil {
+ return nil, err
+ }
+
+ peer := newPeer(conn, peerNodeInfo, outbound, sw.reactorsByCh, sw.chDescs, sw.StopPeerForError)
+
+ // Add the peer to .peers
+ if sw.peers.Add(peer) {
+ log.Info("Added peer", "peer", peer)
+ } else {
+ log.Info("Ignoring duplicate peer", "peer", peer)
+ return nil, ErrSwitchDuplicatePeer
+ }
+
+ if atomic.LoadUint32(&sw.running) == 1 {
+ sw.startInitPeer(peer)
+ }
+ return peer, nil
+}
+
+func (sw *Switch) startInitPeer(peer *Peer) {
+ peer.start()
+ sw.addPeerToReactors(peer)
+}
+
+func (sw *Switch) DialPeerWithAddress(addr *NetAddress) (*Peer, error) {
+ log.Debug("Dialing address", "address", addr)
+ sw.dialing.Set(addr.IP.String(), addr)
+ conn, err := addr.DialTimeout(peerDialTimeoutSeconds * time.Second)
+ sw.dialing.Delete(addr.IP.String())
+ if err != nil {
+ log.Debug("Failed dialing address", "address", addr, "error", err)
+ return nil, err
+ }
+ peer, err := sw.AddPeerWithConnection(conn, true)
+ if err != nil {
+ log.Debug("Failed adding peer", "address", addr, "conn", conn, "error", err)
+ return nil, err
+ }
+ log.Info("Dialed and added peer", "address", addr, "peer", peer)
+ return peer, nil
+}
+
+func (sw *Switch) IsDialing(addr *NetAddress) bool {
+ return sw.dialing.Has(addr.IP.String())
+}
+
+// Broadcast runs a go routine for each attempted send, which will block
+// trying to send for defaultSendTimeoutSeconds. Returns a channel
+// which receives success values for each attempted send (false if times out)
+func (sw *Switch) Broadcast(chId byte, msg interface{}) chan bool {
+ successChan := make(chan bool, len(sw.peers.List()))
+ log.Debug("Broadcast", "channel", chId, "msg", msg)
+ for _, peer := range sw.peers.List() {
+ go func(peer *Peer) {
+ success := peer.Send(chId, msg)
+ successChan <- success
+ }(peer)
+ }
+ return successChan
+
+}
+
+// Returns the count of outbound/inbound and outbound-dialing peers.
+func (sw *Switch) NumPeers() (outbound, inbound, dialing int) {
+ peers := sw.peers.List()
+ for _, peer := range peers {
+ if peer.outbound {
+ outbound++
+ } else {
+ inbound++
+ }
+ }
+ dialing = sw.dialing.Size()
+ return
+}
+
+func (sw *Switch) Peers() IPeerSet {
+ return sw.peers
+}
+
+// Disconnect from a peer due to external error.
+// TODO: make record depending on reason.
+func (sw *Switch) StopPeerForError(peer *Peer, reason interface{}) {
+ log.Info("Stopping peer for error", "peer", peer, "error", reason)
+ sw.peers.Remove(peer)
+ peer.stop()
+ sw.removePeerFromReactors(peer, reason)
+}
+
+// Disconnect from a peer gracefully.
+// TODO: handle graceful disconnects.
+func (sw *Switch) StopPeerGracefully(peer *Peer) {
+ log.Info("Stopping peer gracefully")
+ sw.peers.Remove(peer)
+ peer.stop()
+ sw.removePeerFromReactors(peer, nil)
+}
+
+func (sw *Switch) addPeerToReactors(peer *Peer) {
+ for _, reactor := range sw.reactors {
+ reactor.AddPeer(peer)
+ }
+}
+
+func (sw *Switch) removePeerFromReactors(peer *Peer, reason interface{}) {
+ for _, reactor := range sw.reactors {
+ reactor.RemovePeer(peer, reason)
+ }
+}
+
+func (sw *Switch) listenerRoutine(l Listener) {
+ for {
+ inConn, ok := <-l.Connections()
+ if !ok {
+ break
+ }
+ // New inbound connection!
+ peer, err := sw.AddPeerWithConnection(inConn, false)
+ if err != nil {
+ log.Info(Fmt("Ignoring error from inbound connection: %v\n%v", peer, err))
+ continue
+ }
+ // NOTE: We don't yet have the external address of the
+ // remote (if they have a listener at all).
+ // PEXReactor's pexRoutine will handle that.
+ }
+
+ // cleanup
+}
+
+//-----------------------------------------------------------------------------
+
+type SwitchEventNewPeer struct {
+ Peer *Peer
+}
+
+type SwitchEventDonePeer struct {
+ Peer *Peer
+ Error interface{}
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/switch_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/switch_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..874abcddbcb10f314d4324acb30390519cc95f3f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/switch_test.go
@@ -0,0 +1,229 @@
+package p2p
+
+import (
+ "bytes"
+ "sync"
+ "testing"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+type PeerMessage struct {
+ PeerKey string
+ Bytes []byte
+ Counter int
+}
+
+type TestReactor struct {
+ mtx sync.Mutex
+ channels []*ChannelDescriptor
+ peersAdded []*Peer
+ peersRemoved []*Peer
+ logMessages bool
+ msgsCounter int
+ msgsReceived map[byte][]PeerMessage
+}
+
+func NewTestReactor(channels []*ChannelDescriptor, logMessages bool) *TestReactor {
+ return &TestReactor{
+ channels: channels,
+ logMessages: logMessages,
+ msgsReceived: make(map[byte][]PeerMessage),
+ }
+}
+
+func (tr *TestReactor) Start(sw *Switch) {
+}
+
+func (tr *TestReactor) Stop() {
+}
+
+func (tr *TestReactor) GetChannels() []*ChannelDescriptor {
+ return tr.channels
+}
+
+func (tr *TestReactor) AddPeer(peer *Peer) {
+ tr.mtx.Lock()
+ defer tr.mtx.Unlock()
+ tr.peersAdded = append(tr.peersAdded, peer)
+}
+
+func (tr *TestReactor) RemovePeer(peer *Peer, reason interface{}) {
+ tr.mtx.Lock()
+ defer tr.mtx.Unlock()
+ tr.peersRemoved = append(tr.peersRemoved, peer)
+}
+
+func (tr *TestReactor) Receive(chId byte, peer *Peer, msgBytes []byte) {
+ if tr.logMessages {
+ tr.mtx.Lock()
+ defer tr.mtx.Unlock()
+ //fmt.Printf("Received: %X, %X\n", chId, msgBytes)
+ tr.msgsReceived[chId] = append(tr.msgsReceived[chId], PeerMessage{peer.Key, msgBytes, tr.msgsCounter})
+ tr.msgsCounter++
+ }
+}
+
+//-----------------------------------------------------------------------------
+
+// convenience method for creating two switches connected to each other.
+func makeSwitchPair(t testing.TB, initSwitch func(*Switch) *Switch) (*Switch, *Switch) {
+
+ // Create two switches that will be interconnected.
+ s1 := initSwitch(NewSwitch())
+ s1.SetNodeInfo(&types.NodeInfo{
+ Moniker: "switch1",
+ ChainID: "testing",
+ Version: "123.123.123",
+ })
+ s2 := initSwitch(NewSwitch())
+ s2.SetNodeInfo(&types.NodeInfo{
+ Moniker: "switch2",
+ ChainID: "testing",
+ Version: "123.123.123",
+ })
+
+ // Start switches
+ s1.Start()
+ s2.Start()
+
+ // Create a listener for s1
+ l := NewDefaultListener("tcp", ":8001", true)
+
+ // Dial the listener & add the connection to s2.
+ lAddr := l.ExternalAddress()
+ connOut, err := lAddr.Dial()
+ if err != nil {
+ t.Fatalf("Could not connect to listener address %v", lAddr)
+ } else {
+ t.Logf("Created a connection to listener address %v", lAddr)
+ }
+ connIn, ok := <-l.Connections()
+ if !ok {
+ t.Fatalf("Could not get inbound connection from listener")
+ }
+
+ go s1.AddPeerWithConnection(connIn, false) // AddPeer is blocking, requires handshake.
+ s2.AddPeerWithConnection(connOut, true)
+
+ // Wait for things to happen, peers to get added...
+ time.Sleep(100 * time.Millisecond)
+
+ // Close the server, no longer needed.
+ l.Stop()
+
+ return s1, s2
+}
+
+func TestSwitches(t *testing.T) {
+ s1, s2 := makeSwitchPair(t, func(sw *Switch) *Switch {
+ // Make two reactors of two channels each
+ sw.AddReactor("foo", NewTestReactor([]*ChannelDescriptor{
+ &ChannelDescriptor{Id: byte(0x00), Priority: 10},
+ &ChannelDescriptor{Id: byte(0x01), Priority: 10},
+ }, true)).Start(sw) // Start the reactor
+ sw.AddReactor("bar", NewTestReactor([]*ChannelDescriptor{
+ &ChannelDescriptor{Id: byte(0x02), Priority: 10},
+ &ChannelDescriptor{Id: byte(0x03), Priority: 10},
+ }, true)).Start(sw) // Start the reactor
+ return sw
+ })
+ defer s1.Stop()
+ defer s2.Stop()
+
+ // Lets send a message from s1 to s2.
+ if s1.Peers().Size() != 1 {
+ t.Errorf("Expected exactly 1 peer in s1, got %v", s1.Peers().Size())
+ }
+ if s2.Peers().Size() != 1 {
+ t.Errorf("Expected exactly 1 peer in s2, got %v", s2.Peers().Size())
+ }
+
+ ch0Msg := "channel zero"
+ ch1Msg := "channel foo"
+ ch2Msg := "channel bar"
+
+ s1.Broadcast(byte(0x00), ch0Msg)
+ s1.Broadcast(byte(0x01), ch1Msg)
+ s1.Broadcast(byte(0x02), ch2Msg)
+
+ // Wait for things to settle...
+ time.Sleep(5000 * time.Millisecond)
+
+ // Check message on ch0
+ ch0Msgs := s2.Reactor("foo").(*TestReactor).msgsReceived[byte(0x00)]
+ if len(ch0Msgs) != 1 {
+ t.Errorf("Expected to have received 1 message in ch0")
+ }
+ if !bytes.Equal(ch0Msgs[0].Bytes, binary.BinaryBytes(ch0Msg)) {
+ t.Errorf("Unexpected message bytes. Wanted: %X, Got: %X", binary.BinaryBytes(ch0Msg), ch0Msgs[0].Bytes)
+ }
+
+ // Check message on ch1
+ ch1Msgs := s2.Reactor("foo").(*TestReactor).msgsReceived[byte(0x01)]
+ if len(ch1Msgs) != 1 {
+ t.Errorf("Expected to have received 1 message in ch1")
+ }
+ if !bytes.Equal(ch1Msgs[0].Bytes, binary.BinaryBytes(ch1Msg)) {
+ t.Errorf("Unexpected message bytes. Wanted: %X, Got: %X", binary.BinaryBytes(ch1Msg), ch1Msgs[0].Bytes)
+ }
+
+ // Check message on ch2
+ ch2Msgs := s2.Reactor("bar").(*TestReactor).msgsReceived[byte(0x02)]
+ if len(ch2Msgs) != 1 {
+ t.Errorf("Expected to have received 1 message in ch2")
+ }
+ if !bytes.Equal(ch2Msgs[0].Bytes, binary.BinaryBytes(ch2Msg)) {
+ t.Errorf("Unexpected message bytes. Wanted: %X, Got: %X", binary.BinaryBytes(ch2Msg), ch2Msgs[0].Bytes)
+ }
+
+}
+
+func BenchmarkSwitches(b *testing.B) {
+
+ b.StopTimer()
+
+ s1, s2 := makeSwitchPair(b, func(sw *Switch) *Switch {
+ // Make bar reactors of bar channels each
+ sw.AddReactor("foo", NewTestReactor([]*ChannelDescriptor{
+ &ChannelDescriptor{Id: byte(0x00), Priority: 10},
+ &ChannelDescriptor{Id: byte(0x01), Priority: 10},
+ }, false))
+ sw.AddReactor("bar", NewTestReactor([]*ChannelDescriptor{
+ &ChannelDescriptor{Id: byte(0x02), Priority: 10},
+ &ChannelDescriptor{Id: byte(0x03), Priority: 10},
+ }, false))
+ return sw
+ })
+ defer s1.Stop()
+ defer s2.Stop()
+
+ // Allow time for goroutines to boot up
+ time.Sleep(1000 * time.Millisecond)
+ b.StartTimer()
+
+ numSuccess, numFailure := 0, 0
+
+ // Send random message from foo channel to another
+ for i := 0; i < b.N; i++ {
+ chId := byte(i % 4)
+ successChan := s1.Broadcast(chId, "test data")
+ for s := range successChan {
+ if s {
+ numSuccess += 1
+ } else {
+ numFailure += 1
+ }
+ }
+ }
+
+ log.Warn(Fmt("success: %v, failure: %v", numSuccess, numFailure))
+
+ // Allow everything to flush before stopping switches & closing connections.
+ b.StopTimer()
+ time.Sleep(1000 * time.Millisecond)
+
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/upnp/README.md b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/upnp/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..557d05bdc77722351888d58dc4f8279e6f7f0bd2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/upnp/README.md
@@ -0,0 +1,5 @@
+# `tendermint/p2p/upnp`
+
+## Resources
+
+* http://www.upnp-hacks.org/upnp.html
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/upnp/log.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/upnp/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..335429fa0f6a114a7fba23745108980975e3ed40
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/upnp/log.go
@@ -0,0 +1,7 @@
+package upnp
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/logger"
+)
+
+var log = logger.New("module", "upnp")
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/upnp/probe.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/upnp/probe.go
new file mode 100644
index 0000000000000000000000000000000000000000..6c2147ba6ffe7df476b5d56c4536295df5bc27f4
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/upnp/probe.go
@@ -0,0 +1,111 @@
+package upnp
+
+import (
+ "errors"
+ "fmt"
+ "net"
+ "time"
+
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+type UPNPCapabilities struct {
+ PortMapping bool
+ Hairpin bool
+}
+
+func makeUPNPListener(intPort int, extPort int) (NAT, net.Listener, net.IP, error) {
+ nat, err := Discover()
+ if err != nil {
+ return nil, nil, nil, errors.New(fmt.Sprintf("NAT upnp could not be discovered: %v", err))
+ }
+ log.Debug(Fmt("ourIP: %v", nat.(*upnpNAT).ourIP))
+
+ ext, err := nat.GetExternalAddress()
+ if err != nil {
+ return nat, nil, nil, errors.New(fmt.Sprintf("External address error: %v", err))
+ }
+ log.Debug(Fmt("External address: %v", ext))
+
+ port, err := nat.AddPortMapping("tcp", extPort, intPort, "Tendermint UPnP Probe", 0)
+ if err != nil {
+ return nat, nil, ext, errors.New(fmt.Sprintf("Port mapping error: %v", err))
+ }
+ log.Debug(Fmt("Port mapping mapped: %v", port))
+
+ // also run the listener, open for all remote addresses.
+ listener, err := net.Listen("tcp", fmt.Sprintf(":%v", intPort))
+ if err != nil {
+ return nat, nil, ext, errors.New(fmt.Sprintf("Error establishing listener: %v", err))
+ }
+ return nat, listener, ext, nil
+}
+
+func testHairpin(listener net.Listener, extAddr string) (supportsHairpin bool) {
+ // Listener
+ go func() {
+ inConn, err := listener.Accept()
+ if err != nil {
+ log.Info(Fmt("Listener.Accept() error: %v", err))
+ return
+ }
+ log.Debug(Fmt("Accepted incoming connection: %v -> %v", inConn.LocalAddr(), inConn.RemoteAddr()))
+ buf := make([]byte, 1024)
+ n, err := inConn.Read(buf)
+ if err != nil {
+ log.Info(Fmt("Incoming connection read error: %v", err))
+ return
+ }
+ log.Debug(Fmt("Incoming connection read %v bytes: %X", n, buf))
+ if string(buf) == "test data" {
+ supportsHairpin = true
+ return
+ }
+ }()
+
+ // Establish outgoing
+ outConn, err := net.Dial("tcp", extAddr)
+ if err != nil {
+ log.Info(Fmt("Outgoing connection dial error: %v", err))
+ return
+ }
+
+ n, err := outConn.Write([]byte("test data"))
+ if err != nil {
+ log.Info(Fmt("Outgoing connection write error: %v", err))
+ return
+ }
+ log.Debug(Fmt("Outgoing connection wrote %v bytes", n))
+
+ // Wait for data receipt
+ time.Sleep(1 * time.Second)
+ return
+}
+
+func Probe() (caps UPNPCapabilities, err error) {
+ log.Debug("Probing for UPnP!")
+
+ intPort, extPort := 8001, 8001
+
+ nat, listener, ext, err := makeUPNPListener(intPort, extPort)
+ if err != nil {
+ return
+ }
+ caps.PortMapping = true
+
+ // Deferred cleanup
+ defer func() {
+ err = nat.DeletePortMapping("tcp", intPort, extPort)
+ if err != nil {
+ log.Warn(Fmt("Port mapping delete error: %v", err))
+ }
+ listener.Close()
+ }()
+
+ supportsHairpin := testHairpin(listener, fmt.Sprintf("%v:%v", ext, extPort))
+ if supportsHairpin {
+ caps.Hairpin = true
+ }
+
+ return
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/upnp/upnp.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/upnp/upnp.go
new file mode 100644
index 0000000000000000000000000000000000000000..7aff240baaa83a66e7b13cd0ada28c7ddd5cb63e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/upnp/upnp.go
@@ -0,0 +1,380 @@
+/*
+Taken from taipei-torrent
+
+Just enough UPnP to be able to forward ports
+*/
+package upnp
+
+// BUG(jae): TODO: use syscalls to get actual ourIP. http://pastebin.com/9exZG4rh
+
+import (
+ "bytes"
+ "encoding/xml"
+ "errors"
+ "io/ioutil"
+ "net"
+ "net/http"
+ "strconv"
+ "strings"
+ "time"
+)
+
+type upnpNAT struct {
+ serviceURL string
+ ourIP string
+ urnDomain string
+}
+
+// protocol is either "udp" or "tcp"
+type NAT interface {
+ GetExternalAddress() (addr net.IP, err error)
+ AddPortMapping(protocol string, externalPort, internalPort int, description string, timeout int) (mappedExternalPort int, err error)
+ DeletePortMapping(protocol string, externalPort, internalPort int) (err error)
+}
+
+func Discover() (nat NAT, err error) {
+ ssdp, err := net.ResolveUDPAddr("udp4", "239.255.255.250:1900")
+ if err != nil {
+ return
+ }
+ conn, err := net.ListenPacket("udp4", ":0")
+ if err != nil {
+ return
+ }
+ socket := conn.(*net.UDPConn)
+ defer socket.Close()
+
+ err = socket.SetDeadline(time.Now().Add(3 * time.Second))
+ if err != nil {
+ return
+ }
+
+ st := "InternetGatewayDevice:1"
+
+ buf := bytes.NewBufferString(
+ "M-SEARCH * HTTP/1.1\r\n" +
+ "HOST: 239.255.255.250:1900\r\n" +
+ "ST: ssdp:all\r\n" +
+ "MAN: \"ssdp:discover\"\r\n" +
+ "MX: 2\r\n\r\n")
+ message := buf.Bytes()
+ answerBytes := make([]byte, 1024)
+ for i := 0; i < 3; i++ {
+ _, err = socket.WriteToUDP(message, ssdp)
+ if err != nil {
+ return
+ }
+ var n int
+ n, _, err = socket.ReadFromUDP(answerBytes)
+ for {
+ n, _, err = socket.ReadFromUDP(answerBytes)
+ if err != nil {
+ break
+ }
+ answer := string(answerBytes[0:n])
+ if strings.Index(answer, st) < 0 {
+ continue
+ }
+ // HTTP header field names are case-insensitive.
+ // http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
+ locString := "\r\nlocation:"
+ answer = strings.ToLower(answer)
+ locIndex := strings.Index(answer, locString)
+ if locIndex < 0 {
+ continue
+ }
+ loc := answer[locIndex+len(locString):]
+ endIndex := strings.Index(loc, "\r\n")
+ if endIndex < 0 {
+ continue
+ }
+ locURL := strings.TrimSpace(loc[0:endIndex])
+ var serviceURL, urnDomain string
+ serviceURL, urnDomain, err = getServiceURL(locURL)
+ if err != nil {
+ return
+ }
+ var ourIP net.IP
+ ourIP, err = localIPv4()
+ if err != nil {
+ return
+ }
+ nat = &upnpNAT{serviceURL: serviceURL, ourIP: ourIP.String(), urnDomain: urnDomain}
+ return
+ }
+ }
+ err = errors.New("UPnP port discovery failed.")
+ return
+}
+
+type Envelope struct {
+ XMLName xml.Name `xml:"http://schemas.xmlsoap.org/soap/envelope/ Envelope"`
+ Soap *SoapBody
+}
+type SoapBody struct {
+ XMLName xml.Name `xml:"http://schemas.xmlsoap.org/soap/envelope/ Body"`
+ ExternalIP *ExternalIPAddressResponse
+}
+
+type ExternalIPAddressResponse struct {
+ XMLName xml.Name `xml:"GetExternalIPAddressResponse"`
+ IPAddress string `xml:"NewExternalIPAddress"`
+}
+
+type ExternalIPAddress struct {
+ XMLName xml.Name `xml:"NewExternalIPAddress"`
+ IP string
+}
+
+type Service struct {
+ ServiceType string `xml:"serviceType"`
+ ControlURL string `xml:"controlURL"`
+}
+
+type DeviceList struct {
+ Device []Device `xml:"device"`
+}
+
+type ServiceList struct {
+ Service []Service `xml:"service"`
+}
+
+type Device struct {
+ XMLName xml.Name `xml:"device"`
+ DeviceType string `xml:"deviceType"`
+ DeviceList DeviceList `xml:"deviceList"`
+ ServiceList ServiceList `xml:"serviceList"`
+}
+
+type Root struct {
+ Device Device
+}
+
+func getChildDevice(d *Device, deviceType string) *Device {
+ dl := d.DeviceList.Device
+ for i := 0; i < len(dl); i++ {
+ if strings.Index(dl[i].DeviceType, deviceType) >= 0 {
+ return &dl[i]
+ }
+ }
+ return nil
+}
+
+func getChildService(d *Device, serviceType string) *Service {
+ sl := d.ServiceList.Service
+ for i := 0; i < len(sl); i++ {
+ if strings.Index(sl[i].ServiceType, serviceType) >= 0 {
+ return &sl[i]
+ }
+ }
+ return nil
+}
+
+func localIPv4() (net.IP, error) {
+ tt, err := net.Interfaces()
+ if err != nil {
+ return nil, err
+ }
+ for _, t := range tt {
+ aa, err := t.Addrs()
+ if err != nil {
+ return nil, err
+ }
+ for _, a := range aa {
+ ipnet, ok := a.(*net.IPNet)
+ if !ok {
+ continue
+ }
+ v4 := ipnet.IP.To4()
+ if v4 == nil || v4[0] == 127 { // loopback address
+ continue
+ }
+ return v4, nil
+ }
+ }
+ return nil, errors.New("cannot find local IP address")
+}
+
+func getServiceURL(rootURL string) (url, urnDomain string, err error) {
+ r, err := http.Get(rootURL)
+ if err != nil {
+ return
+ }
+ defer r.Body.Close()
+ if r.StatusCode >= 400 {
+ err = errors.New(string(r.StatusCode))
+ return
+ }
+ var root Root
+ err = xml.NewDecoder(r.Body).Decode(&root)
+ if err != nil {
+ return
+ }
+ a := &root.Device
+ if strings.Index(a.DeviceType, "InternetGatewayDevice:1") < 0 {
+ err = errors.New("No InternetGatewayDevice")
+ return
+ }
+ b := getChildDevice(a, "WANDevice:1")
+ if b == nil {
+ err = errors.New("No WANDevice")
+ return
+ }
+ c := getChildDevice(b, "WANConnectionDevice:1")
+ if c == nil {
+ err = errors.New("No WANConnectionDevice")
+ return
+ }
+ d := getChildService(c, "WANIPConnection:1")
+ if d == nil {
+ // Some routers don't follow the UPnP spec, and put WanIPConnection under WanDevice,
+ // instead of under WanConnectionDevice
+ d = getChildService(b, "WANIPConnection:1")
+
+ if d == nil {
+ err = errors.New("No WANIPConnection")
+ return
+ }
+ }
+ // Extract the domain name, which isn't always 'schemas-upnp-org'
+ urnDomain = strings.Split(d.ServiceType, ":")[1]
+ url = combineURL(rootURL, d.ControlURL)
+ return
+}
+
+func combineURL(rootURL, subURL string) string {
+ protocolEnd := "://"
+ protoEndIndex := strings.Index(rootURL, protocolEnd)
+ a := rootURL[protoEndIndex+len(protocolEnd):]
+ rootIndex := strings.Index(a, "/")
+ return rootURL[0:protoEndIndex+len(protocolEnd)+rootIndex] + subURL
+}
+
+func soapRequest(url, function, message, domain string) (r *http.Response, err error) {
+ fullMessage := "<?xml version=\"1.0\" ?>" +
+ "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">\r\n" +
+ "<s:Body>" + message + "</s:Body></s:Envelope>"
+
+ req, err := http.NewRequest("POST", url, strings.NewReader(fullMessage))
+ if err != nil {
+ return nil, err
+ }
+ req.Header.Set("Content-Type", "text/xml ; charset=\"utf-8\"")
+ req.Header.Set("User-Agent", "Darwin/10.0.0, UPnP/1.0, MiniUPnPc/1.3")
+ //req.Header.Set("Transfer-Encoding", "chunked")
+ req.Header.Set("SOAPAction", "\"urn:"+domain+":service:WANIPConnection:1#"+function+"\"")
+ req.Header.Set("Connection", "Close")
+ req.Header.Set("Cache-Control", "no-cache")
+ req.Header.Set("Pragma", "no-cache")
+
+ // log.Stderr("soapRequest ", req)
+
+ r, err = http.DefaultClient.Do(req)
+ if err != nil {
+ return nil, err
+ }
+ /*if r.Body != nil {
+ defer r.Body.Close()
+ }*/
+
+ if r.StatusCode >= 400 {
+ // log.Stderr(function, r.StatusCode)
+ err = errors.New("Error " + strconv.Itoa(r.StatusCode) + " for " + function)
+ r = nil
+ return
+ }
+ return
+}
+
+type statusInfo struct {
+ externalIpAddress string
+}
+
+func (n *upnpNAT) getExternalIPAddress() (info statusInfo, err error) {
+
+ message := "<u:GetExternalIPAddress xmlns:u=\"urn:" + n.urnDomain + ":service:WANIPConnection:1\">\r\n" +
+ "</u:GetExternalIPAddress>"
+
+ var response *http.Response
+ response, err = soapRequest(n.serviceURL, "GetExternalIPAddress", message, n.urnDomain)
+ if response != nil {
+ defer response.Body.Close()
+ }
+ if err != nil {
+ return
+ }
+ var envelope Envelope
+ data, err := ioutil.ReadAll(response.Body)
+ reader := bytes.NewReader(data)
+ xml.NewDecoder(reader).Decode(&envelope)
+
+ info = statusInfo{envelope.Soap.ExternalIP.IPAddress}
+
+ if err != nil {
+ return
+ }
+
+ return
+}
+
+func (n *upnpNAT) GetExternalAddress() (addr net.IP, err error) {
+ info, err := n.getExternalIPAddress()
+ if err != nil {
+ return
+ }
+ addr = net.ParseIP(info.externalIpAddress)
+ return
+}
+
+func (n *upnpNAT) AddPortMapping(protocol string, externalPort, internalPort int, description string, timeout int) (mappedExternalPort int, err error) {
+ // A single concatenation would break ARM compilation.
+ message := "<u:AddPortMapping xmlns:u=\"urn:" + n.urnDomain + ":service:WANIPConnection:1\">\r\n" +
+ "<NewRemoteHost></NewRemoteHost><NewExternalPort>" + strconv.Itoa(externalPort)
+ message += "</NewExternalPort><NewProtocol>" + protocol + "</NewProtocol>"
+ message += "<NewInternalPort>" + strconv.Itoa(internalPort) + "</NewInternalPort>" +
+ "<NewInternalClient>" + n.ourIP + "</NewInternalClient>" +
+ "<NewEnabled>1</NewEnabled><NewPortMappingDescription>"
+ message += description +
+ "</NewPortMappingDescription><NewLeaseDuration>" + strconv.Itoa(timeout) +
+ "</NewLeaseDuration></u:AddPortMapping>"
+
+ var response *http.Response
+ response, err = soapRequest(n.serviceURL, "AddPortMapping", message, n.urnDomain)
+ if response != nil {
+ defer response.Body.Close()
+ }
+ if err != nil {
+ return
+ }
+
+ // TODO: check response to see if the port was forwarded
+ // log.Println(message, response)
+ // JAE:
+ // body, err := ioutil.ReadAll(response.Body)
+ // fmt.Println(string(body), err)
+ mappedExternalPort = externalPort
+ _ = response
+ return
+}
+
+func (n *upnpNAT) DeletePortMapping(protocol string, externalPort, internalPort int) (err error) {
+
+ message := "<u:DeletePortMapping xmlns:u=\"urn:" + n.urnDomain + ":service:WANIPConnection:1\">\r\n" +
+ "<NewRemoteHost></NewRemoteHost><NewExternalPort>" + strconv.Itoa(externalPort) +
+ "</NewExternalPort><NewProtocol>" + protocol + "</NewProtocol>" +
+ "</u:DeletePortMapping>"
+
+ var response *http.Response
+ response, err = soapRequest(n.serviceURL, "DeletePortMapping", message, n.urnDomain)
+ if response != nil {
+ defer response.Body.Close()
+ }
+ if err != nil {
+ return
+ }
+
+ // TODO: check response to see if the port was deleted
+ // log.Println(message, response)
+ _ = response
+ return
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/util.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..2be320263a9f8974597b680bc09bb979ff51f9cd
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p/util.go
@@ -0,0 +1,15 @@
+package p2p
+
+import (
+ "crypto/sha256"
+)
+
+// doubleSha256 calculates sha256(sha256(b)) and returns the resulting bytes.
+func doubleSha256(b []byte) []byte {
+ hasher := sha256.New()
+ hasher.Write(b)
+ sum := hasher.Sum(nil)
+ hasher.Reset()
+ hasher.Write(sum)
+ return hasher.Sum(nil)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/accounts.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/accounts.go
new file mode 100644
index 0000000000000000000000000000000000000000..c2c9daf0a853790bdb64de751cba30e15ef73ff1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/accounts.go
@@ -0,0 +1,73 @@
+package core
+
+import (
+ "fmt"
+ acm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ ctypes "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/types"
+)
+
+func GenPrivAccount() (*acm.PrivAccount, error) {
+ return acm.GenPrivAccount(), nil
+}
+
+func GetAccount(address []byte) (*acm.Account, error) {
+ cache := mempoolReactor.Mempool.GetCache()
+ account := cache.GetAccount(address)
+ if account == nil {
+ account = &acm.Account{
+ Address: address,
+ PubKey: nil,
+ Sequence: 0,
+ Balance: 0,
+ Code: nil,
+ StorageRoot: nil,
+ }
+ }
+ return account, nil
+}
+
+func GetStorage(address, key []byte) (*ctypes.ResponseGetStorage, error) {
+ state := consensusState.GetState()
+ account := state.GetAccount(address)
+ if account == nil {
+ return nil, fmt.Errorf("Unknown address: %X", address)
+ }
+ storageRoot := account.StorageRoot
+ storageTree := state.LoadStorage(storageRoot)
+
+ _, value := storageTree.Get(LeftPadWord256(key).Bytes())
+ if value == nil {
+ return &ctypes.ResponseGetStorage{key, nil}, nil
+ }
+ return &ctypes.ResponseGetStorage{key, value.([]byte)}, nil
+}
+
+func ListAccounts() (*ctypes.ResponseListAccounts, error) {
+ var blockHeight uint
+ var accounts []*acm.Account
+ state := consensusState.GetState()
+ blockHeight = state.LastBlockHeight
+ state.GetAccounts().Iterate(func(key interface{}, value interface{}) bool {
+ accounts = append(accounts, value.(*acm.Account))
+ return false
+ })
+ return &ctypes.ResponseListAccounts{blockHeight, accounts}, nil
+}
+
+func DumpStorage(address []byte) (*ctypes.ResponseDumpStorage, error) {
+ state := consensusState.GetState()
+ account := state.GetAccount(address)
+ if account == nil {
+ return nil, fmt.Errorf("Unknown address: %X", address)
+ }
+ storageRoot := account.StorageRoot
+ storageTree := state.LoadStorage(storageRoot)
+ storageItems := []ctypes.StorageItem{}
+ storageTree.Iterate(func(key interface{}, value interface{}) bool {
+ storageItems = append(storageItems, ctypes.StorageItem{
+ key.([]byte), value.([]byte)})
+ return false
+ })
+ return &ctypes.ResponseDumpStorage{storageRoot, storageItems}, nil
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/blocks.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/blocks.go
new file mode 100644
index 0000000000000000000000000000000000000000..28d3db7ac286c5a2f7973767f1b7bc328464dfed
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/blocks.go
@@ -0,0 +1,45 @@
+package core
+
+import (
+ "fmt"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ ctypes "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/types"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+//-----------------------------------------------------------------------------
+
+func BlockchainInfo(minHeight, maxHeight uint) (*ctypes.ResponseBlockchainInfo, error) {
+ if maxHeight == 0 {
+ maxHeight = blockStore.Height()
+ } else {
+ maxHeight = MinUint(blockStore.Height(), maxHeight)
+ }
+ if minHeight == 0 {
+ minHeight = uint(MaxInt(1, int(maxHeight)-20))
+ }
+ log.Debug("BlockchainInfoHandler", "maxHeight", maxHeight, "minHeight", minHeight)
+
+ blockMetas := []*types.BlockMeta{}
+ for height := maxHeight; height >= minHeight; height-- {
+ blockMeta := blockStore.LoadBlockMeta(height)
+ blockMetas = append(blockMetas, blockMeta)
+ }
+
+ return &ctypes.ResponseBlockchainInfo{blockStore.Height(), blockMetas}, nil
+}
+
+//-----------------------------------------------------------------------------
+
+func GetBlock(height uint) (*ctypes.ResponseGetBlock, error) {
+ if height == 0 {
+ return nil, fmt.Errorf("height must be greater than 0")
+ }
+ if height > blockStore.Height() {
+ return nil, fmt.Errorf("height must be less than the current blockchain height")
+ }
+
+ blockMeta := blockStore.LoadBlockMeta(height)
+ block := blockStore.LoadBlock(height)
+ return &ctypes.ResponseGetBlock{blockMeta, block}, nil
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/config.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..9fb3f95421e60b84cae5d83ce7781e7215d2be5d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/config.go
@@ -0,0 +1,13 @@
+package core
+
+import (
+ cfg "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config"
+)
+
+var config cfg.Config = nil
+
+func init() {
+ cfg.OnConfig(func(newConfig cfg.Config) {
+ config = newConfig
+ })
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/consensus.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/consensus.go
new file mode 100644
index 0000000000000000000000000000000000000000..c089a8da4cd0fcfdc2d0c80405c66c6b5336d44b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/consensus.go
@@ -0,0 +1,40 @@
+package core
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ cm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus"
+ ctypes "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/types"
+ sm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+)
+
+func ListValidators() (*ctypes.ResponseListValidators, error) {
+ var blockHeight uint
+ var bondedValidators []*sm.Validator
+ var unbondingValidators []*sm.Validator
+
+ state := consensusState.GetState()
+ blockHeight = state.LastBlockHeight
+ state.BondedValidators.Iterate(func(index uint, val *sm.Validator) bool {
+ bondedValidators = append(bondedValidators, val)
+ return false
+ })
+ state.UnbondingValidators.Iterate(func(index uint, val *sm.Validator) bool {
+ unbondingValidators = append(unbondingValidators, val)
+ return false
+ })
+
+ return &ctypes.ResponseListValidators{blockHeight, bondedValidators, unbondingValidators}, nil
+}
+
+func DumpConsensusState() (*ctypes.ResponseDumpConsensusState, error) {
+ roundState := consensusState.GetRoundState()
+ peerRoundStates := []string{}
+ for _, peer := range p2pSwitch.Peers().List() {
+ // TODO: clean this up?
+ peerState := peer.Data.Get(cm.PeerStateKey).(*cm.PeerState)
+ peerRoundState := peerState.GetRoundState()
+ peerRoundStateStr := peer.Key + ":" + string(binary.JSONBytes(peerRoundState))
+ peerRoundStates = append(peerRoundStates, peerRoundStateStr)
+ }
+ return &ctypes.ResponseDumpConsensusState{roundState.String(), peerRoundStates}, nil
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/log.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..a0dfe3d8642abca18b02ca7e220b57da4840705d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/log.go
@@ -0,0 +1,7 @@
+package core
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
+)
+
+var log = log15.New("module", "rpc")
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/mempool.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/mempool.go
new file mode 100644
index 0000000000000000000000000000000000000000..f7fa944286e6f7c2b7ffea873064a35d630c7e1b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/mempool.go
@@ -0,0 +1,34 @@
+package core
+
+import (
+ "fmt"
+ ctypes "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/types"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+//-----------------------------------------------------------------------------
+
+// Note: tx must be signed
+func BroadcastTx(tx types.Tx) (*ctypes.Receipt, error) {
+ err := mempoolReactor.BroadcastTx(tx)
+ if err != nil {
+ return nil, fmt.Errorf("Error broadcasting transaction: %v", err)
+ }
+
+ txHash := types.TxId(mempoolReactor.Mempool.GetState().ChainID, tx)
+ var createsContract uint8
+ var contractAddr []byte
+ // check if creates new contract
+ if callTx, ok := tx.(*types.CallTx); ok {
+ if len(callTx.Address) == 0 {
+ createsContract = 1
+ contractAddr = state.NewContractAddress(callTx.Input.Address, uint64(callTx.Input.Sequence))
+ }
+ }
+ return &ctypes.Receipt{txHash, createsContract, contractAddr}, nil
+}
+
+func ListUnconfirmedTxs() ([]types.Tx, error) {
+ return mempoolReactor.Mempool.GetProposalTxs(), nil
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/names.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/names.go
new file mode 100644
index 0000000000000000000000000000000000000000..0fc60ecff0b5ad948e631c196dad3f4dc4874c32
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/names.go
@@ -0,0 +1,29 @@
+package core
+
+import (
+ "fmt"
+
+ ctypes "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/types"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+func GetName(name string) (*types.NameRegEntry, error) {
+ st := consensusState.GetState() // performs a copy
+ entry := st.GetNameRegEntry(name)
+ if entry == nil {
+ return nil, fmt.Errorf("Name %s not found", name)
+ }
+ return entry, nil
+}
+
+func ListNames() (*ctypes.ResponseListNames, error) {
+ var blockHeight uint
+ var names []*types.NameRegEntry
+ state := consensusState.GetState()
+ blockHeight = state.LastBlockHeight
+ state.GetNames().Iterate(func(key interface{}, value interface{}) bool {
+ names = append(names, value.(*types.NameRegEntry))
+ return false
+ })
+ return &ctypes.ResponseListNames{blockHeight, names}, nil
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/net.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/net.go
new file mode 100644
index 0000000000000000000000000000000000000000..22af3e9a23d1ee1534caa017a3c603c2ba287034
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/net.go
@@ -0,0 +1,81 @@
+package core
+
+import (
+ "io/ioutil"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ dbm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/db"
+ ctypes "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/types"
+ sm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+//-----------------------------------------------------------------------------
+
+func Status() (*ctypes.ResponseStatus, error) {
+ db := dbm.NewMemDB()
+ genesisState := sm.MakeGenesisStateFromFile(db, config.GetString("genesis_file"))
+ genesisHash := genesisState.Hash()
+ latestHeight := blockStore.Height()
+ var (
+ latestBlockMeta *types.BlockMeta
+ latestBlockHash []byte
+ latestBlockTime int64
+ )
+ if latestHeight != 0 {
+ latestBlockMeta = blockStore.LoadBlockMeta(latestHeight)
+ latestBlockHash = latestBlockMeta.Hash
+ latestBlockTime = latestBlockMeta.Header.Time.UnixNano()
+ }
+
+ return &ctypes.ResponseStatus{
+ Moniker: config.GetString("moniker"),
+ ChainID: config.GetString("chain_id"),
+ Version: config.GetString("version"),
+ GenesisHash: genesisHash,
+ PubKey: privValidator.PubKey,
+ LatestBlockHash: latestBlockHash,
+ LatestBlockHeight: latestHeight,
+ LatestBlockTime: latestBlockTime}, nil
+}
+
+//-----------------------------------------------------------------------------
+
+func NetInfo() (*ctypes.ResponseNetInfo, error) {
+ listening := p2pSwitch.IsListening()
+ listeners := []string{}
+ for _, listener := range p2pSwitch.Listeners() {
+ listeners = append(listeners, listener.String())
+ }
+ peers := []ctypes.Peer{}
+ for _, peer := range p2pSwitch.Peers().List() {
+ peers = append(peers, ctypes.Peer{
+ NodeInfo: *peer.NodeInfo,
+ IsOutbound: peer.IsOutbound(),
+ })
+ }
+ return &ctypes.ResponseNetInfo{
+ Listening: listening,
+ Listeners: listeners,
+ Peers: peers,
+ }, nil
+}
+
+//-----------------------------------------------------------------------------
+
+// cache the genesis structure
+var genDoc *sm.GenesisDoc
+
+func Genesis() (*sm.GenesisDoc, error) {
+ if genDoc == nil {
+ b, err := ioutil.ReadFile(config.GetString("genesis_file"))
+ if err != nil {
+ return nil, err
+ }
+ binary.ReadJSON(&genDoc, b, &err)
+ if err != nil {
+ return nil, err
+ }
+ }
+ return genDoc, nil
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/pipe.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/pipe.go
new file mode 100644
index 0000000000000000000000000000000000000000..a2c115f9d8eb0a542c945941b8137d9fea4ea659
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/pipe.go
@@ -0,0 +1,40 @@
+package core
+
+import (
+ bc "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus"
+ mempl "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+)
+
+var blockStore *bc.BlockStore
+var consensusState *consensus.ConsensusState
+var consensusReactor *consensus.ConsensusReactor
+var mempoolReactor *mempl.MempoolReactor
+var p2pSwitch *p2p.Switch
+var privValidator *state.PrivValidator
+
+func SetBlockStore(bs *bc.BlockStore) {
+ blockStore = bs
+}
+
+func SetConsensusState(cs *consensus.ConsensusState) {
+ consensusState = cs
+}
+
+func SetConsensusReactor(cr *consensus.ConsensusReactor) {
+ consensusReactor = cr
+}
+
+func SetMempoolReactor(mr *mempl.MempoolReactor) {
+ mempoolReactor = mr
+}
+
+func SetSwitch(sw *p2p.Switch) {
+ p2pSwitch = sw
+}
+
+func SetPrivValidator(pv *state.PrivValidator) {
+ privValidator = pv
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/routes.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/routes.go
new file mode 100644
index 0000000000000000000000000000000000000000..5ad50d6f17b882b4772e0789745f65fb8c65962b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/routes.go
@@ -0,0 +1,27 @@
+package core
+
+import (
+ rpc "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/server"
+)
+
+var Routes = map[string]*rpc.RPCFunc{
+ "status": rpc.NewRPCFunc(Status, []string{}),
+ "net_info": rpc.NewRPCFunc(NetInfo, []string{}),
+ "blockchain": rpc.NewRPCFunc(BlockchainInfo, []string{"minHeight", "maxHeight"}),
+ "genesis": rpc.NewRPCFunc(Genesis, []string{}),
+ "get_block": rpc.NewRPCFunc(GetBlock, []string{"height"}),
+ "get_account": rpc.NewRPCFunc(GetAccount, []string{"address"}),
+ "get_storage": rpc.NewRPCFunc(GetStorage, []string{"address", "key"}),
+ "call": rpc.NewRPCFunc(Call, []string{"address", "data"}),
+ "call_code": rpc.NewRPCFunc(CallCode, []string{"code", "data"}),
+ "list_validators": rpc.NewRPCFunc(ListValidators, []string{}),
+ "dump_consensus_state": rpc.NewRPCFunc(DumpConsensusState, []string{}),
+ "dump_storage": rpc.NewRPCFunc(DumpStorage, []string{"address"}),
+ "broadcast_tx": rpc.NewRPCFunc(BroadcastTx, []string{"tx"}),
+ "list_unconfirmed_txs": rpc.NewRPCFunc(ListUnconfirmedTxs, []string{}),
+ "list_accounts": rpc.NewRPCFunc(ListAccounts, []string{}),
+ "get_name": rpc.NewRPCFunc(GetName, []string{"name"}),
+ "list_names": rpc.NewRPCFunc(ListNames, []string{}),
+ "unsafe/gen_priv_account": rpc.NewRPCFunc(GenPrivAccount, []string{}),
+ "unsafe/sign_tx": rpc.NewRPCFunc(SignTx, []string{"tx", "privAccounts"}),
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/txs.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/txs.go
new file mode 100644
index 0000000000000000000000000000000000000000..4088542695ae4650ceb33ca993df5ee2f5b8464b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/txs.go
@@ -0,0 +1,117 @@
+package core
+
+import (
+ "fmt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ ctypes "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/types"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/vm"
+)
+
+func toVMAccount(acc *account.Account) *vm.Account {
+ return &vm.Account{
+ Address: LeftPadWord256(acc.Address),
+ Balance: acc.Balance,
+ Code: acc.Code, // This is crazy.
+ Nonce: uint64(acc.Sequence),
+ StorageRoot: LeftPadWord256(acc.StorageRoot),
+ Other: acc.PubKey,
+ }
+}
+
+//-----------------------------------------------------------------------------
+
+// Run a contract's code on an isolated and unpersisted state
+// Cannot be used to create new contracts
+func Call(address, data []byte) (*ctypes.ResponseCall, error) {
+ st := consensusState.GetState() // performs a copy
+ cache := state.NewBlockCache(st)
+ outAcc := cache.GetAccount(address)
+ if outAcc == nil {
+ return nil, fmt.Errorf("Account %x does not exist", address)
+ }
+ callee := toVMAccount(outAcc)
+ caller := &vm.Account{Address: Zero256}
+ txCache := state.NewTxCache(cache)
+ params := vm.Params{
+ BlockHeight: uint64(st.LastBlockHeight),
+ BlockHash: LeftPadWord256(st.LastBlockHash),
+ BlockTime: st.LastBlockTime.Unix(),
+ GasLimit: 10000000,
+ }
+
+ vmach := vm.NewVM(txCache, params, caller.Address, nil)
+ gas := uint64(1000000000)
+ ret, err := vmach.Call(caller, callee, callee.Code, data, 0, &gas)
+ if err != nil {
+ return nil, err
+ }
+ return &ctypes.ResponseCall{Return: ret}, nil
+}
+
+// Run the given code on an isolated and unpersisted state
+// Cannot be used to create new contracts
+func CallCode(code, data []byte) (*ctypes.ResponseCall, error) {
+
+ st := consensusState.GetState() // performs a copy
+ cache := mempoolReactor.Mempool.GetCache()
+ callee := &vm.Account{Address: Zero256}
+ caller := &vm.Account{Address: Zero256}
+ txCache := state.NewTxCache(cache)
+ params := vm.Params{
+ BlockHeight: uint64(st.LastBlockHeight),
+ BlockHash: LeftPadWord256(st.LastBlockHash),
+ BlockTime: st.LastBlockTime.Unix(),
+ GasLimit: 10000000,
+ }
+
+ vmach := vm.NewVM(txCache, params, caller.Address, nil)
+ gas := uint64(1000000000)
+ ret, err := vmach.Call(caller, callee, code, data, 0, &gas)
+ if err != nil {
+ return nil, err
+ }
+ return &ctypes.ResponseCall{Return: ret}, nil
+}
+
+//-----------------------------------------------------------------------------
+
+func SignTx(tx types.Tx, privAccounts []*account.PrivAccount) (types.Tx, error) {
+ // more checks?
+
+ for i, privAccount := range privAccounts {
+ if privAccount == nil || privAccount.PrivKey == nil {
+ return nil, fmt.Errorf("Invalid (empty) privAccount @%v", i)
+ }
+ }
+ switch tx.(type) {
+ case *types.SendTx:
+ sendTx := tx.(*types.SendTx)
+ for i, input := range sendTx.Inputs {
+ input.PubKey = privAccounts[i].PubKey
+ input.Signature = privAccounts[i].Sign(config.GetString("chain_id"), sendTx)
+ }
+ case *types.CallTx:
+ callTx := tx.(*types.CallTx)
+ callTx.Input.PubKey = privAccounts[0].PubKey
+ callTx.Input.Signature = privAccounts[0].Sign(config.GetString("chain_id"), callTx)
+ case *types.BondTx:
+ bondTx := tx.(*types.BondTx)
+ // the first privaccount corresponds to the BondTx pub key.
+ // the rest to the inputs
+ bondTx.Signature = privAccounts[0].Sign(config.GetString("chain_id"), bondTx).(account.SignatureEd25519)
+ for i, input := range bondTx.Inputs {
+ input.PubKey = privAccounts[i+1].PubKey
+ input.Signature = privAccounts[i+1].Sign(config.GetString("chain_id"), bondTx)
+ }
+ case *types.UnbondTx:
+ unbondTx := tx.(*types.UnbondTx)
+ unbondTx.Signature = privAccounts[0].Sign(config.GetString("chain_id"), unbondTx).(account.SignatureEd25519)
+ case *types.RebondTx:
+ rebondTx := tx.(*types.RebondTx)
+ rebondTx.Signature = privAccounts[0].Sign(config.GetString("chain_id"), rebondTx).(account.SignatureEd25519)
+ }
+ return tx, nil
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/types/responses.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/types/responses.go
new file mode 100644
index 0000000000000000000000000000000000000000..bc227e41b2e64bb8da208d419234e28c9241b095
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/core/types/responses.go
@@ -0,0 +1,87 @@
+package core_types
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ sm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+type ResponseGetStorage struct {
+ Key []byte `json:"key"`
+ Value []byte `json:"value"`
+}
+
+type ResponseCall struct {
+ Return []byte `json:"return"`
+ GasUsed uint64 `json:"gas_used"`
+ // TODO ...
+}
+
+type ResponseListAccounts struct {
+ BlockHeight uint `json:"block_height"`
+ Accounts []*account.Account `json:"accounts"`
+}
+
+type StorageItem struct {
+ Key []byte `json:"key"`
+ Value []byte `json:"value"`
+}
+
+type ResponseDumpStorage struct {
+ StorageRoot []byte `json:"storage_root"`
+ StorageItems []StorageItem `json:"storage_items"`
+}
+
+type ResponseBlockchainInfo struct {
+ LastHeight uint `json:"last_height"`
+ BlockMetas []*types.BlockMeta `json:"block_metas"`
+}
+
+type ResponseGetBlock struct {
+ BlockMeta *types.BlockMeta `json:"block_meta"`
+ Block *types.Block `json:"block"`
+}
+
+type Receipt struct {
+ TxHash []byte `json:"tx_hash"`
+ CreatesContract uint8 `json:"creates_contract"`
+ ContractAddr []byte `json:"contract_addr"`
+}
+
+type ResponseStatus struct {
+ Moniker string `json:"moniker"`
+ ChainID string `json:"chain_id"`
+ Version string `json:"version"`
+ GenesisHash []byte `json:"genesis_hash"`
+ PubKey account.PubKey `json:"pub_key"`
+ LatestBlockHash []byte `json:"latest_block_hash"`
+ LatestBlockHeight uint `json:"latest_block_height"`
+ LatestBlockTime int64 `json:"latest_block_time"` // nano
+}
+
+type ResponseNetInfo struct {
+ Listening bool `json:"listening"`
+ Listeners []string `json:"listeners"`
+ Peers []Peer `json:"peers"`
+}
+
+type Peer struct {
+ types.NodeInfo `json:"node_info"`
+ IsOutbound bool `json:"is_outbound"`
+}
+
+type ResponseListValidators struct {
+ BlockHeight uint `json:"block_height"`
+ BondedValidators []*sm.Validator `json:"bonded_validators"`
+ UnbondingValidators []*sm.Validator `json:"unbonding_validators"`
+}
+
+type ResponseDumpConsensusState struct {
+ RoundState string `json:"round_state"`
+ PeerRoundStates []string `json:"peer_round_states"`
+}
+
+type ResponseListNames struct {
+ BlockHeight uint `json:"block_height"`
+ Names []*types.NameRegEntry `json:"names"`
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/server/handlers.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/server/handlers.go
new file mode 100644
index 0000000000000000000000000000000000000000..9bf9a908d47eeedf2aeec3762d4b695f8e82b545
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/server/handlers.go
@@ -0,0 +1,395 @@
+package rpcserver
+
+import (
+ "bytes"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gorilla/websocket"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/events"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/types"
+ "io/ioutil"
+ "net/http"
+ "reflect"
+ "sync/atomic"
+ "time"
+)
+
+func RegisterRPCFuncs(mux *http.ServeMux, funcMap map[string]*RPCFunc) {
+ // HTTP endpoints
+ for funcName, rpcFunc := range funcMap {
+ mux.HandleFunc("/"+funcName, makeHTTPHandler(rpcFunc))
+ }
+
+ // JSONRPC endpoints
+ mux.HandleFunc("/", makeJSONRPCHandler(funcMap))
+}
+
+func RegisterEventsHandler(mux *http.ServeMux, evsw *events.EventSwitch) {
+ // websocket endpoint
+ wm := NewWebsocketManager(evsw)
+ mux.HandleFunc("/events", wm.websocketHandler) // websocket.Handler(w.eventsHandler))
+}
+
+//-------------------------------------
+// function introspection
+
+// holds all type information for each function
+type RPCFunc struct {
+ f reflect.Value // underlying rpc function
+ args []reflect.Type // type of each function arg
+ returns []reflect.Type // type of each return arg
+ argNames []string // name of each argument
+}
+
+// wraps a function for quicker introspection
+func NewRPCFunc(f interface{}, args []string) *RPCFunc {
+ return &RPCFunc{
+ f: reflect.ValueOf(f),
+ args: funcArgTypes(f),
+ returns: funcReturnTypes(f),
+ argNames: args,
+ }
+}
+
+// return a function's argument types
+func funcArgTypes(f interface{}) []reflect.Type {
+ t := reflect.TypeOf(f)
+ n := t.NumIn()
+ types := make([]reflect.Type, n)
+ for i := 0; i < n; i++ {
+ types[i] = t.In(i)
+ }
+ return types
+}
+
+// return a function's return types
+func funcReturnTypes(f interface{}) []reflect.Type {
+ t := reflect.TypeOf(f)
+ n := t.NumOut()
+ types := make([]reflect.Type, n)
+ for i := 0; i < n; i++ {
+ types[i] = t.Out(i)
+ }
+ return types
+}
+
+// function introspection
+//-----------------------------------------------------------------------------
+// rpc.json
+
+// jsonrpc calls grab the given method's function info and runs reflect.Call
+func makeJSONRPCHandler(funcMap map[string]*RPCFunc) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ if len(r.URL.Path) > 1 {
+ WriteRPCResponse(w, NewRPCResponse(nil, fmt.Sprintf("Invalid JSONRPC endpoint %s", r.URL.Path)))
+ return
+ }
+ b, _ := ioutil.ReadAll(r.Body)
+ var request RPCRequest
+ err := json.Unmarshal(b, &request)
+ if err != nil {
+ WriteRPCResponse(w, NewRPCResponse(nil, err.Error()))
+ return
+ }
+ rpcFunc := funcMap[request.Method]
+ if rpcFunc == nil {
+ WriteRPCResponse(w, NewRPCResponse(nil, "RPC method unknown: "+request.Method))
+ return
+ }
+ args, err := jsonParamsToArgs(rpcFunc, request.Params)
+ if err != nil {
+ WriteRPCResponse(w, NewRPCResponse(nil, err.Error()))
+ return
+ }
+ returns := rpcFunc.f.Call(args)
+ log.Debug("HTTPJSONRPC", "method", request.Method, "args", args, "returns", returns)
+ response, err := unreflectResponse(returns)
+ if err != nil {
+ WriteRPCResponse(w, NewRPCResponse(nil, err.Error()))
+ return
+ }
+ WriteRPCResponse(w, NewRPCResponse(response, ""))
+ }
+}
+
+// covert a list of interfaces to properly typed values
+func jsonParamsToArgs(rpcFunc *RPCFunc, params []interface{}) ([]reflect.Value, error) {
+ if len(rpcFunc.argNames) != len(params) {
+ return nil, errors.New(fmt.Sprintf("Expected %v parameters (%v), got %v (%v)",
+ len(rpcFunc.argNames), rpcFunc.argNames, len(params), params))
+ }
+ values := make([]reflect.Value, len(params))
+ for i, p := range params {
+ ty := rpcFunc.args[i]
+ v, err := _jsonObjectToArg(ty, p)
+ if err != nil {
+ return nil, err
+ }
+ values[i] = v
+ }
+ return values, nil
+}
+
+func _jsonObjectToArg(ty reflect.Type, object interface{}) (reflect.Value, error) {
+ var err error
+ v := reflect.New(ty)
+ binary.ReadJSONObject(v.Interface(), object, &err)
+ if err != nil {
+ return v, err
+ }
+ v = v.Elem()
+ return v, nil
+}
+
+// rpc.json
+//-----------------------------------------------------------------------------
+// rpc.http
+
+// convert from a function name to the http handler
+func makeHTTPHandler(rpcFunc *RPCFunc) func(http.ResponseWriter, *http.Request) {
+ return func(w http.ResponseWriter, r *http.Request) {
+ args, err := httpParamsToArgs(rpcFunc, r)
+ if err != nil {
+ WriteRPCResponse(w, NewRPCResponse(nil, err.Error()))
+ return
+ }
+ returns := rpcFunc.f.Call(args)
+ log.Debug("HTTPRestRPC", "method", r.URL.Path, "args", args, "returns", returns)
+ response, err := unreflectResponse(returns)
+ if err != nil {
+ WriteRPCResponse(w, NewRPCResponse(nil, err.Error()))
+ return
+ }
+ WriteRPCResponse(w, NewRPCResponse(response, ""))
+ }
+}
+
+// Covert an http query to a list of properly typed values.
+// To be properly decoded the arg must be a concrete type from tendermint (if its an interface).
+func httpParamsToArgs(rpcFunc *RPCFunc, r *http.Request) ([]reflect.Value, error) {
+ argTypes := rpcFunc.args
+ argNames := rpcFunc.argNames
+
+ var err error
+ values := make([]reflect.Value, len(argNames))
+ for i, name := range argNames {
+ ty := argTypes[i]
+ arg := GetParam(r, name)
+ values[i], err = _jsonStringToArg(ty, arg)
+ if err != nil {
+ return nil, err
+ }
+ }
+ return values, nil
+}
+
+func _jsonStringToArg(ty reflect.Type, arg string) (reflect.Value, error) {
+ var err error
+ v := reflect.New(ty)
+ binary.ReadJSON(v.Interface(), []byte(arg), &err)
+ if err != nil {
+ return v, err
+ }
+ v = v.Elem()
+ return v, nil
+}
+
+// rpc.http
+//-----------------------------------------------------------------------------
+// rpc.websocket
+
+const (
+ WSConnectionReaperSeconds = 5
+ MaxFailedSends = 10
+ WriteChanBufferSize = 10
+)
+
+// a single websocket connection
+// contains listener id, underlying ws connection,
+// and the event switch for subscribing to events
+type WSConnection struct {
+ id string
+ wsConn *websocket.Conn
+ writeChan chan WSResponse
+ quitChan chan struct{}
+ failedSends uint
+ started uint32
+ stopped uint32
+
+ evsw *events.EventSwitch
+}
+
+// new websocket connection wrapper
+func NewWSConnection(wsConn *websocket.Conn) *WSConnection {
+ return &WSConnection{
+ id: wsConn.RemoteAddr().String(),
+ wsConn: wsConn,
+ writeChan: make(chan WSResponse, WriteChanBufferSize), // buffered. we keep track when its full
+ quitChan: make(chan struct{}),
+ }
+}
+
+// start the connection and hand her the event switch
+func (con *WSConnection) Start(evsw *events.EventSwitch) {
+ if atomic.CompareAndSwapUint32(&con.started, 0, 1) {
+ con.evsw = evsw
+
+ // read subscriptions/unsubscriptions to events
+ go con.read()
+ // write responses
+ con.write()
+ }
+}
+
+// close the connection
+func (con *WSConnection) Stop() {
+ if atomic.CompareAndSwapUint32(&con.stopped, 0, 1) {
+ con.evsw.RemoveListener(con.id)
+ close(con.quitChan)
+ // the write loop closes the websocket connection
+ // when it exits its loop, and the read loop
+ // closes the writeChan
+ }
+}
+
+// attempt to write response to writeChan and record failures
+func (con *WSConnection) safeWrite(resp WSResponse) {
+ select {
+ case con.writeChan <- resp:
+ // yay
+ con.failedSends = 0
+ default:
+ // channel is full
+ // if this happens too many times in a row,
+ // close connection
+ con.failedSends += 1
+ }
+}
+
+// read from the socket and subscribe to or unsubscribe from events
+func (con *WSConnection) read() {
+ defer close(con.writeChan)
+ reaper := time.Tick(time.Second * WSConnectionReaperSeconds)
+ for {
+ select {
+ // TODO: this actually doesn't work
+ // since ReadMessage blocks. Really it needs its own
+ // go routine
+ case <-reaper:
+ if con.failedSends > MaxFailedSends {
+ // sending has failed too many times.
+ // kill the connection
+ con.Stop()
+ return
+ }
+ default:
+ var in []byte
+ _, in, err := con.wsConn.ReadMessage()
+ if err != nil {
+ // an error reading the connection,
+ // kill the connection
+ con.Stop()
+ return
+ }
+ var req WSRequest
+ err = json.Unmarshal(in, &req)
+ if err != nil {
+ errStr := fmt.Sprintf("Error unmarshaling data: %s", err.Error())
+ con.safeWrite(WSResponse{Error: errStr})
+ continue
+ }
+ switch req.Type {
+ case "subscribe":
+ log.Info("New event subscription", "con id", con.id, "event", req.Event)
+ con.evsw.AddListenerForEvent(con.id, req.Event, func(msg interface{}) {
+ resp := WSResponse{
+ Event: req.Event,
+ Data: msg,
+ }
+ con.safeWrite(resp)
+ })
+ case "unsubscribe":
+ if req.Event != "" {
+ con.evsw.RemoveListenerForEvent(req.Event, con.id)
+ } else {
+ con.evsw.RemoveListener(con.id)
+ }
+ default:
+ con.safeWrite(WSResponse{Error: "Unknown request type: " + req.Type})
+ }
+ }
+ }
+}
+
+// receives on a write channel and writes out on the socket
+func (con *WSConnection) write() {
+ defer con.wsConn.Close()
+ n, err := new(int64), new(error)
+ for {
+ select {
+ case msg := <-con.writeChan:
+ buf := new(bytes.Buffer)
+ binary.WriteJSON(msg, buf, n, err)
+ if *err != nil {
+ log.Error("Failed to marshal WSResponse to JSON", "error", err)
+ } else {
+ if err := con.wsConn.WriteMessage(websocket.TextMessage, buf.Bytes()); err != nil {
+ log.Error("Failed to write response on websocket", "error", err)
+ con.Stop()
+ return
+ }
+ }
+ case <-con.quitChan:
+ return
+ }
+ }
+}
+
+// main manager for all websocket connections
+// holds the event switch
+type WebsocketManager struct {
+ websocket.Upgrader
+ evsw *events.EventSwitch
+}
+
+func NewWebsocketManager(evsw *events.EventSwitch) *WebsocketManager {
+ return &WebsocketManager{
+ evsw: evsw,
+ Upgrader: websocket.Upgrader{
+ ReadBufferSize: 1024,
+ WriteBufferSize: 1024,
+ CheckOrigin: func(r *http.Request) bool {
+ // TODO
+ return true
+ },
+ },
+ }
+}
+
+func (wm *WebsocketManager) websocketHandler(w http.ResponseWriter, r *http.Request) {
+ wsConn, err := wm.Upgrade(w, r, nil)
+ if err != nil {
+ // TODO - return http error
+ log.Error("Failed to upgrade to websocket connection", "error", err)
+ return
+ }
+
+ // register connection
+ con := NewWSConnection(wsConn)
+ log.Info("New websocket connection", "origin", con.id)
+ con.Start(wm.evsw)
+}
+
+// rpc.websocket
+//-----------------------------------------------------------------------------
+
+// returns is Response struct and error. If error is not nil, return it
+func unreflectResponse(returns []reflect.Value) (interface{}, error) {
+ errV := returns[1]
+ if errV.Interface() != nil {
+ return nil, fmt.Errorf("%v", errV.Interface())
+ }
+ return returns[0].Interface(), nil
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/server/http_params.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/server/http_params.go
new file mode 100644
index 0000000000000000000000000000000000000000..1c0148e46e054ce292ffee28c010eb06d14a1dc6
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/server/http_params.go
@@ -0,0 +1,95 @@
+package rpcserver
+
+import (
+ "encoding/hex"
+ "fmt"
+ "net/http"
+ "regexp"
+ "strconv"
+
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/types"
+)
+
+var (
+ // Parts of regular expressions
+ atom = "[A-Z0-9!#$%&'*+\\-/=?^_`{|}~]+"
+ dotAtom = atom + `(?:\.` + atom + `)*`
+ domain = `[A-Z0-9.-]+\.[A-Z]{2,4}`
+
+ RE_HEX = regexp.MustCompile(`^(?i)[a-f0-9]+$`)
+ RE_EMAIL = regexp.MustCompile(`^(?i)(` + dotAtom + `)@(` + dotAtom + `)$`)
+ RE_ADDRESS = regexp.MustCompile(`^(?i)[a-z0-9]{25,34}$`)
+ RE_HOST = regexp.MustCompile(`^(?i)(` + domain + `)$`)
+
+ //RE_ID12 = regexp.MustCompile(`^[a-zA-Z0-9]{12}$`)
+)
+
+func panicRPC(err error) {
+ panic(NewRPCResponse(nil, err.Error()))
+}
+
+func GetParam(r *http.Request, param string) string {
+ s := r.URL.Query().Get(param)
+ if s == "" {
+ s = r.FormValue(param)
+ }
+ return s
+}
+
+func GetParamByteSlice(r *http.Request, param string) ([]byte, error) {
+ s := GetParam(r, param)
+ return hex.DecodeString(s)
+}
+
+func GetParamInt64(r *http.Request, param string) (int64, error) {
+ s := GetParam(r, param)
+ i, err := strconv.ParseInt(s, 10, 64)
+ if err != nil {
+ return 0, fmt.Errorf(param, err.Error())
+ }
+ return i, nil
+}
+
+func GetParamInt32(r *http.Request, param string) (int32, error) {
+ s := GetParam(r, param)
+ i, err := strconv.ParseInt(s, 10, 32)
+ if err != nil {
+ return 0, fmt.Errorf(param, err.Error())
+ }
+ return int32(i), nil
+}
+
+func GetParamUint64(r *http.Request, param string) (uint64, error) {
+ s := GetParam(r, param)
+ i, err := strconv.ParseUint(s, 10, 64)
+ if err != nil {
+ return 0, fmt.Errorf(param, err.Error())
+ }
+ return i, nil
+}
+
+func GetParamUint(r *http.Request, param string) (uint, error) {
+ s := GetParam(r, param)
+ i, err := strconv.ParseUint(s, 10, 64)
+ if err != nil {
+ return 0, fmt.Errorf(param, err.Error())
+ }
+ return uint(i), nil
+}
+
+func GetParamRegexp(r *http.Request, param string, re *regexp.Regexp) (string, error) {
+ s := GetParam(r, param)
+ if !re.MatchString(s) {
+ return "", fmt.Errorf(param, "Did not match regular expression %v", re.String())
+ }
+ return s, nil
+}
+
+func GetParamFloat64(r *http.Request, param string) (float64, error) {
+ s := GetParam(r, param)
+ f, err := strconv.ParseFloat(s, 64)
+ if err != nil {
+ return 0, fmt.Errorf(param, err.Error())
+ }
+ return f, nil
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/server/http_server.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/server/http_server.go
new file mode 100644
index 0000000000000000000000000000000000000000..8520fba92d8ef20956a352260f7ac62bf9e43559
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/server/http_server.go
@@ -0,0 +1,121 @@
+// Commons for HTTP handling
+package rpcserver
+
+import (
+ "bufio"
+ "bytes"
+ "fmt"
+ "net"
+ "net/http"
+ "runtime/debug"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/alert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/types"
+)
+
+func StartHTTPServer(listenAddr string, handler http.Handler) (net.Listener, error) {
+ log.Info(Fmt("Starting RPC HTTP server on %v", listenAddr))
+ listener, err := net.Listen("tcp", listenAddr)
+ if err != nil {
+ return nil, fmt.Errorf("Failed to listen to %v", listenAddr)
+ }
+ go func() {
+ res := http.Serve(
+ listener,
+ RecoverAndLogHandler(handler),
+ )
+ log.Crit("RPC HTTP server stopped", "result", res)
+ }()
+ return listener, nil
+}
+
+func WriteRPCResponse(w http.ResponseWriter, res RPCResponse) {
+ buf, n, err := new(bytes.Buffer), new(int64), new(error)
+ binary.WriteJSON(res, buf, n, err)
+ if *err != nil {
+ log.Warn("Failed to write RPC response", "error", err)
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ w.WriteHeader(200)
+ w.Write(buf.Bytes())
+}
+
+//-----------------------------------------------------------------------------
+
+// Wraps an HTTP handler, adding error logging.
+// If the inner function panics, the outer function recovers, logs, sends an
+// HTTP 500 error response.
+func RecoverAndLogHandler(handler http.Handler) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ // Wrap the ResponseWriter to remember the status
+ rww := &ResponseWriterWrapper{-1, w}
+ begin := time.Now()
+
+ // Common headers
+ origin := r.Header.Get("Origin")
+ rww.Header().Set("Access-Control-Allow-Origin", origin)
+ rww.Header().Set("Access-Control-Allow-Credentials", "true")
+ rww.Header().Set("Access-Control-Expose-Headers", "X-Server-Time")
+ rww.Header().Set("X-Server-Time", fmt.Sprintf("%v", begin.Unix()))
+
+ defer func() {
+ // Send a 500 error if a panic happens during a handler.
+ // Without this, Chrome & Firefox were retrying aborted ajax requests,
+ // at least to my localhost.
+ if e := recover(); e != nil {
+
+ // If RPCResponse
+ if res, ok := e.(RPCResponse); ok {
+ WriteRPCResponse(rww, res)
+ } else {
+ // For the rest,
+ log.Error("Panic in RPC HTTP handler", "error", e, "stack", string(debug.Stack()))
+ rww.WriteHeader(http.StatusInternalServerError)
+ WriteRPCResponse(rww, NewRPCResponse(nil, Fmt("Internal Server Error: %v", e)))
+ }
+ }
+
+ // Finally, log.
+ durationMS := time.Since(begin).Nanoseconds() / 1000000
+ if rww.Status == -1 {
+ rww.Status = 200
+ }
+ log.Debug("Served RPC HTTP response",
+ "method", r.Method, "url", r.URL,
+ "status", rww.Status, "duration", durationMS,
+ "remoteAddr", r.RemoteAddr,
+ )
+ }()
+
+ handler.ServeHTTP(rww, r)
+ })
+}
+
+// Remember the status for logging
+type ResponseWriterWrapper struct {
+ Status int
+ http.ResponseWriter
+}
+
+func (w *ResponseWriterWrapper) WriteHeader(status int) {
+ w.Status = status
+ w.ResponseWriter.WriteHeader(status)
+}
+
+// implements http.Hijacker
+func (w *ResponseWriterWrapper) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+ return w.ResponseWriter.(http.Hijacker).Hijack()
+}
+
+// Stick it as a deferred statement in gouroutines to prevent the program from crashing.
+func Recover(daemonName string) {
+ if e := recover(); e != nil {
+ stack := string(debug.Stack())
+ errorString := fmt.Sprintf("[%s] %s\n%s", daemonName, e, stack)
+ alert.Alert(errorString)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/server/log.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/server/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..aab9721fd941db6ddd8080281ef57372b8f4d17e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/server/log.go
@@ -0,0 +1,7 @@
+package rpcserver
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
+)
+
+var log = log15.New("module", "rpcserver")
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/types/types.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/types/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..f3c14bbd8dc91a095de6f059d56e003aaab2c504
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/rpc/types/types.go
@@ -0,0 +1,40 @@
+package rpctypes
+
+type RPCRequest struct {
+ JSONRPC string `json:"jsonrpc"`
+ Method string `json:"method"`
+ Params []interface{} `json:"params"`
+ Id int `json:"id"`
+}
+
+type RPCResponse struct {
+ Result interface{} `json:"result"`
+ Error string `json:"error"`
+ Id string `json:"id"`
+ JSONRPC string `json:"jsonrpc"`
+}
+
+func NewRPCResponse(res interface{}, err string) RPCResponse {
+ if res == nil {
+ res = struct{}{}
+ }
+ return RPCResponse{
+ Result: res,
+ Error: err,
+ Id: "",
+ JSONRPC: "2.0",
+ }
+}
+
+// for requests coming in
+type WSRequest struct {
+ Type string `json:"type"` // subscribe or unsubscribe
+ Event string `json:"event"`
+}
+
+// for responses going out
+type WSResponse struct {
+ Event string `json:"event"`
+ Data interface{} `json:"data"`
+ Error string `json:"error"`
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/state/block_cache.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/block_cache.go
new file mode 100644
index 0000000000000000000000000000000000000000..d01d311d9abd360effbe9c7d550de1ef8a1315f3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/block_cache.go
@@ -0,0 +1,304 @@
+package state
+
+import (
+ "bytes"
+ "sort"
+
+ ac "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ dbm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/db"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+func makeStorage(db dbm.DB, root []byte) merkle.Tree {
+ storage := merkle.NewIAVLTree(
+ binary.BasicCodec,
+ binary.BasicCodec,
+ 1024,
+ db,
+ )
+ storage.Load(root)
+ return storage
+}
+
+type BlockCache struct {
+ db dbm.DB
+ backend *State
+ accounts map[string]accountInfo
+ storages map[Tuple256]storageInfo
+ names map[string]nameInfo
+}
+
+func NewBlockCache(backend *State) *BlockCache {
+ return &BlockCache{
+ db: backend.DB,
+ backend: backend,
+ accounts: make(map[string]accountInfo),
+ storages: make(map[Tuple256]storageInfo),
+ names: make(map[string]nameInfo),
+ }
+}
+
+func (cache *BlockCache) State() *State {
+ return cache.backend
+}
+
+//-------------------------------------
+// BlockCache.account
+
+func (cache *BlockCache) GetAccount(addr []byte) *ac.Account {
+ acc, _, removed, _ := cache.accounts[string(addr)].unpack()
+ if removed {
+ return nil
+ } else if acc != nil {
+ return acc
+ } else {
+ acc = cache.backend.GetAccount(addr)
+ cache.accounts[string(addr)] = accountInfo{acc, nil, false, false}
+ return acc
+ }
+}
+
+func (cache *BlockCache) UpdateAccount(acc *ac.Account) {
+ addr := acc.Address
+ // SANITY CHECK
+ _, storage, removed, _ := cache.accounts[string(addr)].unpack()
+ if removed {
+ panic("UpdateAccount on a removed account")
+ }
+ // SANITY CHECK END
+ cache.accounts[string(addr)] = accountInfo{acc, storage, false, true}
+}
+
+func (cache *BlockCache) RemoveAccount(addr []byte) {
+ // SANITY CHECK
+ _, _, removed, _ := cache.accounts[string(addr)].unpack()
+ if removed {
+ panic("RemoveAccount on a removed account")
+ }
+ // SANITY CHECK END
+ cache.accounts[string(addr)] = accountInfo{nil, nil, true, false}
+}
+
+// BlockCache.account
+//-------------------------------------
+// BlockCache.storage
+
+func (cache *BlockCache) GetStorage(addr Word256, key Word256) (value Word256) {
+ // Check cache
+ info, ok := cache.storages[Tuple256{addr, key}]
+ if ok {
+ return info.value
+ }
+
+ // Get or load storage
+ acc, storage, removed, dirty := cache.accounts[string(addr.Postfix(20))].unpack()
+ if removed {
+ panic("GetStorage() on removed account")
+ }
+ if acc != nil && storage == nil {
+ storage = makeStorage(cache.db, acc.StorageRoot)
+ cache.accounts[string(addr.Postfix(20))] = accountInfo{acc, storage, false, dirty}
+ } else if acc == nil {
+ return Zero256
+ }
+
+ // Load and set cache
+ _, val_ := storage.Get(key.Bytes())
+ value = Zero256
+ if val_ != nil {
+ value = LeftPadWord256(val_.([]byte))
+ }
+ cache.storages[Tuple256{addr, key}] = storageInfo{value, false}
+ return value
+}
+
+// NOTE: Set value to zero to removed from the trie.
+func (cache *BlockCache) SetStorage(addr Word256, key Word256, value Word256) {
+ _, _, removed, _ := cache.accounts[string(addr.Postfix(20))].unpack()
+ if removed {
+ panic("SetStorage() on a removed account")
+ }
+ cache.storages[Tuple256{addr, key}] = storageInfo{value, true}
+}
+
+// BlockCache.storage
+//-------------------------------------
+// BlockCache.names
+
+func (cache *BlockCache) GetNameRegEntry(name string) *types.NameRegEntry {
+ entry, removed, _ := cache.names[name].unpack()
+ if removed {
+ return nil
+ } else if entry != nil {
+ return entry
+ } else {
+ entry = cache.backend.GetNameRegEntry(name)
+ cache.names[name] = nameInfo{entry, false, false}
+ return entry
+ }
+}
+
+func (cache *BlockCache) UpdateNameRegEntry(entry *types.NameRegEntry) {
+ name := entry.Name
+ // SANITY CHECK
+ _, removed, _ := cache.names[name].unpack()
+ if removed {
+ panic("UpdateNameRegEntry on a removed name")
+ }
+ // SANITY CHECK END
+ cache.names[name] = nameInfo{entry, false, true}
+}
+
+func (cache *BlockCache) RemoveNameRegEntry(name string) {
+ // SANITY CHECK
+ _, removed, _ := cache.names[name].unpack()
+ if removed {
+ panic("RemoveNameRegEntry on a removed entry")
+ }
+ // SANITY CHECK END
+ cache.names[name] = nameInfo{nil, true, false}
+}
+
+// BlockCache.names
+//-------------------------------------
+
+// CONTRACT the updates are in deterministic order.
+func (cache *BlockCache) Sync() {
+
+ // Determine order for storage updates
+ // The address comes first so it'll be grouped.
+ storageKeys := make([]Tuple256, 0, len(cache.storages))
+ for keyTuple := range cache.storages {
+ storageKeys = append(storageKeys, keyTuple)
+ }
+ Tuple256Slice(storageKeys).Sort()
+
+ // Update storage for all account/key.
+ // Later we'll iterate over all the users and save storage + update storage root.
+ var (
+ curAddr Word256
+ curAcc *ac.Account
+ curAccRemoved bool
+ curStorage merkle.Tree
+ )
+ for _, storageKey := range storageKeys {
+ addr, key := Tuple256Split(storageKey)
+ if addr != curAddr || curAcc == nil {
+ acc, storage, removed, _ := cache.accounts[string(addr.Postfix(20))].unpack()
+ if storage == nil {
+ storage = makeStorage(cache.db, acc.StorageRoot)
+ }
+ curAddr = addr
+ curAcc = acc
+ curAccRemoved = removed
+ curStorage = storage
+ }
+ if curAccRemoved {
+ continue
+ }
+ value, dirty := cache.storages[storageKey].unpack()
+ if !dirty {
+ continue
+ }
+ if value.IsZero() {
+ curStorage.Remove(key.Bytes())
+ } else {
+ curStorage.Set(key.Bytes(), value.Bytes())
+ cache.accounts[string(addr.Postfix(20))] = accountInfo{curAcc, curStorage, false, true}
+ }
+ }
+
+ // Determine order for accounts
+ addrStrs := []string{}
+ for addrStr := range cache.accounts {
+ addrStrs = append(addrStrs, addrStr)
+ }
+ sort.Strings(addrStrs)
+
+ // Update or delete accounts.
+ for _, addrStr := range addrStrs {
+ acc, storage, removed, dirty := cache.accounts[addrStr].unpack()
+ if removed {
+ removed := cache.backend.RemoveAccount(acc.Address)
+ if !removed {
+ panic(Fmt("Could not remove account to be removed: %X", acc.Address))
+ }
+ } else {
+ if acc == nil {
+ continue
+ }
+ if storage != nil {
+ newStorageRoot := storage.Save()
+ if !bytes.Equal(newStorageRoot, acc.StorageRoot) {
+ acc.StorageRoot = newStorageRoot
+ dirty = true
+ }
+ }
+ if dirty {
+ cache.backend.UpdateAccount(acc)
+ }
+ }
+ }
+
+ // Determine order for names
+ // note names may be of any length less than some limit
+ nameStrs := []string{}
+ for nameStr := range cache.names {
+ nameStrs = append(nameStrs, nameStr)
+ }
+ sort.Strings(nameStrs)
+
+ // Update or delete names.
+ for _, nameStr := range nameStrs {
+ entry, removed, dirty := cache.names[nameStr].unpack()
+ if removed {
+ removed := cache.backend.RemoveNameRegEntry(nameStr)
+ if !removed {
+ panic(Fmt("Could not remove namereg entry to be removed: %s", nameStr))
+ }
+ } else {
+ if entry == nil {
+ continue
+ }
+ if dirty {
+ cache.backend.UpdateNameRegEntry(entry)
+ }
+ }
+ }
+
+}
+
+//-----------------------------------------------------------------------------
+
+type accountInfo struct {
+ account *ac.Account
+ storage merkle.Tree
+ removed bool
+ dirty bool
+}
+
+func (accInfo accountInfo) unpack() (*ac.Account, merkle.Tree, bool, bool) {
+ return accInfo.account, accInfo.storage, accInfo.removed, accInfo.dirty
+}
+
+type storageInfo struct {
+ value Word256
+ dirty bool
+}
+
+func (stjInfo storageInfo) unpack() (Word256, bool) {
+ return stjInfo.value, stjInfo.dirty
+}
+
+type nameInfo struct {
+ name *types.NameRegEntry
+ removed bool
+ dirty bool
+}
+
+func (nInfo nameInfo) unpack() (*types.NameRegEntry, bool, bool) {
+ return nInfo.name, nInfo.removed, nInfo.dirty
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/state/common.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/common.go
new file mode 100644
index 0000000000000000000000000000000000000000..0cde469a4caa06f4dbd4d52b0006fc24b194740a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/common.go
@@ -0,0 +1,18 @@
+package state
+
+import (
+ ac "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/vm"
+)
+
+type AccountGetter interface {
+ GetAccount(addr []byte) *ac.Account
+}
+
+type VMAccountState interface {
+ GetAccount(addr Word256) *vm.Account
+ UpdateAccount(acc *vm.Account)
+ RemoveAccount(acc *vm.Account)
+ CreateAccount(creator *vm.Account) *vm.Account
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/state/execution.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/execution.go
new file mode 100644
index 0000000000000000000000000000000000000000..438086dd9b1a71d707c204c3ed8d315f216447c9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/execution.go
@@ -0,0 +1,756 @@
+package state
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/events"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/vm"
+)
+
+// NOTE: If an error occurs during block execution, state will be left
+// at an invalid state. Copy the state before calling ExecBlock!
+func ExecBlock(s *State, block *types.Block, blockPartsHeader types.PartSetHeader) error {
+ err := execBlock(s, block, blockPartsHeader)
+ if err != nil {
+ return err
+ }
+ // State.Hash should match block.StateHash
+ stateHash := s.Hash()
+ if !bytes.Equal(stateHash, block.StateHash) {
+ return fmt.Errorf("Invalid state hash. Expected %X, got %X",
+ stateHash, block.StateHash)
+ }
+ return nil
+}
+
+// executes transactions of a block, does not check block.StateHash
+// NOTE: If an error occurs during block execution, state will be left
+// at an invalid state. Copy the state before calling execBlock!
+func execBlock(s *State, block *types.Block, blockPartsHeader types.PartSetHeader) error {
+ // Basic block validation.
+ err := block.ValidateBasic(s.ChainID, s.LastBlockHeight, s.LastBlockHash, s.LastBlockParts, s.LastBlockTime)
+ if err != nil {
+ return err
+ }
+
+ // Validate block Validation.
+ if block.Height == 1 {
+ if len(block.Validation.Commits) != 0 {
+ return errors.New("Block at height 1 (first block) should have no Validation commits")
+ }
+ } else {
+ if uint(len(block.Validation.Commits)) != s.LastBondedValidators.Size() {
+ return errors.New(Fmt("Invalid block validation size. Expected %v, got %v",
+ s.LastBondedValidators.Size(), len(block.Validation.Commits)))
+ }
+ var sumVotingPower uint64
+ s.LastBondedValidators.Iterate(func(index uint, val *Validator) bool {
+ commit := block.Validation.Commits[index]
+ if commit.IsZero() {
+ return false
+ } else {
+ vote := &types.Vote{
+ Height: block.Height - 1,
+ Round: commit.Round,
+ Type: types.VoteTypeCommit,
+ BlockHash: block.LastBlockHash,
+ BlockParts: block.LastBlockParts,
+ }
+ if val.PubKey.VerifyBytes(account.SignBytes(s.ChainID, vote), commit.Signature) {
+ sumVotingPower += val.VotingPower
+ return false
+ } else {
+ log.Warn(Fmt("Invalid validation signature.\nval: %v\nvote: %v", val, vote))
+ err = errors.New("Invalid validation signature")
+ return true
+ }
+ }
+ })
+ if err != nil {
+ return err
+ }
+ if sumVotingPower <= s.LastBondedValidators.TotalVotingPower()*2/3 {
+ return errors.New("Insufficient validation voting power")
+ }
+ }
+
+ // Update Validator.LastCommitHeight as necessary.
+ for i, commit := range block.Validation.Commits {
+ if commit.IsZero() {
+ continue
+ }
+ _, val := s.LastBondedValidators.GetByIndex(uint(i))
+ if val == nil {
+ panic(Fmt("Failed to fetch validator at index %v", i))
+ }
+ if _, val_ := s.BondedValidators.GetByAddress(val.Address); val_ != nil {
+ val_.LastCommitHeight = block.Height - 1
+ updated := s.BondedValidators.Update(val_)
+ if !updated {
+ panic("Failed to update bonded validator LastCommitHeight")
+ }
+ } else if _, val_ := s.UnbondingValidators.GetByAddress(val.Address); val_ != nil {
+ val_.LastCommitHeight = block.Height - 1
+ updated := s.UnbondingValidators.Update(val_)
+ if !updated {
+ panic("Failed to update unbonding validator LastCommitHeight")
+ }
+ } else {
+ panic("Could not find validator")
+ }
+ }
+
+ // Remember LastBondedValidators
+ s.LastBondedValidators = s.BondedValidators.Copy()
+
+ // Create BlockCache to cache changes to state.
+ blockCache := NewBlockCache(s)
+
+ // Commit each tx
+ for _, tx := range block.Data.Txs {
+ err := ExecTx(blockCache, tx, true, s.evc)
+ if err != nil {
+ return InvalidTxError{tx, err}
+ }
+ }
+
+ // Now sync the BlockCache to the backend.
+ blockCache.Sync()
+
+ // If any unbonding periods are over,
+ // reward account with bonded coins.
+ toRelease := []*Validator{}
+ s.UnbondingValidators.Iterate(func(index uint, val *Validator) bool {
+ if val.UnbondHeight+unbondingPeriodBlocks < block.Height {
+ toRelease = append(toRelease, val)
+ }
+ return false
+ })
+ for _, val := range toRelease {
+ s.releaseValidator(val)
+ }
+
+ // If any validators haven't signed in a while,
+ // unbond them, they have timed out.
+ toTimeout := []*Validator{}
+ s.BondedValidators.Iterate(func(index uint, val *Validator) bool {
+ lastActivityHeight := MaxUint(val.BondHeight, val.LastCommitHeight)
+ if lastActivityHeight+validatorTimeoutBlocks < block.Height {
+ log.Info("Validator timeout", "validator", val, "height", block.Height)
+ toTimeout = append(toTimeout, val)
+ }
+ return false
+ })
+ for _, val := range toTimeout {
+ s.unbondValidator(val)
+ }
+
+ // Increment validator AccumPowers
+ s.BondedValidators.IncrementAccum(1)
+ s.LastBlockHeight = block.Height
+ s.LastBlockHash = block.Hash()
+ s.LastBlockParts = blockPartsHeader
+ s.LastBlockTime = block.Time
+ return nil
+}
+
+// The accounts from the TxInputs must either already have
+// account.PubKey.(type) != nil, (it must be known),
+// or it must be specified in the TxInput. If redeclared,
+// the TxInput is modified and input.PubKey set to nil.
+func getOrMakeAccounts(state AccountGetter, ins []*types.TxInput, outs []*types.TxOutput) (map[string]*account.Account, error) {
+ accounts := map[string]*account.Account{}
+ for _, in := range ins {
+ // Account shouldn't be duplicated
+ if _, ok := accounts[string(in.Address)]; ok {
+ return nil, types.ErrTxDuplicateAddress
+ }
+ acc := state.GetAccount(in.Address)
+ if acc == nil {
+ return nil, types.ErrTxInvalidAddress
+ }
+ // PubKey should be present in either "account" or "in"
+ if err := checkInputPubKey(acc, in); err != nil {
+ return nil, err
+ }
+ accounts[string(in.Address)] = acc
+ }
+ for _, out := range outs {
+ // Account shouldn't be duplicated
+ if _, ok := accounts[string(out.Address)]; ok {
+ return nil, types.ErrTxDuplicateAddress
+ }
+ acc := state.GetAccount(out.Address)
+ // output account may be nil (new)
+ if acc == nil {
+ acc = &account.Account{
+ Address: out.Address,
+ PubKey: nil,
+ Sequence: 0,
+ Balance: 0,
+ }
+ }
+ accounts[string(out.Address)] = acc
+ }
+ return accounts, nil
+}
+
+func checkInputPubKey(acc *account.Account, in *types.TxInput) error {
+ if acc.PubKey == nil {
+ if in.PubKey == nil {
+ return types.ErrTxUnknownPubKey
+ }
+ if !bytes.Equal(in.PubKey.Address(), acc.Address) {
+ return types.ErrTxInvalidPubKey
+ }
+ acc.PubKey = in.PubKey
+ } else {
+ in.PubKey = nil
+ }
+ return nil
+}
+
+func validateInputs(accounts map[string]*account.Account, signBytes []byte, ins []*types.TxInput) (total uint64, err error) {
+ for _, in := range ins {
+ acc := accounts[string(in.Address)]
+ if acc == nil {
+ panic("validateInputs() expects account in accounts")
+ }
+ err = validateInput(acc, signBytes, in)
+ if err != nil {
+ return
+ }
+ // Good. Add amount to total
+ total += in.Amount
+ }
+ return total, nil
+}
+
+func validateInput(acc *account.Account, signBytes []byte, in *types.TxInput) (err error) {
+ // Check TxInput basic
+ if err := in.ValidateBasic(); err != nil {
+ return err
+ }
+ // Check signatures
+ if !acc.PubKey.VerifyBytes(signBytes, in.Signature) {
+ return types.ErrTxInvalidSignature
+ }
+ // Check sequences
+ if acc.Sequence+1 != in.Sequence {
+ return types.ErrTxInvalidSequence{
+ Got: uint64(in.Sequence),
+ Expected: uint64(acc.Sequence + 1),
+ }
+ }
+ // Check amount
+ if acc.Balance < in.Amount {
+ return types.ErrTxInsufficientFunds
+ }
+ return nil
+}
+
+func validateOutputs(outs []*types.TxOutput) (total uint64, err error) {
+ for _, out := range outs {
+ // Check TxOutput basic
+ if err := out.ValidateBasic(); err != nil {
+ return 0, err
+ }
+ // Good. Add amount to total
+ total += out.Amount
+ }
+ return total, nil
+}
+
+func adjustByInputs(accounts map[string]*account.Account, ins []*types.TxInput) {
+ for _, in := range ins {
+ acc := accounts[string(in.Address)]
+ if acc == nil {
+ panic("adjustByInputs() expects account in accounts")
+ }
+ if acc.Balance < in.Amount {
+ panic("adjustByInputs() expects sufficient funds")
+ }
+ acc.Balance -= in.Amount
+ acc.Sequence += 1
+ }
+}
+
+func adjustByOutputs(accounts map[string]*account.Account, outs []*types.TxOutput) {
+ for _, out := range outs {
+ acc := accounts[string(out.Address)]
+ if acc == nil {
+ panic("adjustByOutputs() expects account in accounts")
+ }
+ acc.Balance += out.Amount
+ }
+}
+
+// If the tx is invalid, an error will be returned.
+// Unlike ExecBlock(), state will not be altered.
+func ExecTx(blockCache *BlockCache, tx_ types.Tx, runCall bool, evc events.Fireable) error {
+
+ // TODO: do something with fees
+ fees := uint64(0)
+ _s := blockCache.State() // hack to access validators and block height
+
+ // Exec tx
+ switch tx := tx_.(type) {
+ case *types.SendTx:
+ accounts, err := getOrMakeAccounts(blockCache, tx.Inputs, tx.Outputs)
+ if err != nil {
+ return err
+ }
+ signBytes := account.SignBytes(_s.ChainID, tx)
+ inTotal, err := validateInputs(accounts, signBytes, tx.Inputs)
+ if err != nil {
+ return err
+ }
+ outTotal, err := validateOutputs(tx.Outputs)
+ if err != nil {
+ return err
+ }
+ if outTotal > inTotal {
+ return types.ErrTxInsufficientFunds
+ }
+ fee := inTotal - outTotal
+ fees += fee
+
+ // Good! Adjust accounts
+ adjustByInputs(accounts, tx.Inputs)
+ adjustByOutputs(accounts, tx.Outputs)
+ for _, acc := range accounts {
+ blockCache.UpdateAccount(acc)
+ }
+
+ // if the evc is nil, nothing will happen
+ if evc != nil {
+ for _, i := range tx.Inputs {
+ evc.FireEvent(types.EventStringAccInput(i.Address), tx)
+ }
+
+ for _, o := range tx.Outputs {
+ evc.FireEvent(types.EventStringAccOutput(o.Address), tx)
+ }
+ }
+ return nil
+
+ case *types.CallTx:
+ var inAcc, outAcc *account.Account
+
+ // Validate input
+ inAcc = blockCache.GetAccount(tx.Input.Address)
+ if inAcc == nil {
+ log.Debug(Fmt("Can't find in account %X", tx.Input.Address))
+ return types.ErrTxInvalidAddress
+ }
+ // pubKey should be present in either "inAcc" or "tx.Input"
+ if err := checkInputPubKey(inAcc, tx.Input); err != nil {
+ log.Debug(Fmt("Can't find pubkey for %X", tx.Input.Address))
+ return err
+ }
+ signBytes := account.SignBytes(_s.ChainID, tx)
+ err := validateInput(inAcc, signBytes, tx.Input)
+ if err != nil {
+ log.Debug(Fmt("validateInput failed on %X: %v", tx.Input.Address, err))
+ return err
+ }
+ if tx.Input.Amount < tx.Fee {
+ log.Debug(Fmt("Sender did not send enough to cover the fee %X", tx.Input.Address))
+ return types.ErrTxInsufficientFunds
+ }
+
+ createAccount := len(tx.Address) == 0
+ if !createAccount {
+ // Validate output
+ if len(tx.Address) != 20 {
+ log.Debug(Fmt("Destination address is not 20 bytes %X", tx.Address))
+ return types.ErrTxInvalidAddress
+ }
+ // this may be nil if we are still in mempool and contract was created in same block as this tx
+ // but that's fine, because the account will be created properly when the create tx runs in the block
+ // and then this won't return nil. otherwise, we take their fee
+ outAcc = blockCache.GetAccount(tx.Address)
+ }
+
+ log.Debug(Fmt("Out account: %v", outAcc))
+
+ // Good!
+ value := tx.Input.Amount - tx.Fee
+ inAcc.Sequence += 1
+
+ if runCall {
+
+ var (
+ gas uint64 = tx.GasLimit
+ err error = nil
+ caller *vm.Account = toVMAccount(inAcc)
+ callee *vm.Account = nil
+ code []byte = nil
+ txCache = NewTxCache(blockCache)
+ params = vm.Params{
+ BlockHeight: uint64(_s.LastBlockHeight),
+ BlockHash: LeftPadWord256(_s.LastBlockHash),
+ BlockTime: _s.LastBlockTime.Unix(),
+ GasLimit: 10000000,
+ }
+ )
+
+ // Maybe create a new callee account if
+ // this transaction is creating a new contract.
+ if !createAccount {
+ if outAcc == nil || len(outAcc.Code) == 0 {
+ // if you call an account that doesn't exist
+ // or an account with no code then we take fees (sorry pal)
+ // NOTE: it's fine to create a contract and call it within one
+ // block (nonce will prevent re-ordering of those txs)
+ // but to create with one account and call with another
+ // you have to wait a block to avoid a re-ordering attack
+ // that will take your fees
+ inAcc.Balance -= tx.Fee
+ blockCache.UpdateAccount(inAcc)
+ if outAcc == nil {
+ log.Debug(Fmt("Cannot find destination address %X. Deducting fee from caller", tx.Address))
+ } else {
+ log.Debug(Fmt("Attempting to call an account (%X) with no code. Deducting fee from caller", tx.Address))
+ }
+ return types.ErrTxInvalidAddress
+
+ }
+ callee = toVMAccount(outAcc)
+ code = callee.Code
+ log.Debug(Fmt("Calling contract %X with code %X", callee.Address, callee.Code))
+ } else {
+ callee = txCache.CreateAccount(caller)
+ log.Debug(Fmt("Created new account %X", callee.Address))
+ code = tx.Data
+ }
+ log.Debug(Fmt("Code for this contract: %X", code))
+
+ txCache.UpdateAccount(caller) // because we adjusted by input above, and bumped nonce maybe.
+ txCache.UpdateAccount(callee) // because we adjusted by input above.
+ vmach := vm.NewVM(txCache, params, caller.Address, account.HashSignBytes(_s.ChainID, tx))
+ vmach.SetFireable(evc)
+ // NOTE: Call() transfers the value from caller to callee iff call succeeds.
+
+ ret, err := vmach.Call(caller, callee, code, tx.Data, value, &gas)
+ exception := ""
+ if err != nil {
+ exception = err.Error()
+ // Failure. Charge the gas fee. The 'value' was otherwise not transferred.
+ log.Debug(Fmt("Error on execution: %v", err))
+ inAcc.Balance -= tx.Fee
+ blockCache.UpdateAccount(inAcc)
+ // Throw away 'txCache' which holds incomplete updates (don't sync it).
+ } else {
+ log.Debug("Successful execution")
+ // Success
+ if createAccount {
+ callee.Code = ret
+ }
+
+ txCache.Sync()
+ }
+ // Create a receipt from the ret and whether errored.
+ log.Info("VM call complete", "caller", caller, "callee", callee, "return", ret, "err", err)
+
+ // Fire Events for sender and receiver
+ // a separate event will be fired from vm for each additional call
+ if evc != nil {
+ evc.FireEvent(types.EventStringAccInput(tx.Input.Address), types.EventMsgCallTx{tx, ret, exception})
+ evc.FireEvent(types.EventStringAccOutput(tx.Address), types.EventMsgCallTx{tx, ret, exception})
+ }
+ } else {
+ // The mempool does not call txs until
+ // the proposer determines the order of txs.
+ // So mempool will skip the actual .Call(),
+ // and only deduct from the caller's balance.
+ inAcc.Balance -= value
+ if createAccount {
+ inAcc.Sequence += 1
+ }
+ blockCache.UpdateAccount(inAcc)
+ }
+
+ return nil
+
+ case *types.NameTx:
+ var inAcc *account.Account
+
+ // Validate input
+ inAcc = blockCache.GetAccount(tx.Input.Address)
+ if inAcc == nil {
+ log.Debug(Fmt("Can't find in account %X", tx.Input.Address))
+ return types.ErrTxInvalidAddress
+ }
+ // pubKey should be present in either "inAcc" or "tx.Input"
+ if err := checkInputPubKey(inAcc, tx.Input); err != nil {
+ log.Debug(Fmt("Can't find pubkey for %X", tx.Input.Address))
+ return err
+ }
+ signBytes := account.SignBytes(_s.ChainID, tx)
+ err := validateInput(inAcc, signBytes, tx.Input)
+ if err != nil {
+ log.Debug(Fmt("validateInput failed on %X: %v", tx.Input.Address, err))
+ return err
+ }
+ // fee is in addition to the amount which is used to determine the TTL
+ if tx.Input.Amount < tx.Fee {
+ log.Debug(Fmt("Sender did not send enough to cover the fee %X", tx.Input.Address))
+ return types.ErrTxInsufficientFunds
+ }
+
+ // validate the input strings
+ if err := tx.ValidateStrings(); err != nil {
+ log.Debug(err.Error())
+ return types.ErrTxInvalidString
+ }
+
+ value := tx.Input.Amount - tx.Fee
+
+ // let's say cost of a name for one block is len(data) + 32
+ costPerBlock := types.NameCostPerBlock * types.NameCostPerByte * tx.BaseEntryCost()
+ expiresIn := value / uint64(costPerBlock)
+ lastBlockHeight := uint64(_s.LastBlockHeight)
+
+ log.Debug("New NameTx", "value", value, "costPerBlock", costPerBlock, "expiresIn", expiresIn, "lastBlock", lastBlockHeight)
+
+ // check if the name exists
+ entry := blockCache.GetNameRegEntry(tx.Name)
+
+ if entry != nil {
+ var expired bool
+ // if the entry already exists, and hasn't expired, we must be owner
+ if entry.Expires > lastBlockHeight {
+ // ensure we are owner
+ if bytes.Compare(entry.Owner, tx.Input.Address) != 0 {
+ log.Debug(Fmt("Sender %X is trying to update a name (%s) for which he is not owner", tx.Input.Address, tx.Name))
+ return types.ErrIncorrectOwner
+ }
+ } else {
+ expired = true
+ }
+
+ // no value and empty data means delete the entry
+ if value == 0 && len(tx.Data) == 0 {
+ // maybe we reward you for telling us we can delete this crap
+ // (owners if not expired, anyone if expired)
+ log.Debug("Removing namereg entry", "name", entry.Name)
+ blockCache.RemoveNameRegEntry(entry.Name)
+ } else {
+ // update the entry by bumping the expiry
+ // and changing the data
+ if expired {
+ if expiresIn < types.MinNameRegistrationPeriod {
+ return fmt.Errorf("Names must be registered for at least %d blocks", types.MinNameRegistrationPeriod)
+ }
+ entry.Expires = lastBlockHeight + expiresIn
+ entry.Owner = tx.Input.Address
+ log.Debug("An old namereg entry has expired and been reclaimed", "name", entry.Name, "expiresIn", expiresIn, "owner", entry.Owner)
+ } else {
+ // since the size of the data may have changed
+ // we use the total amount of "credit"
+ oldCredit := (entry.Expires - lastBlockHeight) * types.BaseEntryCost(entry.Name, entry.Data)
+ credit := oldCredit + value
+ expiresIn = credit / costPerBlock
+ if expiresIn < types.MinNameRegistrationPeriod {
+ return fmt.Errorf("Names must be registered for at least %d blocks", types.MinNameRegistrationPeriod)
+ }
+ entry.Expires = lastBlockHeight + expiresIn
+ log.Debug("Updated namereg entry", "name", entry.Name, "expiresIn", expiresIn, "oldCredit", oldCredit, "value", value, "credit", credit)
+ }
+ entry.Data = tx.Data
+ blockCache.UpdateNameRegEntry(entry)
+ }
+ } else {
+ if expiresIn < types.MinNameRegistrationPeriod {
+ return fmt.Errorf("Names must be registered for at least %d blocks", types.MinNameRegistrationPeriod)
+ }
+ // entry does not exist, so create it
+ entry = &types.NameRegEntry{
+ Name: tx.Name,
+ Owner: tx.Input.Address,
+ Data: tx.Data,
+ Expires: lastBlockHeight + expiresIn,
+ }
+ log.Debug("Creating namereg entry", "name", entry.Name, "expiresIn", expiresIn)
+ blockCache.UpdateNameRegEntry(entry)
+ }
+
+ // TODO: something with the value sent?
+
+ // Good!
+ inAcc.Sequence += 1
+ inAcc.Balance -= value
+ blockCache.UpdateAccount(inAcc)
+
+ // TODO: maybe we want to take funds on error and allow txs in that don't do anythingi?
+
+ return nil
+
+ case *types.BondTx:
+ valInfo := blockCache.State().GetValidatorInfo(tx.PubKey.Address())
+ if valInfo != nil {
+ // TODO: In the future, check that the validator wasn't destroyed,
+ // add funds, merge UnbondTo outputs, and unbond validator.
+ return errors.New("Adding coins to existing validators not yet supported")
+ }
+ accounts, err := getOrMakeAccounts(blockCache, tx.Inputs, nil)
+ if err != nil {
+ return err
+ }
+
+ signBytes := account.SignBytes(_s.ChainID, tx)
+ inTotal, err := validateInputs(accounts, signBytes, tx.Inputs)
+ if err != nil {
+ return err
+ }
+ if err := tx.PubKey.ValidateBasic(); err != nil {
+ return err
+ }
+ if !tx.PubKey.VerifyBytes(signBytes, tx.Signature) {
+ return types.ErrTxInvalidSignature
+ }
+ outTotal, err := validateOutputs(tx.UnbondTo)
+ if err != nil {
+ return err
+ }
+ if outTotal > inTotal {
+ return types.ErrTxInsufficientFunds
+ }
+ fee := inTotal - outTotal
+ fees += fee
+
+ // Good! Adjust accounts
+ adjustByInputs(accounts, tx.Inputs)
+ for _, acc := range accounts {
+ blockCache.UpdateAccount(acc)
+ }
+ // Add ValidatorInfo
+ _s.SetValidatorInfo(&ValidatorInfo{
+ Address: tx.PubKey.Address(),
+ PubKey: tx.PubKey,
+ UnbondTo: tx.UnbondTo,
+ FirstBondHeight: _s.LastBlockHeight + 1,
+ FirstBondAmount: outTotal,
+ })
+ // Add Validator
+ added := _s.BondedValidators.Add(&Validator{
+ Address: tx.PubKey.Address(),
+ PubKey: tx.PubKey,
+ BondHeight: _s.LastBlockHeight + 1,
+ VotingPower: outTotal,
+ Accum: 0,
+ })
+ if !added {
+ panic("Failed to add validator")
+ }
+ if evc != nil {
+ evc.FireEvent(types.EventStringBond(), tx)
+ }
+ return nil
+
+ case *types.UnbondTx:
+ // The validator must be active
+ _, val := _s.BondedValidators.GetByAddress(tx.Address)
+ if val == nil {
+ return types.ErrTxInvalidAddress
+ }
+
+ // Verify the signature
+ signBytes := account.SignBytes(_s.ChainID, tx)
+ if !val.PubKey.VerifyBytes(signBytes, tx.Signature) {
+ return types.ErrTxInvalidSignature
+ }
+
+ // tx.Height must be greater than val.LastCommitHeight
+ if tx.Height <= val.LastCommitHeight {
+ return errors.New("Invalid unbond height")
+ }
+
+ // Good!
+ _s.unbondValidator(val)
+ if evc != nil {
+ evc.FireEvent(types.EventStringUnbond(), tx)
+ }
+ return nil
+
+ case *types.RebondTx:
+ // The validator must be inactive
+ _, val := _s.UnbondingValidators.GetByAddress(tx.Address)
+ if val == nil {
+ return types.ErrTxInvalidAddress
+ }
+
+ // Verify the signature
+ signBytes := account.SignBytes(_s.ChainID, tx)
+ if !val.PubKey.VerifyBytes(signBytes, tx.Signature) {
+ return types.ErrTxInvalidSignature
+ }
+
+ // tx.Height must be equal to the next height
+ if tx.Height != _s.LastBlockHeight+1 {
+ return errors.New(Fmt("Invalid rebond height. Expected %v, got %v", _s.LastBlockHeight+1, tx.Height))
+ }
+
+ // Good!
+ _s.rebondValidator(val)
+ if evc != nil {
+ evc.FireEvent(types.EventStringRebond(), tx)
+ }
+ return nil
+
+ case *types.DupeoutTx:
+ // Verify the signatures
+ _, accused := _s.BondedValidators.GetByAddress(tx.Address)
+ if accused == nil {
+ _, accused = _s.UnbondingValidators.GetByAddress(tx.Address)
+ if accused == nil {
+ return types.ErrTxInvalidAddress
+ }
+ }
+ voteASignBytes := account.SignBytes(_s.ChainID, &tx.VoteA)
+ voteBSignBytes := account.SignBytes(_s.ChainID, &tx.VoteB)
+ if !accused.PubKey.VerifyBytes(voteASignBytes, tx.VoteA.Signature) ||
+ !accused.PubKey.VerifyBytes(voteBSignBytes, tx.VoteB.Signature) {
+ return types.ErrTxInvalidSignature
+ }
+
+ // Verify equivocation
+ // TODO: in the future, just require one vote from a previous height that
+ // doesn't exist on this chain.
+ if tx.VoteA.Height != tx.VoteB.Height {
+ return errors.New("DupeoutTx heights don't match")
+ }
+ if tx.VoteA.Type == types.VoteTypeCommit && tx.VoteA.Round < tx.VoteB.Round {
+ // Check special case (not an error, validator must be slashed!)
+ // Validators should not sign another vote after committing.
+ } else if tx.VoteB.Type == types.VoteTypeCommit && tx.VoteB.Round < tx.VoteA.Round {
+ // We need to check both orderings of the votes
+ } else {
+ if tx.VoteA.Round != tx.VoteB.Round {
+ return errors.New("DupeoutTx rounds don't match")
+ }
+ if tx.VoteA.Type != tx.VoteB.Type {
+ return errors.New("DupeoutTx types don't match")
+ }
+ if bytes.Equal(tx.VoteA.BlockHash, tx.VoteB.BlockHash) {
+ return errors.New("DupeoutTx blockhashes shouldn't match")
+ }
+ }
+
+ // Good! (Bad validator!)
+ _s.destroyValidator(accused)
+ if evc != nil {
+ evc.FireEvent(types.EventStringDupeout(), tx)
+ }
+ return nil
+
+ default:
+ panic("Unknown Tx type")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/state/genesis.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/genesis.go
new file mode 100644
index 0000000000000000000000000000000000000000..fcb51f081375b5f7e74a63f2aa8aae6f66590f3e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/genesis.go
@@ -0,0 +1,126 @@
+package state
+
+import (
+ "io/ioutil"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ dbm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/db"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+type GenesisAccount struct {
+ Address []byte `json:"address"`
+ Amount uint64 `json:"amount"`
+}
+
+type GenesisValidator struct {
+ PubKey account.PubKeyEd25519 `json:"pub_key"`
+ Amount uint64 `json:"amount"`
+ UnbondTo []GenesisAccount `json:"unbond_to"`
+}
+
+type GenesisDoc struct {
+ GenesisTime time.Time `json:"genesis_time"`
+ ChainID string `json:"chain_id"`
+ Accounts []GenesisAccount `json:"accounts"`
+ Validators []GenesisValidator `json:"validators"`
+}
+
+func GenesisDocFromJSON(jsonBlob []byte) (genState *GenesisDoc) {
+ var err error
+ binary.ReadJSON(&genState, jsonBlob, &err)
+ if err != nil {
+ panic(Fmt("Couldn't read GenesisDoc: %v", err))
+ }
+ return
+}
+
+func MakeGenesisStateFromFile(db dbm.DB, genDocFile string) *State {
+ jsonBlob, err := ioutil.ReadFile(genDocFile)
+ if err != nil {
+ panic(Fmt("Couldn't read GenesisDoc file: %v", err))
+ }
+ genDoc := GenesisDocFromJSON(jsonBlob)
+ return MakeGenesisState(db, genDoc)
+}
+
+func MakeGenesisState(db dbm.DB, genDoc *GenesisDoc) *State {
+ if len(genDoc.Validators) == 0 {
+ Exit(Fmt("The genesis file has no validators"))
+ }
+
+ if genDoc.GenesisTime.IsZero() {
+ genDoc.GenesisTime = time.Now()
+ }
+
+ // Make accounts state tree
+ accounts := merkle.NewIAVLTree(binary.BasicCodec, account.AccountCodec, defaultAccountsCacheCapacity, db)
+ for _, genAcc := range genDoc.Accounts {
+ acc := &account.Account{
+ Address: genAcc.Address,
+ PubKey: nil,
+ Sequence: 0,
+ Balance: genAcc.Amount,
+ }
+ accounts.Set(acc.Address, acc)
+ }
+
+ // Make validatorInfos state tree && validators slice
+ validatorInfos := merkle.NewIAVLTree(binary.BasicCodec, ValidatorInfoCodec, 0, db)
+ validators := make([]*Validator, len(genDoc.Validators))
+ for i, val := range genDoc.Validators {
+ pubKey := val.PubKey
+ address := pubKey.Address()
+
+ // Make ValidatorInfo
+ valInfo := &ValidatorInfo{
+ Address: address,
+ PubKey: pubKey,
+ UnbondTo: make([]*types.TxOutput, len(val.UnbondTo)),
+ FirstBondHeight: 0,
+ FirstBondAmount: val.Amount,
+ }
+ for i, unbondTo := range val.UnbondTo {
+ valInfo.UnbondTo[i] = &types.TxOutput{
+ Address: unbondTo.Address,
+ Amount: unbondTo.Amount,
+ }
+ }
+ validatorInfos.Set(address, valInfo)
+
+ // Make validator
+ validators[i] = &Validator{
+ Address: address,
+ PubKey: pubKey,
+ VotingPower: val.Amount,
+ }
+ }
+
+ // Make namereg tree
+ nameReg := merkle.NewIAVLTree(binary.BasicCodec, NameRegCodec, 0, db)
+ // TODO: add names to genesis.json
+
+ // IAVLTrees must be persisted before copy operations.
+ accounts.Save()
+ validatorInfos.Save()
+ nameReg.Save()
+
+ return &State{
+ DB: db,
+ ChainID: genDoc.ChainID,
+ LastBlockHeight: 0,
+ LastBlockHash: nil,
+ LastBlockParts: types.PartSetHeader{},
+ LastBlockTime: genDoc.GenesisTime,
+ BondedValidators: NewValidatorSet(validators),
+ LastBondedValidators: NewValidatorSet(nil),
+ UnbondingValidators: NewValidatorSet(nil),
+ accounts: accounts,
+ validatorInfos: validatorInfos,
+ nameReg: nameReg,
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/state/log.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..6b5410463299c30998e21d24bd065de6ce3a5495
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/log.go
@@ -0,0 +1,7 @@
+package state
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/logger"
+)
+
+var log = logger.New("module", "state")
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/state/priv_validator.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/priv_validator.go
new file mode 100644
index 0000000000000000000000000000000000000000..1a9e1048ddce084516658c5342e86d8202f8c00e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/priv_validator.go
@@ -0,0 +1,193 @@
+package state
+
+// TODO: This logic is crude. Should be more transactional.
+
+import (
+ "errors"
+ "fmt"
+ "io/ioutil"
+ "math"
+ "sync"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/types"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/ed25519"
+)
+
+const (
+ stepNone = 0 // Used to distinguish the initial state
+ stepPropose = 1
+ stepPrevote = 2
+ stepPrecommit = 3
+ stepCommit = 4
+)
+
+func voteToStep(vote *types.Vote) uint8 {
+ switch vote.Type {
+ case types.VoteTypePrevote:
+ return stepPrevote
+ case types.VoteTypePrecommit:
+ return stepPrecommit
+ case types.VoteTypeCommit:
+ return stepCommit
+ default:
+ panic("Unknown vote type")
+ }
+}
+
+type PrivValidator struct {
+ Address []byte `json:"address"`
+ PubKey account.PubKeyEd25519 `json:"pub_key"`
+ PrivKey account.PrivKeyEd25519 `json:"priv_key"`
+ LastHeight uint `json:"last_height"`
+ LastRound uint `json:"last_round"`
+ LastStep uint8 `json:"last_step"`
+
+ // For persistence.
+ // Overloaded for testing.
+ filePath string
+ mtx sync.Mutex
+}
+
+// Generates a new validator with private key.
+func GenPrivValidator() *PrivValidator {
+ privKeyBytes := new([64]byte)
+ copy(privKeyBytes[:32], CRandBytes(32))
+ pubKeyBytes := ed25519.MakePublicKey(privKeyBytes)
+ pubKey := account.PubKeyEd25519(pubKeyBytes[:])
+ privKey := account.PrivKeyEd25519(privKeyBytes[:])
+ return &PrivValidator{
+ Address: pubKey.Address(),
+ PubKey: pubKey,
+ PrivKey: privKey,
+ LastHeight: 0,
+ LastRound: 0,
+ LastStep: stepNone,
+ filePath: "",
+ }
+}
+
+func LoadPrivValidator(filePath string) *PrivValidator {
+ privValJSONBytes, err := ioutil.ReadFile(filePath)
+ if err != nil {
+ panic(err)
+ }
+ privVal := binary.ReadJSON(&PrivValidator{}, privValJSONBytes, &err).(*PrivValidator)
+ if err != nil {
+ Exit(Fmt("Error reading PrivValidator from %v: %v\n", filePath, err))
+ }
+ privVal.filePath = filePath
+ return privVal
+}
+
+func (privVal *PrivValidator) SetFile(filePath string) {
+ privVal.mtx.Lock()
+ defer privVal.mtx.Unlock()
+ privVal.filePath = filePath
+}
+
+func (privVal *PrivValidator) Save() {
+ privVal.mtx.Lock()
+ defer privVal.mtx.Unlock()
+ privVal.save()
+}
+
+func (privVal *PrivValidator) save() {
+ if privVal.filePath == "" {
+ panic("Cannot save PrivValidator: filePath not set")
+ }
+ jsonBytes := binary.JSONBytes(privVal)
+ err := WriteFileAtomic(privVal.filePath, jsonBytes)
+ if err != nil {
+ // `@; BOOM!!!
+ panic(err)
+ }
+}
+
+// TODO: test
+func (privVal *PrivValidator) SignVote(chainID string, vote *types.Vote) error {
+ privVal.mtx.Lock()
+ defer privVal.mtx.Unlock()
+
+ // If height regression, panic
+ if privVal.LastHeight > vote.Height {
+ return errors.New("Height regression in SignVote")
+ }
+ // More cases for when the height matches
+ if privVal.LastHeight == vote.Height {
+ // If attempting any sign after commit, panic
+ if privVal.LastStep == stepCommit {
+ return errors.New("SignVote on matching height after a commit")
+ }
+ // If round regression, panic
+ if privVal.LastRound > vote.Round {
+ return errors.New("Round regression in SignVote")
+ }
+ // If step regression, panic
+ if privVal.LastRound == vote.Round && privVal.LastStep > voteToStep(vote) {
+ return errors.New("Step regression in SignVote")
+ }
+ }
+
+ // Persist height/round/step
+ privVal.LastHeight = vote.Height
+ privVal.LastRound = vote.Round
+ privVal.LastStep = voteToStep(vote)
+ privVal.save()
+
+ // Sign
+ privVal.SignVoteUnsafe(chainID, vote)
+ return nil
+}
+
+func (privVal *PrivValidator) SignVoteUnsafe(chainID string, vote *types.Vote) {
+ vote.Signature = privVal.PrivKey.Sign(account.SignBytes(chainID, vote)).(account.SignatureEd25519)
+}
+
+func (privVal *PrivValidator) SignProposal(chainID string, proposal *Proposal) error {
+ privVal.mtx.Lock()
+ defer privVal.mtx.Unlock()
+ if privVal.LastHeight < proposal.Height ||
+ privVal.LastHeight == proposal.Height && privVal.LastRound < proposal.Round ||
+ privVal.LastHeight == 0 && privVal.LastRound == 0 && privVal.LastStep == stepNone {
+
+ // Persist height/round/step
+ privVal.LastHeight = proposal.Height
+ privVal.LastRound = proposal.Round
+ privVal.LastStep = stepPropose
+ privVal.save()
+
+ // Sign
+ proposal.Signature = privVal.PrivKey.Sign(account.SignBytes(chainID, proposal)).(account.SignatureEd25519)
+ return nil
+ } else {
+ return errors.New(fmt.Sprintf("Attempt of duplicate signing of proposal: Height %v, Round %v", proposal.Height, proposal.Round))
+ }
+}
+
+func (privVal *PrivValidator) SignRebondTx(chainID string, rebondTx *types.RebondTx) error {
+ privVal.mtx.Lock()
+ defer privVal.mtx.Unlock()
+ if privVal.LastHeight < rebondTx.Height {
+
+ // Persist height/round/step
+ privVal.LastHeight = rebondTx.Height
+ privVal.LastRound = math.MaxUint64 // We can't do anything else for this rebondTx.Height.
+ privVal.LastStep = math.MaxUint8
+ privVal.save()
+
+ // Sign
+ rebondTx.Signature = privVal.PrivKey.Sign(account.SignBytes(chainID, rebondTx)).(account.SignatureEd25519)
+ return nil
+ } else {
+ return errors.New(fmt.Sprintf("Attempt of duplicate signing of rebondTx: Height %v", rebondTx.Height))
+ }
+}
+
+func (privVal *PrivValidator) String() string {
+ return fmt.Sprintf("PrivValidator{%X LH:%v, LR:%v, LS:%v}", privVal.Address, privVal.LastHeight, privVal.LastRound, privVal.LastStep)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/state/state.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/state.go
new file mode 100644
index 0000000000000000000000000000000000000000..68f28a89f8985e073c7a4e927850f6dbd78b0797
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/state.go
@@ -0,0 +1,338 @@
+package state
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ dbm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/db"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/events"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+var (
+ stateKey = []byte("stateKey")
+ minBondAmount = uint64(1) // TODO adjust
+ defaultAccountsCacheCapacity = 1000 // TODO adjust
+ unbondingPeriodBlocks = uint(60 * 24 * 365) // TODO probably better to make it time based.
+ validatorTimeoutBlocks = uint(10) // TODO adjust
+)
+
+//-----------------------------------------------------------------------------
+
+// NOTE: not goroutine-safe.
+type State struct {
+ DB dbm.DB
+ ChainID string
+ LastBlockHeight uint
+ LastBlockHash []byte
+ LastBlockParts types.PartSetHeader
+ LastBlockTime time.Time
+ BondedValidators *ValidatorSet
+ LastBondedValidators *ValidatorSet
+ UnbondingValidators *ValidatorSet
+ accounts merkle.Tree // Shouldn't be accessed directly.
+ validatorInfos merkle.Tree // Shouldn't be accessed directly.
+ nameReg merkle.Tree // Shouldn't be accessed directly.
+
+ evc events.Fireable // typically an events.EventCache
+}
+
+func LoadState(db dbm.DB) *State {
+ s := &State{DB: db}
+ buf := db.Get(stateKey)
+ if len(buf) == 0 {
+ return nil
+ } else {
+ r, n, err := bytes.NewReader(buf), new(int64), new(error)
+ s.ChainID = binary.ReadString(r, n, err)
+ s.LastBlockHeight = binary.ReadUvarint(r, n, err)
+ s.LastBlockHash = binary.ReadByteSlice(r, n, err)
+ s.LastBlockParts = binary.ReadBinary(types.PartSetHeader{}, r, n, err).(types.PartSetHeader)
+ s.LastBlockTime = binary.ReadTime(r, n, err)
+ s.BondedValidators = binary.ReadBinary(&ValidatorSet{}, r, n, err).(*ValidatorSet)
+ s.LastBondedValidators = binary.ReadBinary(&ValidatorSet{}, r, n, err).(*ValidatorSet)
+ s.UnbondingValidators = binary.ReadBinary(&ValidatorSet{}, r, n, err).(*ValidatorSet)
+ accountsHash := binary.ReadByteSlice(r, n, err)
+ s.accounts = merkle.NewIAVLTree(binary.BasicCodec, account.AccountCodec, defaultAccountsCacheCapacity, db)
+ s.accounts.Load(accountsHash)
+ validatorInfosHash := binary.ReadByteSlice(r, n, err)
+ s.validatorInfos = merkle.NewIAVLTree(binary.BasicCodec, ValidatorInfoCodec, 0, db)
+ s.validatorInfos.Load(validatorInfosHash)
+ nameRegHash := binary.ReadByteSlice(r, n, err)
+ s.nameReg = merkle.NewIAVLTree(binary.BasicCodec, NameRegCodec, 0, db)
+ s.nameReg.Load(nameRegHash)
+ if *err != nil {
+ panic(*err)
+ }
+ // TODO: ensure that buf is completely read.
+ }
+ return s
+}
+
+func (s *State) Save() {
+ s.accounts.Save()
+ s.validatorInfos.Save()
+ s.nameReg.Save()
+ buf, n, err := new(bytes.Buffer), new(int64), new(error)
+ binary.WriteString(s.ChainID, buf, n, err)
+ binary.WriteUvarint(s.LastBlockHeight, buf, n, err)
+ binary.WriteByteSlice(s.LastBlockHash, buf, n, err)
+ binary.WriteBinary(s.LastBlockParts, buf, n, err)
+ binary.WriteTime(s.LastBlockTime, buf, n, err)
+ binary.WriteBinary(s.BondedValidators, buf, n, err)
+ binary.WriteBinary(s.LastBondedValidators, buf, n, err)
+ binary.WriteBinary(s.UnbondingValidators, buf, n, err)
+ binary.WriteByteSlice(s.accounts.Hash(), buf, n, err)
+ binary.WriteByteSlice(s.validatorInfos.Hash(), buf, n, err)
+ binary.WriteByteSlice(s.nameReg.Hash(), buf, n, err)
+ if *err != nil {
+ panic(*err)
+ }
+ s.DB.Set(stateKey, buf.Bytes())
+}
+
+// CONTRACT:
+// Copy() is a cheap way to take a snapshot,
+// as if State were copied by value.
+func (s *State) Copy() *State {
+ return &State{
+ DB: s.DB,
+ ChainID: s.ChainID,
+ LastBlockHeight: s.LastBlockHeight,
+ LastBlockHash: s.LastBlockHash,
+ LastBlockParts: s.LastBlockParts,
+ LastBlockTime: s.LastBlockTime,
+ BondedValidators: s.BondedValidators.Copy(), // TODO remove need for Copy() here.
+ LastBondedValidators: s.LastBondedValidators.Copy(), // That is, make updates to the validator set
+ UnbondingValidators: s.UnbondingValidators.Copy(), // copy the valSet lazily.
+ accounts: s.accounts.Copy(),
+ validatorInfos: s.validatorInfos.Copy(),
+ nameReg: s.nameReg.Copy(),
+ evc: nil,
+ }
+}
+
+// Returns a hash that represents the state data, excluding Last*
+func (s *State) Hash() []byte {
+ hashables := []merkle.Hashable{
+ s.BondedValidators,
+ s.UnbondingValidators,
+ s.accounts,
+ s.validatorInfos,
+ s.nameReg,
+ }
+ return merkle.HashFromHashables(hashables)
+}
+
+// Mutates the block in place and updates it with new state hash.
+func (s *State) SetBlockStateHash(block *types.Block) error {
+ sCopy := s.Copy()
+ // sCopy has no event cache in it, so this won't fire events
+ err := execBlock(sCopy, block, types.PartSetHeader{})
+ if err != nil {
+ return err
+ }
+ // Set block.StateHash
+ block.StateHash = sCopy.Hash()
+ return nil
+}
+
+//-------------------------------------
+// State.accounts
+
+// The returned Account is a copy, so mutating it
+// has no side effects.
+// Implements Statelike
+func (s *State) GetAccount(address []byte) *account.Account {
+ _, acc := s.accounts.Get(address)
+ if acc == nil {
+ return nil
+ }
+ return acc.(*account.Account).Copy()
+}
+
+// The account is copied before setting, so mutating it
+// afterwards has no side effects.
+// Implements Statelike
+func (s *State) UpdateAccount(account *account.Account) bool {
+ return s.accounts.Set(account.Address, account.Copy())
+}
+
+// Implements Statelike
+func (s *State) RemoveAccount(address []byte) bool {
+ _, removed := s.accounts.Remove(address)
+ return removed
+}
+
+// The returned Account is a copy, so mutating it
+// has no side effects.
+func (s *State) GetAccounts() merkle.Tree {
+ return s.accounts.Copy()
+}
+
+// State.accounts
+//-------------------------------------
+// State.validators
+
+// The returned ValidatorInfo is a copy, so mutating it
+// has no side effects.
+func (s *State) GetValidatorInfo(address []byte) *ValidatorInfo {
+ _, valInfo := s.validatorInfos.Get(address)
+ if valInfo == nil {
+ return nil
+ }
+ return valInfo.(*ValidatorInfo).Copy()
+}
+
+// Returns false if new, true if updated.
+// The valInfo is copied before setting, so mutating it
+// afterwards has no side effects.
+func (s *State) SetValidatorInfo(valInfo *ValidatorInfo) (updated bool) {
+ return s.validatorInfos.Set(valInfo.Address, valInfo.Copy())
+}
+
+func (s *State) unbondValidator(val *Validator) {
+ // Move validator to UnbondingValidators
+ val, removed := s.BondedValidators.Remove(val.Address)
+ if !removed {
+ panic("Couldn't remove validator for unbonding")
+ }
+ val.UnbondHeight = s.LastBlockHeight + 1
+ added := s.UnbondingValidators.Add(val)
+ if !added {
+ panic("Couldn't add validator for unbonding")
+ }
+}
+
+func (s *State) rebondValidator(val *Validator) {
+ // Move validator to BondingValidators
+ val, removed := s.UnbondingValidators.Remove(val.Address)
+ if !removed {
+ panic("Couldn't remove validator for rebonding")
+ }
+ val.BondHeight = s.LastBlockHeight + 1
+ added := s.BondedValidators.Add(val)
+ if !added {
+ panic("Couldn't add validator for rebonding")
+ }
+}
+
+func (s *State) releaseValidator(val *Validator) {
+ // Update validatorInfo
+ valInfo := s.GetValidatorInfo(val.Address)
+ if valInfo == nil {
+ panic("Couldn't find validatorInfo for release")
+ }
+ valInfo.ReleasedHeight = s.LastBlockHeight + 1
+ s.SetValidatorInfo(valInfo)
+
+ // Send coins back to UnbondTo outputs
+ accounts, err := getOrMakeAccounts(s, nil, valInfo.UnbondTo)
+ if err != nil {
+ panic("Couldn't get or make unbondTo accounts")
+ }
+ adjustByOutputs(accounts, valInfo.UnbondTo)
+ for _, acc := range accounts {
+ s.UpdateAccount(acc)
+ }
+
+ // Remove validator from UnbondingValidators
+ _, removed := s.UnbondingValidators.Remove(val.Address)
+ if !removed {
+ panic("Couldn't remove validator for release")
+ }
+}
+
+func (s *State) destroyValidator(val *Validator) {
+ // Update validatorInfo
+ valInfo := s.GetValidatorInfo(val.Address)
+ if valInfo == nil {
+ panic("Couldn't find validatorInfo for release")
+ }
+ valInfo.DestroyedHeight = s.LastBlockHeight + 1
+ valInfo.DestroyedAmount = val.VotingPower
+ s.SetValidatorInfo(valInfo)
+
+ // Remove validator
+ _, removed := s.BondedValidators.Remove(val.Address)
+ if !removed {
+ _, removed := s.UnbondingValidators.Remove(val.Address)
+ if !removed {
+ panic("Couldn't remove validator for destruction")
+ }
+ }
+
+}
+
+// State.validators
+//-------------------------------------
+// State.storage
+
+func (s *State) LoadStorage(hash []byte) (storage merkle.Tree) {
+ storage = merkle.NewIAVLTree(binary.BasicCodec, binary.BasicCodec, 1024, s.DB)
+ storage.Load(hash)
+ return storage
+}
+
+// State.storage
+//-------------------------------------
+// State.nameReg
+
+func (s *State) GetNameRegEntry(name string) *types.NameRegEntry {
+ _, value := s.nameReg.Get(name)
+ if value == nil {
+ return nil
+ }
+ entry := value.(*types.NameRegEntry)
+ return entry.Copy()
+}
+
+func (s *State) UpdateNameRegEntry(entry *types.NameRegEntry) bool {
+ return s.nameReg.Set(entry.Name, entry)
+}
+
+func (s *State) RemoveNameRegEntry(name string) bool {
+ _, removed := s.nameReg.Remove(name)
+ return removed
+}
+
+func (s *State) GetNames() merkle.Tree {
+ return s.nameReg.Copy()
+}
+
+func NameRegEncoder(o interface{}, w io.Writer, n *int64, err *error) {
+ binary.WriteBinary(o.(*types.NameRegEntry), w, n, err)
+}
+
+func NameRegDecoder(r io.Reader, n *int64, err *error) interface{} {
+ return binary.ReadBinary(&types.NameRegEntry{}, r, n, err)
+}
+
+var NameRegCodec = binary.Codec{
+ Encode: NameRegEncoder,
+ Decode: NameRegDecoder,
+}
+
+// State.nameReg
+//-------------------------------------
+
+// Implements events.Eventable. Typically uses events.EventCache
+func (s *State) SetFireable(evc events.Fireable) {
+ s.evc = evc
+}
+
+//-----------------------------------------------------------------------------
+
+type InvalidTxError struct {
+ Tx types.Tx
+ Reason error
+}
+
+func (txErr InvalidTxError) Error() string {
+ return fmt.Sprintf("Invalid tx: [%v] reason: [%v]", txErr.Tx, txErr.Reason)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/state/state_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/state_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..0809c63fa4d86c257a721aa17ad8637c9f638e9d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/state_test.go
@@ -0,0 +1,646 @@
+package state
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ _ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint_test"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+
+ "bytes"
+ "testing"
+ "time"
+)
+
+func execTxWithState(state *State, tx types.Tx, runCall bool) error {
+ cache := NewBlockCache(state)
+ err := ExecTx(cache, tx, runCall, nil)
+ if err != nil {
+ return err
+ } else {
+ cache.Sync()
+ return nil
+ }
+}
+
+func execTxWithStateNewBlock(state *State, tx types.Tx, runCall bool) error {
+ if err := execTxWithState(state, tx, runCall); err != nil {
+ return err
+ }
+
+ state.LastBlockHeight += 1
+ return nil
+}
+
+func TestCopyState(t *testing.T) {
+ // Generate a random state
+ s0, privAccounts, _ := RandGenesisState(10, true, 1000, 5, true, 1000)
+ s0Hash := s0.Hash()
+ if len(s0Hash) == 0 {
+ t.Error("Expected state hash")
+ }
+
+ // Check hash of copy
+ s0Copy := s0.Copy()
+ if !bytes.Equal(s0Hash, s0Copy.Hash()) {
+ t.Error("Expected state copy hash to be the same")
+ }
+
+ // Mutate the original; hash should change.
+ acc0Address := privAccounts[0].PubKey.Address()
+ acc := s0.GetAccount(acc0Address)
+ acc.Balance += 1
+
+ // The account balance shouldn't have changed yet.
+ if s0.GetAccount(acc0Address).Balance == acc.Balance {
+ t.Error("Account balance changed unexpectedly")
+ }
+
+ // Setting, however, should change the balance.
+ s0.UpdateAccount(acc)
+ if s0.GetAccount(acc0Address).Balance != acc.Balance {
+ t.Error("Account balance wasn't set")
+ }
+
+ // Now that the state changed, the hash should change too.
+ if bytes.Equal(s0Hash, s0.Hash()) {
+ t.Error("Expected state hash to have changed")
+ }
+
+ // The s0Copy shouldn't have changed though.
+ if !bytes.Equal(s0Hash, s0Copy.Hash()) {
+ t.Error("Expected state copy hash to have not changed")
+ }
+}
+
+func makeBlock(t *testing.T, state *State, commits []types.Commit, txs []types.Tx) *types.Block {
+ block := &types.Block{
+ Header: &types.Header{
+ ChainID: state.ChainID,
+ Height: state.LastBlockHeight + 1,
+ Time: state.LastBlockTime.Add(time.Minute),
+ Fees: 0,
+ NumTxs: uint(len(txs)),
+ LastBlockHash: state.LastBlockHash,
+ LastBlockParts: state.LastBlockParts,
+ StateHash: nil,
+ },
+ Validation: &types.Validation{
+ Commits: commits,
+ },
+ Data: &types.Data{
+ Txs: txs,
+ },
+ }
+
+ // Fill in block StateHash
+ err := state.SetBlockStateHash(block)
+ if err != nil {
+ t.Error("Error appending initial block:", err)
+ }
+ if len(block.Header.StateHash) == 0 {
+ t.Error("Expected StateHash but got nothing.")
+ }
+
+ return block
+}
+
+func TestGenesisSaveLoad(t *testing.T) {
+
+ // Generate a state, save & load it.
+ s0, _, _ := RandGenesisState(10, true, 1000, 5, true, 1000)
+
+ // Make complete block and blockParts
+ block := makeBlock(t, s0, nil, nil)
+ blockParts := block.MakePartSet()
+
+ // Now append the block to s0.
+ err := ExecBlock(s0, block, blockParts.Header())
+ if err != nil {
+ t.Error("Error appending initial block:", err)
+ }
+
+ // Save s0
+ s0.Save()
+
+ // Sanity check s0
+ //s0.DB.(*dbm.MemDB).Print()
+ if s0.BondedValidators.TotalVotingPower() == 0 {
+ t.Error("s0 BondedValidators TotalVotingPower should not be 0")
+ }
+ if s0.LastBlockHeight != 1 {
+ t.Error("s0 LastBlockHeight should be 1, got", s0.LastBlockHeight)
+ }
+
+ // Load s1
+ s1 := LoadState(s0.DB)
+
+ // Compare height & blockHash
+ if s0.LastBlockHeight != s1.LastBlockHeight {
+ t.Error("LastBlockHeight mismatch")
+ }
+ if !bytes.Equal(s0.LastBlockHash, s1.LastBlockHash) {
+ t.Error("LastBlockHash mismatch")
+ }
+
+ // Compare state merkle trees
+ if s0.BondedValidators.Size() != s1.BondedValidators.Size() {
+ t.Error("BondedValidators Size mismatch")
+ }
+ if s0.BondedValidators.TotalVotingPower() != s1.BondedValidators.TotalVotingPower() {
+ t.Error("BondedValidators TotalVotingPower mismatch")
+ }
+ if !bytes.Equal(s0.BondedValidators.Hash(), s1.BondedValidators.Hash()) {
+ t.Error("BondedValidators hash mismatch")
+ }
+ if s0.UnbondingValidators.Size() != s1.UnbondingValidators.Size() {
+ t.Error("UnbondingValidators Size mismatch")
+ }
+ if s0.UnbondingValidators.TotalVotingPower() != s1.UnbondingValidators.TotalVotingPower() {
+ t.Error("UnbondingValidators TotalVotingPower mismatch")
+ }
+ if !bytes.Equal(s0.UnbondingValidators.Hash(), s1.UnbondingValidators.Hash()) {
+ t.Error("UnbondingValidators hash mismatch")
+ }
+ if !bytes.Equal(s0.accounts.Hash(), s1.accounts.Hash()) {
+ t.Error("Accounts mismatch")
+ }
+ if !bytes.Equal(s0.validatorInfos.Hash(), s1.validatorInfos.Hash()) {
+ t.Error("Accounts mismatch")
+ }
+}
+
+func TestTxSequence(t *testing.T) {
+
+ state, privAccounts, _ := RandGenesisState(3, true, 1000, 1, true, 1000)
+ acc0 := state.GetAccount(privAccounts[0].PubKey.Address())
+ acc0PubKey := privAccounts[0].PubKey
+ acc1 := state.GetAccount(privAccounts[1].PubKey.Address())
+
+ // Test a variety of sequence numbers for the tx.
+ // The tx should only pass when i == 1.
+ for i := -1; i < 3; i++ {
+ sequence := acc0.Sequence + uint(i)
+ tx := types.NewSendTx()
+ tx.AddInputWithNonce(acc0PubKey, 1, sequence)
+ tx.AddOutput(acc1.Address, 1)
+ tx.Inputs[0].Signature = privAccounts[0].Sign(state.ChainID, tx)
+ stateCopy := state.Copy()
+ err := execTxWithState(stateCopy, tx, true)
+ if i == 1 {
+ // Sequence is good.
+ if err != nil {
+ t.Errorf("Expected good sequence to pass: %v", err)
+ }
+ // Check acc.Sequence.
+ newAcc0 := stateCopy.GetAccount(acc0.Address)
+ if newAcc0.Sequence != sequence {
+ t.Errorf("Expected account sequence to change to %v, got %v",
+ sequence, newAcc0.Sequence)
+ }
+ } else {
+ // Sequence is bad.
+ if err == nil {
+ t.Errorf("Expected bad sequence to fail")
+ }
+ // Check acc.Sequence. (shouldn't have changed)
+ newAcc0 := stateCopy.GetAccount(acc0.Address)
+ if newAcc0.Sequence != acc0.Sequence {
+ t.Errorf("Expected account sequence to not change from %v, got %v",
+ acc0.Sequence, newAcc0.Sequence)
+ }
+ }
+ }
+}
+
+func TestNameTxs(t *testing.T) {
+ state, privAccounts, _ := RandGenesisState(3, true, 1000, 1, true, 1000)
+
+ types.MinNameRegistrationPeriod = 5
+ startingBlock := uint64(state.LastBlockHeight)
+
+ // try some bad names. these should all fail
+ names := []string{"", "\n", "123#$%", "\x00", string([]byte{20, 40, 60, 80}), "baffledbythespectacleinallofthisyouseeehesaidwithouteyes", "no spaces please"}
+ data := "something about all this just doesn't feel right."
+ fee := uint64(1000)
+ numDesiredBlocks := uint64(5)
+ for _, name := range names {
+ amt := fee + numDesiredBlocks*types.NameCostPerByte*types.NameCostPerBlock*types.BaseEntryCost(name, data)
+ tx, _ := types.NewNameTx(state, privAccounts[0].PubKey, name, data, amt, fee)
+ tx.Sign(state.ChainID, privAccounts[0])
+
+ if err := execTxWithState(state, tx, true); err == nil {
+ t.Fatalf("Expected invalid name error from %s", name)
+ }
+ }
+
+ // try some bad data. these should all fail
+ name := "hold_it_chum"
+ datas := []string{"cold&warm", "!@#$%^&*()", "<<<>>>>", "because why would you ever need a ~ or a & or even a % in a json file? make your case and we'll talk"}
+ for _, data := range datas {
+ amt := fee + numDesiredBlocks*types.NameCostPerByte*types.NameCostPerBlock*types.BaseEntryCost(name, data)
+ tx, _ := types.NewNameTx(state, privAccounts[0].PubKey, name, data, amt, fee)
+ tx.Sign(state.ChainID, privAccounts[0])
+
+ if err := execTxWithState(state, tx, true); err == nil {
+ t.Fatalf("Expected invalid data error from %s", data)
+ }
+ }
+
+ validateEntry := func(t *testing.T, entry *types.NameRegEntry, name, data string, addr []byte, expires uint64) {
+
+ if entry == nil {
+ t.Fatalf("Could not find name %s", name)
+ }
+ if bytes.Compare(entry.Owner, addr) != 0 {
+ t.Fatalf("Wrong owner. Got %X expected %X", entry.Owner, addr)
+ }
+ if data != entry.Data {
+ t.Fatalf("Wrong data. Got %s expected %s", entry.Data, data)
+ }
+ if name != entry.Name {
+ t.Fatalf("Wrong name. Got %s expected %s", entry.Name, name)
+ }
+ if expires != entry.Expires {
+ t.Fatalf("Wrong expiry. Got %d, expected %d", entry.Expires, expires)
+ }
+ }
+
+ // try a good one, check data, owner, expiry
+ name = "looking_good/karaoke_bar"
+ data = "on this side of neptune there are 1234567890 people: first is OMNIVORE. Or is it. Ok this is pretty restrictive. No exclamations :(. Faces tho :')"
+ amt := fee + numDesiredBlocks*types.NameCostPerByte*types.NameCostPerBlock*types.BaseEntryCost(name, data)
+ tx, _ := types.NewNameTx(state, privAccounts[0].PubKey, name, data, amt, fee)
+ tx.Sign(state.ChainID, privAccounts[0])
+ if err := execTxWithState(state, tx, true); err != nil {
+ t.Fatal(err)
+ }
+ entry := state.GetNameRegEntry(name)
+ validateEntry(t, entry, name, data, privAccounts[0].Address, startingBlock+numDesiredBlocks)
+
+ // fail to update it as non-owner, in same block
+ tx, _ = types.NewNameTx(state, privAccounts[1].PubKey, name, data, amt, fee)
+ tx.Sign(state.ChainID, privAccounts[1])
+ if err := execTxWithState(state, tx, true); err == nil {
+ t.Fatal("Expected error")
+ }
+
+ // update it as owner, just to increase expiry, in same block
+ // NOTE: we have to resend the data or it will clear it (is this what we want?)
+ tx, _ = types.NewNameTx(state, privAccounts[0].PubKey, name, data, amt, fee)
+ tx.Sign(state.ChainID, privAccounts[0])
+ if err := execTxWithStateNewBlock(state, tx, true); err != nil {
+ t.Fatal(err)
+ }
+ entry = state.GetNameRegEntry(name)
+ validateEntry(t, entry, name, data, privAccounts[0].Address, startingBlock+numDesiredBlocks*2)
+
+ // update it as owner, just to increase expiry, in next block
+ tx, _ = types.NewNameTx(state, privAccounts[0].PubKey, name, data, amt, fee)
+ tx.Sign(state.ChainID, privAccounts[0])
+ if err := execTxWithStateNewBlock(state, tx, true); err != nil {
+ t.Fatal(err)
+ }
+ entry = state.GetNameRegEntry(name)
+ validateEntry(t, entry, name, data, privAccounts[0].Address, startingBlock+numDesiredBlocks*3)
+
+ // fail to update it as non-owner
+ state.LastBlockHeight = uint(entry.Expires - 1)
+ tx, _ = types.NewNameTx(state, privAccounts[1].PubKey, name, data, amt, fee)
+ tx.Sign(state.ChainID, privAccounts[1])
+ if err := execTxWithState(state, tx, true); err == nil {
+ t.Fatal("Expected error")
+ }
+
+ // once expires, non-owner succeeds
+ state.LastBlockHeight = uint(entry.Expires)
+ tx, _ = types.NewNameTx(state, privAccounts[1].PubKey, name, data, amt, fee)
+ tx.Sign(state.ChainID, privAccounts[1])
+ if err := execTxWithState(state, tx, true); err != nil {
+ t.Fatal(err)
+ }
+ entry = state.GetNameRegEntry(name)
+ validateEntry(t, entry, name, data, privAccounts[1].Address, uint64(state.LastBlockHeight)+numDesiredBlocks)
+
+ // update it as new owner, with new data (longer), but keep the expiry!
+ data = "In the beginning there was no thing, not even the beginning. It hadn't been here, no there, nor for that matter anywhere, not especially because it had not to even exist, let alone to not. Nothing especially odd about that."
+ oldCredit := amt - fee
+ numDesiredBlocks = 10
+ amt = fee + (numDesiredBlocks*types.NameCostPerByte*types.NameCostPerBlock*types.BaseEntryCost(name, data) - oldCredit)
+ tx, _ = types.NewNameTx(state, privAccounts[1].PubKey, name, data, amt, fee)
+ tx.Sign(state.ChainID, privAccounts[1])
+ if err := execTxWithState(state, tx, true); err != nil {
+ t.Fatal(err)
+ }
+ entry = state.GetNameRegEntry(name)
+ validateEntry(t, entry, name, data, privAccounts[1].Address, uint64(state.LastBlockHeight)+numDesiredBlocks)
+
+ // test removal
+ amt = fee
+ data = ""
+ tx, _ = types.NewNameTx(state, privAccounts[1].PubKey, name, data, amt, fee)
+ tx.Sign(state.ChainID, privAccounts[1])
+ if err := execTxWithStateNewBlock(state, tx, true); err != nil {
+ t.Fatal(err)
+ }
+ entry = state.GetNameRegEntry(name)
+ if entry != nil {
+ t.Fatal("Expected removed entry to be nil")
+ }
+
+ // create entry by key0,
+ // test removal by key1 after expiry
+ name = "looking_good/karaoke_bar"
+ data = "some data"
+ amt = fee + numDesiredBlocks*types.NameCostPerByte*types.NameCostPerBlock*types.BaseEntryCost(name, data)
+ tx, _ = types.NewNameTx(state, privAccounts[0].PubKey, name, data, amt, fee)
+ tx.Sign(state.ChainID, privAccounts[0])
+ if err := execTxWithState(state, tx, true); err != nil {
+ t.Fatal(err)
+ }
+ entry = state.GetNameRegEntry(name)
+ validateEntry(t, entry, name, data, privAccounts[0].Address, uint64(state.LastBlockHeight)+numDesiredBlocks)
+ state.LastBlockHeight = uint(entry.Expires)
+
+ amt = fee
+ data = ""
+ tx, _ = types.NewNameTx(state, privAccounts[1].PubKey, name, data, amt, fee)
+ tx.Sign(state.ChainID, privAccounts[1])
+ if err := execTxWithStateNewBlock(state, tx, true); err != nil {
+ t.Fatal(err)
+ }
+ entry = state.GetNameRegEntry(name)
+ if entry != nil {
+ t.Fatal("Expected removed entry to be nil")
+ }
+}
+
+// TODO: test overflows.
+// TODO: test for unbonding validators.
+func TestTxs(t *testing.T) {
+
+ state, privAccounts, _ := RandGenesisState(3, true, 1000, 1, true, 1000)
+
+ //val0 := state.GetValidatorInfo(privValidators[0].Address)
+ acc0 := state.GetAccount(privAccounts[0].PubKey.Address())
+ acc0PubKey := privAccounts[0].PubKey
+ acc1 := state.GetAccount(privAccounts[1].PubKey.Address())
+
+ // SendTx.
+ {
+ state := state.Copy()
+ tx := &types.SendTx{
+ Inputs: []*types.TxInput{
+ &types.TxInput{
+ Address: acc0.Address,
+ Amount: 1,
+ Sequence: acc0.Sequence + 1,
+ PubKey: acc0PubKey,
+ },
+ },
+ Outputs: []*types.TxOutput{
+ &types.TxOutput{
+ Address: acc1.Address,
+ Amount: 1,
+ },
+ },
+ }
+
+ tx.Inputs[0].Signature = privAccounts[0].Sign(state.ChainID, tx)
+ err := execTxWithState(state, tx, true)
+ if err != nil {
+ t.Errorf("Got error in executing send transaction, %v", err)
+ }
+ newAcc0 := state.GetAccount(acc0.Address)
+ if acc0.Balance-1 != newAcc0.Balance {
+ t.Errorf("Unexpected newAcc0 balance. Expected %v, got %v",
+ acc0.Balance-1, newAcc0.Balance)
+ }
+ newAcc1 := state.GetAccount(acc1.Address)
+ if acc1.Balance+1 != newAcc1.Balance {
+ t.Errorf("Unexpected newAcc1 balance. Expected %v, got %v",
+ acc1.Balance+1, newAcc1.Balance)
+ }
+ }
+
+ // CallTx. Just runs through it and checks the transfer. See vm, rpc tests for more
+ {
+ state := state.Copy()
+ newAcc1 := state.GetAccount(acc1.Address)
+ newAcc1.Code = []byte{0x60}
+ state.UpdateAccount(newAcc1)
+ tx := &types.CallTx{
+ Input: &types.TxInput{
+ Address: acc0.Address,
+ Amount: 1,
+ Sequence: acc0.Sequence + 1,
+ PubKey: acc0PubKey,
+ },
+ Address: acc1.Address,
+ GasLimit: 10,
+ }
+
+ tx.Input.Signature = privAccounts[0].Sign(state.ChainID, tx)
+ err := execTxWithState(state, tx, true)
+ if err != nil {
+ t.Errorf("Got error in executing call transaction, %v", err)
+ }
+ newAcc0 := state.GetAccount(acc0.Address)
+ if acc0.Balance-1 != newAcc0.Balance {
+ t.Errorf("Unexpected newAcc0 balance. Expected %v, got %v",
+ acc0.Balance-1, newAcc0.Balance)
+ }
+ newAcc1 = state.GetAccount(acc1.Address)
+ if acc1.Balance+1 != newAcc1.Balance {
+ t.Errorf("Unexpected newAcc1 balance. Expected %v, got %v",
+ acc1.Balance+1, newAcc1.Balance)
+ }
+ }
+
+ // NameTx.
+ {
+ entryName := "satoshi"
+ entryData := `
+A purely peer-to-peer version of electronic cash would allow online
+payments to be sent directly from one party to another without going through a
+financial institution. Digital signatures provide part of the solution, but the main
+benefits are lost if a trusted third party is still required to prevent double-spending.
+We propose a solution to the double-spending problem using a peer-to-peer network.
+The network timestamps transactions by hashing them into an ongoing chain of
+hash-based proof-of-work, forming a record that cannot be changed without redoing
+the proof-of-work. The longest chain not only serves as proof of the sequence of
+events witnessed, but proof that it came from the largest pool of CPU power. As
+long as a majority of CPU power is controlled by nodes that are not cooperating to
+attack the network, they'll generate the longest chain and outpace attackers. The
+network itself requires minimal structure. Messages are broadcast on a best effort
+basis, and nodes can leave and rejoin the network at will, accepting the longest
+proof-of-work chain as proof of what happened while they were gone `
+ entryAmount := uint64(10000)
+
+ state := state.Copy()
+ tx := &types.NameTx{
+ Input: &types.TxInput{
+ Address: acc0.Address,
+ Amount: entryAmount,
+ Sequence: acc0.Sequence + 1,
+ PubKey: acc0PubKey,
+ },
+ Name: entryName,
+ Data: entryData,
+ }
+
+ tx.Input.Signature = privAccounts[0].Sign(state.ChainID, tx)
+ err := execTxWithState(state, tx, true)
+ if err != nil {
+ t.Errorf("Got error in executing call transaction, %v", err)
+ }
+ newAcc0 := state.GetAccount(acc0.Address)
+ if acc0.Balance-entryAmount != newAcc0.Balance {
+ t.Errorf("Unexpected newAcc0 balance. Expected %v, got %v",
+ acc0.Balance-entryAmount, newAcc0.Balance)
+ }
+ entry := state.GetNameRegEntry(entryName)
+ if entry == nil {
+ t.Errorf("Expected an entry but got nil")
+ }
+ if entry.Data != entryData {
+ t.Errorf("Wrong data stored")
+ }
+
+ // test a bad string
+ tx.Data = string([]byte{0, 1, 2, 3, 127, 128, 129, 200, 251})
+ tx.Input.Sequence += 1
+ tx.Input.Signature = privAccounts[0].Sign(state.ChainID, tx)
+ err = execTxWithState(state, tx, true)
+ if err != types.ErrTxInvalidString {
+ t.Errorf("Expected invalid string error. Got: %s", err.Error())
+ }
+ }
+
+ // BondTx.
+ {
+ state := state.Copy()
+ tx := &types.BondTx{
+ PubKey: acc0PubKey.(account.PubKeyEd25519),
+ Inputs: []*types.TxInput{
+ &types.TxInput{
+ Address: acc0.Address,
+ Amount: 1,
+ Sequence: acc0.Sequence + 1,
+ PubKey: acc0PubKey,
+ },
+ },
+ UnbondTo: []*types.TxOutput{
+ &types.TxOutput{
+ Address: acc0.Address,
+ Amount: 1,
+ },
+ },
+ }
+ tx.Signature = privAccounts[0].Sign(state.ChainID, tx).(account.SignatureEd25519)
+ tx.Inputs[0].Signature = privAccounts[0].Sign(state.ChainID, tx)
+ err := execTxWithState(state, tx, true)
+ if err != nil {
+ t.Errorf("Got error in executing bond transaction, %v", err)
+ }
+ newAcc0 := state.GetAccount(acc0.Address)
+ if newAcc0.Balance != acc0.Balance-1 {
+ t.Errorf("Unexpected newAcc0 balance. Expected %v, got %v",
+ acc0.Balance-1, newAcc0.Balance)
+ }
+ _, acc0Val := state.BondedValidators.GetByAddress(acc0.Address)
+ if acc0Val == nil {
+ t.Errorf("acc0Val not present")
+ }
+ if acc0Val.BondHeight != state.LastBlockHeight+1 {
+ t.Errorf("Unexpected bond height. Expected %v, got %v",
+ state.LastBlockHeight, acc0Val.BondHeight)
+ }
+ if acc0Val.VotingPower != 1 {
+ t.Errorf("Unexpected voting power. Expected %v, got %v",
+ acc0Val.VotingPower, acc0.Balance)
+ }
+ if acc0Val.Accum != 0 {
+ t.Errorf("Unexpected accum. Expected 0, got %v",
+ acc0Val.Accum)
+ }
+ }
+
+ // TODO UnbondTx.
+
+}
+
+func TestAddValidator(t *testing.T) {
+
+ // Generate a state, save & load it.
+ s0, privAccounts, privValidators := RandGenesisState(10, false, 1000, 1, false, 1000)
+
+ // The first privAccount will become a validator
+ acc0 := privAccounts[0]
+ bondTx := &types.BondTx{
+ PubKey: acc0.PubKey.(account.PubKeyEd25519),
+ Inputs: []*types.TxInput{
+ &types.TxInput{
+ Address: acc0.Address,
+ Amount: 1000,
+ Sequence: 1,
+ PubKey: acc0.PubKey,
+ },
+ },
+ UnbondTo: []*types.TxOutput{
+ &types.TxOutput{
+ Address: acc0.Address,
+ Amount: 1000,
+ },
+ },
+ }
+ bondTx.Signature = acc0.Sign(s0.ChainID, bondTx).(account.SignatureEd25519)
+ bondTx.Inputs[0].Signature = acc0.Sign(s0.ChainID, bondTx)
+
+ // Make complete block and blockParts
+ block0 := makeBlock(t, s0, nil, []types.Tx{bondTx})
+ block0Parts := block0.MakePartSet()
+
+ // Sanity check
+ if s0.BondedValidators.Size() != 1 {
+ t.Error("Expected there to be 1 validators before bondTx")
+ }
+
+ // Now append the block to s0.
+ err := ExecBlock(s0, block0, block0Parts.Header())
+ if err != nil {
+ t.Error("Error appending initial block:", err)
+ }
+
+ // Must save before further modification
+ s0.Save()
+
+ // Test new validator set
+ if s0.BondedValidators.Size() != 2 {
+ t.Error("Expected there to be 2 validators after bondTx")
+ }
+
+ // The validation for the next block should only require 1 signature
+ // (the new validator wasn't active for block0)
+ commit0 := &types.Vote{
+ Height: 1,
+ Round: 0,
+ Type: types.VoteTypeCommit,
+ BlockHash: block0.Hash(),
+ BlockParts: block0Parts.Header(),
+ }
+ privValidators[0].SignVote(s0.ChainID, commit0)
+
+ block1 := makeBlock(t, s0,
+ []types.Commit{
+ types.Commit{
+ Address: privValidators[0].Address,
+ Round: 0,
+ Signature: commit0.Signature,
+ },
+ }, nil,
+ )
+ block1Parts := block1.MakePartSet()
+ err = ExecBlock(s0, block1, block1Parts.Header())
+ if err != nil {
+ t.Error("Error appending secondary block:", err)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/state/test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/test.go
new file mode 100644
index 0000000000000000000000000000000000000000..38a4cdc9b44b00d1e86c650571a605e9c745644a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/test.go
@@ -0,0 +1,124 @@
+package state
+
+import (
+ "bytes"
+ "sort"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ dbm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/db"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+
+ "io/ioutil"
+ "os"
+ "time"
+)
+
+func Tempfile(prefix string) (*os.File, string) {
+ file, err := ioutil.TempFile("", prefix)
+ if err != nil {
+ panic(err)
+ }
+ return file, file.Name()
+}
+
+func RandAccount(randBalance bool, minBalance uint64) (*account.Account, *account.PrivAccount) {
+ privAccount := account.GenPrivAccount()
+ acc := &account.Account{
+ Address: privAccount.PubKey.Address(),
+ PubKey: privAccount.PubKey,
+ Sequence: RandUint(),
+ Balance: minBalance,
+ }
+ if randBalance {
+ acc.Balance += uint64(RandUint32())
+ }
+ return acc, privAccount
+}
+
+func RandValidator(randBonded bool, minBonded uint64) (*ValidatorInfo, *Validator, *PrivValidator) {
+ privVal := GenPrivValidator()
+ _, tempFilePath := Tempfile("priv_validator_")
+ privVal.SetFile(tempFilePath)
+ bonded := minBonded
+ if randBonded {
+ bonded += uint64(RandUint32())
+ }
+ valInfo := &ValidatorInfo{
+ Address: privVal.Address,
+ PubKey: privVal.PubKey,
+ UnbondTo: []*types.TxOutput{&types.TxOutput{
+ Amount: bonded,
+ Address: privVal.Address,
+ }},
+ FirstBondHeight: 0,
+ FirstBondAmount: bonded,
+ }
+ val := &Validator{
+ Address: valInfo.Address,
+ PubKey: valInfo.PubKey,
+ BondHeight: 0,
+ UnbondHeight: 0,
+ LastCommitHeight: 0,
+ VotingPower: valInfo.FirstBondAmount,
+ Accum: 0,
+ }
+ return valInfo, val, privVal
+}
+
+func RandGenesisState(numAccounts int, randBalance bool, minBalance uint64, numValidators int, randBonded bool, minBonded uint64) (*State, []*account.PrivAccount, []*PrivValidator) {
+ db := dbm.NewMemDB()
+ accounts := make([]GenesisAccount, numAccounts)
+ privAccounts := make([]*account.PrivAccount, numAccounts)
+ for i := 0; i < numAccounts; i++ {
+ account, privAccount := RandAccount(randBalance, minBalance)
+ accounts[i] = GenesisAccount{
+ Address: account.Address,
+ Amount: account.Balance,
+ }
+ privAccounts[i] = privAccount
+ }
+ validators := make([]GenesisValidator, numValidators)
+ privValidators := make([]*PrivValidator, numValidators)
+ for i := 0; i < numValidators; i++ {
+ valInfo, _, privVal := RandValidator(randBonded, minBonded)
+ validators[i] = GenesisValidator{
+ PubKey: valInfo.PubKey,
+ Amount: valInfo.FirstBondAmount,
+ UnbondTo: []GenesisAccount{
+ {
+ Address: valInfo.PubKey.Address(),
+ Amount: valInfo.FirstBondAmount,
+ },
+ },
+ }
+ privValidators[i] = privVal
+ }
+ sort.Sort(PrivValidatorsByAddress(privValidators))
+ s0 := MakeGenesisState(db, &GenesisDoc{
+ GenesisTime: time.Now(),
+ ChainID: "tendermint_test",
+ Accounts: accounts,
+ Validators: validators,
+ })
+ s0.Save()
+ return s0, privAccounts, privValidators
+}
+
+//-------------------------------------
+
+type PrivValidatorsByAddress []*PrivValidator
+
+func (pvs PrivValidatorsByAddress) Len() int {
+ return len(pvs)
+}
+
+func (pvs PrivValidatorsByAddress) Less(i, j int) bool {
+ return bytes.Compare(pvs[i].Address, pvs[j].Address) == -1
+}
+
+func (pvs PrivValidatorsByAddress) Swap(i, j int) {
+ it := pvs[i]
+ pvs[i] = pvs[j]
+ pvs[j] = it
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/state/tx_cache.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/tx_cache.go
new file mode 100644
index 0000000000000000000000000000000000000000..6ff1a634fb1c796b01a6d7ec0ee5346d553063d9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/tx_cache.go
@@ -0,0 +1,195 @@
+package state
+
+import (
+ ac "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/vm"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/sha3"
+)
+
+type TxCache struct {
+ backend *BlockCache
+ accounts map[Word256]vmAccountInfo
+ storages map[Tuple256]Word256
+ logs []*vm.Log
+}
+
+func NewTxCache(backend *BlockCache) *TxCache {
+ return &TxCache{
+ backend: backend,
+ accounts: make(map[Word256]vmAccountInfo),
+ storages: make(map[Tuple256]Word256),
+ logs: make([]*vm.Log, 0),
+ }
+}
+
+//-------------------------------------
+// TxCache.account
+
+func (cache *TxCache) GetAccount(addr Word256) *vm.Account {
+ acc, removed := vmUnpack(cache.accounts[addr])
+ if removed {
+ return nil
+ } else if acc == nil {
+ acc2 := cache.backend.GetAccount(addr.Postfix(20))
+ if acc2 != nil {
+ return toVMAccount(acc2)
+ }
+ }
+ return acc
+}
+
+func (cache *TxCache) UpdateAccount(acc *vm.Account) {
+ addr := acc.Address
+ // SANITY CHECK
+ _, removed := vmUnpack(cache.accounts[addr])
+ if removed {
+ panic("UpdateAccount on a removed account")
+ }
+ // SANITY CHECK END
+ cache.accounts[addr] = vmAccountInfo{acc, false}
+}
+
+func (cache *TxCache) RemoveAccount(acc *vm.Account) {
+ addr := acc.Address
+ // SANITY CHECK
+ _, removed := vmUnpack(cache.accounts[addr])
+ if removed {
+ panic("RemoveAccount on a removed account")
+ }
+ // SANITY CHECK END
+ cache.accounts[addr] = vmAccountInfo{acc, true}
+}
+
+// Creates a 20 byte address and bumps the creator's nonce.
+func (cache *TxCache) CreateAccount(creator *vm.Account) *vm.Account {
+
+ // Generate an address
+ nonce := creator.Nonce
+ creator.Nonce += 1
+
+ addr := LeftPadWord256(NewContractAddress(creator.Address.Postfix(20), nonce))
+
+ // Create account from address.
+ account, removed := vmUnpack(cache.accounts[addr])
+ if removed || account == nil {
+ account = &vm.Account{
+ Address: addr,
+ Balance: 0,
+ Code: nil,
+ Nonce: 0,
+ StorageRoot: Zero256,
+ }
+ cache.accounts[addr] = vmAccountInfo{account, false}
+ return account
+ } else {
+ panic(Fmt("Could not create account, address already exists: %X", addr))
+ }
+}
+
+// TxCache.account
+//-------------------------------------
+// TxCache.storage
+
+func (cache *TxCache) GetStorage(addr Word256, key Word256) Word256 {
+ // Check cache
+ value, ok := cache.storages[Tuple256{addr, key}]
+ if ok {
+ return value
+ }
+
+ // Load from backend
+ return cache.backend.GetStorage(addr, key)
+}
+
+// NOTE: Set value to zero to removed from the trie.
+func (cache *TxCache) SetStorage(addr Word256, key Word256, value Word256) {
+ _, removed := vmUnpack(cache.accounts[addr])
+ if removed {
+ panic("SetStorage() on a removed account")
+ }
+ cache.storages[Tuple256{addr, key}] = value
+}
+
+// TxCache.storage
+//-------------------------------------
+
+// These updates do not have to be in deterministic order,
+// the backend is responsible for ordering updates.
+func (cache *TxCache) Sync() {
+
+ // Remove or update storage
+ for addrKey, value := range cache.storages {
+ addr, key := Tuple256Split(addrKey)
+ cache.backend.SetStorage(addr, key, value)
+ }
+
+ // Remove or update accounts
+ for addr, accInfo := range cache.accounts {
+ acc, removed := vmUnpack(accInfo)
+ if removed {
+ cache.backend.RemoveAccount(addr.Postfix(20))
+ } else {
+ cache.backend.UpdateAccount(toStateAccount(acc))
+ }
+ }
+
+ // TODO support logs, add them to the cache somehow.
+}
+
+func (cache *TxCache) AddLog(log *vm.Log) {
+ cache.logs = append(cache.logs, log)
+}
+
+//-----------------------------------------------------------------------------
+
+// Convenience function to return address of new contract
+func NewContractAddress(caller []byte, nonce uint64) []byte {
+ temp := make([]byte, 32+8)
+ copy(temp, caller)
+ PutUint64BE(temp[32:], nonce)
+ return sha3.Sha3(temp)[:20]
+}
+
+// Converts backend.Account to vm.Account struct.
+func toVMAccount(acc *ac.Account) *vm.Account {
+ return &vm.Account{
+ Address: LeftPadWord256(acc.Address),
+ Balance: acc.Balance,
+ Code: acc.Code, // This is crazy.
+ Nonce: uint64(acc.Sequence),
+ StorageRoot: LeftPadWord256(acc.StorageRoot),
+ Other: acc.PubKey,
+ }
+}
+
+// Converts vm.Account to backend.Account struct.
+func toStateAccount(acc *vm.Account) *ac.Account {
+ pubKey, ok := acc.Other.(ac.PubKey)
+ if !ok {
+ pubKey = nil
+ }
+ var storageRoot []byte
+ if acc.StorageRoot.IsZero() {
+ storageRoot = nil
+ } else {
+ storageRoot = acc.StorageRoot.Bytes()
+ }
+ return &ac.Account{
+ Address: acc.Address.Postfix(20),
+ PubKey: pubKey,
+ Balance: acc.Balance,
+ Code: acc.Code,
+ Sequence: uint(acc.Nonce),
+ StorageRoot: storageRoot,
+ }
+}
+
+type vmAccountInfo struct {
+ account *vm.Account
+ removed bool
+}
+
+func vmUnpack(accInfo vmAccountInfo) (*vm.Account, bool) {
+ return accInfo.account, accInfo.removed
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/state/validator.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/validator.go
new file mode 100644
index 0000000000000000000000000000000000000000..4db4e90e079ae68c1215163bdf6683d22a400f59
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/validator.go
@@ -0,0 +1,115 @@
+package state
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+// Persistent (mostly) static data for each Validator
+type ValidatorInfo struct {
+ Address []byte `json:"address"`
+ PubKey account.PubKeyEd25519 `json:"pub_key"`
+ UnbondTo []*types.TxOutput `json:"unbond_to"`
+ FirstBondHeight uint `json:"first_bond_height"`
+ FirstBondAmount uint64 `json:"first_bond_amount"`
+ DestroyedHeight uint `json:"destroyed_height"` // If destroyed
+ DestroyedAmount uint64 `json:"destroyed_amount"` // If destroyed
+ ReleasedHeight uint `json:"released_height"` // If released
+}
+
+func (valInfo *ValidatorInfo) Copy() *ValidatorInfo {
+ valInfoCopy := *valInfo
+ return &valInfoCopy
+}
+
+func ValidatorInfoEncoder(o interface{}, w io.Writer, n *int64, err *error) {
+ binary.WriteBinary(o.(*ValidatorInfo), w, n, err)
+}
+
+func ValidatorInfoDecoder(r io.Reader, n *int64, err *error) interface{} {
+ return binary.ReadBinary(&ValidatorInfo{}, r, n, err)
+}
+
+var ValidatorInfoCodec = binary.Codec{
+ Encode: ValidatorInfoEncoder,
+ Decode: ValidatorInfoDecoder,
+}
+
+//-----------------------------------------------------------------------------
+
+// Volatile state for each Validator
+// Also persisted with the state, but fields change
+// every height|round so they don't go in merkle.Tree
+type Validator struct {
+ Address []byte `json:"address"`
+ PubKey account.PubKeyEd25519 `json:"pub_key"`
+ BondHeight uint `json:"bond_height"`
+ UnbondHeight uint `json:"unbond_height"`
+ LastCommitHeight uint `json:"last_commit_height"`
+ VotingPower uint64 `json:"voting_power"`
+ Accum int64 `json:"accum"`
+}
+
+// Creates a new copy of the validator so we can mutate accum.
+func (v *Validator) Copy() *Validator {
+ vCopy := *v
+ return &vCopy
+}
+
+// Returns the one with higher Accum.
+func (v *Validator) CompareAccum(other *Validator) *Validator {
+ if v == nil {
+ return other
+ }
+ if v.Accum > other.Accum {
+ return v
+ } else if v.Accum < other.Accum {
+ return other
+ } else {
+ if bytes.Compare(v.Address, other.Address) < 0 {
+ return v
+ } else if bytes.Compare(v.Address, other.Address) > 0 {
+ return other
+ } else {
+ panic("Cannot compare identical validators")
+ }
+ }
+}
+
+func (v *Validator) String() string {
+ return fmt.Sprintf("Validator{%X %v %v-%v-%v VP:%v A:%v}",
+ v.Address,
+ v.PubKey,
+ v.BondHeight,
+ v.LastCommitHeight,
+ v.UnbondHeight,
+ v.VotingPower,
+ v.Accum)
+}
+
+func (v *Validator) Hash() []byte {
+ return binary.BinarySha256(v)
+}
+
+//-------------------------------------
+
+var ValidatorCodec = validatorCodec{}
+
+type validatorCodec struct{}
+
+func (vc validatorCodec) Encode(o interface{}, w io.Writer, n *int64, err *error) {
+ binary.WriteBinary(o.(*Validator), w, n, err)
+}
+
+func (vc validatorCodec) Decode(r io.Reader, n *int64, err *error) interface{} {
+ return binary.ReadBinary(&Validator{}, r, n, err)
+}
+
+func (vc validatorCodec) Compare(o1 interface{}, o2 interface{}) int {
+ panic("ValidatorCodec.Compare not implemented")
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/state/validator_set.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/validator_set.go
new file mode 100644
index 0000000000000000000000000000000000000000..7b235c2f5c0dde9c386f54090a7d4548807cd239
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/validator_set.go
@@ -0,0 +1,296 @@
+package state
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "sort"
+ "strings"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+// ValidatorSet represent a set of *Validator at a given height.
+// The validators can be fetched by address or index.
+// The index is in order of .Address, so the indices are fixed
+// for all rounds of a given blockchain height.
+// On the other hand, the .AccumPower of each validator and
+// the designated .Proposer() of a set changes every round,
+// upon calling .IncrementAccum().
+// NOTE: Not goroutine-safe.
+// NOTE: All get/set to validators should copy the value for safety.
+// TODO: consider validator Accum overflow
+// TODO: replace validators []*Validator with github.com/jaekwon/go-ibbs?
+type ValidatorSet struct {
+ Validators []*Validator // NOTE: persisted via reflect, must be exported.
+
+ // cached (unexported)
+ proposer *Validator
+ totalVotingPower uint64
+}
+
+func NewValidatorSet(vals []*Validator) *ValidatorSet {
+ validators := make([]*Validator, len(vals))
+ for i, val := range vals {
+ validators[i] = val.Copy()
+ }
+ sort.Sort(ValidatorsByAddress(validators))
+ return &ValidatorSet{
+ Validators: validators,
+ }
+}
+
+// TODO: mind the overflow when times and votingPower shares too large.
+func (valSet *ValidatorSet) IncrementAccum(times uint) {
+ // Add VotingPower * times to each validator and order into heap.
+ validatorsHeap := NewHeap()
+ for _, val := range valSet.Validators {
+ val.Accum += int64(val.VotingPower) * int64(times) // TODO: mind overflow
+ validatorsHeap.Push(val, accumComparable(val.Accum))
+ }
+
+ // Decrement the validator with most accum, times times.
+ for i := uint(0); i < times; i++ {
+ mostest := validatorsHeap.Peek().(*Validator)
+ if i == times-1 {
+ valSet.proposer = mostest
+ }
+ mostest.Accum -= int64(valSet.TotalVotingPower())
+ validatorsHeap.Update(mostest, accumComparable(mostest.Accum))
+ }
+}
+
+func (valSet *ValidatorSet) Copy() *ValidatorSet {
+ validators := make([]*Validator, len(valSet.Validators))
+ for i, val := range valSet.Validators {
+ // NOTE: must copy, since IncrementAccum updates in place.
+ validators[i] = val.Copy()
+ }
+ return &ValidatorSet{
+ Validators: validators,
+ proposer: valSet.proposer,
+ totalVotingPower: valSet.totalVotingPower,
+ }
+}
+
+func (valSet *ValidatorSet) HasAddress(address []byte) bool {
+ idx := sort.Search(len(valSet.Validators), func(i int) bool {
+ return bytes.Compare(address, valSet.Validators[i].Address) <= 0
+ })
+ return idx != len(valSet.Validators) && bytes.Compare(valSet.Validators[idx].Address, address) == 0
+}
+
+func (valSet *ValidatorSet) GetByAddress(address []byte) (index uint, val *Validator) {
+ idx := sort.Search(len(valSet.Validators), func(i int) bool {
+ return bytes.Compare(address, valSet.Validators[i].Address) <= 0
+ })
+ if idx != len(valSet.Validators) && bytes.Compare(valSet.Validators[idx].Address, address) == 0 {
+ return uint(idx), valSet.Validators[idx].Copy()
+ } else {
+ return 0, nil
+ }
+}
+
+func (valSet *ValidatorSet) GetByIndex(index uint) (address []byte, val *Validator) {
+ val = valSet.Validators[index]
+ return val.Address, val.Copy()
+}
+
+func (valSet *ValidatorSet) Size() uint {
+ return uint(len(valSet.Validators))
+}
+
+func (valSet *ValidatorSet) TotalVotingPower() uint64 {
+ if valSet.totalVotingPower == 0 {
+ for _, val := range valSet.Validators {
+ valSet.totalVotingPower += val.VotingPower
+ }
+ }
+ return valSet.totalVotingPower
+}
+
+func (valSet *ValidatorSet) Proposer() (proposer *Validator) {
+ if valSet.proposer == nil {
+ for _, val := range valSet.Validators {
+ valSet.proposer = valSet.proposer.CompareAccum(val)
+ }
+ }
+ return valSet.proposer.Copy()
+}
+
+func (valSet *ValidatorSet) Hash() []byte {
+ if len(valSet.Validators) == 0 {
+ return nil
+ }
+ hashables := make([]merkle.Hashable, len(valSet.Validators))
+ for i, val := range valSet.Validators {
+ hashables[i] = val
+ }
+ return merkle.HashFromHashables(hashables)
+}
+
+func (valSet *ValidatorSet) Add(val *Validator) (added bool) {
+ val = val.Copy()
+ idx := sort.Search(len(valSet.Validators), func(i int) bool {
+ return bytes.Compare(val.Address, valSet.Validators[i].Address) <= 0
+ })
+ if idx == len(valSet.Validators) {
+ valSet.Validators = append(valSet.Validators, val)
+ // Invalidate cache
+ valSet.proposer = nil
+ valSet.totalVotingPower = 0
+ return true
+ } else if bytes.Compare(valSet.Validators[idx].Address, val.Address) == 0 {
+ return false
+ } else {
+ newValidators := make([]*Validator, len(valSet.Validators)+1)
+ copy(newValidators[:idx], valSet.Validators[:idx])
+ newValidators[idx] = val
+ copy(newValidators[idx+1:], valSet.Validators[idx:])
+ valSet.Validators = newValidators
+ // Invalidate cache
+ valSet.proposer = nil
+ valSet.totalVotingPower = 0
+ return true
+ }
+}
+
+func (valSet *ValidatorSet) Update(val *Validator) (updated bool) {
+ index, sameVal := valSet.GetByAddress(val.Address)
+ if sameVal == nil {
+ return false
+ } else {
+ valSet.Validators[index] = val.Copy()
+ // Invalidate cache
+ valSet.proposer = nil
+ valSet.totalVotingPower = 0
+ return true
+ }
+}
+
+func (valSet *ValidatorSet) Remove(address []byte) (val *Validator, removed bool) {
+ idx := sort.Search(len(valSet.Validators), func(i int) bool {
+ return bytes.Compare(address, valSet.Validators[i].Address) <= 0
+ })
+ if idx == len(valSet.Validators) || bytes.Compare(valSet.Validators[idx].Address, address) != 0 {
+ return nil, false
+ } else {
+ removedVal := valSet.Validators[idx]
+ newValidators := valSet.Validators[:idx]
+ if idx+1 < len(valSet.Validators) {
+ newValidators = append(newValidators, valSet.Validators[idx+1:]...)
+ }
+ valSet.Validators = newValidators
+ // Invalidate cache
+ valSet.proposer = nil
+ valSet.totalVotingPower = 0
+ return removedVal, true
+ }
+}
+
+func (valSet *ValidatorSet) Iterate(fn func(index uint, val *Validator) bool) {
+ for i, val := range valSet.Validators {
+ stop := fn(uint(i), val.Copy())
+ if stop {
+ break
+ }
+ }
+}
+
+// Verify that +2/3 of the set had signed the given signBytes
+func (valSet *ValidatorSet) VerifyValidation(chainID string, hash []byte, parts types.PartSetHeader, height uint, v *types.Validation) error {
+ if valSet.Size() != uint(len(v.Commits)) {
+ return errors.New(Fmt("Invalid validation -- wrong set size: %v vs %v",
+ valSet.Size(), len(v.Commits)))
+ }
+
+ talliedVotingPower := uint64(0)
+ seenValidators := map[string]struct{}{}
+
+ for idx, commit := range v.Commits {
+ // may be zero, in which case skip.
+ if commit.Signature.IsZero() {
+ continue
+ }
+ _, val := valSet.GetByIndex(uint(idx))
+ commitSignBytes := account.SignBytes(chainID, &types.Vote{
+ Height: height, Round: commit.Round, Type: types.VoteTypeCommit,
+ BlockHash: hash,
+ BlockParts: parts,
+ })
+
+ // Validate
+ if _, seen := seenValidators[string(val.Address)]; seen {
+ return fmt.Errorf("Duplicate validator for commit %v for Validation %v", commit, v)
+ }
+
+ if !val.PubKey.VerifyBytes(commitSignBytes, commit.Signature) {
+ return fmt.Errorf("Invalid signature for commit %v for Validation %v", commit, v)
+ }
+
+ // Tally
+ seenValidators[string(val.Address)] = struct{}{}
+ talliedVotingPower += val.VotingPower
+ }
+
+ if talliedVotingPower > valSet.TotalVotingPower()*2/3 {
+ return nil
+ } else {
+ return fmt.Errorf("insufficient voting power %v, needed %v",
+ talliedVotingPower, (valSet.TotalVotingPower()*2/3 + 1))
+ }
+}
+
+func (valSet *ValidatorSet) String() string {
+ return valSet.StringIndented("")
+}
+
+func (valSet *ValidatorSet) StringIndented(indent string) string {
+ valStrings := []string{}
+ valSet.Iterate(func(index uint, val *Validator) bool {
+ valStrings = append(valStrings, val.String())
+ return false
+ })
+ return fmt.Sprintf(`ValidatorSet{
+%s Proposer: %v
+%s Validators:
+%s %v
+%s}`,
+ indent, valSet.Proposer().String(),
+ indent,
+ indent, strings.Join(valStrings, "\n"+indent+" "),
+ indent)
+
+}
+
+//-------------------------------------
+// Implements sort for sorting validators by address.
+
+type ValidatorsByAddress []*Validator
+
+func (vs ValidatorsByAddress) Len() int {
+ return len(vs)
+}
+
+func (vs ValidatorsByAddress) Less(i, j int) bool {
+ return bytes.Compare(vs[i].Address, vs[j].Address) == -1
+}
+
+func (vs ValidatorsByAddress) Swap(i, j int) {
+ it := vs[i]
+ vs[i] = vs[j]
+ vs[j] = it
+}
+
+//-------------------------------------
+// Use with Heap for sorting validators by accum
+
+type accumComparable uint64
+
+// We want to find the validator with the greatest accum.
+func (ac accumComparable) Less(o interface{}) bool {
+ return uint64(ac) < uint64(o.(accumComparable))
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/state/validator_set_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/validator_set_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..83c310ffc2c6138339045ef2a42b95a01a1c5a2b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/state/validator_set_test.go
@@ -0,0 +1,72 @@
+package state
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+
+ "bytes"
+ "fmt"
+ "testing"
+)
+
+func randValidator_() *Validator {
+ return &Validator{
+ Address: RandBytes(20),
+ PubKey: account.PubKeyEd25519(RandBytes(64)),
+ BondHeight: uint(RandUint32()),
+ VotingPower: RandUint64(),
+ Accum: int64(RandUint64()),
+ }
+}
+
+func randValidatorSet(numValidators int) *ValidatorSet {
+ validators := make([]*Validator, numValidators)
+ for i := 0; i < numValidators; i++ {
+ validators[i] = randValidator_()
+ }
+ return NewValidatorSet(validators)
+}
+
+func TestCopy(t *testing.T) {
+ vset := randValidatorSet(10)
+ vsetHash := vset.Hash()
+ if len(vsetHash) == 0 {
+ t.Fatalf("ValidatorSet had unexpected zero hash")
+ }
+
+ vsetCopy := vset.Copy()
+ vsetCopyHash := vsetCopy.Hash()
+
+ if !bytes.Equal(vsetHash, vsetCopyHash) {
+ t.Fatalf("ValidatorSet copy had wrong hash. Orig: %X, Copy: %X", vsetHash, vsetCopyHash)
+ }
+}
+
+func TestProposerSelection(t *testing.T) {
+ vset := randValidatorSet(10)
+ for i := 0; i < 100; i++ {
+ val := vset.Proposer()
+ fmt.Printf("Proposer: %v\n", val)
+ vset.IncrementAccum(1)
+ }
+}
+
+func BenchmarkValidatorSetCopy(b *testing.B) {
+ b.StopTimer()
+ vset := NewValidatorSet([]*Validator{})
+ for i := 0; i < 1000; i++ {
+ privAccount := account.GenPrivAccount()
+ val := &Validator{
+ Address: privAccount.Address,
+ PubKey: privAccount.PubKey.(account.PubKeyEd25519),
+ }
+ if !vset.Add(val) {
+ panic("Failed to add validator")
+ }
+ }
+ b.StartTimer()
+
+ for i := 0; i < b.N; i++ {
+ vset.Copy()
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/types/README.md b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..f99294b007dd8ac4b3a453f0256d9c0aeb43d247
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/README.md
@@ -0,0 +1,61 @@
+# `tendermint/block`
+
+## Block
+
+TODO: document
+
+### Header
+
+### Validation
+
+### Data
+
+## PartSet
+
+PartSet is used to split a byteslice of data into parts (pieces) for transmission.
+By splitting data into smaller parts and computing a Merkle root hash on the list,
+you can verify that a part is legitimately part of the complete data, and the
+part can be forwarded to other peers before all the parts are known. In short,
+it's a fast way to propagate a large file over a gossip network.
+
+PartSet was inspired by the LibSwift project.
+
+Usage:
+
+```Go
+data := RandBytes(2 << 20) // Something large
+
+partSet := NewPartSetFromData(data)
+partSet.Total() // Total number of 4KB parts
+partSet.Count() // Equal to the Total, since we already have all the parts
+partSet.Hash() // The Merkle root hash
+partSet.BitArray() // A BitArray of partSet.Total() 1's
+
+header := partSet.Header() // Send this to the peer
+header.Total // Total number of parts
+header.Hash // The merkle root hash
+
+// Now we'll reconstruct the data from the parts
+partSet2 := NewPartSetFromHeader(header)
+partSet2.Total() // Same total as partSet.Total()
+partSet2.Count() // Zero, since this PartSet doesn't have any parts yet.
+partSet2.Hash() // Same hash as in partSet.Hash()
+partSet2.BitArray() // A BitArray of partSet.Total() 0's
+
+// In a gossip network the parts would arrive in arbitrary order, perhaps
+// in response to explicit requests for parts, or optimistically in response
+// to the receiving peer's partSet.BitArray().
+for !partSet2.IsComplete() {
+ part := receivePartFromGossipNetwork()
+ added, err := partSet2.AddPart(part)
+ if err != nil {
+ // A wrong part,
+ // the merkle trail does not hash to partSet2.Hash()
+ } else if !added {
+ // A duplicate part already received
+ }
+}
+
+data2, _ := ioutil.ReadAll(partSet2.GetReader())
+bytes.Equal(data, data2) // true
+```
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/types/block.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/block.go
new file mode 100644
index 0000000000000000000000000000000000000000..790158691e91e003afa11fc065ccb28b76a0fd99
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/block.go
@@ -0,0 +1,299 @@
+package types
+
+import (
+ "bytes"
+ "crypto/sha256"
+ "errors"
+ "fmt"
+ "strings"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle"
+)
+
+type Block struct {
+ *Header `json:"header"`
+ *Validation `json:"validation"`
+ *Data `json:"data"`
+}
+
+// Basic validation that doesn't involve state data.
+func (b *Block) ValidateBasic(chainID string, lastBlockHeight uint, lastBlockHash []byte,
+ lastBlockParts PartSetHeader, lastBlockTime time.Time) error {
+ if b.ChainID != chainID {
+ return errors.New("Wrong Block.Header.ChainID")
+ }
+ if b.Height != lastBlockHeight+1 {
+ return errors.New("Wrong Block.Header.Height")
+ }
+ if b.NumTxs != uint(len(b.Data.Txs)) {
+ return errors.New("Wrong Block.Header.NumTxs")
+ }
+ if !bytes.Equal(b.LastBlockHash, lastBlockHash) {
+ return errors.New("Wrong Block.Header.LastBlockHash")
+ }
+ if !b.LastBlockParts.Equals(lastBlockParts) {
+ return errors.New("Wrong Block.Header.LastBlockParts")
+ }
+ /* TODO: Determine bounds
+ See blockchain/reactor "stopSyncingDurationMinutes"
+
+ if !b.Time.After(lastBlockTime) {
+ return errors.New("Invalid Block.Header.Time")
+ }
+ */
+ if b.Header.Height != 1 {
+ if err := b.Validation.ValidateBasic(); err != nil {
+ return err
+ }
+ }
+ // XXX more validation
+ return nil
+}
+
+// Computes and returns the block hash.
+// If the block is incomplete (e.g. missing Header.StateHash)
+// then the hash is nil, to prevent the usage of that hash.
+func (b *Block) Hash() []byte {
+ if b.Header == nil || b.Validation == nil || b.Data == nil {
+ return nil
+ }
+ hashHeader := b.Header.Hash()
+ hashValidation := b.Validation.Hash()
+ hashData := b.Data.Hash()
+
+ // If hashHeader is nil, required fields are missing.
+ if len(hashHeader) == 0 {
+ return nil
+ }
+
+ // Merkle hash from subhashes.
+ hashes := [][]byte{hashHeader, hashValidation, hashData}
+ return merkle.HashFromHashes(hashes)
+}
+
+func (b *Block) MakePartSet() *PartSet {
+ return NewPartSetFromData(binary.BinaryBytes(b))
+}
+
+// Convenience.
+// A nil block never hashes to anything.
+// Nothing hashes to a nil hash.
+func (b *Block) HashesTo(hash []byte) bool {
+ if len(hash) == 0 {
+ return false
+ }
+ if b == nil {
+ return false
+ }
+ return bytes.Equal(b.Hash(), hash)
+}
+
+func (b *Block) String() string {
+ return b.StringIndented("")
+}
+
+func (b *Block) StringIndented(indent string) string {
+ if b == nil {
+ return "nil-Block"
+ }
+ return fmt.Sprintf(`Block{
+%s %v
+%s %v
+%s %v
+%s}#%X`,
+ indent, b.Header.StringIndented(indent+" "),
+ indent, b.Validation.StringIndented(indent+" "),
+ indent, b.Data.StringIndented(indent+" "),
+ indent, b.Hash())
+}
+
+func (b *Block) StringShort() string {
+ if b == nil {
+ return "nil-Block"
+ } else {
+ return fmt.Sprintf("Block#%X", b.Hash())
+ }
+}
+
+//-----------------------------------------------------------------------------
+
+type Header struct {
+ ChainID string `json:"chain_id"`
+ Height uint `json:"height"`
+ Time time.Time `json:"time"`
+ Fees uint64 `json:"fees"`
+ NumTxs uint `json:"num_txs"`
+ LastBlockHash []byte `json:"last_block_hash"`
+ LastBlockParts PartSetHeader `json:"last_block_parts"`
+ StateHash []byte `json:"state_hash"`
+}
+
+// NOTE: hash is nil if required fields are missing.
+func (h *Header) Hash() []byte {
+ if len(h.StateHash) == 0 {
+ return nil
+ }
+
+ buf := new(bytes.Buffer)
+ hasher, n, err := sha256.New(), new(int64), new(error)
+ binary.WriteBinary(h, buf, n, err)
+ if *err != nil {
+ panic(err)
+ }
+ hasher.Write(buf.Bytes())
+ hash := hasher.Sum(nil)
+ return hash
+}
+
+func (h *Header) StringIndented(indent string) string {
+ if h == nil {
+ return "nil-Header"
+ }
+ return fmt.Sprintf(`Header{
+%s ChainID: %v
+%s Height: %v
+%s Time: %v
+%s Fees: %v
+%s NumTxs: %v
+%s LastBlockHash: %X
+%s LastBlockParts: %v
+%s StateHash: %X
+%s}#%X`,
+ indent, h.ChainID,
+ indent, h.Height,
+ indent, h.Time,
+ indent, h.Fees,
+ indent, h.NumTxs,
+ indent, h.LastBlockHash,
+ indent, h.LastBlockParts,
+ indent, h.StateHash,
+ indent, h.Hash())
+}
+
+//-----------------------------------------------------------------------------
+
+type Commit struct {
+ Address []byte `json:"address"`
+ Round uint `json:"round"`
+ Signature account.SignatureEd25519 `json:"signature"`
+}
+
+func (commit Commit) IsZero() bool {
+ return commit.Round == 0 && commit.Signature.IsZero()
+}
+
+func (commit Commit) String() string {
+ return fmt.Sprintf("Commit{A:%X R:%v %X}", commit.Address, commit.Round, Fingerprint(commit.Signature))
+}
+
+//-------------------------------------
+
+// NOTE: The Commits are in order of address to preserve the bonded ValidatorSet order.
+// Any peer with a block can gossip commits by index with a peer without recalculating the
+// active ValidatorSet.
+type Validation struct {
+ Commits []Commit `json:"commits"` // Commits (or nil) of all active validators in address order.
+
+ // Volatile
+ hash []byte
+ bitArray *BitArray
+}
+
+func (v *Validation) ValidateBasic() error {
+ if len(v.Commits) == 0 {
+ return errors.New("No commits in validation")
+ }
+ lastAddress := []byte{}
+ for i := 0; i < len(v.Commits); i++ {
+ commit := v.Commits[i]
+ if commit.IsZero() {
+ if len(commit.Address) > 0 {
+ return errors.New("Zero commits should not have an address")
+ }
+ } else {
+ if len(commit.Address) == 0 {
+ return errors.New("Nonzero commits should have an address")
+ }
+ if len(lastAddress) > 0 && bytes.Compare(lastAddress, commit.Address) != -1 {
+ return errors.New("Invalid commit order")
+ }
+ lastAddress = commit.Address
+ }
+ }
+ return nil
+}
+
+func (v *Validation) Hash() []byte {
+ if v.hash == nil {
+ bs := make([]interface{}, len(v.Commits))
+ for i, commit := range v.Commits {
+ bs[i] = commit
+ }
+ v.hash = merkle.HashFromBinaries(bs)
+ }
+ return v.hash
+}
+
+func (v *Validation) StringIndented(indent string) string {
+ if v == nil {
+ return "nil-Validation"
+ }
+ commitStrings := make([]string, len(v.Commits))
+ for i, commit := range v.Commits {
+ commitStrings[i] = commit.String()
+ }
+ return fmt.Sprintf(`Validation{
+%s %v
+%s}#%X`,
+ indent, strings.Join(commitStrings, "\n"+indent+" "),
+ indent, v.hash)
+}
+
+func (v *Validation) BitArray() *BitArray {
+ if v.bitArray == nil {
+ v.bitArray = NewBitArray(uint(len(v.Commits)))
+ for i, commit := range v.Commits {
+ v.bitArray.SetIndex(uint(i), !commit.IsZero())
+ }
+ }
+ return v.bitArray
+}
+
+//-----------------------------------------------------------------------------
+
+type Data struct {
+ Txs []Tx `json:"txs"`
+
+ // Volatile
+ hash []byte
+}
+
+func (data *Data) Hash() []byte {
+ if data.hash == nil {
+ bs := make([]interface{}, len(data.Txs))
+ for i, tx := range data.Txs {
+ bs[i] = account.SignBytes(config.GetString("chain_id"), tx)
+ }
+ data.hash = merkle.HashFromBinaries(bs)
+ }
+ return data.hash
+}
+
+func (data *Data) StringIndented(indent string) string {
+ if data == nil {
+ return "nil-Data"
+ }
+ txStrings := make([]string, len(data.Txs))
+ for i, tx := range data.Txs {
+ txStrings[i] = fmt.Sprintf("Tx:%v", tx)
+ }
+ return fmt.Sprintf(`Data{
+%s %v
+%s}#%X`,
+ indent, strings.Join(txStrings, "\n"+indent+" "),
+ indent, data.hash)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/types/block_meta.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/block_meta.go
new file mode 100644
index 0000000000000000000000000000000000000000..540da8d1926ef729d9f5c351fece9979ed124c2d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/block_meta.go
@@ -0,0 +1,15 @@
+package types
+
+type BlockMeta struct {
+ Hash []byte `json:"hash"` // The block hash
+ Header *Header `json:"header"` // The block's Header
+ Parts PartSetHeader `json:"parts"` // The PartSetHeader, for transfer
+}
+
+func NewBlockMeta(block *Block, blockParts *PartSet) *BlockMeta {
+ return &BlockMeta{
+ Hash: block.Hash(),
+ Header: block.Header,
+ Parts: blockParts.Header(),
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/types/config.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..14a0192943111918cc56f8a9ddfc07d77117ef98
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/config.go
@@ -0,0 +1,13 @@
+package types
+
+import (
+ cfg "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config"
+)
+
+var config cfg.Config = nil
+
+func init() {
+ cfg.OnConfig(func(newConfig cfg.Config) {
+ config = newConfig
+ })
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/types/events.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/events.go
new file mode 100644
index 0000000000000000000000000000000000000000..e51d9e283fc7c3adea35ea994228044334d71f9d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/events.go
@@ -0,0 +1,84 @@
+package types
+
+import (
+ "fmt"
+)
+
+// Functions to generate eventId strings
+
+func EventStringAccInput(addr []byte) string {
+ return fmt.Sprintf("Acc/%X/Input", addr)
+}
+
+func EventStringAccOutput(addr []byte) string {
+ return fmt.Sprintf("Acc/%X/Output", addr)
+}
+
+func EventStringAccReceive(addr []byte) string {
+ return fmt.Sprintf("Acc/%X/Receive", addr)
+}
+
+func EventStringBond() string {
+ return "Bond"
+}
+
+func EventStringUnbond() string {
+ return "Unbond"
+}
+
+func EventStringRebond() string {
+ return "Rebond"
+}
+
+func EventStringDupeout() string {
+ return "Dupeout"
+}
+
+func EventStringNewBlock() string {
+ return "NewBlock"
+}
+
+func EventStringFork() string {
+ return "Fork"
+}
+
+// Most event messages are basic types (a block, a transaction)
+// but some (an input to a call tx or a receive) are more exotic:
+
+type EventMsgCallTx struct {
+ Tx Tx `json:"tx"`
+ Return []byte `json:"return"`
+ Exception string `json:"exception"`
+}
+
+type CallData struct {
+ Caller []byte `json:"caller"`
+ Callee []byte `json:"callee"`
+ Data []byte `json:"data"`
+ Value uint64 `json:"value"`
+ Gas uint64 `json:"gas"`
+}
+
+type EventMsgCall struct {
+ CallData *CallData `json:"call_data"`
+ Origin []byte `json:"origin"`
+ TxId []byte `json:"tx_id"`
+ Return []byte `json:"return"`
+ Exception string `json:"exception"`
+}
+
+/*
+Acc/XYZ/Input -> full tx or {full tx, return value, exception}
+Acc/XYZ/Output -> full tx
+Acc/XYZ/Receive -> full tx, return value, exception, (optionally?) calldata
+Bond -> full tx
+Unbond -> full tx
+Rebond -> full tx
+Dupeout -> full tx
+NewBlock -> full block
+Fork -> block A, block B
+
+Log -> Fuck this
+NewPeer -> peer
+Alert -> alert msg
+*/
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/types/log.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..19855efc303c5f7c40cb0d67ee8c6ea57ac18fef
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/log.go
@@ -0,0 +1,7 @@
+package types
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/logger"
+)
+
+var log = logger.New("module", "types")
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/types/names.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/names.go
new file mode 100644
index 0000000000000000000000000000000000000000..bebecb479163ce93254a34e807c575cfecf234c2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/names.go
@@ -0,0 +1,48 @@
+package types
+
+import (
+ "regexp"
+)
+
+var (
+ MinNameRegistrationPeriod uint64 = 5
+
+ // cost for storing a name for a block is
+ // CostPerBlock*CostPerByte*(len(data) + 32)
+ NameCostPerByte uint64 = 1
+ NameCostPerBlock uint64 = 1
+
+ MaxNameLength = 32
+ MaxDataLength = 1 << 16
+
+ // Name should be alphanum, underscore, slash
+ // Data should be anything permitted in JSON
+ regexpAlphaNum = regexp.MustCompile("^[a-zA-Z0-9._/]*$")
+ regexpJSON = regexp.MustCompile(`^[a-zA-Z0-9_/ \-"':,\n\t.{}()\[\]]*$`)
+)
+
+// filter strings
+func validateNameRegEntryName(name string) bool {
+ return regexpAlphaNum.Match([]byte(name))
+}
+
+func validateNameRegEntryData(data string) bool {
+ return regexpJSON.Match([]byte(data))
+}
+
+// base cost is "effective" number of bytes
+func BaseEntryCost(name, data string) uint64 {
+ return uint64(len(data) + 32)
+}
+
+type NameRegEntry struct {
+ Name string `json:"name"` // registered name for the entry
+ Owner []byte `json:"owner"` // address that created the entry
+ Data string `json:"data"` // data to store under this name
+ Expires uint64 `json:"expires"` // block at which this entry expires
+}
+
+func (entry *NameRegEntry) Copy() *NameRegEntry {
+ entryCopy := *entry
+ return &entryCopy
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/types/node.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/node.go
new file mode 100644
index 0000000000000000000000000000000000000000..8cb1255a011b34d0997f61d06e860ef6a6f70494
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/node.go
@@ -0,0 +1,56 @@
+package types
+
+import (
+ "fmt"
+ "strings"
+)
+
+type NodeInfo struct {
+ Moniker string `json:"moniker"`
+ ChainID string `json:"chain_id"`
+ Version string `json:"version"`
+
+ Host string `json:"host"`
+ P2PPort uint16 `json:"p2p_port"`
+ RPCPort uint16 `json:"rpc_port"`
+}
+
+func (ni *NodeInfo) CompatibleWith(no *NodeInfo) error {
+ iM, im, _, ie := splitVersion(ni.Version)
+ oM, om, _, oe := splitVersion(no.Version)
+
+ // if our own version number is not formatted right, we messed up
+ if ie != nil {
+ return ie
+ }
+
+ // version number must be formatted correctly ("x.x.x")
+ if oe != nil {
+ return oe
+ }
+
+ // major version must match
+ if iM != oM {
+ return fmt.Errorf("Peer is on a different major version. Got %v, expected %v", oM, iM)
+ }
+
+ // minor version must match
+ if im != om {
+ return fmt.Errorf("Peer is on a different minor version. Got %v, expected %v", om, im)
+ }
+
+ // nodes must be on the same chain_id
+ if ni.ChainID != no.ChainID {
+ return fmt.Errorf("Peer is on a different chain_id. Got %v, expected %v", no.ChainID, ni.ChainID)
+ }
+
+ return nil
+}
+
+func splitVersion(version string) (string, string, string, error) {
+ spl := strings.Split(version, ".")
+ if len(spl) != 3 {
+ return "", "", "", fmt.Errorf("Invalid version format %v", version)
+ }
+ return spl[0], spl[1], spl[2], nil
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/types/part_set.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/part_set.go
new file mode 100644
index 0000000000000000000000000000000000000000..6e9f72b2e5ab0801a4f1cbee0e1cf1f2fa130095
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/part_set.go
@@ -0,0 +1,252 @@
+package types
+
+import (
+ "bytes"
+ "crypto/sha256"
+ "errors"
+ "fmt"
+ "io"
+ "strings"
+ "sync"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/merkle"
+)
+
+const (
+ partSize = 4096 // 4KB
+)
+
+var (
+ ErrPartSetUnexpectedIndex = errors.New("Error part set unexpected index")
+ ErrPartSetInvalidTrail = errors.New("Error part set invalid trail")
+)
+
+type Part struct {
+ Index uint `json:"index"`
+ Trail [][]byte `json:"trail"`
+ Bytes []byte `json:"bytes"`
+
+ // Cache
+ hash []byte
+}
+
+func (part *Part) Hash() []byte {
+ if part.hash != nil {
+ return part.hash
+ } else {
+ hasher := sha256.New()
+ _, err := hasher.Write(part.Bytes)
+ if err != nil {
+ panic(err)
+ }
+ part.hash = hasher.Sum(nil)
+ return part.hash
+ }
+}
+
+func (part *Part) String() string {
+ return part.StringIndented("")
+}
+
+func (part *Part) StringIndented(indent string) string {
+ trailStrings := make([]string, len(part.Trail))
+ for i, hash := range part.Trail {
+ trailStrings[i] = fmt.Sprintf("%X", hash)
+ }
+ return fmt.Sprintf(`Part{
+%s Index: %v
+%s Trail:
+%s %v
+%s}`,
+ indent, part.Index,
+ indent,
+ indent, strings.Join(trailStrings, "\n"+indent+" "),
+ indent)
+}
+
+//-------------------------------------
+
+type PartSetHeader struct {
+ Total uint `json:"total"`
+ Hash []byte `json:"hash"`
+}
+
+func (psh PartSetHeader) String() string {
+ return fmt.Sprintf("PartSet{T:%v %X}", psh.Total, Fingerprint(psh.Hash))
+}
+
+func (psh PartSetHeader) IsZero() bool {
+ return psh.Total == 0
+}
+
+func (psh PartSetHeader) Equals(other PartSetHeader) bool {
+ return psh.Total == other.Total && bytes.Equal(psh.Hash, other.Hash)
+}
+
+func (psh PartSetHeader) WriteSignBytes(w io.Writer, n *int64, err *error) {
+ binary.WriteTo([]byte(Fmt(`{"hash":"%X","total":%v}`, psh.Hash, psh.Total)), w, n, err)
+}
+
+//-------------------------------------
+
+type PartSet struct {
+ total uint
+ hash []byte
+
+ mtx sync.Mutex
+ parts []*Part
+ partsBitArray *BitArray
+ count uint
+}
+
+// Returns an immutable, full PartSet from the data bytes.
+// The data bytes are split into "partSize" chunks, and merkle tree computed.
+func NewPartSetFromData(data []byte) *PartSet {
+ // divide data into 4kb parts.
+ total := (len(data) + partSize - 1) / partSize
+ parts := make([]*Part, total)
+ parts_ := make([]merkle.Hashable, total)
+ partsBitArray := NewBitArray(uint(total))
+ for i := 0; i < total; i++ {
+ part := &Part{
+ Index: uint(i),
+ Bytes: data[i*partSize : MinInt(len(data), (i+1)*partSize)],
+ }
+ parts[i] = part
+ parts_[i] = part
+ partsBitArray.SetIndex(uint(i), true)
+ }
+ // Compute merkle trails
+ trails, rootTrail := merkle.HashTrailsFromHashables(parts_)
+ for i := 0; i < total; i++ {
+ parts[i].Trail = trails[i].Flatten()
+ }
+ return &PartSet{
+ total: uint(total),
+ hash: rootTrail.Hash,
+ parts: parts,
+ partsBitArray: partsBitArray,
+ count: uint(total),
+ }
+}
+
+// Returns an empty PartSet ready to be populated.
+func NewPartSetFromHeader(header PartSetHeader) *PartSet {
+ return &PartSet{
+ total: header.Total,
+ hash: header.Hash,
+ parts: make([]*Part, header.Total),
+ partsBitArray: NewBitArray(uint(header.Total)),
+ count: 0,
+ }
+}
+
+func (ps *PartSet) Header() PartSetHeader {
+ if ps == nil {
+ return PartSetHeader{}
+ } else {
+ return PartSetHeader{
+ Total: ps.total,
+ Hash: ps.hash,
+ }
+ }
+}
+
+func (ps *PartSet) HasHeader(header PartSetHeader) bool {
+ if ps == nil {
+ return false
+ } else {
+ return ps.Header().Equals(header)
+ }
+}
+
+func (ps *PartSet) BitArray() *BitArray {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+ return ps.partsBitArray.Copy()
+}
+
+func (ps *PartSet) Hash() []byte {
+ if ps == nil {
+ return nil
+ }
+ return ps.hash
+}
+
+func (ps *PartSet) HashesTo(hash []byte) bool {
+ if ps == nil {
+ return false
+ }
+ return bytes.Equal(ps.hash, hash)
+}
+
+func (ps *PartSet) Count() uint {
+ if ps == nil {
+ return 0
+ }
+ return ps.count
+}
+
+func (ps *PartSet) Total() uint {
+ if ps == nil {
+ return 0
+ }
+ return ps.total
+}
+
+func (ps *PartSet) AddPart(part *Part) (bool, error) {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+
+ // Invalid part index
+ if part.Index >= ps.total {
+ return false, ErrPartSetUnexpectedIndex
+ }
+
+ // If part already exists, return false.
+ if ps.parts[part.Index] != nil {
+ return false, nil
+ }
+
+ // Check hash trail
+ if !merkle.VerifyHashTrail(uint(part.Index), uint(ps.total), part.Hash(), part.Trail, ps.hash) {
+ return false, ErrPartSetInvalidTrail
+ }
+
+ // Add part
+ ps.parts[part.Index] = part
+ ps.partsBitArray.SetIndex(uint(part.Index), true)
+ ps.count++
+ return true, nil
+}
+
+func (ps *PartSet) GetPart(index uint) *Part {
+ ps.mtx.Lock()
+ defer ps.mtx.Unlock()
+ return ps.parts[index]
+}
+
+func (ps *PartSet) IsComplete() bool {
+ return ps.count == ps.total
+}
+
+func (ps *PartSet) GetReader() io.Reader {
+ if !ps.IsComplete() {
+ panic("Cannot GetReader() on incomplete PartSet")
+ }
+ buf := []byte{}
+ for _, part := range ps.parts {
+ buf = append(buf, part.Bytes...)
+ }
+ return bytes.NewReader(buf)
+}
+
+func (ps *PartSet) StringShort() string {
+ if ps == nil {
+ return "nil-PartSet"
+ } else {
+ return fmt.Sprintf("(%v of %v)", ps.Count(), ps.Total())
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/types/part_set_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/part_set_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..5a65ace5c2bb1eab59b6aaae23cd69ccd37a18a1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/part_set_test.go
@@ -0,0 +1,86 @@
+package types
+
+import (
+ "bytes"
+ "io/ioutil"
+ "testing"
+
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+func TestBasicPartSet(t *testing.T) {
+
+ // Construct random data of size partSize * 100
+ data := RandBytes(partSize * 100)
+
+ partSet := NewPartSetFromData(data)
+ if len(partSet.Hash()) == 0 {
+ t.Error("Expected to get hash")
+ }
+ if partSet.Total() != 100 {
+ t.Errorf("Expected to get 100 parts, but got %v", partSet.Total())
+ }
+ if !partSet.IsComplete() {
+ t.Errorf("PartSet should be complete")
+ }
+
+ // Test adding parts to a new partSet.
+ partSet2 := NewPartSetFromHeader(partSet.Header())
+
+ for i := uint(0); i < partSet.Total(); i++ {
+ part := partSet.GetPart(i)
+ //t.Logf("\n%v", part)
+ added, err := partSet2.AddPart(part)
+ if !added || err != nil {
+ t.Errorf("Failed to add part %v, error: %v", i, err)
+ }
+ }
+
+ if !bytes.Equal(partSet.Hash(), partSet2.Hash()) {
+ t.Error("Expected to get same hash")
+ }
+ if partSet2.Total() != 100 {
+ t.Errorf("Expected to get 100 parts, but got %v", partSet2.Total())
+ }
+ if !partSet2.IsComplete() {
+ t.Errorf("Reconstructed PartSet should be complete")
+ }
+
+ // Reconstruct data, assert that they are equal.
+ data2Reader := partSet2.GetReader()
+ data2, err := ioutil.ReadAll(data2Reader)
+ if err != nil {
+ t.Errorf("Error reading data2Reader: %v", err)
+ }
+ if !bytes.Equal(data, data2) {
+ t.Errorf("Got wrong data.")
+ }
+
+}
+
+func TestWrongTrail(t *testing.T) {
+
+ // Construct random data of size partSize * 100
+ data := RandBytes(partSize * 100)
+ partSet := NewPartSetFromData(data)
+
+ // Test adding a part with wrong data.
+ partSet2 := NewPartSetFromHeader(partSet.Header())
+
+ // Test adding a part with wrong trail.
+ part := partSet.GetPart(0)
+ part.Trail[0][0] += byte(0x01)
+ added, err := partSet2.AddPart(part)
+ if added || err == nil {
+ t.Errorf("Expected to fail adding a part with bad trail.")
+ }
+
+ // Test adding a part with wrong bytes.
+ part = partSet.GetPart(1)
+ part.Bytes[0] += byte(0x01)
+ added, err = partSet2.AddPart(part)
+ if added || err == nil {
+ t.Errorf("Expected to fail adding a part with bad bytes.")
+ }
+
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/types/tx.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/tx.go
new file mode 100644
index 0000000000000000000000000000000000000000..c78cff3c0badde8d36971b432f4ea9e693c52043
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/tx.go
@@ -0,0 +1,331 @@
+package types
+
+import (
+ "encoding/json"
+ "errors"
+ "io"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+var (
+ ErrTxInvalidAddress = errors.New("Error invalid address")
+ ErrTxDuplicateAddress = errors.New("Error duplicate address")
+ ErrTxInvalidAmount = errors.New("Error invalid amount")
+ ErrTxInsufficientFunds = errors.New("Error insufficient funds")
+ ErrTxInsufficientGasPrice = errors.New("Error insufficient gas price")
+ ErrTxUnknownPubKey = errors.New("Error unknown pubkey")
+ ErrTxInvalidPubKey = errors.New("Error invalid pubkey")
+ ErrTxInvalidSignature = errors.New("Error invalid signature")
+ ErrTxInvalidString = errors.New("Error invalid string")
+ ErrIncorrectOwner = errors.New("Error incorrect owner")
+)
+
+type ErrTxInvalidSequence struct {
+ Got uint64
+ Expected uint64
+}
+
+func (e ErrTxInvalidSequence) Error() string {
+ return Fmt("Error invalid sequence. Got %d, expected %d", e.Got, e.Expected)
+}
+
+/*
+Tx (Transaction) is an atomic operation on the ledger state.
+
+Account Txs:
+ - SendTx Send coins to address
+ - CallTx Send a msg to a contract that runs in the vm
+ - NameTx Store some value under a name in the global namereg
+
+Validation Txs:
+ - BondTx New validator posts a bond
+ - UnbondTx Validator leaves
+ - DupeoutTx Validator dupes out (equivocates)
+*/
+type Tx interface {
+ WriteSignBytes(chainID string, w io.Writer, n *int64, err *error)
+}
+
+// Types of Tx implementations
+const (
+ // Account transactions
+ TxTypeSend = byte(0x01)
+ TxTypeCall = byte(0x02)
+ TxTypeName = byte(0x03)
+
+ // Validation transactions
+ TxTypeBond = byte(0x11)
+ TxTypeUnbond = byte(0x12)
+ TxTypeRebond = byte(0x13)
+ TxTypeDupeout = byte(0x14)
+)
+
+// for binary.readReflect
+var _ = binary.RegisterInterface(
+ struct{ Tx }{},
+ binary.ConcreteType{&SendTx{}, TxTypeSend},
+ binary.ConcreteType{&CallTx{}, TxTypeCall},
+ binary.ConcreteType{&NameTx{}, TxTypeName},
+ binary.ConcreteType{&BondTx{}, TxTypeBond},
+ binary.ConcreteType{&UnbondTx{}, TxTypeUnbond},
+ binary.ConcreteType{&RebondTx{}, TxTypeRebond},
+ binary.ConcreteType{&DupeoutTx{}, TxTypeDupeout},
+)
+
+//-----------------------------------------------------------------------------
+
+type TxInput struct {
+ Address []byte `json:"address"` // Hash of the PubKey
+ Amount uint64 `json:"amount"` // Must not exceed account balance
+ Sequence uint `json:"sequence"` // Must be 1 greater than the last committed TxInput
+ Signature account.Signature `json:"signature"` // Depends on the PubKey type and the whole Tx
+ PubKey account.PubKey `json:"pub_key"` // Must not be nil, may be nil
+}
+
+func (txIn *TxInput) ValidateBasic() error {
+ if len(txIn.Address) != 20 {
+ return ErrTxInvalidAddress
+ }
+ if txIn.Amount == 0 {
+ return ErrTxInvalidAmount
+ }
+ return nil
+}
+
+func (txIn *TxInput) WriteSignBytes(w io.Writer, n *int64, err *error) {
+ binary.WriteTo([]byte(Fmt(`{"address":"%X","amount":%v,"sequence":%v}`, txIn.Address, txIn.Amount, txIn.Sequence)), w, n, err)
+}
+
+func (txIn *TxInput) String() string {
+ return Fmt("TxInput{%X,%v,%v,%v,%v}", txIn.Address, txIn.Amount, txIn.Sequence, txIn.Signature, txIn.PubKey)
+}
+
+//-----------------------------------------------------------------------------
+
+type TxOutput struct {
+ Address []byte `json:"address"` // Hash of the PubKey
+ Amount uint64 `json:"amount"` // The sum of all outputs must not exceed the inputs.
+}
+
+func (txOut *TxOutput) ValidateBasic() error {
+ if len(txOut.Address) != 20 {
+ return ErrTxInvalidAddress
+ }
+ if txOut.Amount == 0 {
+ return ErrTxInvalidAmount
+ }
+ return nil
+}
+
+func (txOut *TxOutput) WriteSignBytes(w io.Writer, n *int64, err *error) {
+ binary.WriteTo([]byte(Fmt(`{"address":"%X","amount":%v}`, txOut.Address, txOut.Amount)), w, n, err)
+}
+
+func (txOut *TxOutput) String() string {
+ return Fmt("TxOutput{%X,%v}", txOut.Address, txOut.Amount)
+}
+
+//-----------------------------------------------------------------------------
+
+type SendTx struct {
+ Inputs []*TxInput `json:"inputs"`
+ Outputs []*TxOutput `json:"outputs"`
+}
+
+func (tx *SendTx) WriteSignBytes(chainID string, w io.Writer, n *int64, err *error) {
+ binary.WriteTo([]byte(Fmt(`{"chain_id":%s`, jsonEscape(chainID))), w, n, err)
+ binary.WriteTo([]byte(Fmt(`,"tx":[%v,{"inputs":[`, TxTypeSend)), w, n, err)
+ for i, in := range tx.Inputs {
+ in.WriteSignBytes(w, n, err)
+ if i != len(tx.Inputs)-1 {
+ binary.WriteTo([]byte(","), w, n, err)
+ }
+ }
+ binary.WriteTo([]byte(`],"outputs":[`), w, n, err)
+ for i, out := range tx.Outputs {
+ out.WriteSignBytes(w, n, err)
+ if i != len(tx.Outputs)-1 {
+ binary.WriteTo([]byte(","), w, n, err)
+ }
+ }
+ binary.WriteTo([]byte(`]}]}`), w, n, err)
+}
+
+func (tx *SendTx) String() string {
+ return Fmt("SendTx{%v -> %v}", tx.Inputs, tx.Outputs)
+}
+
+//-----------------------------------------------------------------------------
+
+type CallTx struct {
+ Input *TxInput `json:"input"`
+ Address []byte `json:"address"`
+ GasLimit uint64 `json:"gas_limit"`
+ Fee uint64 `json:"fee"`
+ Data []byte `json:"data"`
+}
+
+func (tx *CallTx) WriteSignBytes(chainID string, w io.Writer, n *int64, err *error) {
+ binary.WriteTo([]byte(Fmt(`{"chain_id":%s`, jsonEscape(chainID))), w, n, err)
+ binary.WriteTo([]byte(Fmt(`,"tx":[%v,{"address":"%X","data":"%X"`, TxTypeCall, tx.Address, tx.Data)), w, n, err)
+ binary.WriteTo([]byte(Fmt(`,"fee":%v,"gas_limit":%v,"input":`, tx.Fee, tx.GasLimit)), w, n, err)
+ tx.Input.WriteSignBytes(w, n, err)
+ binary.WriteTo([]byte(`}]}`), w, n, err)
+}
+
+func (tx *CallTx) String() string {
+ return Fmt("CallTx{%v -> %x: %x}", tx.Input, tx.Address, tx.Data)
+}
+
+//-----------------------------------------------------------------------------
+
+type NameTx struct {
+ Input *TxInput `json:"input"`
+ Name string `json:"name"`
+ Data string `json:"data"`
+ Fee uint64 `json:"fee"`
+}
+
+func (tx *NameTx) WriteSignBytes(chainID string, w io.Writer, n *int64, err *error) {
+ binary.WriteTo([]byte(Fmt(`{"chain_id":%s`, jsonEscape(chainID))), w, n, err)
+ binary.WriteTo([]byte(Fmt(`,"tx":[%v,{"data":%s,"fee":%v`, TxTypeName, jsonEscape(tx.Data), tx.Fee)), w, n, err)
+ binary.WriteTo([]byte(`,"input":`), w, n, err)
+ tx.Input.WriteSignBytes(w, n, err)
+ binary.WriteTo([]byte(Fmt(`,"name":%s`, jsonEscape(tx.Name))), w, n, err)
+ binary.WriteTo([]byte(`}]}`), w, n, err)
+}
+
+func (tx *NameTx) ValidateStrings() error {
+ if len(tx.Name) == 0 {
+ return errors.New("Name must not be empty")
+ }
+ if len(tx.Name) > MaxNameLength {
+ return errors.New(Fmt("Name is too long. Max %d bytes", MaxNameLength))
+ }
+ if len(tx.Data) > MaxDataLength {
+ return errors.New(Fmt("Data is too long. Max %d bytes", MaxDataLength))
+ }
+
+ if !validateNameRegEntryName(tx.Name) {
+ return errors.New(Fmt("Invalid characters found in NameTx.Name (%s). Only alphanumeric, underscores, and forward slashes allowed", tx.Name))
+ }
+
+ if !validateNameRegEntryData(tx.Data) {
+ return errors.New(Fmt("Invalid characters found in NameTx.Data (%s). Only the kind of things found in a JSON file are allowed", tx.Data))
+ }
+
+ return nil
+}
+
+func (tx *NameTx) BaseEntryCost() uint64 {
+ return BaseEntryCost(tx.Name, tx.Data)
+}
+
+func (tx *NameTx) String() string {
+ return Fmt("NameTx{%v -> %s: %s}", tx.Input, tx.Name, tx.Data)
+}
+
+//-----------------------------------------------------------------------------
+
+type BondTx struct {
+ PubKey account.PubKeyEd25519 `json:"pub_key"`
+ Signature account.SignatureEd25519 `json:"signature"`
+ Inputs []*TxInput `json:"inputs"`
+ UnbondTo []*TxOutput `json:"unbond_to"`
+}
+
+func (tx *BondTx) WriteSignBytes(chainID string, w io.Writer, n *int64, err *error) {
+ binary.WriteTo([]byte(Fmt(`{"chain_id":%s`, jsonEscape(chainID))), w, n, err)
+ binary.WriteTo([]byte(Fmt(`,"tx":[%v,{"inputs":[`, TxTypeBond)), w, n, err)
+ for i, in := range tx.Inputs {
+ in.WriteSignBytes(w, n, err)
+ if i != len(tx.Inputs)-1 {
+ binary.WriteTo([]byte(","), w, n, err)
+ }
+ }
+ binary.WriteTo([]byte(Fmt(`],"pub_key":`)), w, n, err)
+ binary.WriteTo(binary.JSONBytes(tx.PubKey), w, n, err)
+ binary.WriteTo([]byte(`,"unbond_to":[`), w, n, err)
+ for i, out := range tx.UnbondTo {
+ out.WriteSignBytes(w, n, err)
+ if i != len(tx.UnbondTo)-1 {
+ binary.WriteTo([]byte(","), w, n, err)
+ }
+ }
+ binary.WriteTo([]byte(`]}]}`), w, n, err)
+}
+
+func (tx *BondTx) String() string {
+ return Fmt("BondTx{%v: %v -> %v}", tx.PubKey, tx.Inputs, tx.UnbondTo)
+}
+
+//-----------------------------------------------------------------------------
+
+type UnbondTx struct {
+ Address []byte `json:"address"`
+ Height uint `json:"height"`
+ Signature account.SignatureEd25519 `json:"signature"`
+}
+
+func (tx *UnbondTx) WriteSignBytes(chainID string, w io.Writer, n *int64, err *error) {
+ binary.WriteTo([]byte(Fmt(`{"chain_id":%s`, jsonEscape(chainID))), w, n, err)
+ binary.WriteTo([]byte(Fmt(`,"tx":[%v,{"address":"%X","height":%v}]}`, TxTypeUnbond, tx.Address, tx.Height)), w, n, err)
+}
+
+func (tx *UnbondTx) String() string {
+ return Fmt("UnbondTx{%X,%v,%v}", tx.Address, tx.Height, tx.Signature)
+}
+
+//-----------------------------------------------------------------------------
+
+type RebondTx struct {
+ Address []byte `json:"address"`
+ Height uint `json:"height"`
+ Signature account.SignatureEd25519 `json:"signature"`
+}
+
+func (tx *RebondTx) WriteSignBytes(chainID string, w io.Writer, n *int64, err *error) {
+ binary.WriteTo([]byte(Fmt(`{"chain_id":%s`, jsonEscape(chainID))), w, n, err)
+ binary.WriteTo([]byte(Fmt(`,"tx":[%v,{"address":"%X","height":%v}]}`, TxTypeRebond, tx.Address, tx.Height)), w, n, err)
+}
+
+func (tx *RebondTx) String() string {
+ return Fmt("RebondTx{%X,%v,%v}", tx.Address, tx.Height, tx.Signature)
+}
+
+//-----------------------------------------------------------------------------
+
+type DupeoutTx struct {
+ Address []byte `json:"address"`
+ VoteA Vote `json:"vote_a"`
+ VoteB Vote `json:"vote_b"`
+}
+
+func (tx *DupeoutTx) WriteSignBytes(chainID string, w io.Writer, n *int64, err *error) {
+ panic("DupeoutTx has no sign bytes")
+}
+
+func (tx *DupeoutTx) String() string {
+ return Fmt("DupeoutTx{%X,%v,%v}", tx.Address, tx.VoteA, tx.VoteB)
+}
+
+//-----------------------------------------------------------------------------
+
+func TxId(chainID string, tx Tx) []byte {
+ signBytes := account.SignBytes(chainID, tx)
+ return binary.BinaryRipemd160(signBytes)
+}
+
+//--------------------------------------------------------------------------------
+
+// Contract: This function is deterministic and completely reversible.
+func jsonEscape(str string) string {
+ escapedBytes, err := json.Marshal(str)
+ if err != nil {
+ panic(Fmt("Error json-escaping a string", str))
+ }
+ return string(escapedBytes)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/types/tx_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/tx_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..b0b035fde69373980d76f7c214c76672ac91cdda
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/tx_test.go
@@ -0,0 +1,134 @@
+package types
+
+import (
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ _ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint_test"
+)
+
+var chainID string
+
+func init() {
+ chainID = config.GetString("chain_id")
+}
+
+func TestSendTxSignable(t *testing.T) {
+ sendTx := &SendTx{
+ Inputs: []*TxInput{
+ &TxInput{
+ Address: []byte("input1"),
+ Amount: 12345,
+ Sequence: 67890,
+ },
+ &TxInput{
+ Address: []byte("input2"),
+ Amount: 111,
+ Sequence: 222,
+ },
+ },
+ Outputs: []*TxOutput{
+ &TxOutput{
+ Address: []byte("output1"),
+ Amount: 333,
+ },
+ &TxOutput{
+ Address: []byte("output2"),
+ Amount: 444,
+ },
+ },
+ }
+ signBytes := account.SignBytes(chainID, sendTx)
+ signStr := string(signBytes)
+ expected := Fmt(`{"chain_id":"%s","tx":[1,{"inputs":[{"address":"696E70757431","amount":12345,"sequence":67890},{"address":"696E70757432","amount":111,"sequence":222}],"outputs":[{"address":"6F757470757431","amount":333},{"address":"6F757470757432","amount":444}]}]}`,
+ config.GetString("chain_id"))
+ if signStr != expected {
+ t.Errorf("Got unexpected sign string for SendTx. Expected:\n%v\nGot:\n%v", expected, signStr)
+ }
+}
+
+func TestCallTxSignable(t *testing.T) {
+ callTx := &CallTx{
+ Input: &TxInput{
+ Address: []byte("input1"),
+ Amount: 12345,
+ Sequence: 67890,
+ },
+ Address: []byte("contract1"),
+ GasLimit: 111,
+ Fee: 222,
+ Data: []byte("data1"),
+ }
+ signBytes := account.SignBytes(chainID, callTx)
+ signStr := string(signBytes)
+ expected := Fmt(`{"chain_id":"%s","tx":[2,{"address":"636F6E747261637431","data":"6461746131","fee":222,"gas_limit":111,"input":{"address":"696E70757431","amount":12345,"sequence":67890}}]}`,
+ config.GetString("chain_id"))
+ if signStr != expected {
+ t.Errorf("Got unexpected sign string for CallTx. Expected:\n%v\nGot:\n%v", expected, signStr)
+ }
+}
+
+func TestBondTxSignable(t *testing.T) {
+ privAccount := account.GenPrivAccountFromKey([64]byte{})
+ bondTx := &BondTx{
+ PubKey: privAccount.PubKey.(account.PubKeyEd25519),
+ Inputs: []*TxInput{
+ &TxInput{
+ Address: []byte("input1"),
+ Amount: 12345,
+ Sequence: 67890,
+ },
+ &TxInput{
+ Address: []byte("input2"),
+ Amount: 111,
+ Sequence: 222,
+ },
+ },
+ UnbondTo: []*TxOutput{
+ &TxOutput{
+ Address: []byte("output1"),
+ Amount: 333,
+ },
+ &TxOutput{
+ Address: []byte("output2"),
+ Amount: 444,
+ },
+ },
+ }
+ signBytes := account.SignBytes(chainID, bondTx)
+ signStr := string(signBytes)
+ expected := Fmt(`{"chain_id":"%s","tx":[17,{"inputs":[{"address":"696E70757431","amount":12345,"sequence":67890},{"address":"696E70757432","amount":111,"sequence":222}],"pub_key":[1,"3B6A27BCCEB6A42D62A3A8D02A6F0D73653215771DE243A63AC048A18B59DA29"],"unbond_to":[{"address":"6F757470757431","amount":333},{"address":"6F757470757432","amount":444}]}]}`,
+ config.GetString("chain_id"))
+ if signStr != expected {
+ t.Errorf("Got unexpected sign string for BondTx")
+ }
+}
+
+func TestUnbondTxSignable(t *testing.T) {
+ unbondTx := &UnbondTx{
+ Address: []byte("address1"),
+ Height: 111,
+ }
+ signBytes := account.SignBytes(chainID, unbondTx)
+ signStr := string(signBytes)
+ expected := Fmt(`{"chain_id":"%s","tx":[18,{"address":"6164647265737331","height":111}]}`,
+ config.GetString("chain_id"))
+ if signStr != expected {
+ t.Errorf("Got unexpected sign string for UnbondTx")
+ }
+}
+
+func TestRebondTxSignable(t *testing.T) {
+ rebondTx := &RebondTx{
+ Address: []byte("address1"),
+ Height: 111,
+ }
+ signBytes := account.SignBytes(chainID, rebondTx)
+ signStr := string(signBytes)
+ expected := Fmt(`{"chain_id":"%s","tx":[19,{"address":"6164647265737331","height":111}]}`,
+ config.GetString("chain_id"))
+ if signStr != expected {
+ t.Errorf("Got unexpected sign string for RebondTx")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/types/tx_utils.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/tx_utils.go
new file mode 100644
index 0000000000000000000000000000000000000000..39f9bb59d00f7169aa2a78576fbffdde73cd8d25
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/tx_utils.go
@@ -0,0 +1,196 @@
+package types
+
+import (
+ "fmt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+)
+
+type AccountGetter interface {
+ GetAccount(addr []byte) *account.Account
+}
+
+//----------------------------------------------------------------------------
+// SendTx interface for adding inputs/outputs and adding signatures
+
+func NewSendTx() *SendTx {
+ return &SendTx{
+ Inputs: []*TxInput{},
+ Outputs: []*TxOutput{},
+ }
+}
+
+func (tx *SendTx) AddInput(st AccountGetter, pubkey account.PubKey, amt uint64) error {
+ addr := pubkey.Address()
+ acc := st.GetAccount(addr)
+ if acc == nil {
+ return fmt.Errorf("Invalid address %X from pubkey %X", addr, pubkey)
+ }
+ return tx.AddInputWithNonce(pubkey, amt, acc.Sequence+1)
+}
+
+func (tx *SendTx) AddInputWithNonce(pubkey account.PubKey, amt uint64, nonce uint) error {
+ addr := pubkey.Address()
+ tx.Inputs = append(tx.Inputs, &TxInput{
+ Address: addr,
+ Amount: amt,
+ Sequence: nonce,
+ Signature: account.SignatureEd25519{},
+ PubKey: pubkey,
+ })
+ return nil
+}
+
+func (tx *SendTx) AddOutput(addr []byte, amt uint64) error {
+ tx.Outputs = append(tx.Outputs, &TxOutput{
+ Address: addr,
+ Amount: amt,
+ })
+ return nil
+}
+
+func (tx *SendTx) SignInput(chainID string, i int, privAccount *account.PrivAccount) error {
+ if i >= len(tx.Inputs) {
+ return fmt.Errorf("Index %v is greater than number of inputs (%v)", i, len(tx.Inputs))
+ }
+ tx.Inputs[i].PubKey = privAccount.PubKey
+ tx.Inputs[i].Signature = privAccount.Sign(chainID, tx)
+ return nil
+}
+
+//----------------------------------------------------------------------------
+// CallTx interface for creating tx
+
+func NewCallTx(st AccountGetter, from account.PubKey, to, data []byte, amt, gasLimit, fee uint64) (*CallTx, error) {
+ addr := from.Address()
+ acc := st.GetAccount(addr)
+ if acc == nil {
+ return nil, fmt.Errorf("Invalid address %X from pubkey %X", addr, from)
+ }
+
+ nonce := acc.Sequence + 1
+ return NewCallTxWithNonce(from, to, data, amt, gasLimit, fee, nonce), nil
+}
+
+func NewCallTxWithNonce(from account.PubKey, to, data []byte, amt, gasLimit, fee uint64, nonce uint) *CallTx {
+ addr := from.Address()
+ input := &TxInput{
+ Address: addr,
+ Amount: amt,
+ Sequence: nonce,
+ Signature: account.SignatureEd25519{},
+ PubKey: from,
+ }
+
+ return &CallTx{
+ Input: input,
+ Address: to,
+ GasLimit: gasLimit,
+ Fee: fee,
+ Data: data,
+ }
+}
+
+func (tx *CallTx) Sign(chainID string, privAccount *account.PrivAccount) {
+ tx.Input.PubKey = privAccount.PubKey
+ tx.Input.Signature = privAccount.Sign(chainID, tx)
+}
+
+//----------------------------------------------------------------------------
+// NameTx interface for creating tx
+
+func NewNameTx(st AccountGetter, from account.PubKey, name, data string, amt, fee uint64) (*NameTx, error) {
+ addr := from.Address()
+ acc := st.GetAccount(addr)
+ if acc == nil {
+ return nil, fmt.Errorf("Invalid address %X from pubkey %X", addr, from)
+ }
+
+ nonce := acc.Sequence + 1
+ return NewNameTxWithNonce(from, name, data, amt, fee, nonce), nil
+}
+
+func NewNameTxWithNonce(from account.PubKey, name, data string, amt, fee uint64, nonce uint) *NameTx {
+ addr := from.Address()
+ input := &TxInput{
+ Address: addr,
+ Amount: amt,
+ Sequence: nonce,
+ Signature: account.SignatureEd25519{},
+ PubKey: from,
+ }
+
+ return &NameTx{
+ Input: input,
+ Name: name,
+ Data: data,
+ Fee: fee,
+ }
+}
+
+func (tx *NameTx) Sign(chainID string, privAccount *account.PrivAccount) {
+ tx.Input.PubKey = privAccount.PubKey
+ tx.Input.Signature = privAccount.Sign(chainID, tx)
+}
+
+//----------------------------------------------------------------------------
+// BondTx interface for adding inputs/outputs and adding signatures
+
+func NewBondTx(pubkey account.PubKey) (*BondTx, error) {
+ pubkeyEd, ok := pubkey.(account.PubKeyEd25519)
+ if !ok {
+ return nil, fmt.Errorf("Pubkey must be ed25519")
+ }
+ return &BondTx{
+ PubKey: pubkeyEd,
+ Inputs: []*TxInput{},
+ UnbondTo: []*TxOutput{},
+ }, nil
+}
+
+func (tx *BondTx) AddInput(st AccountGetter, pubkey account.PubKey, amt uint64) error {
+ addr := pubkey.Address()
+ acc := st.GetAccount(addr)
+ if acc == nil {
+ return fmt.Errorf("Invalid address %X from pubkey %X", addr, pubkey)
+ }
+ return tx.AddInputWithNonce(pubkey, amt, acc.Sequence+1)
+}
+
+func (tx *BondTx) AddInputWithNonce(pubkey account.PubKey, amt uint64, nonce uint) error {
+ addr := pubkey.Address()
+ tx.Inputs = append(tx.Inputs, &TxInput{
+ Address: addr,
+ Amount: amt,
+ Sequence: nonce,
+ Signature: account.SignatureEd25519{},
+ PubKey: pubkey,
+ })
+ return nil
+}
+
+func (tx *BondTx) AddOutput(addr []byte, amt uint64) error {
+ tx.UnbondTo = append(tx.UnbondTo, &TxOutput{
+ Address: addr,
+ Amount: amt,
+ })
+ return nil
+}
+
+func (tx *BondTx) SignBond(chainID string, privAccount *account.PrivAccount) error {
+ sig := privAccount.Sign(chainID, tx)
+ sigEd, ok := sig.(account.SignatureEd25519)
+ if !ok {
+ return fmt.Errorf("Bond signer must be ED25519")
+ }
+ tx.Signature = sigEd
+ return nil
+}
+
+func (tx *BondTx) SignInput(chainID string, i int, privAccount *account.PrivAccount) error {
+ if i >= len(tx.Inputs) {
+ return fmt.Errorf("Index %v is greater than number of inputs (%v)", i, len(tx.Inputs))
+ }
+ tx.Inputs[i].PubKey = privAccount.PubKey
+ tx.Inputs[i].Signature = privAccount.Sign(chainID, tx)
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/types/vote.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/vote.go
new file mode 100644
index 0000000000000000000000000000000000000000..0512344719a12d7f114f1cb7b140188e4cc99d0a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/vote.go
@@ -0,0 +1,73 @@
+package types
+
+import (
+ "errors"
+ "fmt"
+ "io"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+var (
+ ErrVoteUnexpectedStep = errors.New("Unexpected step")
+ ErrVoteInvalidAccount = errors.New("Invalid round vote account")
+ ErrVoteInvalidSignature = errors.New("Invalid round vote signature")
+ ErrVoteInvalidBlockHash = errors.New("Invalid block hash")
+)
+
+type ErrVoteConflictingSignature struct {
+ VoteA *Vote
+ VoteB *Vote
+}
+
+func (err *ErrVoteConflictingSignature) Error() string {
+ return "Conflicting round vote signature"
+}
+
+// Represents a prevote, precommit, or commit vote from validators for consensus.
+// Commit votes get aggregated into the next block's Validaiton.
+// See the whitepaper for details.
+type Vote struct {
+ Height uint `json:"height"`
+ Round uint `json:"round"`
+ Type byte `json:"type"`
+ BlockHash []byte `json:"block_hash"` // empty if vote is nil.
+ BlockParts PartSetHeader `json:"block_parts"` // zero if vote is nil.
+ Signature account.SignatureEd25519 `json:"signature"`
+}
+
+// Types of votes
+const (
+ VoteTypePrevote = byte(0x01)
+ VoteTypePrecommit = byte(0x02)
+ VoteTypeCommit = byte(0x03)
+)
+
+func (vote *Vote) WriteSignBytes(chainID string, w io.Writer, n *int64, err *error) {
+ binary.WriteTo([]byte(Fmt(`{"chain_id":"%s"`, chainID)), w, n, err)
+ binary.WriteTo([]byte(Fmt(`,"vote":{"block_hash":"%X","block_parts":%v`, vote.BlockHash, vote.BlockParts)), w, n, err)
+ binary.WriteTo([]byte(Fmt(`,"height":%v,"round":%v,"type":%v}}`, vote.Height, vote.Round, vote.Type)), w, n, err)
+}
+
+func (vote *Vote) Copy() *Vote {
+ voteCopy := *vote
+ return &voteCopy
+}
+
+func (vote *Vote) String() string {
+ var typeString string
+ switch vote.Type {
+ case VoteTypePrevote:
+ typeString = "Prevote"
+ case VoteTypePrecommit:
+ typeString = "Precommit"
+ case VoteTypeCommit:
+ typeString = "Commit"
+ default:
+ panic("Unknown vote type")
+ }
+
+ return fmt.Sprintf("Vote{%v/%02d/%v(%v) %X#%v %v}", vote.Height, vote.Round, vote.Type, typeString, Fingerprint(vote.BlockHash), vote.BlockParts, vote.Signature)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/.ethtest b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/.ethtest
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/common.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/common.go
new file mode 100644
index 0000000000000000000000000000000000000000..00ab93c775f6b4ba8e29c1cc38eca28a9a7920f2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/common.go
@@ -0,0 +1,26 @@
+package vm
+
+import (
+ "math/big"
+)
+
+// To256
+//
+// "cast" the big int to a 256 big int (i.e., limit to)
+var tt256 = new(big.Int).Lsh(big.NewInt(1), 256)
+var tt256m1 = new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 256), big.NewInt(1))
+var tt255 = new(big.Int).Lsh(big.NewInt(1), 255)
+
+func U256(x *big.Int) *big.Int {
+ x.And(x, tt256m1)
+ return x
+}
+
+func S256(x *big.Int) *big.Int {
+ if x.Cmp(tt255) < 0 {
+ return x
+ } else {
+ // We don't want to modify x, ever
+ return new(big.Int).Sub(x, tt256)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/gas.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/gas.go
new file mode 100644
index 0000000000000000000000000000000000000000..ebe5573a399651d65d053577e92d78a45f70d08f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/gas.go
@@ -0,0 +1,17 @@
+package vm
+
+const (
+ GasSha3 uint64 = 1
+ GasGetAccount uint64 = 1
+ GasStorageUpdate uint64 = 1
+
+ GasStackOp uint64 = 1
+
+ GasEcRecover uint64 = 1
+ GasSha256Word uint64 = 1
+ GasSha256Base uint64 = 1
+ GasRipemd160Word uint64 = 1
+ GasRipemd160Base uint64 = 1
+ GasIdentityWord uint64 = 1
+ GasIdentityBase uint64 = 1
+)
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/log.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..cc097564ff5b6e0b44b2309dc57c963de187ba4c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/log.go
@@ -0,0 +1,7 @@
+package vm
+
+import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/logger"
+)
+
+var log = logger.New("module", "vm")
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/native.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/native.go
new file mode 100644
index 0000000000000000000000000000000000000000..cc8c3005755097de4967ff78acf99324cf9df724
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/native.go
@@ -0,0 +1,89 @@
+package vm
+
+import (
+ "crypto/sha256"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/code.google.com/p/go.crypto/ripemd160"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/sha3"
+)
+
+var nativeContracts = make(map[Word256]NativeContract)
+
+func init() {
+ nativeContracts[Uint64ToWord256(1)] = ecrecoverFunc
+ nativeContracts[Uint64ToWord256(2)] = sha256Func
+ nativeContracts[Uint64ToWord256(3)] = ripemd160Func
+ nativeContracts[Uint64ToWord256(4)] = identityFunc
+}
+
+//-----------------------------------------------------------------------------
+
+type NativeContract func(input []byte, gas *uint64) (output []byte, err error)
+
+func ecrecoverFunc(input []byte, gas *uint64) (output []byte, err error) {
+ // Deduct gas
+ gasRequired := GasEcRecover
+ if *gas < gasRequired {
+ return nil, ErrInsufficientGas
+ } else {
+ *gas -= gasRequired
+ }
+ // Recover
+ hash := input[:32]
+ v := byte(input[32] - 27) // ignore input[33:64], v is small.
+ sig := append(input[64:], v)
+
+ recovered, err := secp256k1.RecoverPubkey(hash, sig)
+ if err != nil {
+ return nil, err
+ }
+ hashed := sha3.Sha3(recovered[1:])
+ return LeftPadBytes(hashed, 32), nil
+}
+
+func sha256Func(input []byte, gas *uint64) (output []byte, err error) {
+ // Deduct gas
+ gasRequired := uint64((len(input)+31)/32)*GasSha256Word + GasSha256Base
+ if *gas < gasRequired {
+ return nil, ErrInsufficientGas
+ } else {
+ *gas -= gasRequired
+ }
+ // Hash
+ hasher := sha256.New()
+ _, err = hasher.Write(input)
+ if err != nil {
+ panic(err)
+ }
+ return hasher.Sum(nil), nil
+}
+
+func ripemd160Func(input []byte, gas *uint64) (output []byte, err error) {
+ // Deduct gas
+ gasRequired := uint64((len(input)+31)/32)*GasRipemd160Word + GasRipemd160Base
+ if *gas < gasRequired {
+ return nil, ErrInsufficientGas
+ } else {
+ *gas -= gasRequired
+ }
+ // Hash
+ hasher := ripemd160.New()
+ _, err = hasher.Write(input)
+ if err != nil {
+ panic(err)
+ }
+ return LeftPadBytes(hasher.Sum(nil), 32), nil
+}
+
+func identityFunc(input []byte, gas *uint64) (output []byte, err error) {
+ // Deduct gas
+ gasRequired := uint64((len(input)+31)/32)*GasIdentityWord + GasIdentityBase
+ if *gas < gasRequired {
+ return nil, ErrInsufficientGas
+ } else {
+ *gas -= gasRequired
+ }
+ // Return identity
+ return input, nil
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/opcodes.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/opcodes.go
new file mode 100644
index 0000000000000000000000000000000000000000..a20f2a01c24194d9ff4cc17714c91f9af7bd030d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/opcodes.go
@@ -0,0 +1,354 @@
+package vm
+
+import (
+ "fmt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/gopkg.in/fatih/set.v0"
+)
+
+type OpCode byte
+
+// Op codes
+const (
+ // 0x0 range - arithmetic ops
+ STOP OpCode = iota
+ ADD
+ MUL
+ SUB
+ DIV
+ SDIV
+ MOD
+ SMOD
+ ADDMOD
+ MULMOD
+ EXP
+ SIGNEXTEND
+)
+
+const (
+ LT OpCode = iota + 0x10
+ GT
+ SLT
+ SGT
+ EQ
+ ISZERO
+ AND
+ OR
+ XOR
+ NOT
+ BYTE
+
+ SHA3 = 0x20
+)
+
+const (
+ // 0x30 range - closure state
+ ADDRESS OpCode = 0x30 + iota
+ BALANCE
+ ORIGIN
+ CALLER
+ CALLVALUE
+ CALLDATALOAD
+ CALLDATASIZE
+ CALLDATACOPY
+ CODESIZE
+ CODECOPY
+ GASPRICE_DEPRECATED
+ EXTCODESIZE
+ EXTCODECOPY
+)
+
+const (
+
+ // 0x40 range - block operations
+ BLOCKHASH OpCode = 0x40 + iota
+ COINBASE
+ TIMESTAMP
+ BLOCKHEIGHT
+ DIFFICULTY_DEPRECATED
+ GASLIMIT
+)
+
+const (
+ // 0x50 range - 'storage' and execution
+ POP OpCode = 0x50 + iota
+ MLOAD
+ MSTORE
+ MSTORE8
+ SLOAD
+ SSTORE
+ JUMP
+ JUMPI
+ PC
+ MSIZE
+ GAS
+ JUMPDEST
+)
+
+const (
+ // 0x60 range
+ PUSH1 OpCode = 0x60 + iota
+ PUSH2
+ PUSH3
+ PUSH4
+ PUSH5
+ PUSH6
+ PUSH7
+ PUSH8
+ PUSH9
+ PUSH10
+ PUSH11
+ PUSH12
+ PUSH13
+ PUSH14
+ PUSH15
+ PUSH16
+ PUSH17
+ PUSH18
+ PUSH19
+ PUSH20
+ PUSH21
+ PUSH22
+ PUSH23
+ PUSH24
+ PUSH25
+ PUSH26
+ PUSH27
+ PUSH28
+ PUSH29
+ PUSH30
+ PUSH31
+ PUSH32
+ DUP1
+ DUP2
+ DUP3
+ DUP4
+ DUP5
+ DUP6
+ DUP7
+ DUP8
+ DUP9
+ DUP10
+ DUP11
+ DUP12
+ DUP13
+ DUP14
+ DUP15
+ DUP16
+ SWAP1
+ SWAP2
+ SWAP3
+ SWAP4
+ SWAP5
+ SWAP6
+ SWAP7
+ SWAP8
+ SWAP9
+ SWAP10
+ SWAP11
+ SWAP12
+ SWAP13
+ SWAP14
+ SWAP15
+ SWAP16
+)
+
+const (
+ LOG0 OpCode = 0xa0 + iota
+ LOG1
+ LOG2
+ LOG3
+ LOG4
+)
+
+const (
+ // 0xf0 range - closures
+ CREATE OpCode = 0xf0 + iota
+ CALL
+ CALLCODE
+ RETURN
+
+ // 0x70 range - other
+ SUICIDE = 0xff
+)
+
+// Since the opcodes aren't all in order we can't use a regular slice
+var opCodeToString = map[OpCode]string{
+ // 0x0 range - arithmetic ops
+ STOP: "STOP",
+ ADD: "ADD",
+ MUL: "MUL",
+ SUB: "SUB",
+ DIV: "DIV",
+ SDIV: "SDIV",
+ MOD: "MOD",
+ SMOD: "SMOD",
+ EXP: "EXP",
+ NOT: "NOT",
+ LT: "LT",
+ GT: "GT",
+ SLT: "SLT",
+ SGT: "SGT",
+ EQ: "EQ",
+ ISZERO: "ISZERO",
+ SIGNEXTEND: "SIGNEXTEND",
+
+ // 0x10 range - bit ops
+ AND: "AND",
+ OR: "OR",
+ XOR: "XOR",
+ BYTE: "BYTE",
+ ADDMOD: "ADDMOD",
+ MULMOD: "MULMOD",
+
+ // 0x20 range - crypto
+ SHA3: "SHA3",
+
+ // 0x30 range - closure state
+ ADDRESS: "ADDRESS",
+ BALANCE: "BALANCE",
+ ORIGIN: "ORIGIN",
+ CALLER: "CALLER",
+ CALLVALUE: "CALLVALUE",
+ CALLDATALOAD: "CALLDATALOAD",
+ CALLDATASIZE: "CALLDATASIZE",
+ CALLDATACOPY: "CALLDATACOPY",
+ CODESIZE: "CODESIZE",
+ CODECOPY: "CODECOPY",
+ GASPRICE_DEPRECATED: "TXGASPRICE_DEPRECATED",
+
+ // 0x40 range - block operations
+ BLOCKHASH: "BLOCKHASH",
+ COINBASE: "COINBASE",
+ TIMESTAMP: "TIMESTAMP",
+ BLOCKHEIGHT: "BLOCKHEIGHT",
+ DIFFICULTY_DEPRECATED: "DIFFICULTY_DEPRECATED",
+ GASLIMIT: "GASLIMIT",
+ EXTCODESIZE: "EXTCODESIZE",
+ EXTCODECOPY: "EXTCODECOPY",
+
+ // 0x50 range - 'storage' and execution
+ POP: "POP",
+ //DUP: "DUP",
+ //SWAP: "SWAP",
+ MLOAD: "MLOAD",
+ MSTORE: "MSTORE",
+ MSTORE8: "MSTORE8",
+ SLOAD: "SLOAD",
+ SSTORE: "SSTORE",
+ JUMP: "JUMP",
+ JUMPI: "JUMPI",
+ PC: "PC",
+ MSIZE: "MSIZE",
+ GAS: "GAS",
+ JUMPDEST: "JUMPDEST",
+
+ // 0x60 range - push
+ PUSH1: "PUSH1",
+ PUSH2: "PUSH2",
+ PUSH3: "PUSH3",
+ PUSH4: "PUSH4",
+ PUSH5: "PUSH5",
+ PUSH6: "PUSH6",
+ PUSH7: "PUSH7",
+ PUSH8: "PUSH8",
+ PUSH9: "PUSH9",
+ PUSH10: "PUSH10",
+ PUSH11: "PUSH11",
+ PUSH12: "PUSH12",
+ PUSH13: "PUSH13",
+ PUSH14: "PUSH14",
+ PUSH15: "PUSH15",
+ PUSH16: "PUSH16",
+ PUSH17: "PUSH17",
+ PUSH18: "PUSH18",
+ PUSH19: "PUSH19",
+ PUSH20: "PUSH20",
+ PUSH21: "PUSH21",
+ PUSH22: "PUSH22",
+ PUSH23: "PUSH23",
+ PUSH24: "PUSH24",
+ PUSH25: "PUSH25",
+ PUSH26: "PUSH26",
+ PUSH27: "PUSH27",
+ PUSH28: "PUSH28",
+ PUSH29: "PUSH29",
+ PUSH30: "PUSH30",
+ PUSH31: "PUSH31",
+ PUSH32: "PUSH32",
+
+ DUP1: "DUP1",
+ DUP2: "DUP2",
+ DUP3: "DUP3",
+ DUP4: "DUP4",
+ DUP5: "DUP5",
+ DUP6: "DUP6",
+ DUP7: "DUP7",
+ DUP8: "DUP8",
+ DUP9: "DUP9",
+ DUP10: "DUP10",
+ DUP11: "DUP11",
+ DUP12: "DUP12",
+ DUP13: "DUP13",
+ DUP14: "DUP14",
+ DUP15: "DUP15",
+ DUP16: "DUP16",
+
+ SWAP1: "SWAP1",
+ SWAP2: "SWAP2",
+ SWAP3: "SWAP3",
+ SWAP4: "SWAP4",
+ SWAP5: "SWAP5",
+ SWAP6: "SWAP6",
+ SWAP7: "SWAP7",
+ SWAP8: "SWAP8",
+ SWAP9: "SWAP9",
+ SWAP10: "SWAP10",
+ SWAP11: "SWAP11",
+ SWAP12: "SWAP12",
+ SWAP13: "SWAP13",
+ SWAP14: "SWAP14",
+ SWAP15: "SWAP15",
+ SWAP16: "SWAP16",
+ LOG0: "LOG0",
+ LOG1: "LOG1",
+ LOG2: "LOG2",
+ LOG3: "LOG3",
+ LOG4: "LOG4",
+
+ // 0xf0 range
+ CREATE: "CREATE",
+ CALL: "CALL",
+ RETURN: "RETURN",
+ CALLCODE: "CALLCODE",
+
+ // 0x70 range - other
+ SUICIDE: "SUICIDE",
+}
+
+func (o OpCode) String() string {
+ str := opCodeToString[o]
+ if len(str) == 0 {
+ return fmt.Sprintf("Missing opcode 0x%x", int(o))
+ }
+
+ return str
+}
+
+//-----------------------------------------------------------------------------
+
+func AnalyzeJumpDests(code []byte) (dests *set.Set) {
+ dests = set.New()
+
+ for pc := uint64(0); pc < uint64(len(code)); pc++ {
+ var op OpCode = OpCode(code[pc])
+ switch op {
+ case PUSH1, PUSH2, PUSH3, PUSH4, PUSH5, PUSH6, PUSH7, PUSH8, PUSH9, PUSH10, PUSH11, PUSH12, PUSH13, PUSH14, PUSH15, PUSH16, PUSH17, PUSH18, PUSH19, PUSH20, PUSH21, PUSH22, PUSH23, PUSH24, PUSH25, PUSH26, PUSH27, PUSH28, PUSH29, PUSH30, PUSH31, PUSH32:
+ a := uint64(op) - uint64(PUSH1) + 1
+
+ pc += a
+ case JUMPDEST:
+ dests.Add(pc)
+ }
+ }
+ return
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/randentropy/rand_entropy.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/randentropy/rand_entropy.go
new file mode 100644
index 0000000000000000000000000000000000000000..c16221c5c2934c96c7a7827ecdbced1af1e16ff0
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/randentropy/rand_entropy.go
@@ -0,0 +1,35 @@
+package randentropy
+
+import (
+ crand "crypto/rand"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/sha3"
+ "io"
+)
+
+var Reader io.Reader = &randEntropy{}
+
+type randEntropy struct {
+}
+
+func (*randEntropy) Read(bytes []byte) (n int, err error) {
+ readBytes := GetEntropyCSPRNG(len(bytes))
+ copy(bytes, readBytes)
+ return len(bytes), nil
+}
+
+// TODO: copied from crypto.go , move to sha3 package?
+func Sha3(data []byte) []byte {
+ d := sha3.NewKeccak256()
+ d.Write(data)
+
+ return d.Sum(nil)
+}
+
+func GetEntropyCSPRNG(n int) []byte {
+ mainBuff := make([]byte, n)
+ _, err := io.ReadFull(crand.Reader, mainBuff)
+ if err != nil {
+ panic("reading from crypto/rand failed: " + err.Error())
+ }
+ return mainBuff
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/.gitignore b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..802b6744a1d9fb2b9711384aca36a8790bae7f0f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/.gitignore
@@ -0,0 +1,24 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+
+*~
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/README.md b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..5a86147d4856306b8c40a28831fb444476d5ffec
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/README.md
@@ -0,0 +1,25 @@
+secp256k1-go
+=======
+
+golang secp256k1 library
+
+Implements cryptographic operations for the secp256k1 ECDSA curve used by Bitcoin.
+
+Installing
+===
+
+GMP library headers are required to build. On Debian-based systems, the package is called `libgmp-dev`.
+
+```
+sudo apt-get install libgmp-dev
+```
+
+Now compiles with cgo!
+
+Test
+===
+
+To run tests do
+```
+go tests
+```
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/notes.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/notes.go
new file mode 100644
index 0000000000000000000000000000000000000000..7ed16caabce99a0a4e2e5991117dff631e081502
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/notes.go
@@ -0,0 +1,192 @@
+package secp256k1
+
+/*
+<HaltingState> sipa, int secp256k1_ecdsa_pubkey_create(unsigned char *pubkey, int *pubkeylen, const unsigned char *seckey, int compressed);
+<HaltingState> is that how i generate private/public keys?
+<sipa> HaltingState: you pass in a random 32-byte string as seckey
+<sipa> HaltingState: if it is valid, the corresponding pubkey is put in pubkey
+<sipa> and true is returned
+<sipa> otherwise, false is returned
+<sipa> around 1 in 2^128 32-byte strings are invalid, so the odds of even ever seeing one is extremely rare
+
+<sipa> private keys are mathematically numbers
+<sipa> each has a corresponding point on the curve as public key
+<sipa> a private key is just a number
+<sipa> a public key is a point with x/y coordinates
+<sipa> almost every 256-bit number is a valid private key (one with a point on the curve corresponding to it)
+<sipa> HaltingState: ok?
+
+<sipa> more than half of random points are not on the curve
+<sipa> and actually, it is less than the square root, not less than half, sorry :)
+!!!
+<sipa> a private key is a NUMBER
+<sipa> a public key is a POINT
+<gmaxwell> half the x,y values in the field are not on the curve, a private key is an integer.
+
+<sipa> HaltingState: yes, n,q = private keys; N,Q = corresponding public keys (N=n*G, Q=q*G); then it follows that n*Q = n*q*G = q*n*G = q*N
+<sipa> that's the reason ECDH works
+<sipa> multiplication is associative and commutativ
+*/
+
+/*
+<HaltingState> sipa, ok; i am doing compact signatures and I want to know; can someone change the signature to get another valid signature for same message without the private key
+<HaltingState> because i know they can do that for the normal 72 byte signatures that openssl was putting out
+<sipa> HaltingState: if you don't enforce non-malleability, yes
+<sipa> HaltingState: if you force the highest bit of t
+
+<sipa> it _creates_ signatures that already satisfy that condition
+<sipa> but it will accept ones that don't
+<sipa> maybe i should change that, and be strict
+<HaltingState> yes; i want some way to know signature is valid but fails malleability
+<sipa> well if the highest bit of S is 1, you can take its complement
+<sipa> and end up with a valid signature
+<sipa> that is canonical
+*/
+
+/*
+
+<HaltingState> sipa, I am signing messages and highest bit of the compact signature is 1!!!
+<HaltingState> if (b & 0x80) == 0x80 {
+<HaltingState> log.Panic("b= %v b2= %v \n", b, b&0x80)
+<HaltingState> }
+<sipa> what bit?
+* Pengoo has quit (Ping timeout: 272 seconds)
+<HaltingState> the highest bit of the first byte of signature
+<sipa> it's the highest bit of S
+<sipa> so the 32nd byte
+<HaltingState> wtf
+
+*/
+
+/*
+ For instance, nonces are used in HTTP digest access authentication to calculate an MD5 digest
+ of the password. The nonces are different each time the 401 authentication challenge
+ response code is presented, thus making replay attacks virtually impossible.
+
+can verify client/server match without sending password over network
+*/
+
+/*
+<hanihani> one thing I dont get about armory for instance,
+is how the hot-wallet can generate new addresses without
+knowing the master key
+*/
+
+/*
+<HaltingState> i am yelling at the telehash people for using secp256r1
+instead of secp256k1; they thing r1 is "more secure" despite fact that
+there is no implementation that works and wrapping it is now taking
+up massive time, lol
+<gmaxwell> ...
+
+<gmaxwell> You know that the *r curves are selected via an undisclosed
+secret process, right?
+<gmaxwell> HaltingState: telehash is offtopic for this channel.
+*/
+/*
+ For instance, nonces are used in HTTP digest access authentication to calculate an MD5 digest
+ of the password. The nonces are different each time the 401 authentication challenge
+ response code is presented, thus making replay attacks virtually impossible.
+
+can verify client/server match without sending password over network
+*/
+
+/*
+void secp256k1_start(void);
+void secp256k1_stop(void);
+
+ * Verify an ECDSA signature.
+ * Returns: 1: correct signature
+ * 0: incorrect signature
+ * -1: invalid public key
+ * -2: invalid signature
+ *
+int secp256k1_ecdsa_verify(const unsigned char *msg, int msglen,
+ const unsigned char *sig, int siglen,
+ const unsigned char *pubkey, int pubkeylen);
+
+http://www.nilsschneider.net/2013/01/28/recovering-bitcoin-private-keys.html
+
+Why did this work? ECDSA requires a random number for each signature. If this random
+number is ever used twice with the same private key it can be recovered.
+This transaction was generated by a hardware bitcoin wallet using a pseudo-random number
+generator that was returning the same “random†number every time.
+
+Nonce is 32 bytes?
+
+ * Create an ECDSA signature.
+ * Returns: 1: signature created
+ * 0: nonce invalid, try another one
+ * In: msg: the message being signed
+ * msglen: the length of the message being signed
+ * seckey: pointer to a 32-byte secret key (assumed to be valid)
+ * nonce: pointer to a 32-byte nonce (generated with a cryptographic PRNG)
+ * Out: sig: pointer to a 72-byte array where the signature will be placed.
+ * siglen: pointer to an int, which will be updated to the signature length (<=72).
+ *
+int secp256k1_ecdsa_sign(const unsigned char *msg, int msglen,
+ unsigned char *sig, int *siglen,
+ const unsigned char *seckey,
+ const unsigned char *nonce);
+
+
+ * Create a compact ECDSA signature (64 byte + recovery id).
+ * Returns: 1: signature created
+ * 0: nonce invalid, try another one
+ * In: msg: the message being signed
+ * msglen: the length of the message being signed
+ * seckey: pointer to a 32-byte secret key (assumed to be valid)
+ * nonce: pointer to a 32-byte nonce (generated with a cryptographic PRNG)
+ * Out: sig: pointer to a 64-byte array where the signature will be placed.
+ * recid: pointer to an int, which will be updated to contain the recovery id.
+ *
+int secp256k1_ecdsa_sign_compact(const unsigned char *msg, int msglen,
+ unsigned char *sig64,
+ const unsigned char *seckey,
+ const unsigned char *nonce,
+ int *recid);
+
+ * Recover an ECDSA public key from a compact signature.
+ * Returns: 1: public key succesfully recovered (which guarantees a correct signature).
+ * 0: otherwise.
+ * In: msg: the message assumed to be signed
+ * msglen: the length of the message
+ * compressed: whether to recover a compressed or uncompressed pubkey
+ * recid: the recovery id (as returned by ecdsa_sign_compact)
+ * Out: pubkey: pointer to a 33 or 65 byte array to put the pubkey.
+ * pubkeylen: pointer to an int that will contain the pubkey length.
+ *
+
+recovery id is between 0 and 3
+
+int secp256k1_ecdsa_recover_compact(const unsigned char *msg, int msglen,
+ const unsigned char *sig64,
+ unsigned char *pubkey, int *pubkeylen,
+ int compressed, int recid);
+
+
+ * Verify an ECDSA secret key.
+ * Returns: 1: secret key is valid
+ * 0: secret key is invalid
+ * In: seckey: pointer to a 32-byte secret key
+ *
+int secp256k1_ecdsa_seckey_verify(const unsigned char *seckey);
+
+** Just validate a public key.
+ * Returns: 1: valid public key
+ * 0: invalid public key
+ *
+int secp256k1_ecdsa_pubkey_verify(const unsigned char *pubkey, int pubkeylen);
+
+** Compute the public key for a secret key.
+ * In: compressed: whether the computed public key should be compressed
+ * seckey: pointer to a 32-byte private key.
+ * Out: pubkey: pointer to a 33-byte (if compressed) or 65-byte (if uncompressed)
+ * area to store the public key.
+ * pubkeylen: pointer to int that will be updated to contains the pubkey's
+ * length.
+ * Returns: 1: secret was valid, public key stores
+ * 0: secret was invalid, try again.
+ *
+int secp256k1_ecdsa_pubkey_create(unsigned char *pubkey, int *pubkeylen, const unsigned char *seckey, int compressed);
+*/
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256.go
new file mode 100644
index 0000000000000000000000000000000000000000..04c3f84c83f9e39b8e11603af61068fd38ffd593
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256.go
@@ -0,0 +1,248 @@
+package secp256k1
+
+// TODO: set USE_SCALAR_4X64 depending on platform?
+
+/*
+#cgo CFLAGS: -I./secp256k1
+#cgo darwin CFLAGS: -I/usr/local/include
+#cgo linux,arm CFLAGS: -I/usr/local/arm/include
+#cgo LDFLAGS: -lgmp
+#cgo darwin LDFLAGS: -L/usr/local/lib
+#cgo linux,arm LDFLAGS: -L/usr/local/arm/lib
+#define USE_NUM_GMP
+#define USE_FIELD_10X26
+#define USE_FIELD_INV_BUILTIN
+#define USE_SCALAR_8X32
+#define USE_SCALAR_INV_BUILTIN
+#define NDEBUG
+#include "./secp256k1/src/secp256k1.c"
+*/
+import "C"
+
+import (
+ "bytes"
+ "errors"
+ "unsafe"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/randentropy"
+)
+
+//#define USE_FIELD_5X64
+
+/*
+ Todo:
+ > Centralize key management in module
+ > add pubkey/private key struct
+ > Dont let keys leave module; address keys as ints
+
+ > store private keys in buffer and shuffle (deters persistance on swap disc)
+ > Byte permutation (changing)
+ > xor with chaning random block (to deter scanning memory for 0x63) (stream cipher?)
+
+ On Disk
+ > Store keys in wallets
+ > use slow key derivation function for wallet encryption key (2 seconds)
+*/
+
+func init() {
+ //takes 10ms to 100ms
+ C.secp256k1_start(3) // SECP256K1_START_SIGN | SECP256K1_START_VERIFY
+}
+
+func Stop() {
+ C.secp256k1_stop()
+}
+
+func GenerateKeyPair() ([]byte, []byte) {
+
+ pubkey_len := C.int(65)
+ const seckey_len = 32
+
+ var pubkey []byte = make([]byte, pubkey_len)
+ var seckey []byte = randentropy.GetEntropyCSPRNG(seckey_len)
+
+ var pubkey_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&pubkey[0]))
+ var seckey_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&seckey[0]))
+
+ ret := C.secp256k1_ec_pubkey_create(
+ pubkey_ptr, &pubkey_len,
+ seckey_ptr, 0)
+
+ if ret != C.int(1) {
+ return GenerateKeyPair() //invalid secret, try again
+ }
+ return pubkey, seckey
+}
+
+func GeneratePubKey(seckey []byte) ([]byte, error) {
+ if err := VerifySeckeyValidity(seckey); err != nil {
+ return nil, err
+ }
+
+ pubkey_len := C.int(65)
+ const seckey_len = 32
+
+ var pubkey []byte = make([]byte, pubkey_len)
+
+ var pubkey_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&pubkey[0]))
+ var seckey_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&seckey[0]))
+
+ ret := C.secp256k1_ec_pubkey_create(
+ pubkey_ptr, &pubkey_len,
+ seckey_ptr, 0)
+
+ if ret != C.int(1) {
+ return nil, errors.New("Unable to generate pubkey from seckey")
+ }
+
+ return pubkey, nil
+}
+
+func Sign(msg []byte, seckey []byte) ([]byte, error) {
+ nonce := randentropy.GetEntropyCSPRNG(32)
+
+ var sig []byte = make([]byte, 65)
+ var recid C.int
+
+ var msg_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&msg[0]))
+ var sig_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&sig[0]))
+ var seckey_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&seckey[0]))
+
+ var noncefp_ptr = &(*C.secp256k1_nonce_function_default)
+ var ndata_ptr = unsafe.Pointer(&nonce[0])
+
+ if C.secp256k1_ec_seckey_verify(seckey_ptr) != C.int(1) {
+ return nil, errors.New("Invalid secret key")
+ }
+
+ ret := C.secp256k1_ecdsa_sign_compact(
+ msg_ptr,
+ sig_ptr,
+ seckey_ptr,
+ noncefp_ptr,
+ ndata_ptr,
+ &recid)
+
+ sig[64] = byte(int(recid))
+
+ if ret != C.int(1) {
+ // nonce invalid, retry
+ return Sign(msg, seckey)
+ }
+
+ return sig, nil
+
+}
+
+func VerifySeckeyValidity(seckey []byte) error {
+ if len(seckey) != 32 {
+ return errors.New("priv key is not 32 bytes")
+ }
+ var seckey_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&seckey[0]))
+ ret := C.secp256k1_ec_seckey_verify(seckey_ptr)
+ if int(ret) != 1 {
+ return errors.New("invalid seckey")
+ }
+ return nil
+}
+
+func VerifyPubkeyValidity(pubkey []byte) error {
+ if len(pubkey) != 65 {
+ return errors.New("pub key is not 65 bytes")
+ }
+ var pubkey_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&pubkey[0]))
+ ret := C.secp256k1_ec_pubkey_verify(pubkey_ptr, 65)
+ if int(ret) != 1 {
+ return errors.New("invalid pubkey")
+ }
+
+ return nil
+}
+
+func VerifySignatureValidity(sig []byte) bool {
+ //64+1
+ if len(sig) != 65 {
+ return false
+ }
+ //malleability check, highest bit must be 1
+ if (sig[32] & 0x80) == 0x80 {
+ return false
+ }
+ //recovery id check
+ if sig[64] >= 4 {
+ return false
+ }
+
+ return true
+}
+
+//for compressed signatures, does not need pubkey
+func VerifySignature(msg []byte, sig []byte, pubkey1 []byte) error {
+ if msg == nil || sig == nil || pubkey1 == nil {
+ return errors.New("inputs must be non-nil")
+ }
+ if len(sig) != 65 {
+ return errors.New("invalid signature length")
+ }
+ if len(pubkey1) != 65 {
+ return errors.New("Invalid public key length")
+ }
+
+ //to enforce malleability, highest bit of S must be 0
+ //S starts at 32nd byte
+ if (sig[32] & 0x80) == 0x80 { //highest bit must be 1
+ return errors.New("Signature not malleable")
+ }
+
+ if sig[64] >= 4 {
+ return errors.New("Recover byte invalid")
+ }
+
+ // if pubkey recovered, signature valid
+ pubkey2, err := RecoverPubkey(msg, sig)
+ if err != nil {
+ return err
+ }
+ if len(pubkey2) != 65 {
+ return errors.New("Invalid recovered public key length")
+ }
+ if !bytes.Equal(pubkey1, pubkey2) {
+ return errors.New("Public key does not match recovered public key")
+ }
+
+ return nil
+}
+
+//recovers the public key from the signature
+//recovery of pubkey means correct signature
+func RecoverPubkey(msg []byte, sig []byte) ([]byte, error) {
+ if len(sig) != 65 {
+ return nil, errors.New("Invalid signature length")
+ }
+
+ var pubkey []byte = make([]byte, 65)
+
+ var msg_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&msg[0]))
+ var sig_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&sig[0]))
+ var pubkey_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&pubkey[0]))
+
+ var pubkeylen C.int
+
+ ret := C.secp256k1_ecdsa_recover_compact(
+ msg_ptr,
+ sig_ptr,
+ pubkey_ptr,
+ &pubkeylen,
+ C.int(0),
+ C.int(sig[64]),
+ )
+
+ if ret == C.int(0) {
+ return nil, errors.New("Failed to recover public key")
+ } else if pubkeylen != C.int(65) {
+ return nil, errors.New("Impossible Error: Invalid recovered public key length")
+ } else {
+ return pubkey, nil
+ }
+ return nil, errors.New("Impossible Error: func RecoverPubkey has reached an unreachable state")
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..cebc3b9f21fd98da3b2c4a6808b395820033e461
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256_test.go
@@ -0,0 +1,238 @@
+package secp256k1
+
+import (
+ "bytes"
+ "fmt"
+ "log"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/randentropy"
+)
+
+const TESTS = 10000 // how many tests
+const SigSize = 65 //64+1
+
+func Test_Secp256_00(t *testing.T) {
+
+ var nonce []byte = randentropy.GetEntropyCSPRNG(32) //going to get bitcoins stolen!
+
+ if len(nonce) != 32 {
+ t.Fatal()
+ }
+
+}
+
+//tests for Malleability
+//highest bit of S must be 0; 32nd byte
+func CompactSigTest(sig []byte) {
+
+ var b int = int(sig[32])
+ if b < 0 {
+ log.Panic()
+ }
+ if ((b >> 7) == 1) != ((b & 0x80) == 0x80) {
+ log.Panic("b= %v b2= %v \n", b, b>>7)
+ }
+ if (b & 0x80) == 0x80 {
+ log.Panic("b= %v b2= %v \n", b, b&0x80)
+ }
+}
+
+//test pubkey/private generation
+func Test_Secp256_01(t *testing.T) {
+ pubkey, seckey := GenerateKeyPair()
+ if err := VerifySeckeyValidity(seckey); err != nil {
+ t.Fatal()
+ }
+ if err := VerifyPubkeyValidity(pubkey); err != nil {
+ t.Fatal()
+ }
+}
+
+//test size of messages
+func Test_Secp256_02s(t *testing.T) {
+ pubkey, seckey := GenerateKeyPair()
+ msg := randentropy.GetEntropyCSPRNG(32)
+ sig, _ := Sign(msg, seckey)
+ CompactSigTest(sig)
+ if sig == nil {
+ t.Fatal("Signature nil")
+ }
+ if len(pubkey) != 65 {
+ t.Fail()
+ }
+ if len(seckey) != 32 {
+ t.Fail()
+ }
+ if len(sig) != 64+1 {
+ t.Fail()
+ }
+ if int(sig[64]) > 4 {
+ t.Fail()
+ } //should be 0 to 4
+}
+
+//test signing message
+func Test_Secp256_02(t *testing.T) {
+ pubkey1, seckey := GenerateKeyPair()
+ msg := randentropy.GetEntropyCSPRNG(32)
+ sig, _ := Sign(msg, seckey)
+ if sig == nil {
+ t.Fatal("Signature nil")
+ }
+
+ pubkey2, _ := RecoverPubkey(msg, sig)
+ if pubkey2 == nil {
+ t.Fatal("Recovered pubkey invalid")
+ }
+ if bytes.Equal(pubkey1, pubkey2) == false {
+ t.Fatal("Recovered pubkey does not match")
+ }
+
+ err := VerifySignature(msg, sig, pubkey1)
+ if err != nil {
+ t.Fatal("Signature invalid")
+ }
+}
+
+//test pubkey recovery
+func Test_Secp256_02a(t *testing.T) {
+ pubkey1, seckey1 := GenerateKeyPair()
+ msg := randentropy.GetEntropyCSPRNG(32)
+ sig, _ := Sign(msg, seckey1)
+
+ if sig == nil {
+ t.Fatal("Signature nil")
+ }
+ err := VerifySignature(msg, sig, pubkey1)
+ if err != nil {
+ t.Fatal("Signature invalid")
+ }
+
+ pubkey2, _ := RecoverPubkey(msg, sig)
+ if len(pubkey1) != len(pubkey2) {
+ t.Fatal()
+ }
+ for i, _ := range pubkey1 {
+ if pubkey1[i] != pubkey2[i] {
+ t.Fatal()
+ }
+ }
+ if bytes.Equal(pubkey1, pubkey2) == false {
+ t.Fatal()
+ }
+}
+
+//test random messages for the same pub/private key
+func Test_Secp256_03(t *testing.T) {
+ _, seckey := GenerateKeyPair()
+ for i := 0; i < TESTS; i++ {
+ msg := randentropy.GetEntropyCSPRNG(32)
+ sig, _ := Sign(msg, seckey)
+ CompactSigTest(sig)
+
+ sig[len(sig)-1] %= 4
+ pubkey2, _ := RecoverPubkey(msg, sig)
+ if pubkey2 == nil {
+ t.Fail()
+ }
+ }
+}
+
+//test random messages for different pub/private keys
+func Test_Secp256_04(t *testing.T) {
+ for i := 0; i < TESTS; i++ {
+ pubkey1, seckey := GenerateKeyPair()
+ msg := randentropy.GetEntropyCSPRNG(32)
+ sig, _ := Sign(msg, seckey)
+ CompactSigTest(sig)
+
+ if sig[len(sig)-1] >= 4 {
+ t.Fail()
+ }
+ pubkey2, _ := RecoverPubkey(msg, sig)
+ if pubkey2 == nil {
+ t.Fail()
+ }
+ if bytes.Equal(pubkey1, pubkey2) == false {
+ t.Fail()
+ }
+ }
+}
+
+//test random signatures against fixed messages; should fail
+
+//crashes:
+// -SIPA look at this
+
+func randSig() []byte {
+ sig := randentropy.GetEntropyCSPRNG(65)
+ sig[32] &= 0x70
+ sig[64] %= 4
+ return sig
+}
+
+func Test_Secp256_06a_alt0(t *testing.T) {
+ pubkey1, seckey := GenerateKeyPair()
+ msg := randentropy.GetEntropyCSPRNG(32)
+ sig, _ := Sign(msg, seckey)
+
+ if sig == nil {
+ t.Fail()
+ }
+ if len(sig) != 65 {
+ t.Fail()
+ }
+ for i := 0; i < TESTS; i++ {
+ sig = randSig()
+ pubkey2, _ := RecoverPubkey(msg, sig)
+
+ if bytes.Equal(pubkey1, pubkey2) == true {
+ t.Fail()
+ }
+
+ if pubkey2 != nil && VerifySignature(msg, sig, pubkey2) != nil {
+ t.Fail()
+ }
+
+ if VerifySignature(msg, sig, pubkey1) == nil {
+ t.Fail()
+ }
+ }
+}
+
+//test random messages against valid signature: should fail
+
+func Test_Secp256_06b(t *testing.T) {
+ pubkey1, seckey := GenerateKeyPair()
+ msg := randentropy.GetEntropyCSPRNG(32)
+ sig, _ := Sign(msg, seckey)
+
+ fail_count := 0
+ for i := 0; i < TESTS; i++ {
+ msg = randentropy.GetEntropyCSPRNG(32)
+ pubkey2, _ := RecoverPubkey(msg, sig)
+ if bytes.Equal(pubkey1, pubkey2) == true {
+ t.Fail()
+ }
+
+ if pubkey2 != nil && VerifySignature(msg, sig, pubkey2) != nil {
+ t.Fail()
+ }
+
+ if VerifySignature(msg, sig, pubkey1) == nil {
+ t.Fail()
+ }
+ }
+ if fail_count != 0 {
+ fmt.Printf("ERROR: Accepted signature for %v of %v random messages\n", fail_count, TESTS)
+ }
+}
+
+func TestInvalidKey(t *testing.T) {
+ p1 := make([]byte, 32)
+ err := VerifySeckeyValidity(p1)
+ if err == nil {
+ t.Errorf("pvk %x varify sec key should have returned error", p1)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/.travis.yml b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..40f8dae23f8b97ffca212bf96391d879f169275e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/.travis.yml
@@ -0,0 +1,32 @@
+language: c
+compiler:
+ - clang
+ - gcc
+install:
+ - sudo apt-get install -qq libssl-dev
+ - if [ "$BIGNUM" = "gmp" -o "$BIGNUM" = "auto" ]; then sudo apt-get install --no-install-recommends --no-upgrade -qq libgmp-dev; fi
+ - if [ -n "$EXTRAPACKAGES" ]; then sudo apt-get update && sudo apt-get install --no-install-recommends --no-upgrade $EXTRAPACKAGES; fi
+env:
+ global:
+ - FIELD=auto BIGNUM=auto SCALAR=auto ENDOMORPHISM=no ASM=no BUILD=check EXTRAFLAGS= HOST= EXTRAPACKAGES=
+ matrix:
+ - SCALAR=32bit
+ - SCALAR=64bit
+ - FIELD=64bit
+ - FIELD=64bit ENDOMORPHISM=yes
+ - FIELD=64bit ASM=x86_64
+ - FIELD=64bit ENDOMORPHISM=yes ASM=x86_64
+ - FIELD=32bit
+ - FIELD=32bit ENDOMORPHISM=yes
+ - BIGNUM=no
+ - BIGNUM=no ENDOMORPHISM=yes
+ - BUILD=distcheck
+ - EXTRAFLAGS=CFLAGS=-DDETERMINISTIC
+ - HOST=i686-linux-gnu EXTRAPACKAGES="gcc-multilib"
+ - HOST=i686-linux-gnu EXTRAPACKAGES="gcc-multilib" ENDOMORPHISM=yes
+before_script: ./autogen.sh
+script:
+ - if [ -n "$HOST" ]; then export USE_HOST="--host=$HOST"; fi
+ - if [ "x$HOST" = "xi686-linux-gnu" ]; then export CC="$CC -m32"; fi
+ - ./configure --enable-endomorphism=$ENDOMORPHISM --with-field=$FIELD --with-bignum=$BIGNUM --with-scalar=$SCALAR $EXTRAFLAGS $USE_HOST && make -j2 $BUILD
+os: linux
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/COPYING b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/COPYING
new file mode 100644
index 0000000000000000000000000000000000000000..4522a5990e2823f2be0db7efcbc4fca139c08025
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/COPYING
@@ -0,0 +1,19 @@
+Copyright (c) 2013 Pieter Wuille
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/Makefile.am b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..cc15338b7ef7c6e7a1acade834d35b6638e27363
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/Makefile.am
@@ -0,0 +1,77 @@
+ACLOCAL_AMFLAGS = -I build-aux/m4
+
+lib_LTLIBRARIES = libsecp256k1.la
+include_HEADERS = include/secp256k1.h
+noinst_HEADERS =
+noinst_HEADERS += src/scalar.h
+noinst_HEADERS += src/scalar_4x64.h
+noinst_HEADERS += src/scalar_8x32.h
+noinst_HEADERS += src/scalar_impl.h
+noinst_HEADERS += src/scalar_4x64_impl.h
+noinst_HEADERS += src/scalar_8x32_impl.h
+noinst_HEADERS += src/group.h
+noinst_HEADERS += src/group_impl.h
+noinst_HEADERS += src/num_gmp.h
+noinst_HEADERS += src/num_gmp_impl.h
+noinst_HEADERS += src/ecdsa.h
+noinst_HEADERS += src/ecdsa_impl.h
+noinst_HEADERS += src/eckey.h
+noinst_HEADERS += src/eckey_impl.h
+noinst_HEADERS += src/ecmult.h
+noinst_HEADERS += src/ecmult_impl.h
+noinst_HEADERS += src/ecmult_gen.h
+noinst_HEADERS += src/ecmult_gen_impl.h
+noinst_HEADERS += src/num.h
+noinst_HEADERS += src/num_impl.h
+noinst_HEADERS += src/field_10x26.h
+noinst_HEADERS += src/field_10x26_impl.h
+noinst_HEADERS += src/field_5x52.h
+noinst_HEADERS += src/field_5x52_impl.h
+noinst_HEADERS += src/field_5x52_int128_impl.h
+noinst_HEADERS += src/field_5x52_asm_impl.h
+noinst_HEADERS += src/java/org_bitcoin_NativeSecp256k1.h
+noinst_HEADERS += src/util.h
+noinst_HEADERS += src/testrand.h
+noinst_HEADERS += src/testrand_impl.h
+noinst_HEADERS += src/hash.h
+noinst_HEADERS += src/hash_impl.h
+noinst_HEADERS += src/field.h
+noinst_HEADERS += src/field_impl.h
+noinst_HEADERS += src/bench.h
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = libsecp256k1.pc
+
+libsecp256k1_la_SOURCES = src/secp256k1.c
+libsecp256k1_la_CPPFLAGS = -I$(top_srcdir)/include $(SECP_INCLUDES)
+libsecp256k1_la_LIBADD = $(SECP_LIBS)
+
+
+noinst_PROGRAMS =
+if USE_BENCHMARK
+noinst_PROGRAMS += bench_verify bench_recover bench_sign bench_internal
+bench_verify_SOURCES = src/bench_verify.c
+bench_verify_LDADD = libsecp256k1.la $(SECP_LIBS)
+bench_verify_LDFLAGS = -static
+bench_recover_SOURCES = src/bench_recover.c
+bench_recover_LDADD = libsecp256k1.la $(SECP_LIBS)
+bench_recover_LDFLAGS = -static
+bench_sign_SOURCES = src/bench_sign.c
+bench_sign_LDADD = libsecp256k1.la $(SECP_LIBS)
+bench_sign_LDFLAGS = -static
+bench_internal_SOURCES = src/bench_internal.c
+bench_internal_LDADD = $(SECP_LIBS)
+bench_internal_LDFLAGS = -static
+bench_internal_CPPFLAGS = $(SECP_INCLUDES)
+endif
+
+if USE_TESTS
+noinst_PROGRAMS += tests
+tests_SOURCES = src/tests.c
+tests_CPPFLAGS = -DVERIFY $(SECP_INCLUDES) $(SECP_TEST_INCLUDES)
+tests_LDADD = $(SECP_LIBS) $(SECP_TEST_LIBS)
+tests_LDFLAGS = -static
+TESTS = tests
+endif
+
+EXTRA_DIST = autogen.sh
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/README.md b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..6095db42205be95ba7f1a8bfc9151e251548dc19
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/README.md
@@ -0,0 +1,61 @@
+libsecp256k1
+============
+
+[](https://travis-ci.org/bitcoin/secp256k1)
+
+Optimized C library for EC operations on curve secp256k1.
+
+This library is a work in progress and is being used to research best practices. Use at your own risk.
+
+Features:
+* secp256k1 ECDSA signing/verification and key generation.
+* Adding/multiplying private/public keys.
+* Serialization/parsing of private keys, public keys, signatures.
+* Constant time, constant memory access signing and pubkey generation.
+* Derandomized DSA (via RFC6979 or with a caller provided function.)
+* Very efficient implementation.
+
+Implementation details
+----------------------
+
+* General
+ * No runtime heap allocation.
+ * Extensive testing infrastructure.
+ * Structured to facilitate review and analysis.
+ * Intended to be portable to any system with a C89 compiler and uint64_t support.
+ * Expose only higher level interfaces to minimize the API surface and improve application security. ("Be difficult to use insecurely.")
+* Field operations
+ * Optimized implementation of arithmetic modulo the curve's field size (2^256 - 0x1000003D1).
+ * Using 5 52-bit limbs (including hand-optimized assembly for x86_64, by Diederik Huys).
+ * Using 10 26-bit limbs.
+ * Field inverses and square roots using a sliding window over blocks of 1s (by Peter Dettman).
+* Scalar operations
+ * Optimized implementation without data-dependent branches of arithmetic modulo the curve's order.
+ * Using 4 64-bit limbs (relying on __int128 support in the compiler).
+ * Using 8 32-bit limbs.
+* Group operations
+ * Point addition formula specifically simplified for the curve equation (y^2 = x^3 + 7).
+ * Use addition between points in Jacobian and affine coordinates where possible.
+ * Use a unified addition/doubling formula where necessary to avoid data-dependent branches.
+ * Point/x comparison without a field inversion by comparison in the Jacobian coordinate space.
+* Point multiplication for verification (a*P + b*G).
+ * Use wNAF notation for point multiplicands.
+ * Use a much larger window for multiples of G, using precomputed multiples.
+ * Use Shamir's trick to do the multiplication with the public key and the generator simultaneously.
+ * Optionally (off by default) use secp256k1's efficiently-computable endomorphism to split the P multiplicand into 2 half-sized ones.
+* Point multiplication for signing
+ * Use a precomputed table of multiples of powers of 16 multiplied with the generator, so general multiplication becomes a series of additions.
+ * Access the table with branch-free conditional moves so memory access is uniform.
+ * No data-dependent branches
+ * The precomputed tables add and eventually subtract points for which no known scalar (private key) is known, preventing even an attacker with control over the private key used to control the data internally.
+
+Build steps
+-----------
+
+libsecp256k1 is built using autotools:
+
+ $ ./autogen.sh
+ $ ./configure
+ $ make
+ $ ./tests
+ $ sudo make install # optional
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/TODO b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/TODO
new file mode 100644
index 0000000000000000000000000000000000000000..a300e1c5eb9b1376c82b1f5d557d56be5708546f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/TODO
@@ -0,0 +1,3 @@
+* Unit tests for fieldelem/groupelem, including ones intended to
+ trigger fieldelem's boundary cases.
+* Complete constant-time operations for signing/keygen
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/autogen.sh b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/autogen.sh
new file mode 100644
index 0000000000000000000000000000000000000000..65286b93530332340a0c4ec89301a54bff92a35b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/autogen.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+set -e
+autoreconf -if --warnings=all
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/build-aux/m4/bitcoin_secp.m4 b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/build-aux/m4/bitcoin_secp.m4
new file mode 100644
index 0000000000000000000000000000000000000000..4a398d6c93a58745e16959ba3b237a282fc4aa5b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/build-aux/m4/bitcoin_secp.m4
@@ -0,0 +1,61 @@
+dnl libsecp25k1 helper checks
+AC_DEFUN([SECP_INT128_CHECK],[
+has_int128=$ac_cv_type___int128
+])
+
+dnl
+AC_DEFUN([SECP_64BIT_ASM_CHECK],[
+AC_MSG_CHECKING(for x86_64 assembly availability)
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+ #include <stdint.h>]],[[
+ uint64_t a = 11, tmp;
+ __asm__ __volatile__("movq $0x100000000,%1; mulq %%rsi" : "+a"(a) : "S"(tmp) : "cc", "%rdx");
+ ]])],[has_64bit_asm=yes],[has_64bit_asm=no])
+AC_MSG_RESULT([$has_64bit_asm])
+])
+
+dnl
+AC_DEFUN([SECP_OPENSSL_CHECK],[
+if test x"$use_pkgconfig" = x"yes"; then
+ : #NOP
+ m4_ifdef([PKG_CHECK_MODULES],[
+ PKG_CHECK_MODULES([CRYPTO], [libcrypto], [has_libcrypto=yes],[has_libcrypto=no])
+ if test x"$has_libcrypto" = x"yes"; then
+ TEMP_LIBS="$LIBS"
+ LIBS="$LIBS $CRYPTO_LIBS"
+ AC_CHECK_LIB(crypto, main,[AC_DEFINE(HAVE_LIBCRYPTO,1,[Define this symbol if libcrypto is installed])],[has_libcrypto=no])
+ LIBS="$TEMP_LIBS"
+ fi
+ ])
+else
+ AC_CHECK_HEADER(openssl/crypto.h,[AC_CHECK_LIB(crypto, main,[has_libcrypto=yes; CRYPTO_LIBS=-lcrypto; AC_DEFINE(HAVE_LIBCRYPTO,1,[Define this symbol if libcrypto is installed])]
+)])
+ LIBS=
+fi
+if test x"$has_libcrypto" = x"yes" && test x"$has_openssl_ec" = x; then
+ AC_MSG_CHECKING(for EC functions in libcrypto)
+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+ #include <openssl/ec.h>
+ #include <openssl/ecdsa.h>
+ #include <openssl/obj_mac.h>]],[[
+ EC_KEY *eckey = EC_KEY_new_by_curve_name(NID_secp256k1);
+ ECDSA_sign(0, NULL, 0, NULL, NULL, eckey);
+ ECDSA_verify(0, NULL, 0, NULL, 0, eckey);
+ EC_KEY_free(eckey);
+ ]])],[has_openssl_ec=yes],[has_openssl_ec=no])
+ AC_MSG_RESULT([$has_openssl_ec])
+fi
+])
+
+dnl
+AC_DEFUN([SECP_GMP_CHECK],[
+if test x"$has_gmp" != x"yes"; then
+ CPPFLAGS_TEMP="$CPPFLAGS"
+ CPPFLAGS="$GMP_CPPFLAGS $CPPFLAGS"
+ LIBS_TEMP="$LIBS"
+ LIBS="$GMP_LIBS $LIBS"
+ AC_CHECK_HEADER(gmp.h,[AC_CHECK_LIB(gmp, __gmpz_init,[has_gmp=yes; GMP_LIBS="$GMP_LIBS -lgmp"; AC_DEFINE(HAVE_LIBGMP,1,[Define this symbol if libgmp is installed])])])
+ CPPFLAGS="$CPPFLAGS_TEMP"
+ LIBS="$LIBS_TEMP"
+fi
+])
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/configure.ac b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/configure.ac
new file mode 100644
index 0000000000000000000000000000000000000000..3dc1829516e4ec574c4dc17f0b692eb977e2b371
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/configure.ac
@@ -0,0 +1,330 @@
+AC_PREREQ([2.60])
+AC_INIT([libsecp256k1],[0.1])
+AC_CONFIG_AUX_DIR([build-aux])
+AC_CONFIG_MACRO_DIR([build-aux/m4])
+AC_CANONICAL_HOST
+AH_TOP([#ifndef LIBSECP256K1_CONFIG_H])
+AH_TOP([#define LIBSECP256K1_CONFIG_H])
+AH_BOTTOM([#endif /*LIBSECP256K1_CONFIG_H*/])
+AM_INIT_AUTOMAKE([foreign subdir-objects])
+LT_INIT
+
+dnl make the compilation flags quiet unless V=1 is used
+m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
+
+PKG_PROG_PKG_CONFIG
+
+AC_PATH_TOOL(AR, ar)
+AC_PATH_TOOL(RANLIB, ranlib)
+AC_PATH_TOOL(STRIP, strip)
+
+if test "x$CFLAGS" = "x"; then
+ CFLAGS="-O3 -g"
+fi
+
+AC_PROG_CC_C89
+if test x"$ac_cv_prog_cc_c89" = x"no"; then
+ AC_MSG_ERROR([c89 compiler support required])
+fi
+
+case $host in
+ *mingw*)
+ use_pkgconfig=no
+ ;;
+ *)
+ use_pkgconfig=yes
+ ;;
+esac
+
+case $host_os in
+ *darwin*)
+ if test x$cross_compiling != xyes; then
+ AC_PATH_PROG([BREW],brew,)
+ if test x$BREW != x; then
+ dnl These Homebrew packages may be keg-only, meaning that they won't be found
+ dnl in expected paths because they may conflict with system files. Ask
+ dnl Homebrew where each one is located, then adjust paths accordingly.
+
+ openssl_prefix=`$BREW --prefix openssl 2>/dev/null`
+ gmp_prefix=`$BREW --prefix gmp 2>/dev/null`
+ if test x$openssl_prefix != x; then
+ PKG_CONFIG_PATH="$openssl_prefix/lib/pkgconfig:$PKG_CONFIG_PATH"
+ export PKG_CONFIG_PATH
+ fi
+ if test x$gmp_prefix != x; then
+ GMP_CPPFLAGS="-I$gmp_prefix/include"
+ GMP_LIBS="-L$gmp_prefix/lib"
+ fi
+ else
+ AC_PATH_PROG([PORT],port,)
+ dnl if homebrew isn't installed and macports is, add the macports default paths
+ dnl as a last resort.
+ if test x$PORT != x; then
+ CPPFLAGS="$CPPFLAGS -isystem /opt/local/include"
+ LDFLAGS="$LDFLAGS -L/opt/local/lib"
+ fi
+ fi
+ fi
+ ;;
+esac
+
+CFLAGS="$CFLAGS -W"
+
+warn_CFLAGS="-std=c89 -pedantic -Wall -Wextra -Wcast-align -Wnested-externs -Wshadow -Wstrict-prototypes -Wno-unused-function -Wno-long-long -Wno-overlength-strings"
+saved_CFLAGS="$CFLAGS"
+CFLAGS="$CFLAGS $warn_CFLAGS"
+AC_MSG_CHECKING([if ${CC} supports ${warn_CFLAGS}])
+AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
+ [ AC_MSG_RESULT([yes]) ],
+ [ AC_MSG_RESULT([no])
+ CFLAGS="$saved_CFLAGS"
+ ])
+
+
+AC_ARG_ENABLE(benchmark,
+ AS_HELP_STRING([--enable-benchmark],[compile benchmark (default is no)]),
+ [use_benchmark=$enableval],
+ [use_benchmark=no])
+
+AC_ARG_ENABLE(tests,
+ AS_HELP_STRING([--enable-tests],[compile tests (default is yes)]),
+ [use_tests=$enableval],
+ [use_tests=yes])
+
+AC_ARG_ENABLE(endomorphism,
+ AS_HELP_STRING([--enable-endomorphism],[enable endomorphism (default is no)]),
+ [use_endomorphism=$enableval],
+ [use_endomorphism=no])
+
+AC_ARG_WITH([field], [AS_HELP_STRING([--with-field=64bit|32bit|auto],
+[Specify Field Implementation. Default is auto])],[req_field=$withval], [req_field=auto])
+
+AC_ARG_WITH([bignum], [AS_HELP_STRING([--with-bignum=gmp|no|auto],
+[Specify Bignum Implementation. Default is auto])],[req_bignum=$withval], [req_bignum=auto])
+
+AC_ARG_WITH([scalar], [AS_HELP_STRING([--with-scalar=64bit|32bit|auto],
+[Specify scalar implementation. Default is auto])],[req_scalar=$withval], [req_scalar=auto])
+
+AC_ARG_WITH([asm], [AS_HELP_STRING([--with-asm=x86_64|no|auto]
+[Specify assembly optimizations to use. Default is auto])],[req_asm=$withval], [req_asm=auto])
+
+AC_CHECK_TYPES([__int128])
+
+AC_MSG_CHECKING([for __builtin_expect])
+AC_COMPILE_IFELSE([AC_LANG_SOURCE([[void myfunc() {__builtin_expect(0,0);}]])],
+ [ AC_MSG_RESULT([yes]);AC_DEFINE(HAVE_BUILTIN_EXPECT,1,[Define this symbol if __builtin_expect is available]) ],
+ [ AC_MSG_RESULT([no])
+ ])
+
+if test x"$req_asm" = x"auto"; then
+ SECP_64BIT_ASM_CHECK
+ if test x"$has_64bit_asm" = x"yes"; then
+ set_asm=x86_64
+ fi
+ if test x"$set_asm" = x; then
+ set_asm=no
+ fi
+else
+ set_asm=$req_asm
+ case $set_asm in
+ x86_64)
+ SECP_64BIT_ASM_CHECK
+ if test x"$has_64bit_asm" != x"yes"; then
+ AC_MSG_ERROR([x86_64 assembly optimization requested but not available])
+ fi
+ ;;
+ no)
+ ;;
+ *)
+ AC_MSG_ERROR([invalid assembly optimization selection])
+ ;;
+ esac
+fi
+
+if test x"$req_field" = x"auto"; then
+ if test x"set_asm" = x"x86_64"; then
+ set_field=64bit
+ fi
+ if test x"$set_field" = x; then
+ SECP_INT128_CHECK
+ if test x"$has_int128" = x"yes"; then
+ set_field=64bit
+ fi
+ fi
+ if test x"$set_field" = x; then
+ set_field=32bit
+ fi
+else
+ set_field=$req_field
+ case $set_field in
+ 64bit)
+ if test x"$set_asm" != x"x86_64"; then
+ SECP_INT128_CHECK
+ if test x"$has_int128" != x"yes"; then
+ AC_MSG_ERROR([64bit field explicitly requested but neither __int128 support or x86_64 assembly available])
+ fi
+ fi
+ ;;
+ 32bit)
+ ;;
+ *)
+ AC_MSG_ERROR([invalid field implementation selection])
+ ;;
+ esac
+fi
+
+if test x"$req_scalar" = x"auto"; then
+ SECP_INT128_CHECK
+ if test x"$has_int128" = x"yes"; then
+ set_scalar=64bit
+ fi
+ if test x"$set_scalar" = x; then
+ set_scalar=32bit
+ fi
+else
+ set_scalar=$req_scalar
+ case $set_scalar in
+ 64bit)
+ SECP_INT128_CHECK
+ if test x"$has_int128" != x"yes"; then
+ AC_MSG_ERROR([64bit scalar explicitly requested but __int128 support not available])
+ fi
+ ;;
+ 32bit)
+ ;;
+ *)
+ AC_MSG_ERROR([invalid scalar implementation selected])
+ ;;
+ esac
+fi
+
+if test x"$req_bignum" = x"auto"; then
+ SECP_GMP_CHECK
+ if test x"$has_gmp" = x"yes"; then
+ set_bignum=gmp
+ fi
+
+ if test x"$set_bignum" = x; then
+ set_bignum=no
+ fi
+else
+ set_bignum=$req_bignum
+ case $set_bignum in
+ gmp)
+ SECP_GMP_CHECK
+ if test x"$has_gmp" != x"yes"; then
+ AC_MSG_ERROR([gmp bignum explicitly requested but libgmp not available])
+ fi
+ ;;
+ no)
+ ;;
+ *)
+ AC_MSG_ERROR([invalid bignum implementation selection])
+ ;;
+ esac
+fi
+
+# select assembly optimization
+case $set_asm in
+x86_64)
+ AC_DEFINE(USE_ASM_X86_64, 1, [Define this symbol to enable x86_64 assembly optimizations])
+ ;;
+no)
+ ;;
+*)
+ AC_MSG_ERROR([invalid assembly optimizations])
+ ;;
+esac
+
+# select field implementation
+case $set_field in
+64bit)
+ AC_DEFINE(USE_FIELD_5X52, 1, [Define this symbol to use the FIELD_5X52 implementation])
+ ;;
+32bit)
+ AC_DEFINE(USE_FIELD_10X26, 1, [Define this symbol to use the FIELD_10X26 implementation])
+ ;;
+*)
+ AC_MSG_ERROR([invalid field implementation])
+ ;;
+esac
+
+# select bignum implementation
+case $set_bignum in
+gmp)
+ AC_DEFINE(HAVE_LIBGMP, 1, [Define this symbol if libgmp is installed])
+ AC_DEFINE(USE_NUM_GMP, 1, [Define this symbol to use the gmp implementation for num])
+ AC_DEFINE(USE_FIELD_INV_NUM, 1, [Define this symbol to use the num-based field inverse implementation])
+ AC_DEFINE(USE_SCALAR_INV_NUM, 1, [Define this symbol to use the num-based scalar inverse implementation])
+ ;;
+no)
+ AC_DEFINE(USE_NUM_NONE, 1, [Define this symbol to use no num implementation])
+ AC_DEFINE(USE_FIELD_INV_BUILTIN, 1, [Define this symbol to use the native field inverse implementation])
+ AC_DEFINE(USE_SCALAR_INV_BUILTIN, 1, [Define this symbol to use the native scalar inverse implementation])
+ ;;
+*)
+ AC_MSG_ERROR([invalid bignum implementation])
+ ;;
+esac
+
+#select scalar implementation
+case $set_scalar in
+64bit)
+ AC_DEFINE(USE_SCALAR_4X64, 1, [Define this symbol to use the 4x64 scalar implementation])
+ ;;
+32bit)
+ AC_DEFINE(USE_SCALAR_8X32, 1, [Define this symbol to use the 8x32 scalar implementation])
+ ;;
+*)
+ AC_MSG_ERROR([invalid scalar implementation])
+ ;;
+esac
+
+if test x"$use_tests" = x"yes"; then
+ SECP_OPENSSL_CHECK
+ if test x"$has_openssl_ec" = x"yes"; then
+ AC_DEFINE(ENABLE_OPENSSL_TESTS, 1, [Define this symbol if OpenSSL EC functions are available])
+ SECP_TEST_INCLUDES="$SSL_CFLAGS $CRYPTO_CFLAGS"
+ SECP_TEST_LIBS="$CRYPTO_LIBS"
+
+ case $host in
+ *mingw*)
+ SECP_TEST_LIBS="$SECP_TEST_LIBS -lgdi32"
+ ;;
+ esac
+
+ fi
+fi
+
+if test x"$set_bignum" = x"gmp"; then
+ SECP_LIBS="$SECP_LIBS $GMP_LIBS"
+ SECP_INCLUDES="$SECP_INCLUDES $GMP_CPPFLAGS"
+fi
+
+if test x"$use_endomorphism" = x"yes"; then
+ AC_DEFINE(USE_ENDOMORPHISM, 1, [Define this symbol to use endomorphism optimization])
+fi
+
+AC_C_BIGENDIAN()
+
+AC_MSG_NOTICE([Using assembly optimizations: $set_asm])
+AC_MSG_NOTICE([Using field implementation: $set_field])
+AC_MSG_NOTICE([Using bignum implementation: $set_bignum])
+AC_MSG_NOTICE([Using scalar implementation: $set_scalar])
+AC_MSG_NOTICE([Using endomorphism optimizations: $use_endomorphism])
+
+AC_CONFIG_HEADERS([src/libsecp256k1-config.h])
+AC_CONFIG_FILES([Makefile libsecp256k1.pc])
+AC_SUBST(SECP_INCLUDES)
+AC_SUBST(SECP_LIBS)
+AC_SUBST(SECP_TEST_LIBS)
+AC_SUBST(SECP_TEST_INCLUDES)
+AM_CONDITIONAL([USE_TESTS], [test x"$use_tests" != x"no"])
+AM_CONDITIONAL([USE_BENCHMARK], [test x"$use_benchmark" = x"yes"])
+
+dnl make sure nothing new is exported so that we don't break the cache
+PKGCONFIG_PATH_TEMP="$PKG_CONFIG_PATH"
+unset PKG_CONFIG_PATH
+PKG_CONFIG_PATH="$PKGCONFIG_PATH_TEMP"
+
+AC_OUTPUT
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/include/secp256k1.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/include/secp256k1.h
new file mode 100644
index 0000000000000000000000000000000000000000..a6e39d13dbe652cac1abcda81fc74cff9495bd94
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/include/secp256k1.h
@@ -0,0 +1,295 @@
+#ifndef _SECP256K1_
+# define _SECP256K1_
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+# if !defined(SECP256K1_GNUC_PREREQ)
+# if defined(__GNUC__)&&defined(__GNUC_MINOR__)
+# define SECP256K1_GNUC_PREREQ(_maj,_min) \
+ ((__GNUC__<<16)+__GNUC_MINOR__>=((_maj)<<16)+(_min))
+# else
+# define SECP256K1_GNUC_PREREQ(_maj,_min) 0
+# endif
+# endif
+
+# if (!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) )
+# if SECP256K1_GNUC_PREREQ(2,7)
+# define SECP256K1_INLINE __inline__
+# elif (defined(_MSC_VER))
+# define SECP256K1_INLINE __inline
+# else
+# define SECP256K1_INLINE
+# endif
+# else
+# define SECP256K1_INLINE inline
+# endif
+
+/**Warning attributes
+ * NONNULL is not used if SECP256K1_BUILD is set to avoid the compiler optimizing out
+ * some paranoid null checks. */
+# if defined(__GNUC__) && SECP256K1_GNUC_PREREQ(3, 4)
+# define SECP256K1_WARN_UNUSED_RESULT __attribute__ ((__warn_unused_result__))
+# else
+# define SECP256K1_WARN_UNUSED_RESULT
+# endif
+# if !defined(SECP256K1_BUILD) && defined(__GNUC__) && SECP256K1_GNUC_PREREQ(3, 4)
+# define SECP256K1_ARG_NONNULL(_x) __attribute__ ((__nonnull__(_x)))
+# else
+# define SECP256K1_ARG_NONNULL(_x)
+# endif
+
+
+/** Flags to pass to secp256k1_start. */
+# define SECP256K1_START_VERIFY (1 << 0)
+# define SECP256K1_START_SIGN (1 << 1)
+
+/** Initialize the library. This may take some time (10-100 ms).
+ * You need to call this before calling any other function.
+ * It cannot run in parallel with any other functions, but once
+ * secp256k1_start() returns, all other functions are thread-safe.
+ */
+void secp256k1_start(unsigned int flags);
+
+/** Free all memory associated with this library. After this, no
+ * functions can be called anymore, except secp256k1_start()
+ */
+void secp256k1_stop(void);
+
+/** Verify an ECDSA signature.
+ * Returns: 1: correct signature
+ * 0: incorrect signature
+ * -1: invalid public key
+ * -2: invalid signature
+ * In: msg32: the 32-byte message hash being verified (cannot be NULL)
+ * sig: the signature being verified (cannot be NULL)
+ * siglen: the length of the signature
+ * pubkey: the public key to verify with (cannot be NULL)
+ * pubkeylen: the length of pubkey
+ * Requires starting using SECP256K1_START_VERIFY.
+ */
+SECP256K1_WARN_UNUSED_RESULT int secp256k1_ecdsa_verify(
+ const unsigned char *msg32,
+ const unsigned char *sig,
+ int siglen,
+ const unsigned char *pubkey,
+ int pubkeylen
+) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(4);
+
+/** A pointer to a function to deterministically generate a nonce.
+ * Returns: 1 if a nonce was successfully generated. 0 will cause signing to fail.
+ * In: msg32: the 32-byte message hash being verified (will not be NULL)
+ * key32: pointer to a 32-byte secret key (will not be NULL)
+ * attempt: how many iterations we have tried to find a nonce.
+ * This will almost always be 0, but different attempt values
+ * are required to result in a different nonce.
+ * data: Arbitrary data pointer that is passed through.
+ * Out: nonce32: pointer to a 32-byte array to be filled by the function.
+ * Except for test cases, this function should compute some cryptographic hash of
+ * the message, the key and the attempt.
+ */
+typedef int (*secp256k1_nonce_function_t)(
+ unsigned char *nonce32,
+ const unsigned char *msg32,
+ const unsigned char *key32,
+ unsigned int attempt,
+ const void *data
+);
+
+/** An implementation of RFC6979 (using HMAC-SHA256) as nonce generation function.
+ * If a data pointer is passed, it is assumed to be a pointer to 32 bytes of
+ * extra entropy.
+ */
+extern const secp256k1_nonce_function_t secp256k1_nonce_function_rfc6979;
+
+/** A default safe nonce generation function (currently equal to secp256k1_nonce_function_rfc6979). */
+extern const secp256k1_nonce_function_t secp256k1_nonce_function_default;
+
+
+/** Create an ECDSA signature.
+ * Returns: 1: signature created
+ * 0: the nonce generation function failed, the private key was invalid, or there is not
+ * enough space in the signature (as indicated by siglen).
+ * In: msg32: the 32-byte message hash being signed (cannot be NULL)
+ * seckey: pointer to a 32-byte secret key (cannot be NULL)
+ * noncefp:pointer to a nonce generation function. If NULL, secp256k1_nonce_function_default is used
+ * ndata: pointer to arbitrary data used by the nonce generation function (can be NULL)
+ * Out: sig: pointer to an array where the signature will be placed (cannot be NULL)
+ * In/Out: siglen: pointer to an int with the length of sig, which will be updated
+ * to contain the actual signature length (<=72). If 0 is returned, this will be
+ * set to zero.
+ * Requires starting using SECP256K1_START_SIGN.
+ *
+ * The sig always has an s value in the lower half of the range (From 0x1
+ * to 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,
+ * inclusive), unlike many other implementations.
+ * With ECDSA a third-party can can forge a second distinct signature
+ * of the same message given a single initial signature without knowing
+ * the key by setting s to its additive inverse mod-order, 'flipping' the
+ * sign of the random point R which is not included in the signature.
+ * Since the forgery is of the same message this isn't universally
+ * problematic, but in systems where message malleability or uniqueness
+ * of signatures is important this can cause issues. This forgery can be
+ * blocked by all verifiers forcing signers to use a canonical form. The
+ * lower-S form reduces the size of signatures slightly on average when
+ * variable length encodings (such as DER) are used and is cheap to
+ * verify, making it a good choice. Security of always using lower-S is
+ * assured because anyone can trivially modify a signature after the
+ * fact to enforce this property. Adjusting it inside the signing
+ * function avoids the need to re-serialize or have curve specific
+ * constants outside of the library. By always using a canonical form
+ * even in applications where it isn't needed it becomes possible to
+ * impose a requirement later if a need is discovered.
+ * No other forms of ECDSA malleability are known and none seem likely,
+ * but there is no formal proof that ECDSA, even with this additional
+ * restriction, is free of other malleability. Commonly used serialization
+ * schemes will also accept various non-unique encodings, so care should
+ * be taken when this property is required for an application.
+ */
+int secp256k1_ecdsa_sign(
+ const unsigned char *msg32,
+ unsigned char *sig,
+ int *siglen,
+ const unsigned char *seckey,
+ secp256k1_nonce_function_t noncefp,
+ const void *ndata
+) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
+
+/** Create a compact ECDSA signature (64 byte + recovery id).
+ * Returns: 1: signature created
+ * 0: the nonce generation function failed, or the secret key was invalid.
+ * In: msg32: the 32-byte message hash being signed (cannot be NULL)
+ * seckey: pointer to a 32-byte secret key (cannot be NULL)
+ * noncefp:pointer to a nonce generation function. If NULL, secp256k1_nonce_function_default is used
+ * ndata: pointer to arbitrary data used by the nonce generation function (can be NULL)
+ * Out: sig: pointer to a 64-byte array where the signature will be placed (cannot be NULL)
+ * In case 0 is returned, the returned signature length will be zero.
+ * recid: pointer to an int, which will be updated to contain the recovery id (can be NULL)
+ * Requires starting using SECP256K1_START_SIGN.
+ */
+int secp256k1_ecdsa_sign_compact(
+ const unsigned char *msg32,
+ unsigned char *sig64,
+ const unsigned char *seckey,
+ secp256k1_nonce_function_t noncefp,
+ const void *ndata,
+ int *recid
+) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
+
+/** Recover an ECDSA public key from a compact signature.
+ * Returns: 1: public key successfully recovered (which guarantees a correct signature).
+ * 0: otherwise.
+ * In: msg32: the 32-byte message hash assumed to be signed (cannot be NULL)
+ * sig64: signature as 64 byte array (cannot be NULL)
+ * compressed: whether to recover a compressed or uncompressed pubkey
+ * recid: the recovery id (0-3, as returned by ecdsa_sign_compact)
+ * Out: pubkey: pointer to a 33 or 65 byte array to put the pubkey (cannot be NULL)
+ * pubkeylen: pointer to an int that will contain the pubkey length (cannot be NULL)
+ * Requires starting using SECP256K1_START_VERIFY.
+ */
+SECP256K1_WARN_UNUSED_RESULT int secp256k1_ecdsa_recover_compact(
+ const unsigned char *msg32,
+ const unsigned char *sig64,
+ unsigned char *pubkey,
+ int *pubkeylen,
+ int compressed,
+ int recid
+) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
+
+/** Verify an ECDSA secret key.
+ * Returns: 1: secret key is valid
+ * 0: secret key is invalid
+ * In: seckey: pointer to a 32-byte secret key (cannot be NULL)
+ */
+SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_seckey_verify(const unsigned char *seckey) SECP256K1_ARG_NONNULL(1);
+
+/** Just validate a public key.
+ * Returns: 1: valid public key
+ * 0: invalid public key
+ * In: pubkey: pointer to a 33-byte or 65-byte public key (cannot be NULL).
+ * pubkeylen: length of pubkey
+ */
+SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_verify(const unsigned char *pubkey, int pubkeylen) SECP256K1_ARG_NONNULL(1);
+
+/** Compute the public key for a secret key.
+ * In: compressed: whether the computed public key should be compressed
+ * seckey: pointer to a 32-byte private key (cannot be NULL)
+ * Out: pubkey: pointer to a 33-byte (if compressed) or 65-byte (if uncompressed)
+ * area to store the public key (cannot be NULL)
+ * pubkeylen: pointer to int that will be updated to contains the pubkey's
+ * length (cannot be NULL)
+ * Returns: 1: secret was valid, public key stores
+ * 0: secret was invalid, try again.
+ * Requires starting using SECP256K1_START_SIGN.
+ */
+SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_create(
+ unsigned char *pubkey,
+ int *pubkeylen,
+ const unsigned char *seckey,
+ int compressed
+) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
+
+/** Decompress a public key.
+ * In/Out: pubkey: pointer to a 65-byte array to put the decompressed public key.
+ It must contain a 33-byte or 65-byte public key already (cannot be NULL)
+ * pubkeylen: pointer to the size of the public key pointed to by pubkey (cannot be NULL)
+ It will be updated to reflect the new size.
+ * Returns: 0 if the passed public key was invalid, 1 otherwise. If 1 is returned, the
+ pubkey is replaced with its decompressed version.
+ */
+SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_decompress(
+ unsigned char *pubkey,
+ int *pubkeylen
+) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2);
+
+/** Export a private key in DER format. */
+SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_privkey_export(
+ const unsigned char *seckey,
+ unsigned char *privkey,
+ int *privkeylen,
+ int compressed
+) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
+
+/** Import a private key in DER format. */
+SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_privkey_import(
+ unsigned char *seckey,
+ const unsigned char *privkey,
+ int privkeylen
+) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2);
+
+/** Tweak a private key by adding tweak to it. */
+SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_privkey_tweak_add(
+ unsigned char *seckey,
+ const unsigned char *tweak
+) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2);
+
+/** Tweak a public key by adding tweak times the generator to it.
+ * Requires starting with SECP256K1_START_VERIFY.
+ */
+SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_tweak_add(
+ unsigned char *pubkey,
+ int pubkeylen,
+ const unsigned char *tweak
+) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(3);
+
+/** Tweak a private key by multiplying it with tweak. */
+SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_privkey_tweak_mul(
+ unsigned char *seckey,
+ const unsigned char *tweak
+) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2);
+
+/** Tweak a public key by multiplying it with tweak.
+ * Requires starting with SECP256K1_START_VERIFY.
+ */
+SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_tweak_mul(
+ unsigned char *pubkey,
+ int pubkeylen,
+ const unsigned char *tweak
+) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(3);
+
+# ifdef __cplusplus
+}
+# endif
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/libsecp256k1.pc.in b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/libsecp256k1.pc.in
new file mode 100644
index 0000000000000000000000000000000000000000..1c72dd00037b5cbef34d24792f809d700049e105
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/libsecp256k1.pc.in
@@ -0,0 +1,13 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: libsecp256k1
+Description: Optimized C library for EC operations on curve secp256k1
+URL: https://github.com/bitcoin/secp256k1
+Version: @PACKAGE_VERSION@
+Cflags: -I${includedir}
+Libs.private: @SECP_LIBS@
+Libs: -L${libdir} -lsecp256k1
+
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/obj/.gitignore b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/obj/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/bench.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/bench.h
new file mode 100644
index 0000000000000000000000000000000000000000..0559b3e85352c55858d830cb98fed25af4fe4e19
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/bench.h
@@ -0,0 +1,56 @@
+/**********************************************************************
+ * Copyright (c) 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_BENCH_H_
+#define _SECP256K1_BENCH_H_
+
+#include <stdio.h>
+#include <math.h>
+#include "sys/time.h"
+
+static double gettimedouble(void) {
+ struct timeval tv;
+ gettimeofday(&tv, NULL);
+ return tv.tv_usec * 0.000001 + tv.tv_sec;
+}
+
+void print_number(double x) {
+ double y = x;
+ int c = 0;
+ if (y < 0.0) y = -y;
+ while (y < 100.0) {
+ y *= 10.0;
+ c++;
+ }
+ printf("%.*f", c, x);
+}
+
+void run_benchmark(char *name, void (*benchmark)(void*), void (*setup)(void*), void (*teardown)(void*), void* data, int count, int iter) {
+ int i;
+ double min = HUGE_VAL;
+ double sum = 0.0;
+ double max = 0.0;
+ for (i = 0; i < count; i++) {
+ double begin, total;
+ if (setup) setup(data);
+ begin = gettimedouble();
+ benchmark(data);
+ total = gettimedouble() - begin;
+ if (teardown) teardown(data);
+ if (total < min) min = total;
+ if (total > max) max = total;
+ sum += total;
+ }
+ printf("%s: min ", name);
+ print_number(min * 1000000.0 / iter);
+ printf("us / avg ");
+ print_number((sum / count) * 1000000.0 / iter);
+ printf("us / avg ");
+ print_number(max * 1000000.0 / iter);
+ printf("us\n");
+}
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/bench_internal.c b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/bench_internal.c
new file mode 100644
index 0000000000000000000000000000000000000000..a960549b94ff0f57db967f556c4d339de5505659
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/bench_internal.c
@@ -0,0 +1,318 @@
+/**********************************************************************
+ * Copyright (c) 2014-2015 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+#include <stdio.h>
+
+#include "include/secp256k1.h"
+
+#include "util.h"
+#include "hash_impl.h"
+#include "num_impl.h"
+#include "field_impl.h"
+#include "group_impl.h"
+#include "scalar_impl.h"
+#include "ecmult_impl.h"
+#include "bench.h"
+
+typedef struct {
+ secp256k1_scalar_t scalar_x, scalar_y;
+ secp256k1_fe_t fe_x, fe_y;
+ secp256k1_ge_t ge_x, ge_y;
+ secp256k1_gej_t gej_x, gej_y;
+ unsigned char data[32];
+ int wnaf[256];
+} bench_inv_t;
+
+void bench_setup(void* arg) {
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ static const unsigned char init_x[32] = {
+ 0x02, 0x03, 0x05, 0x07, 0x0b, 0x0d, 0x11, 0x13,
+ 0x17, 0x1d, 0x1f, 0x25, 0x29, 0x2b, 0x2f, 0x35,
+ 0x3b, 0x3d, 0x43, 0x47, 0x49, 0x4f, 0x53, 0x59,
+ 0x61, 0x65, 0x67, 0x6b, 0x6d, 0x71, 0x7f, 0x83
+ };
+
+ static const unsigned char init_y[32] = {
+ 0x82, 0x83, 0x85, 0x87, 0x8b, 0x8d, 0x81, 0x83,
+ 0x97, 0xad, 0xaf, 0xb5, 0xb9, 0xbb, 0xbf, 0xc5,
+ 0xdb, 0xdd, 0xe3, 0xe7, 0xe9, 0xef, 0xf3, 0xf9,
+ 0x11, 0x15, 0x17, 0x1b, 0x1d, 0xb1, 0xbf, 0xd3
+ };
+
+ secp256k1_scalar_set_b32(&data->scalar_x, init_x, NULL);
+ secp256k1_scalar_set_b32(&data->scalar_y, init_y, NULL);
+ secp256k1_fe_set_b32(&data->fe_x, init_x);
+ secp256k1_fe_set_b32(&data->fe_y, init_y);
+ CHECK(secp256k1_ge_set_xo_var(&data->ge_x, &data->fe_x, 0));
+ CHECK(secp256k1_ge_set_xo_var(&data->ge_y, &data->fe_y, 1));
+ secp256k1_gej_set_ge(&data->gej_x, &data->ge_x);
+ secp256k1_gej_set_ge(&data->gej_y, &data->ge_y);
+ memcpy(data->data, init_x, 32);
+}
+
+void bench_scalar_add(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 2000000; i++) {
+ secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
+ }
+}
+
+void bench_scalar_negate(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 2000000; i++) {
+ secp256k1_scalar_negate(&data->scalar_x, &data->scalar_x);
+ }
+}
+
+void bench_scalar_sqr(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 200000; i++) {
+ secp256k1_scalar_sqr(&data->scalar_x, &data->scalar_x);
+ }
+}
+
+void bench_scalar_mul(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 200000; i++) {
+ secp256k1_scalar_mul(&data->scalar_x, &data->scalar_x, &data->scalar_y);
+ }
+}
+
+#ifdef USE_ENDOMORPHISM
+void bench_scalar_split(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 20000; i++) {
+ secp256k1_scalar_t l, r;
+ secp256k1_scalar_split_lambda_var(&l, &r, &data->scalar_x);
+ secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
+ }
+}
+#endif
+
+void bench_scalar_inverse(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 2000; i++) {
+ secp256k1_scalar_inverse(&data->scalar_x, &data->scalar_x);
+ secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
+ }
+}
+
+void bench_scalar_inverse_var(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 2000; i++) {
+ secp256k1_scalar_inverse_var(&data->scalar_x, &data->scalar_x);
+ secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
+ }
+}
+
+void bench_field_normalize(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 2000000; i++) {
+ secp256k1_fe_normalize(&data->fe_x);
+ }
+}
+
+void bench_field_normalize_weak(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 2000000; i++) {
+ secp256k1_fe_normalize_weak(&data->fe_x);
+ }
+}
+
+void bench_field_mul(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 200000; i++) {
+ secp256k1_fe_mul(&data->fe_x, &data->fe_x, &data->fe_y);
+ }
+}
+
+void bench_field_sqr(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 200000; i++) {
+ secp256k1_fe_sqr(&data->fe_x, &data->fe_x);
+ }
+}
+
+void bench_field_inverse(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 20000; i++) {
+ secp256k1_fe_inv(&data->fe_x, &data->fe_x);
+ secp256k1_fe_add(&data->fe_x, &data->fe_y);
+ }
+}
+
+void bench_field_inverse_var(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 20000; i++) {
+ secp256k1_fe_inv_var(&data->fe_x, &data->fe_x);
+ secp256k1_fe_add(&data->fe_x, &data->fe_y);
+ }
+}
+
+void bench_field_sqrt_var(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 20000; i++) {
+ secp256k1_fe_sqrt_var(&data->fe_x, &data->fe_x);
+ secp256k1_fe_add(&data->fe_x, &data->fe_y);
+ }
+}
+
+void bench_group_double_var(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 200000; i++) {
+ secp256k1_gej_double_var(&data->gej_x, &data->gej_x);
+ }
+}
+
+void bench_group_add_var(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 200000; i++) {
+ secp256k1_gej_add_var(&data->gej_x, &data->gej_x, &data->gej_y);
+ }
+}
+
+void bench_group_add_affine(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 200000; i++) {
+ secp256k1_gej_add_ge(&data->gej_x, &data->gej_x, &data->ge_y);
+ }
+}
+
+void bench_group_add_affine_var(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 200000; i++) {
+ secp256k1_gej_add_ge_var(&data->gej_x, &data->gej_x, &data->ge_y);
+ }
+}
+
+void bench_ecmult_wnaf(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+
+ for (i = 0; i < 20000; i++) {
+ secp256k1_ecmult_wnaf(data->wnaf, &data->scalar_x, WINDOW_A);
+ secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
+ }
+}
+
+
+void bench_sha256(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+ secp256k1_sha256_t sha;
+
+ for (i = 0; i < 20000; i++) {
+ secp256k1_sha256_initialize(&sha);
+ secp256k1_sha256_write(&sha, data->data, 32);
+ secp256k1_sha256_finalize(&sha, data->data);
+ }
+}
+
+void bench_hmac_sha256(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+ secp256k1_hmac_sha256_t hmac;
+
+ for (i = 0; i < 20000; i++) {
+ secp256k1_hmac_sha256_initialize(&hmac, data->data, 32);
+ secp256k1_hmac_sha256_write(&hmac, data->data, 32);
+ secp256k1_hmac_sha256_finalize(&hmac, data->data);
+ }
+}
+
+void bench_rfc6979_hmac_sha256(void* arg) {
+ int i;
+ bench_inv_t *data = (bench_inv_t*)arg;
+ secp256k1_rfc6979_hmac_sha256_t rng;
+
+ for (i = 0; i < 20000; i++) {
+ secp256k1_rfc6979_hmac_sha256_initialize(&rng, data->data, 32, data->data, 32, NULL, 0);
+ secp256k1_rfc6979_hmac_sha256_generate(&rng, data->data, 32);
+ }
+}
+
+
+int have_flag(int argc, char** argv, char *flag) {
+ char** argm = argv + argc;
+ argv++;
+ if (argv == argm) {
+ return 1;
+ }
+ while (argv != NULL && argv != argm) {
+ if (strcmp(*argv, flag) == 0) return 1;
+ argv++;
+ }
+ return 0;
+}
+
+int main(int argc, char **argv) {
+ bench_inv_t data;
+ if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "add")) run_benchmark("scalar_add", bench_scalar_add, bench_setup, NULL, &data, 10, 2000000);
+ if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "negate")) run_benchmark("scalar_negate", bench_scalar_negate, bench_setup, NULL, &data, 10, 2000000);
+ if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "sqr")) run_benchmark("scalar_sqr", bench_scalar_sqr, bench_setup, NULL, &data, 10, 200000);
+ if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "mul")) run_benchmark("scalar_mul", bench_scalar_mul, bench_setup, NULL, &data, 10, 200000);
+#ifdef USE_ENDOMORPHISM
+ if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "split")) run_benchmark("scalar_split", bench_scalar_split, bench_setup, NULL, &data, 10, 20000);
+#endif
+ if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "inverse")) run_benchmark("scalar_inverse", bench_scalar_inverse, bench_setup, NULL, &data, 10, 2000);
+ if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "inverse")) run_benchmark("scalar_inverse_var", bench_scalar_inverse_var, bench_setup, NULL, &data, 10, 2000);
+
+ if (have_flag(argc, argv, "field") || have_flag(argc, argv, "normalize")) run_benchmark("field_normalize", bench_field_normalize, bench_setup, NULL, &data, 10, 2000000);
+ if (have_flag(argc, argv, "field") || have_flag(argc, argv, "normalize")) run_benchmark("field_normalize_weak", bench_field_normalize_weak, bench_setup, NULL, &data, 10, 2000000);
+ if (have_flag(argc, argv, "field") || have_flag(argc, argv, "sqr")) run_benchmark("field_sqr", bench_field_sqr, bench_setup, NULL, &data, 10, 200000);
+ if (have_flag(argc, argv, "field") || have_flag(argc, argv, "mul")) run_benchmark("field_mul", bench_field_mul, bench_setup, NULL, &data, 10, 200000);
+ if (have_flag(argc, argv, "field") || have_flag(argc, argv, "inverse")) run_benchmark("field_inverse", bench_field_inverse, bench_setup, NULL, &data, 10, 20000);
+ if (have_flag(argc, argv, "field") || have_flag(argc, argv, "inverse")) run_benchmark("field_inverse_var", bench_field_inverse_var, bench_setup, NULL, &data, 10, 20000);
+ if (have_flag(argc, argv, "field") || have_flag(argc, argv, "sqrt")) run_benchmark("field_sqrt_var", bench_field_sqrt_var, bench_setup, NULL, &data, 10, 20000);
+
+ if (have_flag(argc, argv, "group") || have_flag(argc, argv, "double")) run_benchmark("group_double_var", bench_group_double_var, bench_setup, NULL, &data, 10, 200000);
+ if (have_flag(argc, argv, "group") || have_flag(argc, argv, "add")) run_benchmark("group_add_var", bench_group_add_var, bench_setup, NULL, &data, 10, 200000);
+ if (have_flag(argc, argv, "group") || have_flag(argc, argv, "add")) run_benchmark("group_add_affine", bench_group_add_affine, bench_setup, NULL, &data, 10, 200000);
+ if (have_flag(argc, argv, "group") || have_flag(argc, argv, "add")) run_benchmark("group_add_affine_var", bench_group_add_affine_var, bench_setup, NULL, &data, 10, 200000);
+
+ if (have_flag(argc, argv, "ecmult") || have_flag(argc, argv, "wnaf")) run_benchmark("ecmult_wnaf", bench_ecmult_wnaf, bench_setup, NULL, &data, 10, 20000);
+
+ if (have_flag(argc, argv, "hash") || have_flag(argc, argv, "sha256")) run_benchmark("hash_sha256", bench_sha256, bench_setup, NULL, &data, 10, 20000);
+ if (have_flag(argc, argv, "hash") || have_flag(argc, argv, "hmac")) run_benchmark("hash_hmac_sha256", bench_hmac_sha256, bench_setup, NULL, &data, 10, 20000);
+ if (have_flag(argc, argv, "hash") || have_flag(argc, argv, "rng6979")) run_benchmark("hash_rfc6979_hmac_sha256", bench_rfc6979_hmac_sha256, bench_setup, NULL, &data, 10, 20000);
+ return 0;
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/bench_recover.c b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/bench_recover.c
new file mode 100644
index 0000000000000000000000000000000000000000..6991cc9d6c595765386fefcb99270ecf7b0a9935
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/bench_recover.c
@@ -0,0 +1,49 @@
+/**********************************************************************
+ * Copyright (c) 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#include "include/secp256k1.h"
+#include "util.h"
+#include "bench.h"
+
+typedef struct {
+ unsigned char msg[32];
+ unsigned char sig[64];
+} bench_recover_t;
+
+void bench_recover(void* arg) {
+ int i;
+ bench_recover_t *data = (bench_recover_t*)arg;
+ unsigned char pubkey[33];
+
+ for (i = 0; i < 20000; i++) {
+ int j;
+ int pubkeylen = 33;
+ CHECK(secp256k1_ecdsa_recover_compact(data->msg, data->sig, pubkey, &pubkeylen, 1, i % 2));
+ for (j = 0; j < 32; j++) {
+ data->sig[j + 32] = data->msg[j]; /* Move former message to S. */
+ data->msg[j] = data->sig[j]; /* Move former R to message. */
+ data->sig[j] = pubkey[j + 1]; /* Move recovered pubkey X coordinate to R (which must be a valid X coordinate). */
+ }
+ }
+}
+
+void bench_recover_setup(void* arg) {
+ int i;
+ bench_recover_t *data = (bench_recover_t*)arg;
+
+ for (i = 0; i < 32; i++) data->msg[i] = 1 + i;
+ for (i = 0; i < 64; i++) data->sig[i] = 65 + i;
+}
+
+int main(void) {
+ bench_recover_t data;
+ secp256k1_start(SECP256K1_START_VERIFY);
+
+ run_benchmark("ecdsa_recover", bench_recover, bench_recover_setup, NULL, &data, 10, 20000);
+
+ secp256k1_stop();
+ return 0;
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/bench_sign.c b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/bench_sign.c
new file mode 100644
index 0000000000000000000000000000000000000000..c5b6829a84639a647a136a404bfd77afd36a0f8f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/bench_sign.c
@@ -0,0 +1,48 @@
+/**********************************************************************
+ * Copyright (c) 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#include "include/secp256k1.h"
+#include "util.h"
+#include "bench.h"
+
+typedef struct {
+ unsigned char msg[32];
+ unsigned char key[32];
+} bench_sign_t;
+
+static void bench_sign_setup(void* arg) {
+ int i;
+ bench_sign_t *data = (bench_sign_t*)arg;
+
+ for (i = 0; i < 32; i++) data->msg[i] = i + 1;
+ for (i = 0; i < 32; i++) data->key[i] = i + 65;
+}
+
+static void bench_sign(void* arg) {
+ int i;
+ bench_sign_t *data = (bench_sign_t*)arg;
+
+ unsigned char sig[64];
+ for (i = 0; i < 20000; i++) {
+ int j;
+ int recid = 0;
+ CHECK(secp256k1_ecdsa_sign_compact(data->msg, sig, data->key, NULL, NULL, &recid));
+ for (j = 0; j < 32; j++) {
+ data->msg[j] = sig[j]; /* Move former R to message. */
+ data->key[j] = sig[j + 32]; /* Move former S to key. */
+ }
+ }
+}
+
+int main(void) {
+ bench_sign_t data;
+ secp256k1_start(SECP256K1_START_SIGN);
+
+ run_benchmark("ecdsa_sign", bench_sign, bench_sign_setup, NULL, &data, 10, 20000);
+
+ secp256k1_stop();
+ return 0;
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/bench_verify.c b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/bench_verify.c
new file mode 100644
index 0000000000000000000000000000000000000000..c279305a0dba6e7560bc834e011f574a30c8ccd0
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/bench_verify.c
@@ -0,0 +1,55 @@
+/**********************************************************************
+ * Copyright (c) 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+
+#include "include/secp256k1.h"
+#include "util.h"
+#include "bench.h"
+
+typedef struct {
+ unsigned char msg[32];
+ unsigned char key[32];
+ unsigned char sig[72];
+ int siglen;
+ unsigned char pubkey[33];
+ int pubkeylen;
+} benchmark_verify_t;
+
+static void benchmark_verify(void* arg) {
+ int i;
+ benchmark_verify_t* data = (benchmark_verify_t*)arg;
+
+ for (i = 0; i < 20000; i++) {
+ data->sig[data->siglen - 1] ^= (i & 0xFF);
+ data->sig[data->siglen - 2] ^= ((i >> 8) & 0xFF);
+ data->sig[data->siglen - 3] ^= ((i >> 16) & 0xFF);
+ CHECK(secp256k1_ecdsa_verify(data->msg, data->sig, data->siglen, data->pubkey, data->pubkeylen) == (i == 0));
+ data->sig[data->siglen - 1] ^= (i & 0xFF);
+ data->sig[data->siglen - 2] ^= ((i >> 8) & 0xFF);
+ data->sig[data->siglen - 3] ^= ((i >> 16) & 0xFF);
+ }
+}
+
+int main(void) {
+ int i;
+ benchmark_verify_t data;
+
+ secp256k1_start(SECP256K1_START_VERIFY | SECP256K1_START_SIGN);
+
+ for (i = 0; i < 32; i++) data.msg[i] = 1 + i;
+ for (i = 0; i < 32; i++) data.key[i] = 33 + i;
+ data.siglen = 72;
+ secp256k1_ecdsa_sign(data.msg, data.sig, &data.siglen, data.key, NULL, NULL);
+ data.pubkeylen = 33;
+ CHECK(secp256k1_ec_pubkey_create(data.pubkey, &data.pubkeylen, data.key, 1));
+
+ run_benchmark("ecdsa_verify", benchmark_verify, NULL, NULL, &data, 10, 20000);
+
+ secp256k1_stop();
+ return 0;
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/ecdsa.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/ecdsa.h
new file mode 100644
index 0000000000000000000000000000000000000000..c195e7afcbf115e4efaceca526aabdd80a8c0c2d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/ecdsa.h
@@ -0,0 +1,23 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_ECDSA_
+#define _SECP256K1_ECDSA_
+
+#include "scalar.h"
+#include "group.h"
+
+typedef struct {
+ secp256k1_scalar_t r, s;
+} secp256k1_ecdsa_sig_t;
+
+static int secp256k1_ecdsa_sig_parse(secp256k1_ecdsa_sig_t *r, const unsigned char *sig, int size);
+static int secp256k1_ecdsa_sig_serialize(unsigned char *sig, int *size, const secp256k1_ecdsa_sig_t *a);
+static int secp256k1_ecdsa_sig_verify(const secp256k1_ecdsa_sig_t *sig, const secp256k1_ge_t *pubkey, const secp256k1_scalar_t *message);
+static int secp256k1_ecdsa_sig_sign(secp256k1_ecdsa_sig_t *sig, const secp256k1_scalar_t *seckey, const secp256k1_scalar_t *message, const secp256k1_scalar_t *nonce, int *recid);
+static int secp256k1_ecdsa_sig_recover(const secp256k1_ecdsa_sig_t *sig, secp256k1_ge_t *pubkey, const secp256k1_scalar_t *message, int recid);
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/ecdsa_impl.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/ecdsa_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..17514047b9c72afe866ed2abcbbd4a114cf45135
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/ecdsa_impl.h
@@ -0,0 +1,263 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+
+#ifndef _SECP256K1_ECDSA_IMPL_H_
+#define _SECP256K1_ECDSA_IMPL_H_
+
+#include "scalar.h"
+#include "field.h"
+#include "group.h"
+#include "ecmult.h"
+#include "ecmult_gen.h"
+#include "ecdsa.h"
+
+/** Group order for secp256k1 defined as 'n' in "Standards for Efficient Cryptography" (SEC2) 2.7.1
+ * sage: for t in xrange(1023, -1, -1):
+ * .. p = 2**256 - 2**32 - t
+ * .. if p.is_prime():
+ * .. print '%x'%p
+ * .. break
+ * 'fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f'
+ * sage: a = 0
+ * sage: b = 7
+ * sage: F = FiniteField (p)
+ * sage: '%x' % (EllipticCurve ([F (a), F (b)]).order())
+ * 'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141'
+ */
+static const secp256k1_fe_t secp256k1_ecdsa_const_order_as_fe = SECP256K1_FE_CONST(
+ 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFEUL,
+ 0xBAAEDCE6UL, 0xAF48A03BUL, 0xBFD25E8CUL, 0xD0364141UL
+);
+
+/** Difference between field and order, values 'p' and 'n' values defined in
+ * "Standards for Efficient Cryptography" (SEC2) 2.7.1.
+ * sage: p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
+ * sage: a = 0
+ * sage: b = 7
+ * sage: F = FiniteField (p)
+ * sage: '%x' % (p - EllipticCurve ([F (a), F (b)]).order())
+ * '14551231950b75fc4402da1722fc9baee'
+ */
+static const secp256k1_fe_t secp256k1_ecdsa_const_p_minus_order = SECP256K1_FE_CONST(
+ 0, 0, 0, 1, 0x45512319UL, 0x50B75FC4UL, 0x402DA172UL, 0x2FC9BAEEUL
+);
+
+static int secp256k1_ecdsa_sig_parse(secp256k1_ecdsa_sig_t *r, const unsigned char *sig, int size) {
+ unsigned char ra[32] = {0}, sa[32] = {0};
+ const unsigned char *rp;
+ const unsigned char *sp;
+ int lenr;
+ int lens;
+ int overflow;
+ if (sig[0] != 0x30) {
+ return 0;
+ }
+ lenr = sig[3];
+ if (5+lenr >= size) {
+ return 0;
+ }
+ lens = sig[lenr+5];
+ if (sig[1] != lenr+lens+4) {
+ return 0;
+ }
+ if (lenr+lens+6 > size) {
+ return 0;
+ }
+ if (sig[2] != 0x02) {
+ return 0;
+ }
+ if (lenr == 0) {
+ return 0;
+ }
+ if (sig[lenr+4] != 0x02) {
+ return 0;
+ }
+ if (lens == 0) {
+ return 0;
+ }
+ sp = sig + 6 + lenr;
+ while (lens > 0 && sp[0] == 0) {
+ lens--;
+ sp++;
+ }
+ if (lens > 32) {
+ return 0;
+ }
+ rp = sig + 4;
+ while (lenr > 0 && rp[0] == 0) {
+ lenr--;
+ rp++;
+ }
+ if (lenr > 32) {
+ return 0;
+ }
+ memcpy(ra + 32 - lenr, rp, lenr);
+ memcpy(sa + 32 - lens, sp, lens);
+ overflow = 0;
+ secp256k1_scalar_set_b32(&r->r, ra, &overflow);
+ if (overflow) {
+ return 0;
+ }
+ secp256k1_scalar_set_b32(&r->s, sa, &overflow);
+ if (overflow) {
+ return 0;
+ }
+ return 1;
+}
+
+static int secp256k1_ecdsa_sig_serialize(unsigned char *sig, int *size, const secp256k1_ecdsa_sig_t *a) {
+ unsigned char r[33] = {0}, s[33] = {0};
+ unsigned char *rp = r, *sp = s;
+ int lenR = 33, lenS = 33;
+ secp256k1_scalar_get_b32(&r[1], &a->r);
+ secp256k1_scalar_get_b32(&s[1], &a->s);
+ while (lenR > 1 && rp[0] == 0 && rp[1] < 0x80) { lenR--; rp++; }
+ while (lenS > 1 && sp[0] == 0 && sp[1] < 0x80) { lenS--; sp++; }
+ if (*size < 6+lenS+lenR) {
+ return 0;
+ }
+ *size = 6 + lenS + lenR;
+ sig[0] = 0x30;
+ sig[1] = 4 + lenS + lenR;
+ sig[2] = 0x02;
+ sig[3] = lenR;
+ memcpy(sig+4, rp, lenR);
+ sig[4+lenR] = 0x02;
+ sig[5+lenR] = lenS;
+ memcpy(sig+lenR+6, sp, lenS);
+ return 1;
+}
+
+static int secp256k1_ecdsa_sig_verify(const secp256k1_ecdsa_sig_t *sig, const secp256k1_ge_t *pubkey, const secp256k1_scalar_t *message) {
+ unsigned char c[32];
+ secp256k1_scalar_t sn, u1, u2;
+ secp256k1_fe_t xr;
+ secp256k1_gej_t pubkeyj;
+ secp256k1_gej_t pr;
+
+ if (secp256k1_scalar_is_zero(&sig->r) || secp256k1_scalar_is_zero(&sig->s)) {
+ return 0;
+ }
+
+ secp256k1_scalar_inverse_var(&sn, &sig->s);
+ secp256k1_scalar_mul(&u1, &sn, message);
+ secp256k1_scalar_mul(&u2, &sn, &sig->r);
+ secp256k1_gej_set_ge(&pubkeyj, pubkey);
+ secp256k1_ecmult(&pr, &pubkeyj, &u2, &u1);
+ if (secp256k1_gej_is_infinity(&pr)) {
+ return 0;
+ }
+ secp256k1_scalar_get_b32(c, &sig->r);
+ secp256k1_fe_set_b32(&xr, c);
+
+ /** We now have the recomputed R point in pr, and its claimed x coordinate (modulo n)
+ * in xr. Naively, we would extract the x coordinate from pr (requiring a inversion modulo p),
+ * compute the remainder modulo n, and compare it to xr. However:
+ *
+ * xr == X(pr) mod n
+ * <=> exists h. (xr + h * n < p && xr + h * n == X(pr))
+ * [Since 2 * n > p, h can only be 0 or 1]
+ * <=> (xr == X(pr)) || (xr + n < p && xr + n == X(pr))
+ * [In Jacobian coordinates, X(pr) is pr.x / pr.z^2 mod p]
+ * <=> (xr == pr.x / pr.z^2 mod p) || (xr + n < p && xr + n == pr.x / pr.z^2 mod p)
+ * [Multiplying both sides of the equations by pr.z^2 mod p]
+ * <=> (xr * pr.z^2 mod p == pr.x) || (xr + n < p && (xr + n) * pr.z^2 mod p == pr.x)
+ *
+ * Thus, we can avoid the inversion, but we have to check both cases separately.
+ * secp256k1_gej_eq_x implements the (xr * pr.z^2 mod p == pr.x) test.
+ */
+ if (secp256k1_gej_eq_x_var(&xr, &pr)) {
+ /* xr.x == xr * xr.z^2 mod p, so the signature is valid. */
+ return 1;
+ }
+ if (secp256k1_fe_cmp_var(&xr, &secp256k1_ecdsa_const_p_minus_order) >= 0) {
+ /* xr + p >= n, so we can skip testing the second case. */
+ return 0;
+ }
+ secp256k1_fe_add(&xr, &secp256k1_ecdsa_const_order_as_fe);
+ if (secp256k1_gej_eq_x_var(&xr, &pr)) {
+ /* (xr + n) * pr.z^2 mod p == pr.x, so the signature is valid. */
+ return 1;
+ }
+ return 0;
+}
+
+static int secp256k1_ecdsa_sig_recover(const secp256k1_ecdsa_sig_t *sig, secp256k1_ge_t *pubkey, const secp256k1_scalar_t *message, int recid) {
+ unsigned char brx[32];
+ secp256k1_fe_t fx;
+ secp256k1_ge_t x;
+ secp256k1_gej_t xj;
+ secp256k1_scalar_t rn, u1, u2;
+ secp256k1_gej_t qj;
+
+ if (secp256k1_scalar_is_zero(&sig->r) || secp256k1_scalar_is_zero(&sig->s)) {
+ return 0;
+ }
+
+ secp256k1_scalar_get_b32(brx, &sig->r);
+ VERIFY_CHECK(secp256k1_fe_set_b32(&fx, brx)); /* brx comes from a scalar, so is less than the order; certainly less than p */
+ if (recid & 2) {
+ if (secp256k1_fe_cmp_var(&fx, &secp256k1_ecdsa_const_p_minus_order) >= 0) {
+ return 0;
+ }
+ secp256k1_fe_add(&fx, &secp256k1_ecdsa_const_order_as_fe);
+ }
+ if (!secp256k1_ge_set_xo_var(&x, &fx, recid & 1)) {
+ return 0;
+ }
+ secp256k1_gej_set_ge(&xj, &x);
+ secp256k1_scalar_inverse_var(&rn, &sig->r);
+ secp256k1_scalar_mul(&u1, &rn, message);
+ secp256k1_scalar_negate(&u1, &u1);
+ secp256k1_scalar_mul(&u2, &rn, &sig->s);
+ secp256k1_ecmult(&qj, &xj, &u2, &u1);
+ secp256k1_ge_set_gej_var(pubkey, &qj);
+ return !secp256k1_gej_is_infinity(&qj);
+}
+
+static int secp256k1_ecdsa_sig_sign(secp256k1_ecdsa_sig_t *sig, const secp256k1_scalar_t *seckey, const secp256k1_scalar_t *message, const secp256k1_scalar_t *nonce, int *recid) {
+ unsigned char b[32];
+ secp256k1_gej_t rp;
+ secp256k1_ge_t r;
+ secp256k1_scalar_t n;
+ int overflow = 0;
+
+ secp256k1_ecmult_gen(&rp, nonce);
+ secp256k1_ge_set_gej(&r, &rp);
+ secp256k1_fe_normalize(&r.x);
+ secp256k1_fe_normalize(&r.y);
+ secp256k1_fe_get_b32(b, &r.x);
+ secp256k1_scalar_set_b32(&sig->r, b, &overflow);
+ if (secp256k1_scalar_is_zero(&sig->r)) {
+ /* P.x = order is on the curve, so technically sig->r could end up zero, which would be an invalid signature. */
+ secp256k1_gej_clear(&rp);
+ secp256k1_ge_clear(&r);
+ return 0;
+ }
+ if (recid) {
+ *recid = (overflow ? 2 : 0) | (secp256k1_fe_is_odd(&r.y) ? 1 : 0);
+ }
+ secp256k1_scalar_mul(&n, &sig->r, seckey);
+ secp256k1_scalar_add(&n, &n, message);
+ secp256k1_scalar_inverse(&sig->s, nonce);
+ secp256k1_scalar_mul(&sig->s, &sig->s, &n);
+ secp256k1_scalar_clear(&n);
+ secp256k1_gej_clear(&rp);
+ secp256k1_ge_clear(&r);
+ if (secp256k1_scalar_is_zero(&sig->s)) {
+ return 0;
+ }
+ if (secp256k1_scalar_is_high(&sig->s)) {
+ secp256k1_scalar_negate(&sig->s, &sig->s);
+ if (recid) {
+ *recid ^= 1;
+ }
+ }
+ return 1;
+}
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/eckey.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/eckey.h
new file mode 100644
index 0000000000000000000000000000000000000000..6de5dc0a590fb9849e3f2c6ddbce766d2295ce11
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/eckey.h
@@ -0,0 +1,24 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_ECKEY_
+#define _SECP256K1_ECKEY_
+
+#include "group.h"
+#include "scalar.h"
+
+static int secp256k1_eckey_pubkey_parse(secp256k1_ge_t *elem, const unsigned char *pub, int size);
+static int secp256k1_eckey_pubkey_serialize(secp256k1_ge_t *elem, unsigned char *pub, int *size, int compressed);
+
+static int secp256k1_eckey_privkey_parse(secp256k1_scalar_t *key, const unsigned char *privkey, int privkeylen);
+static int secp256k1_eckey_privkey_serialize(unsigned char *privkey, int *privkeylen, const secp256k1_scalar_t *key, int compressed);
+
+static int secp256k1_eckey_privkey_tweak_add(secp256k1_scalar_t *key, const secp256k1_scalar_t *tweak);
+static int secp256k1_eckey_pubkey_tweak_add(secp256k1_ge_t *key, const secp256k1_scalar_t *tweak);
+static int secp256k1_eckey_privkey_tweak_mul(secp256k1_scalar_t *key, const secp256k1_scalar_t *tweak);
+static int secp256k1_eckey_pubkey_tweak_mul(secp256k1_ge_t *key, const secp256k1_scalar_t *tweak);
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/eckey_impl.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/eckey_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..4382ff5f324b549c30bfa1ea0b1e104dd2b1bba8
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/eckey_impl.h
@@ -0,0 +1,202 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_ECKEY_IMPL_H_
+#define _SECP256K1_ECKEY_IMPL_H_
+
+#include "eckey.h"
+
+#include "scalar.h"
+#include "field.h"
+#include "group.h"
+#include "ecmult_gen.h"
+
+static int secp256k1_eckey_pubkey_parse(secp256k1_ge_t *elem, const unsigned char *pub, int size) {
+ if (size == 33 && (pub[0] == 0x02 || pub[0] == 0x03)) {
+ secp256k1_fe_t x;
+ return secp256k1_fe_set_b32(&x, pub+1) && secp256k1_ge_set_xo_var(elem, &x, pub[0] == 0x03);
+ } else if (size == 65 && (pub[0] == 0x04 || pub[0] == 0x06 || pub[0] == 0x07)) {
+ secp256k1_fe_t x, y;
+ if (!secp256k1_fe_set_b32(&x, pub+1) || !secp256k1_fe_set_b32(&y, pub+33)) {
+ return 0;
+ }
+ secp256k1_ge_set_xy(elem, &x, &y);
+ if ((pub[0] == 0x06 || pub[0] == 0x07) && secp256k1_fe_is_odd(&y) != (pub[0] == 0x07)) {
+ return 0;
+ }
+ return secp256k1_ge_is_valid_var(elem);
+ } else {
+ return 0;
+ }
+}
+
+static int secp256k1_eckey_pubkey_serialize(secp256k1_ge_t *elem, unsigned char *pub, int *size, int compressed) {
+ if (secp256k1_ge_is_infinity(elem)) {
+ return 0;
+ }
+ secp256k1_fe_normalize_var(&elem->x);
+ secp256k1_fe_normalize_var(&elem->y);
+ secp256k1_fe_get_b32(&pub[1], &elem->x);
+ if (compressed) {
+ *size = 33;
+ pub[0] = 0x02 | (secp256k1_fe_is_odd(&elem->y) ? 0x01 : 0x00);
+ } else {
+ *size = 65;
+ pub[0] = 0x04;
+ secp256k1_fe_get_b32(&pub[33], &elem->y);
+ }
+ return 1;
+}
+
+static int secp256k1_eckey_privkey_parse(secp256k1_scalar_t *key, const unsigned char *privkey, int privkeylen) {
+ unsigned char c[32] = {0};
+ const unsigned char *end = privkey + privkeylen;
+ int lenb = 0;
+ int len = 0;
+ int overflow = 0;
+ /* sequence header */
+ if (end < privkey+1 || *privkey != 0x30) {
+ return 0;
+ }
+ privkey++;
+ /* sequence length constructor */
+ if (end < privkey+1 || !(*privkey & 0x80)) {
+ return 0;
+ }
+ lenb = *privkey & ~0x80; privkey++;
+ if (lenb < 1 || lenb > 2) {
+ return 0;
+ }
+ if (end < privkey+lenb) {
+ return 0;
+ }
+ /* sequence length */
+ len = privkey[lenb-1] | (lenb > 1 ? privkey[lenb-2] << 8 : 0);
+ privkey += lenb;
+ if (end < privkey+len) {
+ return 0;
+ }
+ /* sequence element 0: version number (=1) */
+ if (end < privkey+3 || privkey[0] != 0x02 || privkey[1] != 0x01 || privkey[2] != 0x01) {
+ return 0;
+ }
+ privkey += 3;
+ /* sequence element 1: octet string, up to 32 bytes */
+ if (end < privkey+2 || privkey[0] != 0x04 || privkey[1] > 0x20 || end < privkey+2+privkey[1]) {
+ return 0;
+ }
+ memcpy(c + 32 - privkey[1], privkey + 2, privkey[1]);
+ secp256k1_scalar_set_b32(key, c, &overflow);
+ memset(c, 0, 32);
+ return !overflow;
+}
+
+static int secp256k1_eckey_privkey_serialize(unsigned char *privkey, int *privkeylen, const secp256k1_scalar_t *key, int compressed) {
+ secp256k1_gej_t rp;
+ secp256k1_ge_t r;
+ int pubkeylen = 0;
+ secp256k1_ecmult_gen(&rp, key);
+ secp256k1_ge_set_gej(&r, &rp);
+ if (compressed) {
+ static const unsigned char begin[] = {
+ 0x30,0x81,0xD3,0x02,0x01,0x01,0x04,0x20
+ };
+ static const unsigned char middle[] = {
+ 0xA0,0x81,0x85,0x30,0x81,0x82,0x02,0x01,0x01,0x30,0x2C,0x06,0x07,0x2A,0x86,0x48,
+ 0xCE,0x3D,0x01,0x01,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F,0x30,0x06,0x04,0x01,0x00,0x04,0x01,0x07,0x04,
+ 0x21,0x02,0x79,0xBE,0x66,0x7E,0xF9,0xDC,0xBB,0xAC,0x55,0xA0,0x62,0x95,0xCE,0x87,
+ 0x0B,0x07,0x02,0x9B,0xFC,0xDB,0x2D,0xCE,0x28,0xD9,0x59,0xF2,0x81,0x5B,0x16,0xF8,
+ 0x17,0x98,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,0xBF,0xD2,0x5E,
+ 0x8C,0xD0,0x36,0x41,0x41,0x02,0x01,0x01,0xA1,0x24,0x03,0x22,0x00
+ };
+ unsigned char *ptr = privkey;
+ memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
+ secp256k1_scalar_get_b32(ptr, key); ptr += 32;
+ memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
+ if (!secp256k1_eckey_pubkey_serialize(&r, ptr, &pubkeylen, 1)) {
+ return 0;
+ }
+ ptr += pubkeylen;
+ *privkeylen = ptr - privkey;
+ } else {
+ static const unsigned char begin[] = {
+ 0x30,0x82,0x01,0x13,0x02,0x01,0x01,0x04,0x20
+ };
+ static const unsigned char middle[] = {
+ 0xA0,0x81,0xA5,0x30,0x81,0xA2,0x02,0x01,0x01,0x30,0x2C,0x06,0x07,0x2A,0x86,0x48,
+ 0xCE,0x3D,0x01,0x01,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F,0x30,0x06,0x04,0x01,0x00,0x04,0x01,0x07,0x04,
+ 0x41,0x04,0x79,0xBE,0x66,0x7E,0xF9,0xDC,0xBB,0xAC,0x55,0xA0,0x62,0x95,0xCE,0x87,
+ 0x0B,0x07,0x02,0x9B,0xFC,0xDB,0x2D,0xCE,0x28,0xD9,0x59,0xF2,0x81,0x5B,0x16,0xF8,
+ 0x17,0x98,0x48,0x3A,0xDA,0x77,0x26,0xA3,0xC4,0x65,0x5D,0xA4,0xFB,0xFC,0x0E,0x11,
+ 0x08,0xA8,0xFD,0x17,0xB4,0x48,0xA6,0x85,0x54,0x19,0x9C,0x47,0xD0,0x8F,0xFB,0x10,
+ 0xD4,0xB8,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,0xBF,0xD2,0x5E,
+ 0x8C,0xD0,0x36,0x41,0x41,0x02,0x01,0x01,0xA1,0x44,0x03,0x42,0x00
+ };
+ unsigned char *ptr = privkey;
+ memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
+ secp256k1_scalar_get_b32(ptr, key); ptr += 32;
+ memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
+ if (!secp256k1_eckey_pubkey_serialize(&r, ptr, &pubkeylen, 0)) {
+ return 0;
+ }
+ ptr += pubkeylen;
+ *privkeylen = ptr - privkey;
+ }
+ return 1;
+}
+
+static int secp256k1_eckey_privkey_tweak_add(secp256k1_scalar_t *key, const secp256k1_scalar_t *tweak) {
+ secp256k1_scalar_add(key, key, tweak);
+ if (secp256k1_scalar_is_zero(key)) {
+ return 0;
+ }
+ return 1;
+}
+
+static int secp256k1_eckey_pubkey_tweak_add(secp256k1_ge_t *key, const secp256k1_scalar_t *tweak) {
+ secp256k1_gej_t pt;
+ secp256k1_scalar_t one;
+ secp256k1_gej_set_ge(&pt, key);
+ secp256k1_scalar_set_int(&one, 1);
+ secp256k1_ecmult(&pt, &pt, &one, tweak);
+
+ if (secp256k1_gej_is_infinity(&pt)) {
+ return 0;
+ }
+ secp256k1_ge_set_gej(key, &pt);
+ return 1;
+}
+
+static int secp256k1_eckey_privkey_tweak_mul(secp256k1_scalar_t *key, const secp256k1_scalar_t *tweak) {
+ if (secp256k1_scalar_is_zero(tweak)) {
+ return 0;
+ }
+
+ secp256k1_scalar_mul(key, key, tweak);
+ return 1;
+}
+
+static int secp256k1_eckey_pubkey_tweak_mul(secp256k1_ge_t *key, const secp256k1_scalar_t *tweak) {
+ secp256k1_scalar_t zero;
+ secp256k1_gej_t pt;
+ if (secp256k1_scalar_is_zero(tweak)) {
+ return 0;
+ }
+
+ secp256k1_scalar_set_int(&zero, 0);
+ secp256k1_gej_set_ge(&pt, key);
+ secp256k1_ecmult(&pt, &pt, tweak, &zero);
+ secp256k1_ge_set_gej(key, &pt);
+ return 1;
+}
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/ecmult.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/ecmult.h
new file mode 100644
index 0000000000000000000000000000000000000000..15a7100a4a1fa03468f6c434c6372aa22809b1b1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/ecmult.h
@@ -0,0 +1,19 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_ECMULT_
+#define _SECP256K1_ECMULT_
+
+#include "num.h"
+#include "group.h"
+
+static void secp256k1_ecmult_start(void);
+static void secp256k1_ecmult_stop(void);
+
+/** Double multiply: R = na*A + ng*G */
+static void secp256k1_ecmult(secp256k1_gej_t *r, const secp256k1_gej_t *a, const secp256k1_scalar_t *na, const secp256k1_scalar_t *ng);
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/ecmult_gen.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/ecmult_gen.h
new file mode 100644
index 0000000000000000000000000000000000000000..42f822f9cef299f354968ec4fbe0b2ef55c9606c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/ecmult_gen.h
@@ -0,0 +1,19 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_ECMULT_GEN_
+#define _SECP256K1_ECMULT_GEN_
+
+#include "scalar.h"
+#include "group.h"
+
+static void secp256k1_ecmult_gen_start(void);
+static void secp256k1_ecmult_gen_stop(void);
+
+/** Multiply with the generator: R = a*G */
+static void secp256k1_ecmult_gen(secp256k1_gej_t *r, const secp256k1_scalar_t *a);
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/ecmult_gen_impl.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/ecmult_gen_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..3146a93b572c13d49813a221aa0128fd6630d8dd
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/ecmult_gen_impl.h
@@ -0,0 +1,128 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_ECMULT_GEN_IMPL_H_
+#define _SECP256K1_ECMULT_GEN_IMPL_H_
+
+#include "scalar.h"
+#include "group.h"
+#include "ecmult_gen.h"
+
+typedef struct {
+ /* For accelerating the computation of a*G:
+ * To harden against timing attacks, use the following mechanism:
+ * * Break up the multiplicand into groups of 4 bits, called n_0, n_1, n_2, ..., n_63.
+ * * Compute sum(n_i * 16^i * G + U_i, i=0..63), where:
+ * * U_i = U * 2^i (for i=0..62)
+ * * U_i = U * (1-2^63) (for i=63)
+ * where U is a point with no known corresponding scalar. Note that sum(U_i, i=0..63) = 0.
+ * For each i, and each of the 16 possible values of n_i, (n_i * 16^i * G + U_i) is
+ * precomputed (call it prec(i, n_i)). The formula now becomes sum(prec(i, n_i), i=0..63).
+ * None of the resulting prec group elements have a known scalar, and neither do any of
+ * the intermediate sums while computing a*G.
+ */
+ secp256k1_ge_storage_t prec[64][16]; /* prec[j][i] = 16^j * i * G + U_i */
+} secp256k1_ecmult_gen_consts_t;
+
+static const secp256k1_ecmult_gen_consts_t *secp256k1_ecmult_gen_consts = NULL;
+
+static void secp256k1_ecmult_gen_start(void) {
+ secp256k1_ge_t prec[1024];
+ secp256k1_gej_t gj;
+ secp256k1_gej_t nums_gej;
+ secp256k1_ecmult_gen_consts_t *ret;
+ int i, j;
+ if (secp256k1_ecmult_gen_consts != NULL) {
+ return;
+ }
+
+ /* Allocate the precomputation table. */
+ ret = (secp256k1_ecmult_gen_consts_t*)checked_malloc(sizeof(secp256k1_ecmult_gen_consts_t));
+
+ /* get the generator */
+ secp256k1_gej_set_ge(&gj, &secp256k1_ge_const_g);
+
+ /* Construct a group element with no known corresponding scalar (nothing up my sleeve). */
+ {
+ static const unsigned char nums_b32[33] = "The scalar for this x is unknown";
+ secp256k1_fe_t nums_x;
+ secp256k1_ge_t nums_ge;
+ VERIFY_CHECK(secp256k1_fe_set_b32(&nums_x, nums_b32));
+ VERIFY_CHECK(secp256k1_ge_set_xo_var(&nums_ge, &nums_x, 0));
+ secp256k1_gej_set_ge(&nums_gej, &nums_ge);
+ /* Add G to make the bits in x uniformly distributed. */
+ secp256k1_gej_add_ge_var(&nums_gej, &nums_gej, &secp256k1_ge_const_g);
+ }
+
+ /* compute prec. */
+ {
+ secp256k1_gej_t precj[1024]; /* Jacobian versions of prec. */
+ secp256k1_gej_t gbase;
+ secp256k1_gej_t numsbase;
+ gbase = gj; /* 16^j * G */
+ numsbase = nums_gej; /* 2^j * nums. */
+ for (j = 0; j < 64; j++) {
+ /* Set precj[j*16 .. j*16+15] to (numsbase, numsbase + gbase, ..., numsbase + 15*gbase). */
+ precj[j*16] = numsbase;
+ for (i = 1; i < 16; i++) {
+ secp256k1_gej_add_var(&precj[j*16 + i], &precj[j*16 + i - 1], &gbase);
+ }
+ /* Multiply gbase by 16. */
+ for (i = 0; i < 4; i++) {
+ secp256k1_gej_double_var(&gbase, &gbase);
+ }
+ /* Multiply numbase by 2. */
+ secp256k1_gej_double_var(&numsbase, &numsbase);
+ if (j == 62) {
+ /* In the last iteration, numsbase is (1 - 2^j) * nums instead. */
+ secp256k1_gej_neg(&numsbase, &numsbase);
+ secp256k1_gej_add_var(&numsbase, &numsbase, &nums_gej);
+ }
+ }
+ secp256k1_ge_set_all_gej_var(1024, prec, precj);
+ }
+ for (j = 0; j < 64; j++) {
+ for (i = 0; i < 16; i++) {
+ secp256k1_ge_to_storage(&ret->prec[j][i], &prec[j*16 + i]);
+ }
+ }
+
+ /* Set the global pointer to the precomputation table. */
+ secp256k1_ecmult_gen_consts = ret;
+}
+
+static void secp256k1_ecmult_gen_stop(void) {
+ secp256k1_ecmult_gen_consts_t *c;
+ if (secp256k1_ecmult_gen_consts == NULL) {
+ return;
+ }
+
+ c = (secp256k1_ecmult_gen_consts_t*)secp256k1_ecmult_gen_consts;
+ secp256k1_ecmult_gen_consts = NULL;
+ free(c);
+}
+
+static void secp256k1_ecmult_gen(secp256k1_gej_t *r, const secp256k1_scalar_t *gn) {
+ const secp256k1_ecmult_gen_consts_t *c = secp256k1_ecmult_gen_consts;
+ secp256k1_ge_t add;
+ secp256k1_ge_storage_t adds;
+ int bits;
+ int i, j;
+ secp256k1_gej_set_infinity(r);
+ add.infinity = 0;
+ for (j = 0; j < 64; j++) {
+ bits = secp256k1_scalar_get_bits(gn, j * 4, 4);
+ for (i = 0; i < 16; i++) {
+ secp256k1_ge_storage_cmov(&adds, &c->prec[j][i], i == bits);
+ }
+ secp256k1_ge_from_storage(&add, &adds);
+ secp256k1_gej_add_ge(r, r, &add);
+ }
+ bits = 0;
+ secp256k1_ge_clear(&add);
+}
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/ecmult_impl.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/ecmult_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..f6f0c4294e87950fea9aff7aeec129d7b744a1f9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/ecmult_impl.h
@@ -0,0 +1,302 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_ECMULT_IMPL_H_
+#define _SECP256K1_ECMULT_IMPL_H_
+
+#include "group.h"
+#include "scalar.h"
+#include "ecmult.h"
+
+/* optimal for 128-bit and 256-bit exponents. */
+#define WINDOW_A 5
+
+/** larger numbers may result in slightly better performance, at the cost of
+ exponentially larger precomputed tables. */
+#ifdef USE_ENDOMORPHISM
+/** Two tables for window size 15: 1.375 MiB. */
+#define WINDOW_G 15
+#else
+/** One table for window size 16: 1.375 MiB. */
+#define WINDOW_G 16
+#endif
+
+/** Fill a table 'pre' with precomputed odd multiples of a. W determines the size of the table.
+ * pre will contains the values [1*a,3*a,5*a,...,(2^(w-1)-1)*a], so it needs place for
+ * 2^(w-2) entries.
+ *
+ * There are two versions of this function:
+ * - secp256k1_ecmult_precomp_wnaf_gej, which operates on group elements in jacobian notation,
+ * fast to precompute, but slower to use in later additions.
+ * - secp256k1_ecmult_precomp_wnaf_ge, which operates on group elements in affine notations,
+ * (much) slower to precompute, but a bit faster to use in later additions.
+ * To compute a*P + b*G, we use the jacobian version for P, and the affine version for G, as
+ * G is constant, so it only needs to be done once in advance.
+ */
+static void secp256k1_ecmult_table_precomp_gej_var(secp256k1_gej_t *pre, const secp256k1_gej_t *a, int w) {
+ secp256k1_gej_t d;
+ int i;
+ pre[0] = *a;
+ secp256k1_gej_double_var(&d, &pre[0]);
+ for (i = 1; i < (1 << (w-2)); i++) {
+ secp256k1_gej_add_var(&pre[i], &d, &pre[i-1]);
+ }
+}
+
+static void secp256k1_ecmult_table_precomp_ge_storage_var(secp256k1_ge_storage_t *pre, const secp256k1_gej_t *a, int w) {
+ secp256k1_gej_t d;
+ int i;
+ const int table_size = 1 << (w-2);
+ secp256k1_gej_t *prej = (secp256k1_gej_t *)checked_malloc(sizeof(secp256k1_gej_t) * table_size);
+ secp256k1_ge_t *prea = (secp256k1_ge_t *)checked_malloc(sizeof(secp256k1_ge_t) * table_size);
+ prej[0] = *a;
+ secp256k1_gej_double_var(&d, a);
+ for (i = 1; i < table_size; i++) {
+ secp256k1_gej_add_var(&prej[i], &d, &prej[i-1]);
+ }
+ secp256k1_ge_set_all_gej_var(table_size, prea, prej);
+ for (i = 0; i < table_size; i++) {
+ secp256k1_ge_to_storage(&pre[i], &prea[i]);
+ }
+ free(prej);
+ free(prea);
+}
+
+/** The number of entries a table with precomputed multiples needs to have. */
+#define ECMULT_TABLE_SIZE(w) (1 << ((w)-2))
+
+/** The following two macro retrieves a particular odd multiple from a table
+ * of precomputed multiples. */
+#define ECMULT_TABLE_GET_GEJ(r,pre,n,w) do { \
+ VERIFY_CHECK(((n) & 1) == 1); \
+ VERIFY_CHECK((n) >= -((1 << ((w)-1)) - 1)); \
+ VERIFY_CHECK((n) <= ((1 << ((w)-1)) - 1)); \
+ if ((n) > 0) { \
+ *(r) = (pre)[((n)-1)/2]; \
+ } else { \
+ secp256k1_gej_neg((r), &(pre)[(-(n)-1)/2]); \
+ } \
+} while(0)
+#define ECMULT_TABLE_GET_GE_STORAGE(r,pre,n,w) do { \
+ VERIFY_CHECK(((n) & 1) == 1); \
+ VERIFY_CHECK((n) >= -((1 << ((w)-1)) - 1)); \
+ VERIFY_CHECK((n) <= ((1 << ((w)-1)) - 1)); \
+ if ((n) > 0) { \
+ secp256k1_ge_from_storage((r), &(pre)[((n)-1)/2]); \
+ } else { \
+ secp256k1_ge_from_storage((r), &(pre)[(-(n)-1)/2]); \
+ secp256k1_ge_neg((r), (r)); \
+ } \
+} while(0)
+
+typedef struct {
+ /* For accelerating the computation of a*P + b*G: */
+ secp256k1_ge_storage_t pre_g[ECMULT_TABLE_SIZE(WINDOW_G)]; /* odd multiples of the generator */
+#ifdef USE_ENDOMORPHISM
+ secp256k1_ge_storage_t pre_g_128[ECMULT_TABLE_SIZE(WINDOW_G)]; /* odd multiples of 2^128*generator */
+#endif
+} secp256k1_ecmult_consts_t;
+
+static const secp256k1_ecmult_consts_t *secp256k1_ecmult_consts = NULL;
+
+static void secp256k1_ecmult_start(void) {
+ secp256k1_gej_t gj;
+ secp256k1_ecmult_consts_t *ret;
+ if (secp256k1_ecmult_consts != NULL) {
+ return;
+ }
+
+ /* Allocate the precomputation table. */
+ ret = (secp256k1_ecmult_consts_t*)checked_malloc(sizeof(secp256k1_ecmult_consts_t));
+
+ /* get the generator */
+ secp256k1_gej_set_ge(&gj, &secp256k1_ge_const_g);
+
+
+ /* precompute the tables with odd multiples */
+ secp256k1_ecmult_table_precomp_ge_storage_var(ret->pre_g, &gj, WINDOW_G);
+
+#ifdef USE_ENDOMORPHISM
+ {
+ secp256k1_gej_t g_128j;
+ int i;
+ /* calculate 2^128*generator */
+ g_128j = gj;
+ for (i = 0; i < 128; i++) {
+ secp256k1_gej_double_var(&g_128j, &g_128j);
+ }
+ secp256k1_ecmult_table_precomp_ge_storage_var(ret->pre_g_128, &g_128j, WINDOW_G);
+ }
+#endif
+
+ /* Set the global pointer to the precomputation table. */
+ secp256k1_ecmult_consts = ret;
+}
+
+static void secp256k1_ecmult_stop(void) {
+ secp256k1_ecmult_consts_t *c;
+ if (secp256k1_ecmult_consts == NULL) {
+ return;
+ }
+
+ c = (secp256k1_ecmult_consts_t*)secp256k1_ecmult_consts;
+ secp256k1_ecmult_consts = NULL;
+ free(c);
+}
+
+/** Convert a number to WNAF notation. The number becomes represented by sum(2^i * wnaf[i], i=0..bits),
+ * with the following guarantees:
+ * - each wnaf[i] is either 0, or an odd integer between -(1<<(w-1) - 1) and (1<<(w-1) - 1)
+ * - two non-zero entries in wnaf are separated by at least w-1 zeroes.
+ * - the number of set values in wnaf is returned. This number is at most 256, and at most one more
+ * - than the number of bits in the (absolute value) of the input.
+ */
+static int secp256k1_ecmult_wnaf(int *wnaf, const secp256k1_scalar_t *a, int w) {
+ secp256k1_scalar_t s = *a;
+ int set_bits = 0;
+ int bit = 0;
+ int sign = 1;
+
+ if (secp256k1_scalar_get_bits(&s, 255, 1)) {
+ secp256k1_scalar_negate(&s, &s);
+ sign = -1;
+ }
+
+ while (bit < 256) {
+ int now;
+ int word;
+ if (secp256k1_scalar_get_bits(&s, bit, 1) == 0) {
+ bit++;
+ continue;
+ }
+ while (set_bits < bit) {
+ wnaf[set_bits++] = 0;
+ }
+ now = w;
+ if (bit + now > 256) {
+ now = 256 - bit;
+ }
+ word = secp256k1_scalar_get_bits_var(&s, bit, now);
+ if (word & (1 << (w-1))) {
+ secp256k1_scalar_add_bit(&s, bit + w);
+ wnaf[set_bits++] = sign * (word - (1 << w));
+ } else {
+ wnaf[set_bits++] = sign * word;
+ }
+ bit += now;
+ }
+ return set_bits;
+}
+
+static void secp256k1_ecmult(secp256k1_gej_t *r, const secp256k1_gej_t *a, const secp256k1_scalar_t *na, const secp256k1_scalar_t *ng) {
+ secp256k1_gej_t tmpj;
+ secp256k1_gej_t pre_a[ECMULT_TABLE_SIZE(WINDOW_A)];
+ secp256k1_ge_t tmpa;
+ const secp256k1_ecmult_consts_t *c = secp256k1_ecmult_consts;
+#ifdef USE_ENDOMORPHISM
+ secp256k1_gej_t pre_a_lam[ECMULT_TABLE_SIZE(WINDOW_A)];
+ secp256k1_scalar_t na_1, na_lam;
+ /* Splitted G factors. */
+ secp256k1_scalar_t ng_1, ng_128;
+ int wnaf_na_1[130];
+ int wnaf_na_lam[130];
+ int bits_na_1;
+ int bits_na_lam;
+ int wnaf_ng_1[129];
+ int bits_ng_1;
+ int wnaf_ng_128[129];
+ int bits_ng_128;
+#else
+ int wnaf_na[256];
+ int bits_na;
+ int wnaf_ng[257];
+ int bits_ng;
+#endif
+ int i;
+ int bits;
+
+#ifdef USE_ENDOMORPHISM
+ /* split na into na_1 and na_lam (where na = na_1 + na_lam*lambda, and na_1 and na_lam are ~128 bit) */
+ secp256k1_scalar_split_lambda_var(&na_1, &na_lam, na);
+
+ /* build wnaf representation for na_1 and na_lam. */
+ bits_na_1 = secp256k1_ecmult_wnaf(wnaf_na_1, &na_1, WINDOW_A);
+ bits_na_lam = secp256k1_ecmult_wnaf(wnaf_na_lam, &na_lam, WINDOW_A);
+ VERIFY_CHECK(bits_na_1 <= 130);
+ VERIFY_CHECK(bits_na_lam <= 130);
+ bits = bits_na_1;
+ if (bits_na_lam > bits) {
+ bits = bits_na_lam;
+ }
+#else
+ /* build wnaf representation for na. */
+ bits_na = secp256k1_ecmult_wnaf(wnaf_na, na, WINDOW_A);
+ bits = bits_na;
+#endif
+
+ /* calculate odd multiples of a */
+ secp256k1_ecmult_table_precomp_gej_var(pre_a, a, WINDOW_A);
+
+#ifdef USE_ENDOMORPHISM
+ for (i = 0; i < ECMULT_TABLE_SIZE(WINDOW_A); i++) {
+ secp256k1_gej_mul_lambda(&pre_a_lam[i], &pre_a[i]);
+ }
+
+ /* split ng into ng_1 and ng_128 (where gn = gn_1 + gn_128*2^128, and gn_1 and gn_128 are ~128 bit) */
+ secp256k1_scalar_split_128(&ng_1, &ng_128, ng);
+
+ /* Build wnaf representation for ng_1 and ng_128 */
+ bits_ng_1 = secp256k1_ecmult_wnaf(wnaf_ng_1, &ng_1, WINDOW_G);
+ bits_ng_128 = secp256k1_ecmult_wnaf(wnaf_ng_128, &ng_128, WINDOW_G);
+ if (bits_ng_1 > bits) {
+ bits = bits_ng_1;
+ }
+ if (bits_ng_128 > bits) {
+ bits = bits_ng_128;
+ }
+#else
+ bits_ng = secp256k1_ecmult_wnaf(wnaf_ng, ng, WINDOW_G);
+ if (bits_ng > bits) {
+ bits = bits_ng;
+ }
+#endif
+
+ secp256k1_gej_set_infinity(r);
+
+ for (i = bits-1; i >= 0; i--) {
+ int n;
+ secp256k1_gej_double_var(r, r);
+#ifdef USE_ENDOMORPHISM
+ if (i < bits_na_1 && (n = wnaf_na_1[i])) {
+ ECMULT_TABLE_GET_GEJ(&tmpj, pre_a, n, WINDOW_A);
+ secp256k1_gej_add_var(r, r, &tmpj);
+ }
+ if (i < bits_na_lam && (n = wnaf_na_lam[i])) {
+ ECMULT_TABLE_GET_GEJ(&tmpj, pre_a_lam, n, WINDOW_A);
+ secp256k1_gej_add_var(r, r, &tmpj);
+ }
+ if (i < bits_ng_1 && (n = wnaf_ng_1[i])) {
+ ECMULT_TABLE_GET_GE_STORAGE(&tmpa, c->pre_g, n, WINDOW_G);
+ secp256k1_gej_add_ge_var(r, r, &tmpa);
+ }
+ if (i < bits_ng_128 && (n = wnaf_ng_128[i])) {
+ ECMULT_TABLE_GET_GE_STORAGE(&tmpa, c->pre_g_128, n, WINDOW_G);
+ secp256k1_gej_add_ge_var(r, r, &tmpa);
+ }
+#else
+ if (i < bits_na && (n = wnaf_na[i])) {
+ ECMULT_TABLE_GET_GEJ(&tmpj, pre_a, n, WINDOW_A);
+ secp256k1_gej_add_var(r, r, &tmpj);
+ }
+ if (i < bits_ng && (n = wnaf_ng[i])) {
+ ECMULT_TABLE_GET_GE_STORAGE(&tmpa, c->pre_g, n, WINDOW_G);
+ secp256k1_gej_add_ge_var(r, r, &tmpa);
+ }
+#endif
+ }
+}
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field.h
new file mode 100644
index 0000000000000000000000000000000000000000..9e6d7d3c0421314faee7b6dbbad225b44c8410eb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field.h
@@ -0,0 +1,116 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_FIELD_
+#define _SECP256K1_FIELD_
+
+/** Field element module.
+ *
+ * Field elements can be represented in several ways, but code accessing
+ * it (and implementations) need to take certain properaties into account:
+ * - Each field element can be normalized or not.
+ * - Each field element has a magnitude, which represents how far away
+ * its representation is away from normalization. Normalized elements
+ * always have a magnitude of 1, but a magnitude of 1 doesn't imply
+ * normality.
+ */
+
+#if defined HAVE_CONFIG_H
+#include "libsecp256k1-config.h"
+#endif
+
+#if defined(USE_FIELD_10X26)
+#include "field_10x26.h"
+#elif defined(USE_FIELD_5X52)
+#include "field_5x52.h"
+#else
+#error "Please select field implementation"
+#endif
+
+/** Normalize a field element. */
+static void secp256k1_fe_normalize(secp256k1_fe_t *r);
+
+/** Weakly normalize a field element: reduce it magnitude to 1, but don't fully normalize. */
+static void secp256k1_fe_normalize_weak(secp256k1_fe_t *r);
+
+/** Normalize a field element, without constant-time guarantee. */
+static void secp256k1_fe_normalize_var(secp256k1_fe_t *r);
+
+/** Verify whether a field element represents zero i.e. would normalize to a zero value. The field
+ * implementation may optionally normalize the input, but this should not be relied upon. */
+static int secp256k1_fe_normalizes_to_zero(secp256k1_fe_t *r);
+
+/** Verify whether a field element represents zero i.e. would normalize to a zero value. The field
+ * implementation may optionally normalize the input, but this should not be relied upon. */
+static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe_t *r);
+
+/** Set a field element equal to a small integer. Resulting field element is normalized. */
+static void secp256k1_fe_set_int(secp256k1_fe_t *r, int a);
+
+/** Verify whether a field element is zero. Requires the input to be normalized. */
+static int secp256k1_fe_is_zero(const secp256k1_fe_t *a);
+
+/** Check the "oddness" of a field element. Requires the input to be normalized. */
+static int secp256k1_fe_is_odd(const secp256k1_fe_t *a);
+
+/** Compare two field elements. Requires magnitude-1 inputs. */
+static int secp256k1_fe_equal_var(const secp256k1_fe_t *a, const secp256k1_fe_t *b);
+
+/** Compare two field elements. Requires both inputs to be normalized */
+static int secp256k1_fe_cmp_var(const secp256k1_fe_t *a, const secp256k1_fe_t *b);
+
+/** Set a field element equal to 32-byte big endian value. If succesful, the resulting field element is normalized. */
+static int secp256k1_fe_set_b32(secp256k1_fe_t *r, const unsigned char *a);
+
+/** Convert a field element to a 32-byte big endian value. Requires the input to be normalized */
+static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe_t *a);
+
+/** Set a field element equal to the additive inverse of another. Takes a maximum magnitude of the input
+ * as an argument. The magnitude of the output is one higher. */
+static void secp256k1_fe_negate(secp256k1_fe_t *r, const secp256k1_fe_t *a, int m);
+
+/** Multiplies the passed field element with a small integer constant. Multiplies the magnitude by that
+ * small integer. */
+static void secp256k1_fe_mul_int(secp256k1_fe_t *r, int a);
+
+/** Adds a field element to another. The result has the sum of the inputs' magnitudes as magnitude. */
+static void secp256k1_fe_add(secp256k1_fe_t *r, const secp256k1_fe_t *a);
+
+/** Sets a field element to be the product of two others. Requires the inputs' magnitudes to be at most 8.
+ * The output magnitude is 1 (but not guaranteed to be normalized). */
+static void secp256k1_fe_mul(secp256k1_fe_t *r, const secp256k1_fe_t *a, const secp256k1_fe_t * SECP256K1_RESTRICT b);
+
+/** Sets a field element to be the square of another. Requires the input's magnitude to be at most 8.
+ * The output magnitude is 1 (but not guaranteed to be normalized). */
+static void secp256k1_fe_sqr(secp256k1_fe_t *r, const secp256k1_fe_t *a);
+
+/** Sets a field element to be the (modular) square root (if any exist) of another. Requires the
+ * input's magnitude to be at most 8. The output magnitude is 1 (but not guaranteed to be
+ * normalized). Return value indicates whether a square root was found. */
+static int secp256k1_fe_sqrt_var(secp256k1_fe_t *r, const secp256k1_fe_t *a);
+
+/** Sets a field element to be the (modular) inverse of another. Requires the input's magnitude to be
+ * at most 8. The output magnitude is 1 (but not guaranteed to be normalized). */
+static void secp256k1_fe_inv(secp256k1_fe_t *r, const secp256k1_fe_t *a);
+
+/** Potentially faster version of secp256k1_fe_inv, without constant-time guarantee. */
+static void secp256k1_fe_inv_var(secp256k1_fe_t *r, const secp256k1_fe_t *a);
+
+/** Calculate the (modular) inverses of a batch of field elements. Requires the inputs' magnitudes to be
+ * at most 8. The output magnitudes are 1 (but not guaranteed to be normalized). The inputs and
+ * outputs must not overlap in memory. */
+static void secp256k1_fe_inv_all_var(size_t len, secp256k1_fe_t *r, const secp256k1_fe_t *a);
+
+/** Convert a field element to the storage type. */
+static void secp256k1_fe_to_storage(secp256k1_fe_storage_t *r, const secp256k1_fe_t*);
+
+/** Convert a field element back from the storage type. */
+static void secp256k1_fe_from_storage(secp256k1_fe_t *r, const secp256k1_fe_storage_t*);
+
+/** If flag is true, set *r equal to *a; otherwise leave it. Constant-time. */
+static void secp256k1_fe_storage_cmov(secp256k1_fe_storage_t *r, const secp256k1_fe_storage_t *a, int flag);
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_10x26.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_10x26.h
new file mode 100644
index 0000000000000000000000000000000000000000..44bce6525df9f154ea6a394f8ea56acb10cde44d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_10x26.h
@@ -0,0 +1,47 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_FIELD_REPR_
+#define _SECP256K1_FIELD_REPR_
+
+#include <stdint.h>
+
+typedef struct {
+ /* X = sum(i=0..9, elem[i]*2^26) mod n */
+ uint32_t n[10];
+#ifdef VERIFY
+ int magnitude;
+ int normalized;
+#endif
+} secp256k1_fe_t;
+
+/* Unpacks a constant into a overlapping multi-limbed FE element. */
+#define SECP256K1_FE_CONST_INNER(d7, d6, d5, d4, d3, d2, d1, d0) { \
+ (d0) & 0x3FFFFFFUL, \
+ ((d0) >> 26) | ((d1) & 0xFFFFFUL) << 6, \
+ ((d1) >> 20) | ((d2) & 0x3FFFUL) << 12, \
+ ((d2) >> 14) | ((d3) & 0xFFUL) << 18, \
+ ((d3) >> 8) | ((d4) & 0x3) << 24, \
+ ((d4) >> 2) & 0x3FFFFFFUL, \
+ ((d4) >> 28) | ((d5) & 0x3FFFFFUL) << 4, \
+ ((d5) >> 22) | ((d6) & 0xFFFF) << 10, \
+ ((d6) >> 16) | ((d7) & 0x3FF) << 16, \
+ ((d7) >> 10) \
+}
+
+#ifdef VERIFY
+#define SECP256K1_FE_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {SECP256K1_FE_CONST_INNER((d7), (d6), (d5), (d4), (d3), (d2), (d1), (d0)), 1, 1}
+#else
+#define SECP256K1_FE_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {SECP256K1_FE_CONST_INNER((d7), (d6), (d5), (d4), (d3), (d2), (d1), (d0))}
+#endif
+
+typedef struct {
+ uint32_t n[8];
+} secp256k1_fe_storage_t;
+
+#define SECP256K1_FE_STORAGE_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{ (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }}
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_10x26_impl.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_10x26_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..b32a666f5373d7c8848590312ec106994eea0608
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_10x26_impl.h
@@ -0,0 +1,1116 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_FIELD_REPR_IMPL_H_
+#define _SECP256K1_FIELD_REPR_IMPL_H_
+
+#include <stdio.h>
+#include <string.h>
+#include "util.h"
+#include "num.h"
+#include "field.h"
+
+#ifdef VERIFY
+static void secp256k1_fe_verify(const secp256k1_fe_t *a) {
+ const uint32_t *d = a->n;
+ int m = a->normalized ? 1 : 2 * a->magnitude, r = 1;
+ r &= (d[0] <= 0x3FFFFFFUL * m);
+ r &= (d[1] <= 0x3FFFFFFUL * m);
+ r &= (d[2] <= 0x3FFFFFFUL * m);
+ r &= (d[3] <= 0x3FFFFFFUL * m);
+ r &= (d[4] <= 0x3FFFFFFUL * m);
+ r &= (d[5] <= 0x3FFFFFFUL * m);
+ r &= (d[6] <= 0x3FFFFFFUL * m);
+ r &= (d[7] <= 0x3FFFFFFUL * m);
+ r &= (d[8] <= 0x3FFFFFFUL * m);
+ r &= (d[9] <= 0x03FFFFFUL * m);
+ r &= (a->magnitude >= 0);
+ r &= (a->magnitude <= 32);
+ if (a->normalized) {
+ r &= (a->magnitude <= 1);
+ if (r && (d[9] == 0x03FFFFFUL)) {
+ uint32_t mid = d[8] & d[7] & d[6] & d[5] & d[4] & d[3] & d[2];
+ if (mid == 0x3FFFFFFUL) {
+ r &= ((d[1] + 0x40UL + ((d[0] + 0x3D1UL) >> 26)) <= 0x3FFFFFFUL);
+ }
+ }
+ }
+ VERIFY_CHECK(r == 1);
+}
+#else
+static void secp256k1_fe_verify(const secp256k1_fe_t *a) {
+ (void)a;
+}
+#endif
+
+static void secp256k1_fe_normalize(secp256k1_fe_t *r) {
+ uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
+ t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
+
+ /* Reduce t9 at the start so there will be at most a single carry from the first pass */
+ uint32_t m;
+ uint32_t x = t9 >> 22; t9 &= 0x03FFFFFUL;
+
+ /* The first pass ensures the magnitude is 1, ... */
+ t0 += x * 0x3D1UL; t1 += (x << 6);
+ t1 += (t0 >> 26); t0 &= 0x3FFFFFFUL;
+ t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL;
+ t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL; m = t2;
+ t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL; m &= t3;
+ t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL; m &= t4;
+ t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL; m &= t5;
+ t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL; m &= t6;
+ t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL; m &= t7;
+ t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL; m &= t8;
+
+ /* ... except for a possible carry at bit 22 of t9 (i.e. bit 256 of the field element) */
+ VERIFY_CHECK(t9 >> 23 == 0);
+
+ /* At most a single final reduction is needed; check if the value is >= the field characteristic */
+ x = (t9 >> 22) | ((t9 == 0x03FFFFFUL) & (m == 0x3FFFFFFUL)
+ & ((t1 + 0x40UL + ((t0 + 0x3D1UL) >> 26)) > 0x3FFFFFFUL));
+
+ /* Apply the final reduction (for constant-time behaviour, we do it always) */
+ t0 += x * 0x3D1UL; t1 += (x << 6);
+ t1 += (t0 >> 26); t0 &= 0x3FFFFFFUL;
+ t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL;
+ t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL;
+ t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL;
+ t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL;
+ t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL;
+ t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL;
+ t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL;
+ t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL;
+
+ /* If t9 didn't carry to bit 22 already, then it should have after any final reduction */
+ VERIFY_CHECK(t9 >> 22 == x);
+
+ /* Mask off the possible multiple of 2^256 from the final reduction */
+ t9 &= 0x03FFFFFUL;
+
+ r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
+ r->n[5] = t5; r->n[6] = t6; r->n[7] = t7; r->n[8] = t8; r->n[9] = t9;
+
+#ifdef VERIFY
+ r->magnitude = 1;
+ r->normalized = 1;
+ secp256k1_fe_verify(r);
+#endif
+}
+
+static void secp256k1_fe_normalize_weak(secp256k1_fe_t *r) {
+ uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
+ t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
+
+ /* Reduce t9 at the start so there will be at most a single carry from the first pass */
+ uint32_t x = t9 >> 22; t9 &= 0x03FFFFFUL;
+
+ /* The first pass ensures the magnitude is 1, ... */
+ t0 += x * 0x3D1UL; t1 += (x << 6);
+ t1 += (t0 >> 26); t0 &= 0x3FFFFFFUL;
+ t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL;
+ t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL;
+ t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL;
+ t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL;
+ t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL;
+ t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL;
+ t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL;
+ t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL;
+
+ /* ... except for a possible carry at bit 22 of t9 (i.e. bit 256 of the field element) */
+ VERIFY_CHECK(t9 >> 23 == 0);
+
+ r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
+ r->n[5] = t5; r->n[6] = t6; r->n[7] = t7; r->n[8] = t8; r->n[9] = t9;
+
+#ifdef VERIFY
+ r->magnitude = 1;
+ secp256k1_fe_verify(r);
+#endif
+}
+
+static void secp256k1_fe_normalize_var(secp256k1_fe_t *r) {
+ uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
+ t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
+
+ /* Reduce t9 at the start so there will be at most a single carry from the first pass */
+ uint32_t m;
+ uint32_t x = t9 >> 22; t9 &= 0x03FFFFFUL;
+
+ /* The first pass ensures the magnitude is 1, ... */
+ t0 += x * 0x3D1UL; t1 += (x << 6);
+ t1 += (t0 >> 26); t0 &= 0x3FFFFFFUL;
+ t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL;
+ t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL; m = t2;
+ t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL; m &= t3;
+ t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL; m &= t4;
+ t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL; m &= t5;
+ t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL; m &= t6;
+ t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL; m &= t7;
+ t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL; m &= t8;
+
+ /* ... except for a possible carry at bit 22 of t9 (i.e. bit 256 of the field element) */
+ VERIFY_CHECK(t9 >> 23 == 0);
+
+ /* At most a single final reduction is needed; check if the value is >= the field characteristic */
+ x = (t9 >> 22) | ((t9 == 0x03FFFFFUL) & (m == 0x3FFFFFFUL)
+ & ((t1 + 0x40UL + ((t0 + 0x3D1UL) >> 26)) > 0x3FFFFFFUL));
+
+ if (x) {
+ t0 += 0x3D1UL; t1 += (x << 6);
+ t1 += (t0 >> 26); t0 &= 0x3FFFFFFUL;
+ t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL;
+ t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL;
+ t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL;
+ t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL;
+ t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL;
+ t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL;
+ t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL;
+ t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL;
+
+ /* If t9 didn't carry to bit 22 already, then it should have after any final reduction */
+ VERIFY_CHECK(t9 >> 22 == x);
+
+ /* Mask off the possible multiple of 2^256 from the final reduction */
+ t9 &= 0x03FFFFFUL;
+ }
+
+ r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
+ r->n[5] = t5; r->n[6] = t6; r->n[7] = t7; r->n[8] = t8; r->n[9] = t9;
+
+#ifdef VERIFY
+ r->magnitude = 1;
+ r->normalized = 1;
+ secp256k1_fe_verify(r);
+#endif
+}
+
+static int secp256k1_fe_normalizes_to_zero(secp256k1_fe_t *r) {
+ uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
+ t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
+
+ /* z0 tracks a possible raw value of 0, z1 tracks a possible raw value of P */
+ uint32_t z0, z1;
+
+ /* Reduce t9 at the start so there will be at most a single carry from the first pass */
+ uint32_t x = t9 >> 22; t9 &= 0x03FFFFFUL;
+
+ /* The first pass ensures the magnitude is 1, ... */
+ t0 += x * 0x3D1UL; t1 += (x << 6);
+ t1 += (t0 >> 26); t0 &= 0x3FFFFFFUL; z0 = t0; z1 = t0 ^ 0x3D0UL;
+ t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL; z0 |= t1; z1 &= t1 ^ 0x40UL;
+ t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL; z0 |= t2; z1 &= t2;
+ t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL; z0 |= t3; z1 &= t3;
+ t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL; z0 |= t4; z1 &= t4;
+ t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL; z0 |= t5; z1 &= t5;
+ t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL; z0 |= t6; z1 &= t6;
+ t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL; z0 |= t7; z1 &= t7;
+ t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL; z0 |= t8; z1 &= t8;
+ z0 |= t9; z1 &= t9 ^ 0x3C00000UL;
+
+ /* ... except for a possible carry at bit 22 of t9 (i.e. bit 256 of the field element) */
+ VERIFY_CHECK(t9 >> 23 == 0);
+
+ return (z0 == 0) | (z1 == 0x3FFFFFFUL);
+}
+
+static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe_t *r) {
+ uint32_t t0, t1, t2, t3, t4, t5, t6, t7, t8, t9;
+ uint32_t z0, z1;
+ uint32_t x;
+
+ t0 = r->n[0];
+ t9 = r->n[9];
+
+ /* Reduce t9 at the start so there will be at most a single carry from the first pass */
+ x = t9 >> 22;
+
+ /* The first pass ensures the magnitude is 1, ... */
+ t0 += x * 0x3D1UL;
+
+ /* z0 tracks a possible raw value of 0, z1 tracks a possible raw value of P */
+ z0 = t0 & 0x3FFFFFFUL;
+ z1 = z0 ^ 0x3D0UL;
+
+ /* Fast return path should catch the majority of cases */
+ if ((z0 != 0UL) & (z1 != 0x3FFFFFFUL)) {
+ return 0;
+ }
+
+ t1 = r->n[1];
+ t2 = r->n[2];
+ t3 = r->n[3];
+ t4 = r->n[4];
+ t5 = r->n[5];
+ t6 = r->n[6];
+ t7 = r->n[7];
+ t8 = r->n[8];
+
+ t9 &= 0x03FFFFFUL;
+ t1 += (x << 6);
+
+ t1 += (t0 >> 26); t0 = z0;
+ t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL; z0 |= t1; z1 &= t1 ^ 0x40UL;
+ t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL; z0 |= t2; z1 &= t2;
+ t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL; z0 |= t3; z1 &= t3;
+ t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL; z0 |= t4; z1 &= t4;
+ t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL; z0 |= t5; z1 &= t5;
+ t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL; z0 |= t6; z1 &= t6;
+ t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL; z0 |= t7; z1 &= t7;
+ t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL; z0 |= t8; z1 &= t8;
+ z0 |= t9; z1 &= t9 ^ 0x3C00000UL;
+
+ /* ... except for a possible carry at bit 22 of t9 (i.e. bit 256 of the field element) */
+ VERIFY_CHECK(t9 >> 23 == 0);
+
+ return (z0 == 0) | (z1 == 0x3FFFFFFUL);
+}
+
+SECP256K1_INLINE static void secp256k1_fe_set_int(secp256k1_fe_t *r, int a) {
+ r->n[0] = a;
+ r->n[1] = r->n[2] = r->n[3] = r->n[4] = r->n[5] = r->n[6] = r->n[7] = r->n[8] = r->n[9] = 0;
+#ifdef VERIFY
+ r->magnitude = 1;
+ r->normalized = 1;
+ secp256k1_fe_verify(r);
+#endif
+}
+
+SECP256K1_INLINE static int secp256k1_fe_is_zero(const secp256k1_fe_t *a) {
+ const uint32_t *t = a->n;
+#ifdef VERIFY
+ VERIFY_CHECK(a->normalized);
+ secp256k1_fe_verify(a);
+#endif
+ return (t[0] | t[1] | t[2] | t[3] | t[4] | t[5] | t[6] | t[7] | t[8] | t[9]) == 0;
+}
+
+SECP256K1_INLINE static int secp256k1_fe_is_odd(const secp256k1_fe_t *a) {
+#ifdef VERIFY
+ VERIFY_CHECK(a->normalized);
+ secp256k1_fe_verify(a);
+#endif
+ return a->n[0] & 1;
+}
+
+SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe_t *a) {
+ int i;
+#ifdef VERIFY
+ a->magnitude = 0;
+ a->normalized = 1;
+#endif
+ for (i=0; i<10; i++) {
+ a->n[i] = 0;
+ }
+}
+
+static int secp256k1_fe_cmp_var(const secp256k1_fe_t *a, const secp256k1_fe_t *b) {
+ int i;
+#ifdef VERIFY
+ VERIFY_CHECK(a->normalized);
+ VERIFY_CHECK(b->normalized);
+ secp256k1_fe_verify(a);
+ secp256k1_fe_verify(b);
+#endif
+ for (i = 9; i >= 0; i--) {
+ if (a->n[i] > b->n[i]) {
+ return 1;
+ }
+ if (a->n[i] < b->n[i]) {
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int secp256k1_fe_set_b32(secp256k1_fe_t *r, const unsigned char *a) {
+ int i;
+ r->n[0] = r->n[1] = r->n[2] = r->n[3] = r->n[4] = 0;
+ r->n[5] = r->n[6] = r->n[7] = r->n[8] = r->n[9] = 0;
+ for (i=0; i<32; i++) {
+ int j;
+ for (j=0; j<4; j++) {
+ int limb = (8*i+2*j)/26;
+ int shift = (8*i+2*j)%26;
+ r->n[limb] |= (uint32_t)((a[31-i] >> (2*j)) & 0x3) << shift;
+ }
+ }
+ if (r->n[9] == 0x3FFFFFUL && (r->n[8] & r->n[7] & r->n[6] & r->n[5] & r->n[4] & r->n[3] & r->n[2]) == 0x3FFFFFFUL && (r->n[1] + 0x40UL + ((r->n[0] + 0x3D1UL) >> 26)) > 0x3FFFFFFUL) {
+ return 0;
+ }
+#ifdef VERIFY
+ r->magnitude = 1;
+ r->normalized = 1;
+ secp256k1_fe_verify(r);
+#endif
+ return 1;
+}
+
+/** Convert a field element to a 32-byte big endian value. Requires the input to be normalized */
+static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe_t *a) {
+ int i;
+#ifdef VERIFY
+ VERIFY_CHECK(a->normalized);
+ secp256k1_fe_verify(a);
+#endif
+ for (i=0; i<32; i++) {
+ int j;
+ int c = 0;
+ for (j=0; j<4; j++) {
+ int limb = (8*i+2*j)/26;
+ int shift = (8*i+2*j)%26;
+ c |= ((a->n[limb] >> shift) & 0x3) << (2 * j);
+ }
+ r[31-i] = c;
+ }
+}
+
+SECP256K1_INLINE static void secp256k1_fe_negate(secp256k1_fe_t *r, const secp256k1_fe_t *a, int m) {
+#ifdef VERIFY
+ VERIFY_CHECK(a->magnitude <= m);
+ secp256k1_fe_verify(a);
+#endif
+ r->n[0] = 0x3FFFC2FUL * 2 * (m + 1) - a->n[0];
+ r->n[1] = 0x3FFFFBFUL * 2 * (m + 1) - a->n[1];
+ r->n[2] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[2];
+ r->n[3] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[3];
+ r->n[4] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[4];
+ r->n[5] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[5];
+ r->n[6] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[6];
+ r->n[7] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[7];
+ r->n[8] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[8];
+ r->n[9] = 0x03FFFFFUL * 2 * (m + 1) - a->n[9];
+#ifdef VERIFY
+ r->magnitude = m + 1;
+ r->normalized = 0;
+ secp256k1_fe_verify(r);
+#endif
+}
+
+SECP256K1_INLINE static void secp256k1_fe_mul_int(secp256k1_fe_t *r, int a) {
+ r->n[0] *= a;
+ r->n[1] *= a;
+ r->n[2] *= a;
+ r->n[3] *= a;
+ r->n[4] *= a;
+ r->n[5] *= a;
+ r->n[6] *= a;
+ r->n[7] *= a;
+ r->n[8] *= a;
+ r->n[9] *= a;
+#ifdef VERIFY
+ r->magnitude *= a;
+ r->normalized = 0;
+ secp256k1_fe_verify(r);
+#endif
+}
+
+SECP256K1_INLINE static void secp256k1_fe_add(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
+#ifdef VERIFY
+ secp256k1_fe_verify(a);
+#endif
+ r->n[0] += a->n[0];
+ r->n[1] += a->n[1];
+ r->n[2] += a->n[2];
+ r->n[3] += a->n[3];
+ r->n[4] += a->n[4];
+ r->n[5] += a->n[5];
+ r->n[6] += a->n[6];
+ r->n[7] += a->n[7];
+ r->n[8] += a->n[8];
+ r->n[9] += a->n[9];
+#ifdef VERIFY
+ r->magnitude += a->magnitude;
+ r->normalized = 0;
+ secp256k1_fe_verify(r);
+#endif
+}
+
+#ifdef VERIFY
+#define VERIFY_BITS(x, n) VERIFY_CHECK(((x) >> (n)) == 0)
+#else
+#define VERIFY_BITS(x, n) do { } while(0)
+#endif
+
+SECP256K1_INLINE static void secp256k1_fe_mul_inner(uint32_t *r, const uint32_t *a, const uint32_t * SECP256K1_RESTRICT b) {
+ uint64_t c, d;
+ uint64_t u0, u1, u2, u3, u4, u5, u6, u7, u8;
+ uint32_t t9, t1, t0, t2, t3, t4, t5, t6, t7;
+ const uint32_t M = 0x3FFFFFFUL, R0 = 0x3D10UL, R1 = 0x400UL;
+
+ VERIFY_BITS(a[0], 30);
+ VERIFY_BITS(a[1], 30);
+ VERIFY_BITS(a[2], 30);
+ VERIFY_BITS(a[3], 30);
+ VERIFY_BITS(a[4], 30);
+ VERIFY_BITS(a[5], 30);
+ VERIFY_BITS(a[6], 30);
+ VERIFY_BITS(a[7], 30);
+ VERIFY_BITS(a[8], 30);
+ VERIFY_BITS(a[9], 26);
+ VERIFY_BITS(b[0], 30);
+ VERIFY_BITS(b[1], 30);
+ VERIFY_BITS(b[2], 30);
+ VERIFY_BITS(b[3], 30);
+ VERIFY_BITS(b[4], 30);
+ VERIFY_BITS(b[5], 30);
+ VERIFY_BITS(b[6], 30);
+ VERIFY_BITS(b[7], 30);
+ VERIFY_BITS(b[8], 30);
+ VERIFY_BITS(b[9], 26);
+
+ /** [... a b c] is a shorthand for ... + a<<52 + b<<26 + c<<0 mod n.
+ * px is a shorthand for sum(a[i]*b[x-i], i=0..x).
+ * Note that [x 0 0 0 0 0 0 0 0 0 0] = [x*R1 x*R0].
+ */
+
+ d = (uint64_t)a[0] * b[9]
+ + (uint64_t)a[1] * b[8]
+ + (uint64_t)a[2] * b[7]
+ + (uint64_t)a[3] * b[6]
+ + (uint64_t)a[4] * b[5]
+ + (uint64_t)a[5] * b[4]
+ + (uint64_t)a[6] * b[3]
+ + (uint64_t)a[7] * b[2]
+ + (uint64_t)a[8] * b[1]
+ + (uint64_t)a[9] * b[0];
+ /* VERIFY_BITS(d, 64); */
+ /* [d 0 0 0 0 0 0 0 0 0] = [p9 0 0 0 0 0 0 0 0 0] */
+ t9 = d & M; d >>= 26;
+ VERIFY_BITS(t9, 26);
+ VERIFY_BITS(d, 38);
+ /* [d t9 0 0 0 0 0 0 0 0 0] = [p9 0 0 0 0 0 0 0 0 0] */
+
+ c = (uint64_t)a[0] * b[0];
+ VERIFY_BITS(c, 60);
+ /* [d t9 0 0 0 0 0 0 0 0 c] = [p9 0 0 0 0 0 0 0 0 p0] */
+ d += (uint64_t)a[1] * b[9]
+ + (uint64_t)a[2] * b[8]
+ + (uint64_t)a[3] * b[7]
+ + (uint64_t)a[4] * b[6]
+ + (uint64_t)a[5] * b[5]
+ + (uint64_t)a[6] * b[4]
+ + (uint64_t)a[7] * b[3]
+ + (uint64_t)a[8] * b[2]
+ + (uint64_t)a[9] * b[1];
+ VERIFY_BITS(d, 63);
+ /* [d t9 0 0 0 0 0 0 0 0 c] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
+ u0 = d & M; d >>= 26; c += u0 * R0;
+ VERIFY_BITS(u0, 26);
+ VERIFY_BITS(d, 37);
+ VERIFY_BITS(c, 61);
+ /* [d u0 t9 0 0 0 0 0 0 0 0 c-u0*R0] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
+ t0 = c & M; c >>= 26; c += u0 * R1;
+ VERIFY_BITS(t0, 26);
+ VERIFY_BITS(c, 37);
+ /* [d u0 t9 0 0 0 0 0 0 0 c-u0*R1 t0-u0*R0] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
+ /* [d 0 t9 0 0 0 0 0 0 0 c t0] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
+
+ c += (uint64_t)a[0] * b[1]
+ + (uint64_t)a[1] * b[0];
+ VERIFY_BITS(c, 62);
+ /* [d 0 t9 0 0 0 0 0 0 0 c t0] = [p10 p9 0 0 0 0 0 0 0 p1 p0] */
+ d += (uint64_t)a[2] * b[9]
+ + (uint64_t)a[3] * b[8]
+ + (uint64_t)a[4] * b[7]
+ + (uint64_t)a[5] * b[6]
+ + (uint64_t)a[6] * b[5]
+ + (uint64_t)a[7] * b[4]
+ + (uint64_t)a[8] * b[3]
+ + (uint64_t)a[9] * b[2];
+ VERIFY_BITS(d, 63);
+ /* [d 0 t9 0 0 0 0 0 0 0 c t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
+ u1 = d & M; d >>= 26; c += u1 * R0;
+ VERIFY_BITS(u1, 26);
+ VERIFY_BITS(d, 37);
+ VERIFY_BITS(c, 63);
+ /* [d u1 0 t9 0 0 0 0 0 0 0 c-u1*R0 t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
+ t1 = c & M; c >>= 26; c += u1 * R1;
+ VERIFY_BITS(t1, 26);
+ VERIFY_BITS(c, 38);
+ /* [d u1 0 t9 0 0 0 0 0 0 c-u1*R1 t1-u1*R0 t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
+ /* [d 0 0 t9 0 0 0 0 0 0 c t1 t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
+
+ c += (uint64_t)a[0] * b[2]
+ + (uint64_t)a[1] * b[1]
+ + (uint64_t)a[2] * b[0];
+ VERIFY_BITS(c, 62);
+ /* [d 0 0 t9 0 0 0 0 0 0 c t1 t0] = [p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
+ d += (uint64_t)a[3] * b[9]
+ + (uint64_t)a[4] * b[8]
+ + (uint64_t)a[5] * b[7]
+ + (uint64_t)a[6] * b[6]
+ + (uint64_t)a[7] * b[5]
+ + (uint64_t)a[8] * b[4]
+ + (uint64_t)a[9] * b[3];
+ VERIFY_BITS(d, 63);
+ /* [d 0 0 t9 0 0 0 0 0 0 c t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
+ u2 = d & M; d >>= 26; c += u2 * R0;
+ VERIFY_BITS(u2, 26);
+ VERIFY_BITS(d, 37);
+ VERIFY_BITS(c, 63);
+ /* [d u2 0 0 t9 0 0 0 0 0 0 c-u2*R0 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
+ t2 = c & M; c >>= 26; c += u2 * R1;
+ VERIFY_BITS(t2, 26);
+ VERIFY_BITS(c, 38);
+ /* [d u2 0 0 t9 0 0 0 0 0 c-u2*R1 t2-u2*R0 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
+ /* [d 0 0 0 t9 0 0 0 0 0 c t2 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
+
+ c += (uint64_t)a[0] * b[3]
+ + (uint64_t)a[1] * b[2]
+ + (uint64_t)a[2] * b[1]
+ + (uint64_t)a[3] * b[0];
+ VERIFY_BITS(c, 63);
+ /* [d 0 0 0 t9 0 0 0 0 0 c t2 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
+ d += (uint64_t)a[4] * b[9]
+ + (uint64_t)a[5] * b[8]
+ + (uint64_t)a[6] * b[7]
+ + (uint64_t)a[7] * b[6]
+ + (uint64_t)a[8] * b[5]
+ + (uint64_t)a[9] * b[4];
+ VERIFY_BITS(d, 63);
+ /* [d 0 0 0 t9 0 0 0 0 0 c t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
+ u3 = d & M; d >>= 26; c += u3 * R0;
+ VERIFY_BITS(u3, 26);
+ VERIFY_BITS(d, 37);
+ /* VERIFY_BITS(c, 64); */
+ /* [d u3 0 0 0 t9 0 0 0 0 0 c-u3*R0 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
+ t3 = c & M; c >>= 26; c += u3 * R1;
+ VERIFY_BITS(t3, 26);
+ VERIFY_BITS(c, 39);
+ /* [d u3 0 0 0 t9 0 0 0 0 c-u3*R1 t3-u3*R0 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
+ /* [d 0 0 0 0 t9 0 0 0 0 c t3 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
+
+ c += (uint64_t)a[0] * b[4]
+ + (uint64_t)a[1] * b[3]
+ + (uint64_t)a[2] * b[2]
+ + (uint64_t)a[3] * b[1]
+ + (uint64_t)a[4] * b[0];
+ VERIFY_BITS(c, 63);
+ /* [d 0 0 0 0 t9 0 0 0 0 c t3 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
+ d += (uint64_t)a[5] * b[9]
+ + (uint64_t)a[6] * b[8]
+ + (uint64_t)a[7] * b[7]
+ + (uint64_t)a[8] * b[6]
+ + (uint64_t)a[9] * b[5];
+ VERIFY_BITS(d, 62);
+ /* [d 0 0 0 0 t9 0 0 0 0 c t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
+ u4 = d & M; d >>= 26; c += u4 * R0;
+ VERIFY_BITS(u4, 26);
+ VERIFY_BITS(d, 36);
+ /* VERIFY_BITS(c, 64); */
+ /* [d u4 0 0 0 0 t9 0 0 0 0 c-u4*R0 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
+ t4 = c & M; c >>= 26; c += u4 * R1;
+ VERIFY_BITS(t4, 26);
+ VERIFY_BITS(c, 39);
+ /* [d u4 0 0 0 0 t9 0 0 0 c-u4*R1 t4-u4*R0 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
+ /* [d 0 0 0 0 0 t9 0 0 0 c t4 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
+
+ c += (uint64_t)a[0] * b[5]
+ + (uint64_t)a[1] * b[4]
+ + (uint64_t)a[2] * b[3]
+ + (uint64_t)a[3] * b[2]
+ + (uint64_t)a[4] * b[1]
+ + (uint64_t)a[5] * b[0];
+ VERIFY_BITS(c, 63);
+ /* [d 0 0 0 0 0 t9 0 0 0 c t4 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
+ d += (uint64_t)a[6] * b[9]
+ + (uint64_t)a[7] * b[8]
+ + (uint64_t)a[8] * b[7]
+ + (uint64_t)a[9] * b[6];
+ VERIFY_BITS(d, 62);
+ /* [d 0 0 0 0 0 t9 0 0 0 c t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
+ u5 = d & M; d >>= 26; c += u5 * R0;
+ VERIFY_BITS(u5, 26);
+ VERIFY_BITS(d, 36);
+ /* VERIFY_BITS(c, 64); */
+ /* [d u5 0 0 0 0 0 t9 0 0 0 c-u5*R0 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
+ t5 = c & M; c >>= 26; c += u5 * R1;
+ VERIFY_BITS(t5, 26);
+ VERIFY_BITS(c, 39);
+ /* [d u5 0 0 0 0 0 t9 0 0 c-u5*R1 t5-u5*R0 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
+ /* [d 0 0 0 0 0 0 t9 0 0 c t5 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
+
+ c += (uint64_t)a[0] * b[6]
+ + (uint64_t)a[1] * b[5]
+ + (uint64_t)a[2] * b[4]
+ + (uint64_t)a[3] * b[3]
+ + (uint64_t)a[4] * b[2]
+ + (uint64_t)a[5] * b[1]
+ + (uint64_t)a[6] * b[0];
+ VERIFY_BITS(c, 63);
+ /* [d 0 0 0 0 0 0 t9 0 0 c t5 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
+ d += (uint64_t)a[7] * b[9]
+ + (uint64_t)a[8] * b[8]
+ + (uint64_t)a[9] * b[7];
+ VERIFY_BITS(d, 61);
+ /* [d 0 0 0 0 0 0 t9 0 0 c t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
+ u6 = d & M; d >>= 26; c += u6 * R0;
+ VERIFY_BITS(u6, 26);
+ VERIFY_BITS(d, 35);
+ /* VERIFY_BITS(c, 64); */
+ /* [d u6 0 0 0 0 0 0 t9 0 0 c-u6*R0 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
+ t6 = c & M; c >>= 26; c += u6 * R1;
+ VERIFY_BITS(t6, 26);
+ VERIFY_BITS(c, 39);
+ /* [d u6 0 0 0 0 0 0 t9 0 c-u6*R1 t6-u6*R0 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
+ /* [d 0 0 0 0 0 0 0 t9 0 c t6 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
+
+ c += (uint64_t)a[0] * b[7]
+ + (uint64_t)a[1] * b[6]
+ + (uint64_t)a[2] * b[5]
+ + (uint64_t)a[3] * b[4]
+ + (uint64_t)a[4] * b[3]
+ + (uint64_t)a[5] * b[2]
+ + (uint64_t)a[6] * b[1]
+ + (uint64_t)a[7] * b[0];
+ /* VERIFY_BITS(c, 64); */
+ VERIFY_CHECK(c <= 0x8000007C00000007ULL);
+ /* [d 0 0 0 0 0 0 0 t9 0 c t6 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
+ d += (uint64_t)a[8] * b[9]
+ + (uint64_t)a[9] * b[8];
+ VERIFY_BITS(d, 58);
+ /* [d 0 0 0 0 0 0 0 t9 0 c t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
+ u7 = d & M; d >>= 26; c += u7 * R0;
+ VERIFY_BITS(u7, 26);
+ VERIFY_BITS(d, 32);
+ /* VERIFY_BITS(c, 64); */
+ VERIFY_CHECK(c <= 0x800001703FFFC2F7ULL);
+ /* [d u7 0 0 0 0 0 0 0 t9 0 c-u7*R0 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
+ t7 = c & M; c >>= 26; c += u7 * R1;
+ VERIFY_BITS(t7, 26);
+ VERIFY_BITS(c, 38);
+ /* [d u7 0 0 0 0 0 0 0 t9 c-u7*R1 t7-u7*R0 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
+ /* [d 0 0 0 0 0 0 0 0 t9 c t7 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
+
+ c += (uint64_t)a[0] * b[8]
+ + (uint64_t)a[1] * b[7]
+ + (uint64_t)a[2] * b[6]
+ + (uint64_t)a[3] * b[5]
+ + (uint64_t)a[4] * b[4]
+ + (uint64_t)a[5] * b[3]
+ + (uint64_t)a[6] * b[2]
+ + (uint64_t)a[7] * b[1]
+ + (uint64_t)a[8] * b[0];
+ /* VERIFY_BITS(c, 64); */
+ VERIFY_CHECK(c <= 0x9000007B80000008ULL);
+ /* [d 0 0 0 0 0 0 0 0 t9 c t7 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ d += (uint64_t)a[9] * b[9];
+ VERIFY_BITS(d, 57);
+ /* [d 0 0 0 0 0 0 0 0 t9 c t7 t6 t5 t4 t3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ u8 = d & M; d >>= 26; c += u8 * R0;
+ VERIFY_BITS(u8, 26);
+ VERIFY_BITS(d, 31);
+ /* VERIFY_BITS(c, 64); */
+ VERIFY_CHECK(c <= 0x9000016FBFFFC2F8ULL);
+ /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 t5 t4 t3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+
+ r[3] = t3;
+ VERIFY_BITS(r[3], 26);
+ /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 t5 t4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[4] = t4;
+ VERIFY_BITS(r[4], 26);
+ /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 t5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[5] = t5;
+ VERIFY_BITS(r[5], 26);
+ /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[6] = t6;
+ VERIFY_BITS(r[6], 26);
+ /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[7] = t7;
+ VERIFY_BITS(r[7], 26);
+ /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+
+ r[8] = c & M; c >>= 26; c += u8 * R1;
+ VERIFY_BITS(r[8], 26);
+ VERIFY_BITS(c, 39);
+ /* [d u8 0 0 0 0 0 0 0 0 t9+c-u8*R1 r8-u8*R0 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ /* [d 0 0 0 0 0 0 0 0 0 t9+c r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ c += d * R0 + t9;
+ VERIFY_BITS(c, 45);
+ /* [d 0 0 0 0 0 0 0 0 0 c-d*R0 r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[9] = c & (M >> 4); c >>= 22; c += d * (R1 << 4);
+ VERIFY_BITS(r[9], 22);
+ VERIFY_BITS(c, 46);
+ /* [d 0 0 0 0 0 0 0 0 r9+((c-d*R1<<4)<<22)-d*R0 r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ /* [d 0 0 0 0 0 0 0 -d*R1 r9+(c<<22)-d*R0 r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+
+ d = c * (R0 >> 4) + t0;
+ VERIFY_BITS(d, 56);
+ /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 t1 d-c*R0>>4] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[0] = d & M; d >>= 26;
+ VERIFY_BITS(r[0], 26);
+ VERIFY_BITS(d, 30);
+ /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 t1+d r0-c*R0>>4] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ d += c * (R1 >> 4) + t1;
+ VERIFY_BITS(d, 53);
+ VERIFY_CHECK(d <= 0x10000003FFFFBFULL);
+ /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 d-c*R1>>4 r0-c*R0>>4] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ /* [r9 r8 r7 r6 r5 r4 r3 t2 d r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[1] = d & M; d >>= 26;
+ VERIFY_BITS(r[1], 26);
+ VERIFY_BITS(d, 27);
+ VERIFY_CHECK(d <= 0x4000000ULL);
+ /* [r9 r8 r7 r6 r5 r4 r3 t2+d r1 r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ d += t2;
+ VERIFY_BITS(d, 27);
+ /* [r9 r8 r7 r6 r5 r4 r3 d r1 r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[2] = d;
+ VERIFY_BITS(r[2], 27);
+ /* [r9 r8 r7 r6 r5 r4 r3 r2 r1 r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+}
+
+SECP256K1_INLINE static void secp256k1_fe_sqr_inner(uint32_t *r, const uint32_t *a) {
+ uint64_t c, d;
+ uint64_t u0, u1, u2, u3, u4, u5, u6, u7, u8;
+ uint32_t t9, t0, t1, t2, t3, t4, t5, t6, t7;
+ const uint32_t M = 0x3FFFFFFUL, R0 = 0x3D10UL, R1 = 0x400UL;
+
+ VERIFY_BITS(a[0], 30);
+ VERIFY_BITS(a[1], 30);
+ VERIFY_BITS(a[2], 30);
+ VERIFY_BITS(a[3], 30);
+ VERIFY_BITS(a[4], 30);
+ VERIFY_BITS(a[5], 30);
+ VERIFY_BITS(a[6], 30);
+ VERIFY_BITS(a[7], 30);
+ VERIFY_BITS(a[8], 30);
+ VERIFY_BITS(a[9], 26);
+
+ /** [... a b c] is a shorthand for ... + a<<52 + b<<26 + c<<0 mod n.
+ * px is a shorthand for sum(a[i]*a[x-i], i=0..x).
+ * Note that [x 0 0 0 0 0 0 0 0 0 0] = [x*R1 x*R0].
+ */
+
+ d = (uint64_t)(a[0]*2) * a[9]
+ + (uint64_t)(a[1]*2) * a[8]
+ + (uint64_t)(a[2]*2) * a[7]
+ + (uint64_t)(a[3]*2) * a[6]
+ + (uint64_t)(a[4]*2) * a[5];
+ /* VERIFY_BITS(d, 64); */
+ /* [d 0 0 0 0 0 0 0 0 0] = [p9 0 0 0 0 0 0 0 0 0] */
+ t9 = d & M; d >>= 26;
+ VERIFY_BITS(t9, 26);
+ VERIFY_BITS(d, 38);
+ /* [d t9 0 0 0 0 0 0 0 0 0] = [p9 0 0 0 0 0 0 0 0 0] */
+
+ c = (uint64_t)a[0] * a[0];
+ VERIFY_BITS(c, 60);
+ /* [d t9 0 0 0 0 0 0 0 0 c] = [p9 0 0 0 0 0 0 0 0 p0] */
+ d += (uint64_t)(a[1]*2) * a[9]
+ + (uint64_t)(a[2]*2) * a[8]
+ + (uint64_t)(a[3]*2) * a[7]
+ + (uint64_t)(a[4]*2) * a[6]
+ + (uint64_t)a[5] * a[5];
+ VERIFY_BITS(d, 63);
+ /* [d t9 0 0 0 0 0 0 0 0 c] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
+ u0 = d & M; d >>= 26; c += u0 * R0;
+ VERIFY_BITS(u0, 26);
+ VERIFY_BITS(d, 37);
+ VERIFY_BITS(c, 61);
+ /* [d u0 t9 0 0 0 0 0 0 0 0 c-u0*R0] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
+ t0 = c & M; c >>= 26; c += u0 * R1;
+ VERIFY_BITS(t0, 26);
+ VERIFY_BITS(c, 37);
+ /* [d u0 t9 0 0 0 0 0 0 0 c-u0*R1 t0-u0*R0] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
+ /* [d 0 t9 0 0 0 0 0 0 0 c t0] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
+
+ c += (uint64_t)(a[0]*2) * a[1];
+ VERIFY_BITS(c, 62);
+ /* [d 0 t9 0 0 0 0 0 0 0 c t0] = [p10 p9 0 0 0 0 0 0 0 p1 p0] */
+ d += (uint64_t)(a[2]*2) * a[9]
+ + (uint64_t)(a[3]*2) * a[8]
+ + (uint64_t)(a[4]*2) * a[7]
+ + (uint64_t)(a[5]*2) * a[6];
+ VERIFY_BITS(d, 63);
+ /* [d 0 t9 0 0 0 0 0 0 0 c t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
+ u1 = d & M; d >>= 26; c += u1 * R0;
+ VERIFY_BITS(u1, 26);
+ VERIFY_BITS(d, 37);
+ VERIFY_BITS(c, 63);
+ /* [d u1 0 t9 0 0 0 0 0 0 0 c-u1*R0 t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
+ t1 = c & M; c >>= 26; c += u1 * R1;
+ VERIFY_BITS(t1, 26);
+ VERIFY_BITS(c, 38);
+ /* [d u1 0 t9 0 0 0 0 0 0 c-u1*R1 t1-u1*R0 t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
+ /* [d 0 0 t9 0 0 0 0 0 0 c t1 t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
+
+ c += (uint64_t)(a[0]*2) * a[2]
+ + (uint64_t)a[1] * a[1];
+ VERIFY_BITS(c, 62);
+ /* [d 0 0 t9 0 0 0 0 0 0 c t1 t0] = [p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
+ d += (uint64_t)(a[3]*2) * a[9]
+ + (uint64_t)(a[4]*2) * a[8]
+ + (uint64_t)(a[5]*2) * a[7]
+ + (uint64_t)a[6] * a[6];
+ VERIFY_BITS(d, 63);
+ /* [d 0 0 t9 0 0 0 0 0 0 c t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
+ u2 = d & M; d >>= 26; c += u2 * R0;
+ VERIFY_BITS(u2, 26);
+ VERIFY_BITS(d, 37);
+ VERIFY_BITS(c, 63);
+ /* [d u2 0 0 t9 0 0 0 0 0 0 c-u2*R0 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
+ t2 = c & M; c >>= 26; c += u2 * R1;
+ VERIFY_BITS(t2, 26);
+ VERIFY_BITS(c, 38);
+ /* [d u2 0 0 t9 0 0 0 0 0 c-u2*R1 t2-u2*R0 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
+ /* [d 0 0 0 t9 0 0 0 0 0 c t2 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
+
+ c += (uint64_t)(a[0]*2) * a[3]
+ + (uint64_t)(a[1]*2) * a[2];
+ VERIFY_BITS(c, 63);
+ /* [d 0 0 0 t9 0 0 0 0 0 c t2 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
+ d += (uint64_t)(a[4]*2) * a[9]
+ + (uint64_t)(a[5]*2) * a[8]
+ + (uint64_t)(a[6]*2) * a[7];
+ VERIFY_BITS(d, 63);
+ /* [d 0 0 0 t9 0 0 0 0 0 c t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
+ u3 = d & M; d >>= 26; c += u3 * R0;
+ VERIFY_BITS(u3, 26);
+ VERIFY_BITS(d, 37);
+ /* VERIFY_BITS(c, 64); */
+ /* [d u3 0 0 0 t9 0 0 0 0 0 c-u3*R0 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
+ t3 = c & M; c >>= 26; c += u3 * R1;
+ VERIFY_BITS(t3, 26);
+ VERIFY_BITS(c, 39);
+ /* [d u3 0 0 0 t9 0 0 0 0 c-u3*R1 t3-u3*R0 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
+ /* [d 0 0 0 0 t9 0 0 0 0 c t3 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
+
+ c += (uint64_t)(a[0]*2) * a[4]
+ + (uint64_t)(a[1]*2) * a[3]
+ + (uint64_t)a[2] * a[2];
+ VERIFY_BITS(c, 63);
+ /* [d 0 0 0 0 t9 0 0 0 0 c t3 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
+ d += (uint64_t)(a[5]*2) * a[9]
+ + (uint64_t)(a[6]*2) * a[8]
+ + (uint64_t)a[7] * a[7];
+ VERIFY_BITS(d, 62);
+ /* [d 0 0 0 0 t9 0 0 0 0 c t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
+ u4 = d & M; d >>= 26; c += u4 * R0;
+ VERIFY_BITS(u4, 26);
+ VERIFY_BITS(d, 36);
+ /* VERIFY_BITS(c, 64); */
+ /* [d u4 0 0 0 0 t9 0 0 0 0 c-u4*R0 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
+ t4 = c & M; c >>= 26; c += u4 * R1;
+ VERIFY_BITS(t4, 26);
+ VERIFY_BITS(c, 39);
+ /* [d u4 0 0 0 0 t9 0 0 0 c-u4*R1 t4-u4*R0 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
+ /* [d 0 0 0 0 0 t9 0 0 0 c t4 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
+
+ c += (uint64_t)(a[0]*2) * a[5]
+ + (uint64_t)(a[1]*2) * a[4]
+ + (uint64_t)(a[2]*2) * a[3];
+ VERIFY_BITS(c, 63);
+ /* [d 0 0 0 0 0 t9 0 0 0 c t4 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
+ d += (uint64_t)(a[6]*2) * a[9]
+ + (uint64_t)(a[7]*2) * a[8];
+ VERIFY_BITS(d, 62);
+ /* [d 0 0 0 0 0 t9 0 0 0 c t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
+ u5 = d & M; d >>= 26; c += u5 * R0;
+ VERIFY_BITS(u5, 26);
+ VERIFY_BITS(d, 36);
+ /* VERIFY_BITS(c, 64); */
+ /* [d u5 0 0 0 0 0 t9 0 0 0 c-u5*R0 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
+ t5 = c & M; c >>= 26; c += u5 * R1;
+ VERIFY_BITS(t5, 26);
+ VERIFY_BITS(c, 39);
+ /* [d u5 0 0 0 0 0 t9 0 0 c-u5*R1 t5-u5*R0 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
+ /* [d 0 0 0 0 0 0 t9 0 0 c t5 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
+
+ c += (uint64_t)(a[0]*2) * a[6]
+ + (uint64_t)(a[1]*2) * a[5]
+ + (uint64_t)(a[2]*2) * a[4]
+ + (uint64_t)a[3] * a[3];
+ VERIFY_BITS(c, 63);
+ /* [d 0 0 0 0 0 0 t9 0 0 c t5 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
+ d += (uint64_t)(a[7]*2) * a[9]
+ + (uint64_t)a[8] * a[8];
+ VERIFY_BITS(d, 61);
+ /* [d 0 0 0 0 0 0 t9 0 0 c t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
+ u6 = d & M; d >>= 26; c += u6 * R0;
+ VERIFY_BITS(u6, 26);
+ VERIFY_BITS(d, 35);
+ /* VERIFY_BITS(c, 64); */
+ /* [d u6 0 0 0 0 0 0 t9 0 0 c-u6*R0 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
+ t6 = c & M; c >>= 26; c += u6 * R1;
+ VERIFY_BITS(t6, 26);
+ VERIFY_BITS(c, 39);
+ /* [d u6 0 0 0 0 0 0 t9 0 c-u6*R1 t6-u6*R0 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
+ /* [d 0 0 0 0 0 0 0 t9 0 c t6 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
+
+ c += (uint64_t)(a[0]*2) * a[7]
+ + (uint64_t)(a[1]*2) * a[6]
+ + (uint64_t)(a[2]*2) * a[5]
+ + (uint64_t)(a[3]*2) * a[4];
+ /* VERIFY_BITS(c, 64); */
+ VERIFY_CHECK(c <= 0x8000007C00000007ULL);
+ /* [d 0 0 0 0 0 0 0 t9 0 c t6 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
+ d += (uint64_t)(a[8]*2) * a[9];
+ VERIFY_BITS(d, 58);
+ /* [d 0 0 0 0 0 0 0 t9 0 c t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
+ u7 = d & M; d >>= 26; c += u7 * R0;
+ VERIFY_BITS(u7, 26);
+ VERIFY_BITS(d, 32);
+ /* VERIFY_BITS(c, 64); */
+ VERIFY_CHECK(c <= 0x800001703FFFC2F7ULL);
+ /* [d u7 0 0 0 0 0 0 0 t9 0 c-u7*R0 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
+ t7 = c & M; c >>= 26; c += u7 * R1;
+ VERIFY_BITS(t7, 26);
+ VERIFY_BITS(c, 38);
+ /* [d u7 0 0 0 0 0 0 0 t9 c-u7*R1 t7-u7*R0 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
+ /* [d 0 0 0 0 0 0 0 0 t9 c t7 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
+
+ c += (uint64_t)(a[0]*2) * a[8]
+ + (uint64_t)(a[1]*2) * a[7]
+ + (uint64_t)(a[2]*2) * a[6]
+ + (uint64_t)(a[3]*2) * a[5]
+ + (uint64_t)a[4] * a[4];
+ /* VERIFY_BITS(c, 64); */
+ VERIFY_CHECK(c <= 0x9000007B80000008ULL);
+ /* [d 0 0 0 0 0 0 0 0 t9 c t7 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ d += (uint64_t)a[9] * a[9];
+ VERIFY_BITS(d, 57);
+ /* [d 0 0 0 0 0 0 0 0 t9 c t7 t6 t5 t4 t3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ u8 = d & M; d >>= 26; c += u8 * R0;
+ VERIFY_BITS(u8, 26);
+ VERIFY_BITS(d, 31);
+ /* VERIFY_BITS(c, 64); */
+ VERIFY_CHECK(c <= 0x9000016FBFFFC2F8ULL);
+ /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 t5 t4 t3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+
+ r[3] = t3;
+ VERIFY_BITS(r[3], 26);
+ /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 t5 t4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[4] = t4;
+ VERIFY_BITS(r[4], 26);
+ /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 t5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[5] = t5;
+ VERIFY_BITS(r[5], 26);
+ /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[6] = t6;
+ VERIFY_BITS(r[6], 26);
+ /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[7] = t7;
+ VERIFY_BITS(r[7], 26);
+ /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+
+ r[8] = c & M; c >>= 26; c += u8 * R1;
+ VERIFY_BITS(r[8], 26);
+ VERIFY_BITS(c, 39);
+ /* [d u8 0 0 0 0 0 0 0 0 t9+c-u8*R1 r8-u8*R0 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ /* [d 0 0 0 0 0 0 0 0 0 t9+c r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ c += d * R0 + t9;
+ VERIFY_BITS(c, 45);
+ /* [d 0 0 0 0 0 0 0 0 0 c-d*R0 r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[9] = c & (M >> 4); c >>= 22; c += d * (R1 << 4);
+ VERIFY_BITS(r[9], 22);
+ VERIFY_BITS(c, 46);
+ /* [d 0 0 0 0 0 0 0 0 r9+((c-d*R1<<4)<<22)-d*R0 r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ /* [d 0 0 0 0 0 0 0 -d*R1 r9+(c<<22)-d*R0 r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+
+ d = c * (R0 >> 4) + t0;
+ VERIFY_BITS(d, 56);
+ /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 t1 d-c*R0>>4] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[0] = d & M; d >>= 26;
+ VERIFY_BITS(r[0], 26);
+ VERIFY_BITS(d, 30);
+ /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 t1+d r0-c*R0>>4] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ d += c * (R1 >> 4) + t1;
+ VERIFY_BITS(d, 53);
+ VERIFY_CHECK(d <= 0x10000003FFFFBFULL);
+ /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 d-c*R1>>4 r0-c*R0>>4] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ /* [r9 r8 r7 r6 r5 r4 r3 t2 d r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[1] = d & M; d >>= 26;
+ VERIFY_BITS(r[1], 26);
+ VERIFY_BITS(d, 27);
+ VERIFY_CHECK(d <= 0x4000000ULL);
+ /* [r9 r8 r7 r6 r5 r4 r3 t2+d r1 r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ d += t2;
+ VERIFY_BITS(d, 27);
+ /* [r9 r8 r7 r6 r5 r4 r3 d r1 r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[2] = d;
+ VERIFY_BITS(r[2], 27);
+ /* [r9 r8 r7 r6 r5 r4 r3 r2 r1 r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+}
+
+
+static void secp256k1_fe_mul(secp256k1_fe_t *r, const secp256k1_fe_t *a, const secp256k1_fe_t * SECP256K1_RESTRICT b) {
+#ifdef VERIFY
+ VERIFY_CHECK(a->magnitude <= 8);
+ VERIFY_CHECK(b->magnitude <= 8);
+ secp256k1_fe_verify(a);
+ secp256k1_fe_verify(b);
+ VERIFY_CHECK(r != b);
+#endif
+ secp256k1_fe_mul_inner(r->n, a->n, b->n);
+#ifdef VERIFY
+ r->magnitude = 1;
+ r->normalized = 0;
+ secp256k1_fe_verify(r);
+#endif
+}
+
+static void secp256k1_fe_sqr(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
+#ifdef VERIFY
+ VERIFY_CHECK(a->magnitude <= 8);
+ secp256k1_fe_verify(a);
+#endif
+ secp256k1_fe_sqr_inner(r->n, a->n);
+#ifdef VERIFY
+ r->magnitude = 1;
+ r->normalized = 0;
+ secp256k1_fe_verify(r);
+#endif
+}
+
+static SECP256K1_INLINE void secp256k1_fe_storage_cmov(secp256k1_fe_storage_t *r, const secp256k1_fe_storage_t *a, int flag) {
+ uint32_t mask0, mask1;
+ mask0 = flag + ~((uint32_t)0);
+ mask1 = ~mask0;
+ r->n[0] = (r->n[0] & mask0) | (a->n[0] & mask1);
+ r->n[1] = (r->n[1] & mask0) | (a->n[1] & mask1);
+ r->n[2] = (r->n[2] & mask0) | (a->n[2] & mask1);
+ r->n[3] = (r->n[3] & mask0) | (a->n[3] & mask1);
+ r->n[4] = (r->n[4] & mask0) | (a->n[4] & mask1);
+ r->n[5] = (r->n[5] & mask0) | (a->n[5] & mask1);
+ r->n[6] = (r->n[6] & mask0) | (a->n[6] & mask1);
+ r->n[7] = (r->n[7] & mask0) | (a->n[7] & mask1);
+}
+
+static void secp256k1_fe_to_storage(secp256k1_fe_storage_t *r, const secp256k1_fe_t *a) {
+#ifdef VERIFY
+ VERIFY_CHECK(a->normalized);
+#endif
+ r->n[0] = a->n[0] | a->n[1] << 26;
+ r->n[1] = a->n[1] >> 6 | a->n[2] << 20;
+ r->n[2] = a->n[2] >> 12 | a->n[3] << 14;
+ r->n[3] = a->n[3] >> 18 | a->n[4] << 8;
+ r->n[4] = a->n[4] >> 24 | a->n[5] << 2 | a->n[6] << 28;
+ r->n[5] = a->n[6] >> 4 | a->n[7] << 22;
+ r->n[6] = a->n[7] >> 10 | a->n[8] << 16;
+ r->n[7] = a->n[8] >> 16 | a->n[9] << 10;
+}
+
+static SECP256K1_INLINE void secp256k1_fe_from_storage(secp256k1_fe_t *r, const secp256k1_fe_storage_t *a) {
+ r->n[0] = a->n[0] & 0x3FFFFFFUL;
+ r->n[1] = a->n[0] >> 26 | ((a->n[1] << 6) & 0x3FFFFFFUL);
+ r->n[2] = a->n[1] >> 20 | ((a->n[2] << 12) & 0x3FFFFFFUL);
+ r->n[3] = a->n[2] >> 14 | ((a->n[3] << 18) & 0x3FFFFFFUL);
+ r->n[4] = a->n[3] >> 8 | ((a->n[4] << 24) & 0x3FFFFFFUL);
+ r->n[5] = (a->n[4] >> 2) & 0x3FFFFFFUL;
+ r->n[6] = a->n[4] >> 28 | ((a->n[5] << 4) & 0x3FFFFFFUL);
+ r->n[7] = a->n[5] >> 22 | ((a->n[6] << 10) & 0x3FFFFFFUL);
+ r->n[8] = a->n[6] >> 16 | ((a->n[7] << 16) & 0x3FFFFFFUL);
+ r->n[9] = a->n[7] >> 10;
+#ifdef VERIFY
+ r->magnitude = 1;
+ r->normalized = 1;
+#endif
+}
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_5x52.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_5x52.h
new file mode 100644
index 0000000000000000000000000000000000000000..4513d36f49f3fde2aec60861afe0ed534815b746
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_5x52.h
@@ -0,0 +1,47 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_FIELD_REPR_
+#define _SECP256K1_FIELD_REPR_
+
+#include <stdint.h>
+
+typedef struct {
+ /* X = sum(i=0..4, elem[i]*2^52) mod n */
+ uint64_t n[5];
+#ifdef VERIFY
+ int magnitude;
+ int normalized;
+#endif
+} secp256k1_fe_t;
+
+/* Unpacks a constant into a overlapping multi-limbed FE element. */
+#define SECP256K1_FE_CONST_INNER(d7, d6, d5, d4, d3, d2, d1, d0) { \
+ (d0) | ((uint64_t)(d1) & 0xFFFFFUL) << 32, \
+ ((d1) >> 20) | ((uint64_t)(d2)) << 12 | ((uint64_t)(d3) & 0xFFUL) << 44, \
+ ((d3) >> 8) | ((uint64_t)(d4) & 0xFFFFFFFUL) << 24, \
+ ((d4) >> 28) | ((uint64_t)(d5)) << 4 | ((uint64_t)(d6) & 0xFFFFUL) << 36, \
+ ((d6) >> 16) | ((uint64_t)(d7)) << 16 \
+}
+
+#ifdef VERIFY
+#define SECP256K1_FE_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {SECP256K1_FE_CONST_INNER((d7), (d6), (d5), (d4), (d3), (d2), (d1), (d0)), 1, 1}
+#else
+#define SECP256K1_FE_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {SECP256K1_FE_CONST_INNER((d7), (d6), (d5), (d4), (d3), (d2), (d1), (d0))}
+#endif
+
+typedef struct {
+ uint64_t n[4];
+} secp256k1_fe_storage_t;
+
+#define SECP256K1_FE_STORAGE_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{ \
+ (d0) | ((uint64_t)(d1)) << 32, \
+ (d2) | ((uint64_t)(d3)) << 32, \
+ (d4) | ((uint64_t)(d5)) << 32, \
+ (d6) | ((uint64_t)(d7)) << 32 \
+}}
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_5x52_asm_impl.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_5x52_asm_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..98cc004bf04a69c201c996a7f1c3ccac68354b5e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_5x52_asm_impl.h
@@ -0,0 +1,502 @@
+/**********************************************************************
+ * Copyright (c) 2013-2014 Diederik Huys, Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+/**
+ * Changelog:
+ * - March 2013, Diederik Huys: original version
+ * - November 2014, Pieter Wuille: updated to use Peter Dettman's parallel multiplication algorithm
+ * - December 2014, Pieter Wuille: converted from YASM to GCC inline assembly
+ */
+
+#ifndef _SECP256K1_FIELD_INNER5X52_IMPL_H_
+#define _SECP256K1_FIELD_INNER5X52_IMPL_H_
+
+SECP256K1_INLINE static void secp256k1_fe_mul_inner(uint64_t *r, const uint64_t *a, const uint64_t * SECP256K1_RESTRICT b) {
+/**
+ * Registers: rdx:rax = multiplication accumulator
+ * r9:r8 = c
+ * r15:rcx = d
+ * r10-r14 = a0-a4
+ * rbx = b
+ * rdi = r
+ * rsi = a / t?
+ */
+ uint64_t tmp1, tmp2, tmp3;
+__asm__ __volatile__(
+ "movq 0(%%rsi),%%r10\n"
+ "movq 8(%%rsi),%%r11\n"
+ "movq 16(%%rsi),%%r12\n"
+ "movq 24(%%rsi),%%r13\n"
+ "movq 32(%%rsi),%%r14\n"
+
+ /* d += a3 * b0 */
+ "movq 0(%%rbx),%%rax\n"
+ "mulq %%r13\n"
+ "movq %%rax,%%rcx\n"
+ "movq %%rdx,%%r15\n"
+ /* d += a2 * b1 */
+ "movq 8(%%rbx),%%rax\n"
+ "mulq %%r12\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* d += a1 * b2 */
+ "movq 16(%%rbx),%%rax\n"
+ "mulq %%r11\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* d = a0 * b3 */
+ "movq 24(%%rbx),%%rax\n"
+ "mulq %%r10\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* c = a4 * b4 */
+ "movq 32(%%rbx),%%rax\n"
+ "mulq %%r14\n"
+ "movq %%rax,%%r8\n"
+ "movq %%rdx,%%r9\n"
+ /* d += (c & M) * R */
+ "movq $0xfffffffffffff,%%rdx\n"
+ "andq %%rdx,%%rax\n"
+ "movq $0x1000003d10,%%rdx\n"
+ "mulq %%rdx\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* c >>= 52 (%%r8 only) */
+ "shrdq $52,%%r9,%%r8\n"
+ /* t3 (tmp1) = d & M */
+ "movq %%rcx,%%rsi\n"
+ "movq $0xfffffffffffff,%%rdx\n"
+ "andq %%rdx,%%rsi\n"
+ "movq %%rsi,%q1\n"
+ /* d >>= 52 */
+ "shrdq $52,%%r15,%%rcx\n"
+ "xorq %%r15,%%r15\n"
+ /* d += a4 * b0 */
+ "movq 0(%%rbx),%%rax\n"
+ "mulq %%r14\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* d += a3 * b1 */
+ "movq 8(%%rbx),%%rax\n"
+ "mulq %%r13\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* d += a2 * b2 */
+ "movq 16(%%rbx),%%rax\n"
+ "mulq %%r12\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* d += a1 * b3 */
+ "movq 24(%%rbx),%%rax\n"
+ "mulq %%r11\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* d += a0 * b4 */
+ "movq 32(%%rbx),%%rax\n"
+ "mulq %%r10\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* d += c * R */
+ "movq %%r8,%%rax\n"
+ "movq $0x1000003d10,%%rdx\n"
+ "mulq %%rdx\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* t4 = d & M (%%rsi) */
+ "movq %%rcx,%%rsi\n"
+ "movq $0xfffffffffffff,%%rdx\n"
+ "andq %%rdx,%%rsi\n"
+ /* d >>= 52 */
+ "shrdq $52,%%r15,%%rcx\n"
+ "xorq %%r15,%%r15\n"
+ /* tx = t4 >> 48 (tmp3) */
+ "movq %%rsi,%%rax\n"
+ "shrq $48,%%rax\n"
+ "movq %%rax,%q3\n"
+ /* t4 &= (M >> 4) (tmp2) */
+ "movq $0xffffffffffff,%%rax\n"
+ "andq %%rax,%%rsi\n"
+ "movq %%rsi,%q2\n"
+ /* c = a0 * b0 */
+ "movq 0(%%rbx),%%rax\n"
+ "mulq %%r10\n"
+ "movq %%rax,%%r8\n"
+ "movq %%rdx,%%r9\n"
+ /* d += a4 * b1 */
+ "movq 8(%%rbx),%%rax\n"
+ "mulq %%r14\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* d += a3 * b2 */
+ "movq 16(%%rbx),%%rax\n"
+ "mulq %%r13\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* d += a2 * b3 */
+ "movq 24(%%rbx),%%rax\n"
+ "mulq %%r12\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* d += a1 * b4 */
+ "movq 32(%%rbx),%%rax\n"
+ "mulq %%r11\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* u0 = d & M (%%rsi) */
+ "movq %%rcx,%%rsi\n"
+ "movq $0xfffffffffffff,%%rdx\n"
+ "andq %%rdx,%%rsi\n"
+ /* d >>= 52 */
+ "shrdq $52,%%r15,%%rcx\n"
+ "xorq %%r15,%%r15\n"
+ /* u0 = (u0 << 4) | tx (%%rsi) */
+ "shlq $4,%%rsi\n"
+ "movq %q3,%%rax\n"
+ "orq %%rax,%%rsi\n"
+ /* c += u0 * (R >> 4) */
+ "movq $0x1000003d1,%%rax\n"
+ "mulq %%rsi\n"
+ "addq %%rax,%%r8\n"
+ "adcq %%rdx,%%r9\n"
+ /* r[0] = c & M */
+ "movq %%r8,%%rax\n"
+ "movq $0xfffffffffffff,%%rdx\n"
+ "andq %%rdx,%%rax\n"
+ "movq %%rax,0(%%rdi)\n"
+ /* c >>= 52 */
+ "shrdq $52,%%r9,%%r8\n"
+ "xorq %%r9,%%r9\n"
+ /* c += a1 * b0 */
+ "movq 0(%%rbx),%%rax\n"
+ "mulq %%r11\n"
+ "addq %%rax,%%r8\n"
+ "adcq %%rdx,%%r9\n"
+ /* c += a0 * b1 */
+ "movq 8(%%rbx),%%rax\n"
+ "mulq %%r10\n"
+ "addq %%rax,%%r8\n"
+ "adcq %%rdx,%%r9\n"
+ /* d += a4 * b2 */
+ "movq 16(%%rbx),%%rax\n"
+ "mulq %%r14\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* d += a3 * b3 */
+ "movq 24(%%rbx),%%rax\n"
+ "mulq %%r13\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* d += a2 * b4 */
+ "movq 32(%%rbx),%%rax\n"
+ "mulq %%r12\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* c += (d & M) * R */
+ "movq %%rcx,%%rax\n"
+ "movq $0xfffffffffffff,%%rdx\n"
+ "andq %%rdx,%%rax\n"
+ "movq $0x1000003d10,%%rdx\n"
+ "mulq %%rdx\n"
+ "addq %%rax,%%r8\n"
+ "adcq %%rdx,%%r9\n"
+ /* d >>= 52 */
+ "shrdq $52,%%r15,%%rcx\n"
+ "xorq %%r15,%%r15\n"
+ /* r[1] = c & M */
+ "movq %%r8,%%rax\n"
+ "movq $0xfffffffffffff,%%rdx\n"
+ "andq %%rdx,%%rax\n"
+ "movq %%rax,8(%%rdi)\n"
+ /* c >>= 52 */
+ "shrdq $52,%%r9,%%r8\n"
+ "xorq %%r9,%%r9\n"
+ /* c += a2 * b0 */
+ "movq 0(%%rbx),%%rax\n"
+ "mulq %%r12\n"
+ "addq %%rax,%%r8\n"
+ "adcq %%rdx,%%r9\n"
+ /* c += a1 * b1 */
+ "movq 8(%%rbx),%%rax\n"
+ "mulq %%r11\n"
+ "addq %%rax,%%r8\n"
+ "adcq %%rdx,%%r9\n"
+ /* c += a0 * b2 (last use of %%r10 = a0) */
+ "movq 16(%%rbx),%%rax\n"
+ "mulq %%r10\n"
+ "addq %%rax,%%r8\n"
+ "adcq %%rdx,%%r9\n"
+ /* fetch t3 (%%r10, overwrites a0), t4 (%%rsi) */
+ "movq %q2,%%rsi\n"
+ "movq %q1,%%r10\n"
+ /* d += a4 * b3 */
+ "movq 24(%%rbx),%%rax\n"
+ "mulq %%r14\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* d += a3 * b4 */
+ "movq 32(%%rbx),%%rax\n"
+ "mulq %%r13\n"
+ "addq %%rax,%%rcx\n"
+ "adcq %%rdx,%%r15\n"
+ /* c += (d & M) * R */
+ "movq %%rcx,%%rax\n"
+ "movq $0xfffffffffffff,%%rdx\n"
+ "andq %%rdx,%%rax\n"
+ "movq $0x1000003d10,%%rdx\n"
+ "mulq %%rdx\n"
+ "addq %%rax,%%r8\n"
+ "adcq %%rdx,%%r9\n"
+ /* d >>= 52 (%%rcx only) */
+ "shrdq $52,%%r15,%%rcx\n"
+ /* r[2] = c & M */
+ "movq %%r8,%%rax\n"
+ "movq $0xfffffffffffff,%%rdx\n"
+ "andq %%rdx,%%rax\n"
+ "movq %%rax,16(%%rdi)\n"
+ /* c >>= 52 */
+ "shrdq $52,%%r9,%%r8\n"
+ "xorq %%r9,%%r9\n"
+ /* c += t3 */
+ "addq %%r10,%%r8\n"
+ /* c += d * R */
+ "movq %%rcx,%%rax\n"
+ "movq $0x1000003d10,%%rdx\n"
+ "mulq %%rdx\n"
+ "addq %%rax,%%r8\n"
+ "adcq %%rdx,%%r9\n"
+ /* r[3] = c & M */
+ "movq %%r8,%%rax\n"
+ "movq $0xfffffffffffff,%%rdx\n"
+ "andq %%rdx,%%rax\n"
+ "movq %%rax,24(%%rdi)\n"
+ /* c >>= 52 (%%r8 only) */
+ "shrdq $52,%%r9,%%r8\n"
+ /* c += t4 (%%r8 only) */
+ "addq %%rsi,%%r8\n"
+ /* r[4] = c */
+ "movq %%r8,32(%%rdi)\n"
+: "+S"(a), "=m"(tmp1), "=m"(tmp2), "=m"(tmp3)
+: "b"(b), "D"(r)
+: "%rax", "%rcx", "%rdx", "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15", "cc", "memory"
+);
+}
+
+SECP256K1_INLINE static void secp256k1_fe_sqr_inner(uint64_t *r, const uint64_t *a) {
+/**
+ * Registers: rdx:rax = multiplication accumulator
+ * r9:r8 = c
+ * rcx:rbx = d
+ * r10-r14 = a0-a4
+ * r15 = M (0xfffffffffffff)
+ * rdi = r
+ * rsi = a / t?
+ */
+ uint64_t tmp1, tmp2, tmp3;
+__asm__ __volatile__(
+ "movq 0(%%rsi),%%r10\n"
+ "movq 8(%%rsi),%%r11\n"
+ "movq 16(%%rsi),%%r12\n"
+ "movq 24(%%rsi),%%r13\n"
+ "movq 32(%%rsi),%%r14\n"
+ "movq $0xfffffffffffff,%%r15\n"
+
+ /* d = (a0*2) * a3 */
+ "leaq (%%r10,%%r10,1),%%rax\n"
+ "mulq %%r13\n"
+ "movq %%rax,%%rbx\n"
+ "movq %%rdx,%%rcx\n"
+ /* d += (a1*2) * a2 */
+ "leaq (%%r11,%%r11,1),%%rax\n"
+ "mulq %%r12\n"
+ "addq %%rax,%%rbx\n"
+ "adcq %%rdx,%%rcx\n"
+ /* c = a4 * a4 */
+ "movq %%r14,%%rax\n"
+ "mulq %%r14\n"
+ "movq %%rax,%%r8\n"
+ "movq %%rdx,%%r9\n"
+ /* d += (c & M) * R */
+ "andq %%r15,%%rax\n"
+ "movq $0x1000003d10,%%rdx\n"
+ "mulq %%rdx\n"
+ "addq %%rax,%%rbx\n"
+ "adcq %%rdx,%%rcx\n"
+ /* c >>= 52 (%%r8 only) */
+ "shrdq $52,%%r9,%%r8\n"
+ /* t3 (tmp1) = d & M */
+ "movq %%rbx,%%rsi\n"
+ "andq %%r15,%%rsi\n"
+ "movq %%rsi,%q1\n"
+ /* d >>= 52 */
+ "shrdq $52,%%rcx,%%rbx\n"
+ "xorq %%rcx,%%rcx\n"
+ /* a4 *= 2 */
+ "addq %%r14,%%r14\n"
+ /* d += a0 * a4 */
+ "movq %%r10,%%rax\n"
+ "mulq %%r14\n"
+ "addq %%rax,%%rbx\n"
+ "adcq %%rdx,%%rcx\n"
+ /* d+= (a1*2) * a3 */
+ "leaq (%%r11,%%r11,1),%%rax\n"
+ "mulq %%r13\n"
+ "addq %%rax,%%rbx\n"
+ "adcq %%rdx,%%rcx\n"
+ /* d += a2 * a2 */
+ "movq %%r12,%%rax\n"
+ "mulq %%r12\n"
+ "addq %%rax,%%rbx\n"
+ "adcq %%rdx,%%rcx\n"
+ /* d += c * R */
+ "movq %%r8,%%rax\n"
+ "movq $0x1000003d10,%%rdx\n"
+ "mulq %%rdx\n"
+ "addq %%rax,%%rbx\n"
+ "adcq %%rdx,%%rcx\n"
+ /* t4 = d & M (%%rsi) */
+ "movq %%rbx,%%rsi\n"
+ "andq %%r15,%%rsi\n"
+ /* d >>= 52 */
+ "shrdq $52,%%rcx,%%rbx\n"
+ "xorq %%rcx,%%rcx\n"
+ /* tx = t4 >> 48 (tmp3) */
+ "movq %%rsi,%%rax\n"
+ "shrq $48,%%rax\n"
+ "movq %%rax,%q3\n"
+ /* t4 &= (M >> 4) (tmp2) */
+ "movq $0xffffffffffff,%%rax\n"
+ "andq %%rax,%%rsi\n"
+ "movq %%rsi,%q2\n"
+ /* c = a0 * a0 */
+ "movq %%r10,%%rax\n"
+ "mulq %%r10\n"
+ "movq %%rax,%%r8\n"
+ "movq %%rdx,%%r9\n"
+ /* d += a1 * a4 */
+ "movq %%r11,%%rax\n"
+ "mulq %%r14\n"
+ "addq %%rax,%%rbx\n"
+ "adcq %%rdx,%%rcx\n"
+ /* d += (a2*2) * a3 */
+ "leaq (%%r12,%%r12,1),%%rax\n"
+ "mulq %%r13\n"
+ "addq %%rax,%%rbx\n"
+ "adcq %%rdx,%%rcx\n"
+ /* u0 = d & M (%%rsi) */
+ "movq %%rbx,%%rsi\n"
+ "andq %%r15,%%rsi\n"
+ /* d >>= 52 */
+ "shrdq $52,%%rcx,%%rbx\n"
+ "xorq %%rcx,%%rcx\n"
+ /* u0 = (u0 << 4) | tx (%%rsi) */
+ "shlq $4,%%rsi\n"
+ "movq %q3,%%rax\n"
+ "orq %%rax,%%rsi\n"
+ /* c += u0 * (R >> 4) */
+ "movq $0x1000003d1,%%rax\n"
+ "mulq %%rsi\n"
+ "addq %%rax,%%r8\n"
+ "adcq %%rdx,%%r9\n"
+ /* r[0] = c & M */
+ "movq %%r8,%%rax\n"
+ "andq %%r15,%%rax\n"
+ "movq %%rax,0(%%rdi)\n"
+ /* c >>= 52 */
+ "shrdq $52,%%r9,%%r8\n"
+ "xorq %%r9,%%r9\n"
+ /* a0 *= 2 */
+ "addq %%r10,%%r10\n"
+ /* c += a0 * a1 */
+ "movq %%r10,%%rax\n"
+ "mulq %%r11\n"
+ "addq %%rax,%%r8\n"
+ "adcq %%rdx,%%r9\n"
+ /* d += a2 * a4 */
+ "movq %%r12,%%rax\n"
+ "mulq %%r14\n"
+ "addq %%rax,%%rbx\n"
+ "adcq %%rdx,%%rcx\n"
+ /* d += a3 * a3 */
+ "movq %%r13,%%rax\n"
+ "mulq %%r13\n"
+ "addq %%rax,%%rbx\n"
+ "adcq %%rdx,%%rcx\n"
+ /* c += (d & M) * R */
+ "movq %%rbx,%%rax\n"
+ "andq %%r15,%%rax\n"
+ "movq $0x1000003d10,%%rdx\n"
+ "mulq %%rdx\n"
+ "addq %%rax,%%r8\n"
+ "adcq %%rdx,%%r9\n"
+ /* d >>= 52 */
+ "shrdq $52,%%rcx,%%rbx\n"
+ "xorq %%rcx,%%rcx\n"
+ /* r[1] = c & M */
+ "movq %%r8,%%rax\n"
+ "andq %%r15,%%rax\n"
+ "movq %%rax,8(%%rdi)\n"
+ /* c >>= 52 */
+ "shrdq $52,%%r9,%%r8\n"
+ "xorq %%r9,%%r9\n"
+ /* c += a0 * a2 (last use of %%r10) */
+ "movq %%r10,%%rax\n"
+ "mulq %%r12\n"
+ "addq %%rax,%%r8\n"
+ "adcq %%rdx,%%r9\n"
+ /* fetch t3 (%%r10, overwrites a0),t4 (%%rsi) */
+ "movq %q2,%%rsi\n"
+ "movq %q1,%%r10\n"
+ /* c += a1 * a1 */
+ "movq %%r11,%%rax\n"
+ "mulq %%r11\n"
+ "addq %%rax,%%r8\n"
+ "adcq %%rdx,%%r9\n"
+ /* d += a3 * a4 */
+ "movq %%r13,%%rax\n"
+ "mulq %%r14\n"
+ "addq %%rax,%%rbx\n"
+ "adcq %%rdx,%%rcx\n"
+ /* c += (d & M) * R */
+ "movq %%rbx,%%rax\n"
+ "andq %%r15,%%rax\n"
+ "movq $0x1000003d10,%%rdx\n"
+ "mulq %%rdx\n"
+ "addq %%rax,%%r8\n"
+ "adcq %%rdx,%%r9\n"
+ /* d >>= 52 (%%rbx only) */
+ "shrdq $52,%%rcx,%%rbx\n"
+ /* r[2] = c & M */
+ "movq %%r8,%%rax\n"
+ "andq %%r15,%%rax\n"
+ "movq %%rax,16(%%rdi)\n"
+ /* c >>= 52 */
+ "shrdq $52,%%r9,%%r8\n"
+ "xorq %%r9,%%r9\n"
+ /* c += t3 */
+ "addq %%r10,%%r8\n"
+ /* c += d * R */
+ "movq %%rbx,%%rax\n"
+ "movq $0x1000003d10,%%rdx\n"
+ "mulq %%rdx\n"
+ "addq %%rax,%%r8\n"
+ "adcq %%rdx,%%r9\n"
+ /* r[3] = c & M */
+ "movq %%r8,%%rax\n"
+ "andq %%r15,%%rax\n"
+ "movq %%rax,24(%%rdi)\n"
+ /* c >>= 52 (%%r8 only) */
+ "shrdq $52,%%r9,%%r8\n"
+ /* c += t4 (%%r8 only) */
+ "addq %%rsi,%%r8\n"
+ /* r[4] = c */
+ "movq %%r8,32(%%rdi)\n"
+: "+S"(a), "=m"(tmp1), "=m"(tmp2), "=m"(tmp3)
+: "D"(r)
+: "%rax", "%rbx", "%rcx", "%rdx", "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15", "cc", "memory"
+);
+}
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_5x52_impl.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_5x52_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..874d3caaba65c8409cd47e370b7e2a7ed32d0817
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_5x52_impl.h
@@ -0,0 +1,439 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_FIELD_REPR_IMPL_H_
+#define _SECP256K1_FIELD_REPR_IMPL_H_
+
+#if defined HAVE_CONFIG_H
+#include "libsecp256k1-config.h"
+#endif
+
+#include <string.h>
+#include "util.h"
+#include "num.h"
+#include "field.h"
+
+#if defined(USE_ASM_X86_64)
+#include "field_5x52_asm_impl.h"
+#else
+#include "field_5x52_int128_impl.h"
+#endif
+
+/** Implements arithmetic modulo FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE FFFFFC2F,
+ * represented as 5 uint64_t's in base 2^52. The values are allowed to contain >52 each. In particular,
+ * each FieldElem has a 'magnitude' associated with it. Internally, a magnitude M means each element
+ * is at most M*(2^53-1), except the most significant one, which is limited to M*(2^49-1). All operations
+ * accept any input with magnitude at most M, and have different rules for propagating magnitude to their
+ * output.
+ */
+
+#ifdef VERIFY
+static void secp256k1_fe_verify(const secp256k1_fe_t *a) {
+ const uint64_t *d = a->n;
+ int m = a->normalized ? 1 : 2 * a->magnitude, r = 1;
+ /* secp256k1 'p' value defined in "Standards for Efficient Cryptography" (SEC2) 2.7.1. */
+ r &= (d[0] <= 0xFFFFFFFFFFFFFULL * m);
+ r &= (d[1] <= 0xFFFFFFFFFFFFFULL * m);
+ r &= (d[2] <= 0xFFFFFFFFFFFFFULL * m);
+ r &= (d[3] <= 0xFFFFFFFFFFFFFULL * m);
+ r &= (d[4] <= 0x0FFFFFFFFFFFFULL * m);
+ r &= (a->magnitude >= 0);
+ r &= (a->magnitude <= 2048);
+ if (a->normalized) {
+ r &= (a->magnitude <= 1);
+ if (r && (d[4] == 0x0FFFFFFFFFFFFULL) && ((d[3] & d[2] & d[1]) == 0xFFFFFFFFFFFFFULL)) {
+ r &= (d[0] < 0xFFFFEFFFFFC2FULL);
+ }
+ }
+ VERIFY_CHECK(r == 1);
+}
+#else
+static void secp256k1_fe_verify(const secp256k1_fe_t *a) {
+ (void)a;
+}
+#endif
+
+static void secp256k1_fe_normalize(secp256k1_fe_t *r) {
+ uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
+
+ /* Reduce t4 at the start so there will be at most a single carry from the first pass */
+ uint64_t m;
+ uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
+
+ /* The first pass ensures the magnitude is 1, ... */
+ t0 += x * 0x1000003D1ULL;
+ t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
+ t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; m = t1;
+ t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; m &= t2;
+ t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL; m &= t3;
+
+ /* ... except for a possible carry at bit 48 of t4 (i.e. bit 256 of the field element) */
+ VERIFY_CHECK(t4 >> 49 == 0);
+
+ /* At most a single final reduction is needed; check if the value is >= the field characteristic */
+ x = (t4 >> 48) | ((t4 == 0x0FFFFFFFFFFFFULL) & (m == 0xFFFFFFFFFFFFFULL)
+ & (t0 >= 0xFFFFEFFFFFC2FULL));
+
+ /* Apply the final reduction (for constant-time behaviour, we do it always) */
+ t0 += x * 0x1000003D1ULL;
+ t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
+ t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL;
+ t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL;
+ t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL;
+
+ /* If t4 didn't carry to bit 48 already, then it should have after any final reduction */
+ VERIFY_CHECK(t4 >> 48 == x);
+
+ /* Mask off the possible multiple of 2^256 from the final reduction */
+ t4 &= 0x0FFFFFFFFFFFFULL;
+
+ r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
+
+#ifdef VERIFY
+ r->magnitude = 1;
+ r->normalized = 1;
+ secp256k1_fe_verify(r);
+#endif
+}
+
+static void secp256k1_fe_normalize_weak(secp256k1_fe_t *r) {
+ uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
+
+ /* Reduce t4 at the start so there will be at most a single carry from the first pass */
+ uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
+
+ /* The first pass ensures the magnitude is 1, ... */
+ t0 += x * 0x1000003D1ULL;
+ t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
+ t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL;
+ t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL;
+ t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL;
+
+ /* ... except for a possible carry at bit 48 of t4 (i.e. bit 256 of the field element) */
+ VERIFY_CHECK(t4 >> 49 == 0);
+
+ r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
+
+#ifdef VERIFY
+ r->magnitude = 1;
+ secp256k1_fe_verify(r);
+#endif
+}
+
+static void secp256k1_fe_normalize_var(secp256k1_fe_t *r) {
+ uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
+
+ /* Reduce t4 at the start so there will be at most a single carry from the first pass */
+ uint64_t m;
+ uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
+
+ /* The first pass ensures the magnitude is 1, ... */
+ t0 += x * 0x1000003D1ULL;
+ t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
+ t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; m = t1;
+ t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; m &= t2;
+ t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL; m &= t3;
+
+ /* ... except for a possible carry at bit 48 of t4 (i.e. bit 256 of the field element) */
+ VERIFY_CHECK(t4 >> 49 == 0);
+
+ /* At most a single final reduction is needed; check if the value is >= the field characteristic */
+ x = (t4 >> 48) | ((t4 == 0x0FFFFFFFFFFFFULL) & (m == 0xFFFFFFFFFFFFFULL)
+ & (t0 >= 0xFFFFEFFFFFC2FULL));
+
+ if (x) {
+ t0 += 0x1000003D1ULL;
+ t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
+ t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL;
+ t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL;
+ t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL;
+
+ /* If t4 didn't carry to bit 48 already, then it should have after any final reduction */
+ VERIFY_CHECK(t4 >> 48 == x);
+
+ /* Mask off the possible multiple of 2^256 from the final reduction */
+ t4 &= 0x0FFFFFFFFFFFFULL;
+ }
+
+ r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
+
+#ifdef VERIFY
+ r->magnitude = 1;
+ r->normalized = 1;
+ secp256k1_fe_verify(r);
+#endif
+}
+
+static int secp256k1_fe_normalizes_to_zero(secp256k1_fe_t *r) {
+ uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
+
+ /* z0 tracks a possible raw value of 0, z1 tracks a possible raw value of P */
+ uint64_t z0, z1;
+
+ /* Reduce t4 at the start so there will be at most a single carry from the first pass */
+ uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
+
+ /* The first pass ensures the magnitude is 1, ... */
+ t0 += x * 0x1000003D1ULL;
+ t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL; z0 = t0; z1 = t0 ^ 0x1000003D0ULL;
+ t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; z0 |= t1; z1 &= t1;
+ t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; z0 |= t2; z1 &= t2;
+ t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL; z0 |= t3; z1 &= t3;
+ z0 |= t4; z1 &= t4 ^ 0xF000000000000ULL;
+
+ /* ... except for a possible carry at bit 48 of t4 (i.e. bit 256 of the field element) */
+ VERIFY_CHECK(t4 >> 49 == 0);
+
+ return (z0 == 0) | (z1 == 0xFFFFFFFFFFFFFULL);
+}
+
+static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe_t *r) {
+ uint64_t t0, t1, t2, t3, t4;
+ uint64_t z0, z1;
+ uint64_t x;
+
+ t0 = r->n[0];
+ t4 = r->n[4];
+
+ /* Reduce t4 at the start so there will be at most a single carry from the first pass */
+ x = t4 >> 48;
+
+ /* The first pass ensures the magnitude is 1, ... */
+ t0 += x * 0x1000003D1ULL;
+
+ /* z0 tracks a possible raw value of 0, z1 tracks a possible raw value of P */
+ z0 = t0 & 0xFFFFFFFFFFFFFULL;
+ z1 = z0 ^ 0x1000003D0ULL;
+
+ /* Fast return path should catch the majority of cases */
+ if ((z0 != 0ULL) & (z1 != 0xFFFFFFFFFFFFFULL)) {
+ return 0;
+ }
+
+ t1 = r->n[1];
+ t2 = r->n[2];
+ t3 = r->n[3];
+
+ t4 &= 0x0FFFFFFFFFFFFULL;
+
+ t1 += (t0 >> 52); t0 = z0;
+ t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; z0 |= t1; z1 &= t1;
+ t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; z0 |= t2; z1 &= t2;
+ t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL; z0 |= t3; z1 &= t3;
+ z0 |= t4; z1 &= t4 ^ 0xF000000000000ULL;
+
+ /* ... except for a possible carry at bit 48 of t4 (i.e. bit 256 of the field element) */
+ VERIFY_CHECK(t4 >> 49 == 0);
+
+ return (z0 == 0) | (z1 == 0xFFFFFFFFFFFFFULL);
+}
+
+SECP256K1_INLINE static void secp256k1_fe_set_int(secp256k1_fe_t *r, int a) {
+ r->n[0] = a;
+ r->n[1] = r->n[2] = r->n[3] = r->n[4] = 0;
+#ifdef VERIFY
+ r->magnitude = 1;
+ r->normalized = 1;
+ secp256k1_fe_verify(r);
+#endif
+}
+
+SECP256K1_INLINE static int secp256k1_fe_is_zero(const secp256k1_fe_t *a) {
+ const uint64_t *t = a->n;
+#ifdef VERIFY
+ VERIFY_CHECK(a->normalized);
+ secp256k1_fe_verify(a);
+#endif
+ return (t[0] | t[1] | t[2] | t[3] | t[4]) == 0;
+}
+
+SECP256K1_INLINE static int secp256k1_fe_is_odd(const secp256k1_fe_t *a) {
+#ifdef VERIFY
+ VERIFY_CHECK(a->normalized);
+ secp256k1_fe_verify(a);
+#endif
+ return a->n[0] & 1;
+}
+
+SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe_t *a) {
+ int i;
+#ifdef VERIFY
+ a->magnitude = 0;
+ a->normalized = 1;
+#endif
+ for (i=0; i<5; i++) {
+ a->n[i] = 0;
+ }
+}
+
+static int secp256k1_fe_cmp_var(const secp256k1_fe_t *a, const secp256k1_fe_t *b) {
+ int i;
+#ifdef VERIFY
+ VERIFY_CHECK(a->normalized);
+ VERIFY_CHECK(b->normalized);
+ secp256k1_fe_verify(a);
+ secp256k1_fe_verify(b);
+#endif
+ for (i = 4; i >= 0; i--) {
+ if (a->n[i] > b->n[i]) {
+ return 1;
+ }
+ if (a->n[i] < b->n[i]) {
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int secp256k1_fe_set_b32(secp256k1_fe_t *r, const unsigned char *a) {
+ int i;
+ r->n[0] = r->n[1] = r->n[2] = r->n[3] = r->n[4] = 0;
+ for (i=0; i<32; i++) {
+ int j;
+ for (j=0; j<2; j++) {
+ int limb = (8*i+4*j)/52;
+ int shift = (8*i+4*j)%52;
+ r->n[limb] |= (uint64_t)((a[31-i] >> (4*j)) & 0xF) << shift;
+ }
+ }
+ if (r->n[4] == 0x0FFFFFFFFFFFFULL && (r->n[3] & r->n[2] & r->n[1]) == 0xFFFFFFFFFFFFFULL && r->n[0] >= 0xFFFFEFFFFFC2FULL) {
+ return 0;
+ }
+#ifdef VERIFY
+ r->magnitude = 1;
+ r->normalized = 1;
+ secp256k1_fe_verify(r);
+#endif
+ return 1;
+}
+
+/** Convert a field element to a 32-byte big endian value. Requires the input to be normalized */
+static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe_t *a) {
+ int i;
+#ifdef VERIFY
+ VERIFY_CHECK(a->normalized);
+ secp256k1_fe_verify(a);
+#endif
+ for (i=0; i<32; i++) {
+ int j;
+ int c = 0;
+ for (j=0; j<2; j++) {
+ int limb = (8*i+4*j)/52;
+ int shift = (8*i+4*j)%52;
+ c |= ((a->n[limb] >> shift) & 0xF) << (4 * j);
+ }
+ r[31-i] = c;
+ }
+}
+
+SECP256K1_INLINE static void secp256k1_fe_negate(secp256k1_fe_t *r, const secp256k1_fe_t *a, int m) {
+#ifdef VERIFY
+ VERIFY_CHECK(a->magnitude <= m);
+ secp256k1_fe_verify(a);
+#endif
+ r->n[0] = 0xFFFFEFFFFFC2FULL * 2 * (m + 1) - a->n[0];
+ r->n[1] = 0xFFFFFFFFFFFFFULL * 2 * (m + 1) - a->n[1];
+ r->n[2] = 0xFFFFFFFFFFFFFULL * 2 * (m + 1) - a->n[2];
+ r->n[3] = 0xFFFFFFFFFFFFFULL * 2 * (m + 1) - a->n[3];
+ r->n[4] = 0x0FFFFFFFFFFFFULL * 2 * (m + 1) - a->n[4];
+#ifdef VERIFY
+ r->magnitude = m + 1;
+ r->normalized = 0;
+ secp256k1_fe_verify(r);
+#endif
+}
+
+SECP256K1_INLINE static void secp256k1_fe_mul_int(secp256k1_fe_t *r, int a) {
+ r->n[0] *= a;
+ r->n[1] *= a;
+ r->n[2] *= a;
+ r->n[3] *= a;
+ r->n[4] *= a;
+#ifdef VERIFY
+ r->magnitude *= a;
+ r->normalized = 0;
+ secp256k1_fe_verify(r);
+#endif
+}
+
+SECP256K1_INLINE static void secp256k1_fe_add(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
+#ifdef VERIFY
+ secp256k1_fe_verify(a);
+#endif
+ r->n[0] += a->n[0];
+ r->n[1] += a->n[1];
+ r->n[2] += a->n[2];
+ r->n[3] += a->n[3];
+ r->n[4] += a->n[4];
+#ifdef VERIFY
+ r->magnitude += a->magnitude;
+ r->normalized = 0;
+ secp256k1_fe_verify(r);
+#endif
+}
+
+static void secp256k1_fe_mul(secp256k1_fe_t *r, const secp256k1_fe_t *a, const secp256k1_fe_t * SECP256K1_RESTRICT b) {
+#ifdef VERIFY
+ VERIFY_CHECK(a->magnitude <= 8);
+ VERIFY_CHECK(b->magnitude <= 8);
+ secp256k1_fe_verify(a);
+ secp256k1_fe_verify(b);
+ VERIFY_CHECK(r != b);
+#endif
+ secp256k1_fe_mul_inner(r->n, a->n, b->n);
+#ifdef VERIFY
+ r->magnitude = 1;
+ r->normalized = 0;
+ secp256k1_fe_verify(r);
+#endif
+}
+
+static void secp256k1_fe_sqr(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
+#ifdef VERIFY
+ VERIFY_CHECK(a->magnitude <= 8);
+ secp256k1_fe_verify(a);
+#endif
+ secp256k1_fe_sqr_inner(r->n, a->n);
+#ifdef VERIFY
+ r->magnitude = 1;
+ r->normalized = 0;
+ secp256k1_fe_verify(r);
+#endif
+}
+
+static SECP256K1_INLINE void secp256k1_fe_storage_cmov(secp256k1_fe_storage_t *r, const secp256k1_fe_storage_t *a, int flag) {
+ uint64_t mask0, mask1;
+ mask0 = flag + ~((uint64_t)0);
+ mask1 = ~mask0;
+ r->n[0] = (r->n[0] & mask0) | (a->n[0] & mask1);
+ r->n[1] = (r->n[1] & mask0) | (a->n[1] & mask1);
+ r->n[2] = (r->n[2] & mask0) | (a->n[2] & mask1);
+ r->n[3] = (r->n[3] & mask0) | (a->n[3] & mask1);
+}
+
+static void secp256k1_fe_to_storage(secp256k1_fe_storage_t *r, const secp256k1_fe_t *a) {
+#ifdef VERIFY
+ VERIFY_CHECK(a->normalized);
+#endif
+ r->n[0] = a->n[0] | a->n[1] << 52;
+ r->n[1] = a->n[1] >> 12 | a->n[2] << 40;
+ r->n[2] = a->n[2] >> 24 | a->n[3] << 28;
+ r->n[3] = a->n[3] >> 36 | a->n[4] << 16;
+}
+
+static SECP256K1_INLINE void secp256k1_fe_from_storage(secp256k1_fe_t *r, const secp256k1_fe_storage_t *a) {
+ r->n[0] = a->n[0] & 0xFFFFFFFFFFFFFULL;
+ r->n[1] = a->n[0] >> 52 | ((a->n[1] << 12) & 0xFFFFFFFFFFFFFULL);
+ r->n[2] = a->n[1] >> 40 | ((a->n[2] << 24) & 0xFFFFFFFFFFFFFULL);
+ r->n[3] = a->n[2] >> 28 | ((a->n[3] << 36) & 0xFFFFFFFFFFFFFULL);
+ r->n[4] = a->n[3] >> 16;
+#ifdef VERIFY
+ r->magnitude = 1;
+ r->normalized = 1;
+#endif
+}
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_5x52_int128_impl.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_5x52_int128_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..9280bb5ea221645b4a7fc2459ee1053f433abe3a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_5x52_int128_impl.h
@@ -0,0 +1,277 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_FIELD_INNER5X52_IMPL_H_
+#define _SECP256K1_FIELD_INNER5X52_IMPL_H_
+
+#include <stdint.h>
+
+#ifdef VERIFY
+#define VERIFY_BITS(x, n) VERIFY_CHECK(((x) >> (n)) == 0)
+#else
+#define VERIFY_BITS(x, n) do { } while(0)
+#endif
+
+SECP256K1_INLINE static void secp256k1_fe_mul_inner(uint64_t *r, const uint64_t *a, const uint64_t * SECP256K1_RESTRICT b) {
+ uint128_t c, d;
+ uint64_t t3, t4, tx, u0;
+ uint64_t a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4];
+ const uint64_t M = 0xFFFFFFFFFFFFFULL, R = 0x1000003D10ULL;
+
+ VERIFY_BITS(a[0], 56);
+ VERIFY_BITS(a[1], 56);
+ VERIFY_BITS(a[2], 56);
+ VERIFY_BITS(a[3], 56);
+ VERIFY_BITS(a[4], 52);
+ VERIFY_BITS(b[0], 56);
+ VERIFY_BITS(b[1], 56);
+ VERIFY_BITS(b[2], 56);
+ VERIFY_BITS(b[3], 56);
+ VERIFY_BITS(b[4], 52);
+ VERIFY_CHECK(r != b);
+
+ /* [... a b c] is a shorthand for ... + a<<104 + b<<52 + c<<0 mod n.
+ * px is a shorthand for sum(a[i]*b[x-i], i=0..x).
+ * Note that [x 0 0 0 0 0] = [x*R].
+ */
+
+ d = (uint128_t)a0 * b[3]
+ + (uint128_t)a1 * b[2]
+ + (uint128_t)a2 * b[1]
+ + (uint128_t)a3 * b[0];
+ VERIFY_BITS(d, 114);
+ /* [d 0 0 0] = [p3 0 0 0] */
+ c = (uint128_t)a4 * b[4];
+ VERIFY_BITS(c, 112);
+ /* [c 0 0 0 0 d 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
+ d += (c & M) * R; c >>= 52;
+ VERIFY_BITS(d, 115);
+ VERIFY_BITS(c, 60);
+ /* [c 0 0 0 0 0 d 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
+ t3 = d & M; d >>= 52;
+ VERIFY_BITS(t3, 52);
+ VERIFY_BITS(d, 63);
+ /* [c 0 0 0 0 d t3 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
+
+ d += (uint128_t)a0 * b[4]
+ + (uint128_t)a1 * b[3]
+ + (uint128_t)a2 * b[2]
+ + (uint128_t)a3 * b[1]
+ + (uint128_t)a4 * b[0];
+ VERIFY_BITS(d, 115);
+ /* [c 0 0 0 0 d t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
+ d += c * R;
+ VERIFY_BITS(d, 116);
+ /* [d t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
+ t4 = d & M; d >>= 52;
+ VERIFY_BITS(t4, 52);
+ VERIFY_BITS(d, 64);
+ /* [d t4 t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
+ tx = (t4 >> 48); t4 &= (M >> 4);
+ VERIFY_BITS(tx, 4);
+ VERIFY_BITS(t4, 48);
+ /* [d t4+(tx<<48) t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
+
+ c = (uint128_t)a0 * b[0];
+ VERIFY_BITS(c, 112);
+ /* [d t4+(tx<<48) t3 0 0 c] = [p8 0 0 0 p4 p3 0 0 p0] */
+ d += (uint128_t)a1 * b[4]
+ + (uint128_t)a2 * b[3]
+ + (uint128_t)a3 * b[2]
+ + (uint128_t)a4 * b[1];
+ VERIFY_BITS(d, 115);
+ /* [d t4+(tx<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
+ u0 = d & M; d >>= 52;
+ VERIFY_BITS(u0, 52);
+ VERIFY_BITS(d, 63);
+ /* [d u0 t4+(tx<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
+ /* [d 0 t4+(tx<<48)+(u0<<52) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
+ u0 = (u0 << 4) | tx;
+ VERIFY_BITS(u0, 56);
+ /* [d 0 t4+(u0<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
+ c += (uint128_t)u0 * (R >> 4);
+ VERIFY_BITS(c, 115);
+ /* [d 0 t4 t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
+ r[0] = c & M; c >>= 52;
+ VERIFY_BITS(r[0], 52);
+ VERIFY_BITS(c, 61);
+ /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 0 p0] */
+
+ c += (uint128_t)a0 * b[1]
+ + (uint128_t)a1 * b[0];
+ VERIFY_BITS(c, 114);
+ /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 p1 p0] */
+ d += (uint128_t)a2 * b[4]
+ + (uint128_t)a3 * b[3]
+ + (uint128_t)a4 * b[2];
+ VERIFY_BITS(d, 114);
+ /* [d 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
+ c += (d & M) * R; d >>= 52;
+ VERIFY_BITS(c, 115);
+ VERIFY_BITS(d, 62);
+ /* [d 0 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
+ r[1] = c & M; c >>= 52;
+ VERIFY_BITS(r[1], 52);
+ VERIFY_BITS(c, 63);
+ /* [d 0 0 t4 t3 c r1 r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
+
+ c += (uint128_t)a0 * b[2]
+ + (uint128_t)a1 * b[1]
+ + (uint128_t)a2 * b[0];
+ VERIFY_BITS(c, 114);
+ /* [d 0 0 t4 t3 c r1 r0] = [p8 0 p6 p5 p4 p3 p2 p1 p0] */
+ d += (uint128_t)a3 * b[4]
+ + (uint128_t)a4 * b[3];
+ VERIFY_BITS(d, 114);
+ /* [d 0 0 t4 t3 c t1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ c += (d & M) * R; d >>= 52;
+ VERIFY_BITS(c, 115);
+ VERIFY_BITS(d, 62);
+ /* [d 0 0 0 t4 t3 c r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+
+ /* [d 0 0 0 t4 t3 c r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[2] = c & M; c >>= 52;
+ VERIFY_BITS(r[2], 52);
+ VERIFY_BITS(c, 63);
+ /* [d 0 0 0 t4 t3+c r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ c += d * R + t3;;
+ VERIFY_BITS(c, 100);
+ /* [t4 c r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[3] = c & M; c >>= 52;
+ VERIFY_BITS(r[3], 52);
+ VERIFY_BITS(c, 48);
+ /* [t4+c r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ c += t4;
+ VERIFY_BITS(c, 49);
+ /* [c r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[4] = c;
+ VERIFY_BITS(r[4], 49);
+ /* [r4 r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+}
+
+SECP256K1_INLINE static void secp256k1_fe_sqr_inner(uint64_t *r, const uint64_t *a) {
+ uint128_t c, d;
+ uint64_t a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4];
+ int64_t t3, t4, tx, u0;
+ const uint64_t M = 0xFFFFFFFFFFFFFULL, R = 0x1000003D10ULL;
+
+ VERIFY_BITS(a[0], 56);
+ VERIFY_BITS(a[1], 56);
+ VERIFY_BITS(a[2], 56);
+ VERIFY_BITS(a[3], 56);
+ VERIFY_BITS(a[4], 52);
+
+ /** [... a b c] is a shorthand for ... + a<<104 + b<<52 + c<<0 mod n.
+ * px is a shorthand for sum(a[i]*a[x-i], i=0..x).
+ * Note that [x 0 0 0 0 0] = [x*R].
+ */
+
+ d = (uint128_t)(a0*2) * a3
+ + (uint128_t)(a1*2) * a2;
+ VERIFY_BITS(d, 114);
+ /* [d 0 0 0] = [p3 0 0 0] */
+ c = (uint128_t)a4 * a4;
+ VERIFY_BITS(c, 112);
+ /* [c 0 0 0 0 d 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
+ d += (c & M) * R; c >>= 52;
+ VERIFY_BITS(d, 115);
+ VERIFY_BITS(c, 60);
+ /* [c 0 0 0 0 0 d 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
+ t3 = d & M; d >>= 52;
+ VERIFY_BITS(t3, 52);
+ VERIFY_BITS(d, 63);
+ /* [c 0 0 0 0 d t3 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
+
+ a4 *= 2;
+ d += (uint128_t)a0 * a4
+ + (uint128_t)(a1*2) * a3
+ + (uint128_t)a2 * a2;
+ VERIFY_BITS(d, 115);
+ /* [c 0 0 0 0 d t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
+ d += c * R;
+ VERIFY_BITS(d, 116);
+ /* [d t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
+ t4 = d & M; d >>= 52;
+ VERIFY_BITS(t4, 52);
+ VERIFY_BITS(d, 64);
+ /* [d t4 t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
+ tx = (t4 >> 48); t4 &= (M >> 4);
+ VERIFY_BITS(tx, 4);
+ VERIFY_BITS(t4, 48);
+ /* [d t4+(tx<<48) t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
+
+ c = (uint128_t)a0 * a0;
+ VERIFY_BITS(c, 112);
+ /* [d t4+(tx<<48) t3 0 0 c] = [p8 0 0 0 p4 p3 0 0 p0] */
+ d += (uint128_t)a1 * a4
+ + (uint128_t)(a2*2) * a3;
+ VERIFY_BITS(d, 114);
+ /* [d t4+(tx<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
+ u0 = d & M; d >>= 52;
+ VERIFY_BITS(u0, 52);
+ VERIFY_BITS(d, 62);
+ /* [d u0 t4+(tx<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
+ /* [d 0 t4+(tx<<48)+(u0<<52) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
+ u0 = (u0 << 4) | tx;
+ VERIFY_BITS(u0, 56);
+ /* [d 0 t4+(u0<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
+ c += (uint128_t)u0 * (R >> 4);
+ VERIFY_BITS(c, 113);
+ /* [d 0 t4 t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
+ r[0] = c & M; c >>= 52;
+ VERIFY_BITS(r[0], 52);
+ VERIFY_BITS(c, 61);
+ /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 0 p0] */
+
+ a0 *= 2;
+ c += (uint128_t)a0 * a1;
+ VERIFY_BITS(c, 114);
+ /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 p1 p0] */
+ d += (uint128_t)a2 * a4
+ + (uint128_t)a3 * a3;
+ VERIFY_BITS(d, 114);
+ /* [d 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
+ c += (d & M) * R; d >>= 52;
+ VERIFY_BITS(c, 115);
+ VERIFY_BITS(d, 62);
+ /* [d 0 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
+ r[1] = c & M; c >>= 52;
+ VERIFY_BITS(r[1], 52);
+ VERIFY_BITS(c, 63);
+ /* [d 0 0 t4 t3 c r1 r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
+
+ c += (uint128_t)a0 * a2
+ + (uint128_t)a1 * a1;
+ VERIFY_BITS(c, 114);
+ /* [d 0 0 t4 t3 c r1 r0] = [p8 0 p6 p5 p4 p3 p2 p1 p0] */
+ d += (uint128_t)a3 * a4;
+ VERIFY_BITS(d, 114);
+ /* [d 0 0 t4 t3 c r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ c += (d & M) * R; d >>= 52;
+ VERIFY_BITS(c, 115);
+ VERIFY_BITS(d, 62);
+ /* [d 0 0 0 t4 t3 c r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[2] = c & M; c >>= 52;
+ VERIFY_BITS(r[2], 52);
+ VERIFY_BITS(c, 63);
+ /* [d 0 0 0 t4 t3+c r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+
+ c += d * R + t3;;
+ VERIFY_BITS(c, 100);
+ /* [t4 c r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[3] = c & M; c >>= 52;
+ VERIFY_BITS(r[3], 52);
+ VERIFY_BITS(c, 48);
+ /* [t4+c r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ c += t4;
+ VERIFY_BITS(c, 49);
+ /* [c r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+ r[4] = c;
+ VERIFY_BITS(r[4], 49);
+ /* [r4 r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
+}
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_impl.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..e6ec11e8f2c48c88863b61cb34dd6d778aa2da03
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/field_impl.h
@@ -0,0 +1,263 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_FIELD_IMPL_H_
+#define _SECP256K1_FIELD_IMPL_H_
+
+#if defined HAVE_CONFIG_H
+#include "libsecp256k1-config.h"
+#endif
+
+#include "util.h"
+
+#if defined(USE_FIELD_10X26)
+#include "field_10x26_impl.h"
+#elif defined(USE_FIELD_5X52)
+#include "field_5x52_impl.h"
+#else
+#error "Please select field implementation"
+#endif
+
+SECP256K1_INLINE static int secp256k1_fe_equal_var(const secp256k1_fe_t *a, const secp256k1_fe_t *b) {
+ secp256k1_fe_t na;
+ secp256k1_fe_negate(&na, a, 1);
+ secp256k1_fe_add(&na, b);
+ return secp256k1_fe_normalizes_to_zero_var(&na);
+}
+
+static int secp256k1_fe_sqrt_var(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
+ secp256k1_fe_t x2, x3, x6, x9, x11, x22, x44, x88, x176, x220, x223, t1;
+ int j;
+
+ /** The binary representation of (p + 1)/4 has 3 blocks of 1s, with lengths in
+ * { 2, 22, 223 }. Use an addition chain to calculate 2^n - 1 for each block:
+ * 1, [2], 3, 6, 9, 11, [22], 44, 88, 176, 220, [223]
+ */
+
+ secp256k1_fe_sqr(&x2, a);
+ secp256k1_fe_mul(&x2, &x2, a);
+
+ secp256k1_fe_sqr(&x3, &x2);
+ secp256k1_fe_mul(&x3, &x3, a);
+
+ x6 = x3;
+ for (j=0; j<3; j++) {
+ secp256k1_fe_sqr(&x6, &x6);
+ }
+ secp256k1_fe_mul(&x6, &x6, &x3);
+
+ x9 = x6;
+ for (j=0; j<3; j++) {
+ secp256k1_fe_sqr(&x9, &x9);
+ }
+ secp256k1_fe_mul(&x9, &x9, &x3);
+
+ x11 = x9;
+ for (j=0; j<2; j++) {
+ secp256k1_fe_sqr(&x11, &x11);
+ }
+ secp256k1_fe_mul(&x11, &x11, &x2);
+
+ x22 = x11;
+ for (j=0; j<11; j++) {
+ secp256k1_fe_sqr(&x22, &x22);
+ }
+ secp256k1_fe_mul(&x22, &x22, &x11);
+
+ x44 = x22;
+ for (j=0; j<22; j++) {
+ secp256k1_fe_sqr(&x44, &x44);
+ }
+ secp256k1_fe_mul(&x44, &x44, &x22);
+
+ x88 = x44;
+ for (j=0; j<44; j++) {
+ secp256k1_fe_sqr(&x88, &x88);
+ }
+ secp256k1_fe_mul(&x88, &x88, &x44);
+
+ x176 = x88;
+ for (j=0; j<88; j++) {
+ secp256k1_fe_sqr(&x176, &x176);
+ }
+ secp256k1_fe_mul(&x176, &x176, &x88);
+
+ x220 = x176;
+ for (j=0; j<44; j++) {
+ secp256k1_fe_sqr(&x220, &x220);
+ }
+ secp256k1_fe_mul(&x220, &x220, &x44);
+
+ x223 = x220;
+ for (j=0; j<3; j++) {
+ secp256k1_fe_sqr(&x223, &x223);
+ }
+ secp256k1_fe_mul(&x223, &x223, &x3);
+
+ /* The final result is then assembled using a sliding window over the blocks. */
+
+ t1 = x223;
+ for (j=0; j<23; j++) {
+ secp256k1_fe_sqr(&t1, &t1);
+ }
+ secp256k1_fe_mul(&t1, &t1, &x22);
+ for (j=0; j<6; j++) {
+ secp256k1_fe_sqr(&t1, &t1);
+ }
+ secp256k1_fe_mul(&t1, &t1, &x2);
+ secp256k1_fe_sqr(&t1, &t1);
+ secp256k1_fe_sqr(r, &t1);
+
+ /* Check that a square root was actually calculated */
+
+ secp256k1_fe_sqr(&t1, r);
+ return secp256k1_fe_equal_var(&t1, a);
+}
+
+static void secp256k1_fe_inv(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
+ secp256k1_fe_t x2, x3, x6, x9, x11, x22, x44, x88, x176, x220, x223, t1;
+ int j;
+
+ /** The binary representation of (p - 2) has 5 blocks of 1s, with lengths in
+ * { 1, 2, 22, 223 }. Use an addition chain to calculate 2^n - 1 for each block:
+ * [1], [2], 3, 6, 9, 11, [22], 44, 88, 176, 220, [223]
+ */
+
+ secp256k1_fe_sqr(&x2, a);
+ secp256k1_fe_mul(&x2, &x2, a);
+
+ secp256k1_fe_sqr(&x3, &x2);
+ secp256k1_fe_mul(&x3, &x3, a);
+
+ x6 = x3;
+ for (j=0; j<3; j++) {
+ secp256k1_fe_sqr(&x6, &x6);
+ }
+ secp256k1_fe_mul(&x6, &x6, &x3);
+
+ x9 = x6;
+ for (j=0; j<3; j++) {
+ secp256k1_fe_sqr(&x9, &x9);
+ }
+ secp256k1_fe_mul(&x9, &x9, &x3);
+
+ x11 = x9;
+ for (j=0; j<2; j++) {
+ secp256k1_fe_sqr(&x11, &x11);
+ }
+ secp256k1_fe_mul(&x11, &x11, &x2);
+
+ x22 = x11;
+ for (j=0; j<11; j++) {
+ secp256k1_fe_sqr(&x22, &x22);
+ }
+ secp256k1_fe_mul(&x22, &x22, &x11);
+
+ x44 = x22;
+ for (j=0; j<22; j++) {
+ secp256k1_fe_sqr(&x44, &x44);
+ }
+ secp256k1_fe_mul(&x44, &x44, &x22);
+
+ x88 = x44;
+ for (j=0; j<44; j++) {
+ secp256k1_fe_sqr(&x88, &x88);
+ }
+ secp256k1_fe_mul(&x88, &x88, &x44);
+
+ x176 = x88;
+ for (j=0; j<88; j++) {
+ secp256k1_fe_sqr(&x176, &x176);
+ }
+ secp256k1_fe_mul(&x176, &x176, &x88);
+
+ x220 = x176;
+ for (j=0; j<44; j++) {
+ secp256k1_fe_sqr(&x220, &x220);
+ }
+ secp256k1_fe_mul(&x220, &x220, &x44);
+
+ x223 = x220;
+ for (j=0; j<3; j++) {
+ secp256k1_fe_sqr(&x223, &x223);
+ }
+ secp256k1_fe_mul(&x223, &x223, &x3);
+
+ /* The final result is then assembled using a sliding window over the blocks. */
+
+ t1 = x223;
+ for (j=0; j<23; j++) {
+ secp256k1_fe_sqr(&t1, &t1);
+ }
+ secp256k1_fe_mul(&t1, &t1, &x22);
+ for (j=0; j<5; j++) {
+ secp256k1_fe_sqr(&t1, &t1);
+ }
+ secp256k1_fe_mul(&t1, &t1, a);
+ for (j=0; j<3; j++) {
+ secp256k1_fe_sqr(&t1, &t1);
+ }
+ secp256k1_fe_mul(&t1, &t1, &x2);
+ for (j=0; j<2; j++) {
+ secp256k1_fe_sqr(&t1, &t1);
+ }
+ secp256k1_fe_mul(r, a, &t1);
+}
+
+static void secp256k1_fe_inv_var(secp256k1_fe_t *r, const secp256k1_fe_t *a) {
+#if defined(USE_FIELD_INV_BUILTIN)
+ secp256k1_fe_inv(r, a);
+#elif defined(USE_FIELD_INV_NUM)
+ secp256k1_num_t n, m;
+ /* secp256k1 field prime, value p defined in "Standards for Efficient Cryptography" (SEC2) 2.7.1. */
+ static const unsigned char prime[32] = {
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F
+ };
+ unsigned char b[32];
+ secp256k1_fe_t c = *a;
+ secp256k1_fe_normalize_var(&c);
+ secp256k1_fe_get_b32(b, &c);
+ secp256k1_num_set_bin(&n, b, 32);
+ secp256k1_num_set_bin(&m, prime, 32);
+ secp256k1_num_mod_inverse(&n, &n, &m);
+ secp256k1_num_get_bin(b, 32, &n);
+ VERIFY_CHECK(secp256k1_fe_set_b32(r, b));
+#else
+#error "Please select field inverse implementation"
+#endif
+}
+
+static void secp256k1_fe_inv_all_var(size_t len, secp256k1_fe_t *r, const secp256k1_fe_t *a) {
+ secp256k1_fe_t u;
+ size_t i;
+ if (len < 1) {
+ return;
+ }
+
+ VERIFY_CHECK((r + len <= a) || (a + len <= r));
+
+ r[0] = a[0];
+
+ i = 0;
+ while (++i < len) {
+ secp256k1_fe_mul(&r[i], &r[i - 1], &a[i]);
+ }
+
+ secp256k1_fe_inv_var(&u, &r[--i]);
+
+ while (i > 0) {
+ int j = i--;
+ secp256k1_fe_mul(&r[j], &r[i], &u);
+ secp256k1_fe_mul(&u, &u, &a[j]);
+ }
+
+ r[0] = u;
+}
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/group.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/group.h
new file mode 100644
index 0000000000000000000000000000000000000000..d1e58349096847ab32988313fda39703d685105d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/group.h
@@ -0,0 +1,118 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_GROUP_
+#define _SECP256K1_GROUP_
+
+#include "num.h"
+#include "field.h"
+
+/** A group element of the secp256k1 curve, in affine coordinates. */
+typedef struct {
+ secp256k1_fe_t x;
+ secp256k1_fe_t y;
+ int infinity; /* whether this represents the point at infinity */
+} secp256k1_ge_t;
+
+#define SECP256K1_GE_CONST(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) {SECP256K1_FE_CONST((a),(b),(c),(d),(e),(f),(g),(h)), SECP256K1_FE_CONST((i),(j),(k),(l),(m),(n),(o),(p)), 0}
+#define SECP256K1_GE_CONST_INFINITY {SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), 1}
+
+/** A group element of the secp256k1 curve, in jacobian coordinates. */
+typedef struct {
+ secp256k1_fe_t x; /* actual X: x/z^2 */
+ secp256k1_fe_t y; /* actual Y: y/z^3 */
+ secp256k1_fe_t z;
+ int infinity; /* whether this represents the point at infinity */
+} secp256k1_gej_t;
+
+#define SECP256K1_GEJ_CONST(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) {SECP256K1_FE_CONST((a),(b),(c),(d),(e),(f),(g),(h)), SECP256K1_FE_CONST((i),(j),(k),(l),(m),(n),(o),(p)), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 1), 0}
+#define SECP256K1_GEJ_CONST_INFINITY {SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), 1}
+
+typedef struct {
+ secp256k1_fe_storage_t x;
+ secp256k1_fe_storage_t y;
+} secp256k1_ge_storage_t;
+
+#define SECP256K1_GE_STORAGE_CONST(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) {SECP256K1_FE_STORAGE_CONST((a),(b),(c),(d),(e),(f),(g),(h)), SECP256K1_FE_STORAGE_CONST((i),(j),(k),(l),(m),(n),(o),(p))}
+
+/** Set a group element equal to the point at infinity */
+static void secp256k1_ge_set_infinity(secp256k1_ge_t *r);
+
+/** Set a group element equal to the point with given X and Y coordinates */
+static void secp256k1_ge_set_xy(secp256k1_ge_t *r, const secp256k1_fe_t *x, const secp256k1_fe_t *y);
+
+/** Set a group element (affine) equal to the point with the given X coordinate, and given oddness
+ * for Y. Return value indicates whether the result is valid. */
+static int secp256k1_ge_set_xo_var(secp256k1_ge_t *r, const secp256k1_fe_t *x, int odd);
+
+/** Check whether a group element is the point at infinity. */
+static int secp256k1_ge_is_infinity(const secp256k1_ge_t *a);
+
+/** Check whether a group element is valid (i.e., on the curve). */
+static int secp256k1_ge_is_valid_var(const secp256k1_ge_t *a);
+
+static void secp256k1_ge_neg(secp256k1_ge_t *r, const secp256k1_ge_t *a);
+
+/** Set a group element equal to another which is given in jacobian coordinates */
+static void secp256k1_ge_set_gej(secp256k1_ge_t *r, secp256k1_gej_t *a);
+
+/** Set a batch of group elements equal to the inputs given in jacobian coordinates */
+static void secp256k1_ge_set_all_gej_var(size_t len, secp256k1_ge_t *r, const secp256k1_gej_t *a);
+
+
+/** Set a group element (jacobian) equal to the point at infinity. */
+static void secp256k1_gej_set_infinity(secp256k1_gej_t *r);
+
+/** Set a group element (jacobian) equal to the point with given X and Y coordinates. */
+static void secp256k1_gej_set_xy(secp256k1_gej_t *r, const secp256k1_fe_t *x, const secp256k1_fe_t *y);
+
+/** Set a group element (jacobian) equal to another which is given in affine coordinates. */
+static void secp256k1_gej_set_ge(secp256k1_gej_t *r, const secp256k1_ge_t *a);
+
+/** Compare the X coordinate of a group element (jacobian). */
+static int secp256k1_gej_eq_x_var(const secp256k1_fe_t *x, const secp256k1_gej_t *a);
+
+/** Set r equal to the inverse of a (i.e., mirrored around the X axis) */
+static void secp256k1_gej_neg(secp256k1_gej_t *r, const secp256k1_gej_t *a);
+
+/** Check whether a group element is the point at infinity. */
+static int secp256k1_gej_is_infinity(const secp256k1_gej_t *a);
+
+/** Set r equal to the double of a. */
+static void secp256k1_gej_double_var(secp256k1_gej_t *r, const secp256k1_gej_t *a);
+
+/** Set r equal to the sum of a and b. */
+static void secp256k1_gej_add_var(secp256k1_gej_t *r, const secp256k1_gej_t *a, const secp256k1_gej_t *b);
+
+/** Set r equal to the sum of a and b (with b given in affine coordinates, and not infinity). */
+static void secp256k1_gej_add_ge(secp256k1_gej_t *r, const secp256k1_gej_t *a, const secp256k1_ge_t *b);
+
+/** Set r equal to the sum of a and b (with b given in affine coordinates). This is more efficient
+ than secp256k1_gej_add_var. It is identical to secp256k1_gej_add_ge but without constant-time
+ guarantee, and b is allowed to be infinity. */
+static void secp256k1_gej_add_ge_var(secp256k1_gej_t *r, const secp256k1_gej_t *a, const secp256k1_ge_t *b);
+
+#ifdef USE_ENDOMORPHISM
+/** Set r to be equal to lambda times a, where lambda is chosen in a way such that this is very fast. */
+static void secp256k1_gej_mul_lambda(secp256k1_gej_t *r, const secp256k1_gej_t *a);
+#endif
+
+/** Clear a secp256k1_gej_t to prevent leaking sensitive information. */
+static void secp256k1_gej_clear(secp256k1_gej_t *r);
+
+/** Clear a secp256k1_ge_t to prevent leaking sensitive information. */
+static void secp256k1_ge_clear(secp256k1_ge_t *r);
+
+/** Convert a group element to the storage type. */
+static void secp256k1_ge_to_storage(secp256k1_ge_storage_t *r, const secp256k1_ge_t*);
+
+/** Convert a group element back from the storage type. */
+static void secp256k1_ge_from_storage(secp256k1_ge_t *r, const secp256k1_ge_storage_t*);
+
+/** If flag is true, set *r equal to *a; otherwise leave it. Constant-time. */
+static void secp256k1_ge_storage_cmov(secp256k1_ge_storage_t *r, const secp256k1_ge_storage_t *a, int flag);
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/group_impl.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/group_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..0d1c7b02ff3b7f50c50dfa637665b5d8deb7b529
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/group_impl.h
@@ -0,0 +1,434 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_GROUP_IMPL_H_
+#define _SECP256K1_GROUP_IMPL_H_
+
+#include <string.h>
+
+#include "num.h"
+#include "field.h"
+#include "group.h"
+
+/** Generator for secp256k1, value 'g' defined in
+ * "Standards for Efficient Cryptography" (SEC2) 2.7.1.
+ */
+static const secp256k1_ge_t secp256k1_ge_const_g = SECP256K1_GE_CONST(
+ 0x79BE667EUL, 0xF9DCBBACUL, 0x55A06295UL, 0xCE870B07UL,
+ 0x029BFCDBUL, 0x2DCE28D9UL, 0x59F2815BUL, 0x16F81798UL,
+ 0x483ADA77UL, 0x26A3C465UL, 0x5DA4FBFCUL, 0x0E1108A8UL,
+ 0xFD17B448UL, 0xA6855419UL, 0x9C47D08FUL, 0xFB10D4B8UL
+);
+
+static void secp256k1_ge_set_infinity(secp256k1_ge_t *r) {
+ r->infinity = 1;
+}
+
+static void secp256k1_ge_set_xy(secp256k1_ge_t *r, const secp256k1_fe_t *x, const secp256k1_fe_t *y) {
+ r->infinity = 0;
+ r->x = *x;
+ r->y = *y;
+}
+
+static int secp256k1_ge_is_infinity(const secp256k1_ge_t *a) {
+ return a->infinity;
+}
+
+static void secp256k1_ge_neg(secp256k1_ge_t *r, const secp256k1_ge_t *a) {
+ *r = *a;
+ secp256k1_fe_normalize_weak(&r->y);
+ secp256k1_fe_negate(&r->y, &r->y, 1);
+}
+
+static void secp256k1_ge_set_gej(secp256k1_ge_t *r, secp256k1_gej_t *a) {
+ secp256k1_fe_t z2, z3;
+ r->infinity = a->infinity;
+ secp256k1_fe_inv(&a->z, &a->z);
+ secp256k1_fe_sqr(&z2, &a->z);
+ secp256k1_fe_mul(&z3, &a->z, &z2);
+ secp256k1_fe_mul(&a->x, &a->x, &z2);
+ secp256k1_fe_mul(&a->y, &a->y, &z3);
+ secp256k1_fe_set_int(&a->z, 1);
+ r->x = a->x;
+ r->y = a->y;
+}
+
+static void secp256k1_ge_set_gej_var(secp256k1_ge_t *r, secp256k1_gej_t *a) {
+ secp256k1_fe_t z2, z3;
+ r->infinity = a->infinity;
+ if (a->infinity) {
+ return;
+ }
+ secp256k1_fe_inv_var(&a->z, &a->z);
+ secp256k1_fe_sqr(&z2, &a->z);
+ secp256k1_fe_mul(&z3, &a->z, &z2);
+ secp256k1_fe_mul(&a->x, &a->x, &z2);
+ secp256k1_fe_mul(&a->y, &a->y, &z3);
+ secp256k1_fe_set_int(&a->z, 1);
+ r->x = a->x;
+ r->y = a->y;
+}
+
+static void secp256k1_ge_set_all_gej_var(size_t len, secp256k1_ge_t *r, const secp256k1_gej_t *a) {
+ secp256k1_fe_t *az;
+ secp256k1_fe_t *azi;
+ size_t i;
+ size_t count = 0;
+ az = (secp256k1_fe_t *)checked_malloc(sizeof(secp256k1_fe_t) * len);
+ for (i = 0; i < len; i++) {
+ if (!a[i].infinity) {
+ az[count++] = a[i].z;
+ }
+ }
+
+ azi = (secp256k1_fe_t *)checked_malloc(sizeof(secp256k1_fe_t) * count);
+ secp256k1_fe_inv_all_var(count, azi, az);
+ free(az);
+
+ count = 0;
+ for (i = 0; i < len; i++) {
+ r[i].infinity = a[i].infinity;
+ if (!a[i].infinity) {
+ secp256k1_fe_t zi2, zi3;
+ secp256k1_fe_t *zi = &azi[count++];
+ secp256k1_fe_sqr(&zi2, zi);
+ secp256k1_fe_mul(&zi3, &zi2, zi);
+ secp256k1_fe_mul(&r[i].x, &a[i].x, &zi2);
+ secp256k1_fe_mul(&r[i].y, &a[i].y, &zi3);
+ }
+ }
+ free(azi);
+}
+
+static void secp256k1_gej_set_infinity(secp256k1_gej_t *r) {
+ r->infinity = 1;
+ secp256k1_fe_set_int(&r->x, 0);
+ secp256k1_fe_set_int(&r->y, 0);
+ secp256k1_fe_set_int(&r->z, 0);
+}
+
+static void secp256k1_gej_set_xy(secp256k1_gej_t *r, const secp256k1_fe_t *x, const secp256k1_fe_t *y) {
+ r->infinity = 0;
+ r->x = *x;
+ r->y = *y;
+ secp256k1_fe_set_int(&r->z, 1);
+}
+
+static void secp256k1_gej_clear(secp256k1_gej_t *r) {
+ r->infinity = 0;
+ secp256k1_fe_clear(&r->x);
+ secp256k1_fe_clear(&r->y);
+ secp256k1_fe_clear(&r->z);
+}
+
+static void secp256k1_ge_clear(secp256k1_ge_t *r) {
+ r->infinity = 0;
+ secp256k1_fe_clear(&r->x);
+ secp256k1_fe_clear(&r->y);
+}
+
+static int secp256k1_ge_set_xo_var(secp256k1_ge_t *r, const secp256k1_fe_t *x, int odd) {
+ secp256k1_fe_t x2, x3, c;
+ r->x = *x;
+ secp256k1_fe_sqr(&x2, x);
+ secp256k1_fe_mul(&x3, x, &x2);
+ r->infinity = 0;
+ secp256k1_fe_set_int(&c, 7);
+ secp256k1_fe_add(&c, &x3);
+ if (!secp256k1_fe_sqrt_var(&r->y, &c)) {
+ return 0;
+ }
+ secp256k1_fe_normalize_var(&r->y);
+ if (secp256k1_fe_is_odd(&r->y) != odd) {
+ secp256k1_fe_negate(&r->y, &r->y, 1);
+ }
+ return 1;
+}
+
+static void secp256k1_gej_set_ge(secp256k1_gej_t *r, const secp256k1_ge_t *a) {
+ r->infinity = a->infinity;
+ r->x = a->x;
+ r->y = a->y;
+ secp256k1_fe_set_int(&r->z, 1);
+}
+
+static int secp256k1_gej_eq_x_var(const secp256k1_fe_t *x, const secp256k1_gej_t *a) {
+ secp256k1_fe_t r, r2;
+ VERIFY_CHECK(!a->infinity);
+ secp256k1_fe_sqr(&r, &a->z); secp256k1_fe_mul(&r, &r, x);
+ r2 = a->x; secp256k1_fe_normalize_weak(&r2);
+ return secp256k1_fe_equal_var(&r, &r2);
+}
+
+static void secp256k1_gej_neg(secp256k1_gej_t *r, const secp256k1_gej_t *a) {
+ r->infinity = a->infinity;
+ r->x = a->x;
+ r->y = a->y;
+ r->z = a->z;
+ secp256k1_fe_normalize_weak(&r->y);
+ secp256k1_fe_negate(&r->y, &r->y, 1);
+}
+
+static int secp256k1_gej_is_infinity(const secp256k1_gej_t *a) {
+ return a->infinity;
+}
+
+static int secp256k1_gej_is_valid_var(const secp256k1_gej_t *a) {
+ secp256k1_fe_t y2, x3, z2, z6;
+ if (a->infinity) {
+ return 0;
+ }
+ /** y^2 = x^3 + 7
+ * (Y/Z^3)^2 = (X/Z^2)^3 + 7
+ * Y^2 / Z^6 = X^3 / Z^6 + 7
+ * Y^2 = X^3 + 7*Z^6
+ */
+ secp256k1_fe_sqr(&y2, &a->y);
+ secp256k1_fe_sqr(&x3, &a->x); secp256k1_fe_mul(&x3, &x3, &a->x);
+ secp256k1_fe_sqr(&z2, &a->z);
+ secp256k1_fe_sqr(&z6, &z2); secp256k1_fe_mul(&z6, &z6, &z2);
+ secp256k1_fe_mul_int(&z6, 7);
+ secp256k1_fe_add(&x3, &z6);
+ secp256k1_fe_normalize_weak(&x3);
+ return secp256k1_fe_equal_var(&y2, &x3);
+}
+
+static int secp256k1_ge_is_valid_var(const secp256k1_ge_t *a) {
+ secp256k1_fe_t y2, x3, c;
+ if (a->infinity) {
+ return 0;
+ }
+ /* y^2 = x^3 + 7 */
+ secp256k1_fe_sqr(&y2, &a->y);
+ secp256k1_fe_sqr(&x3, &a->x); secp256k1_fe_mul(&x3, &x3, &a->x);
+ secp256k1_fe_set_int(&c, 7);
+ secp256k1_fe_add(&x3, &c);
+ secp256k1_fe_normalize_weak(&x3);
+ return secp256k1_fe_equal_var(&y2, &x3);
+}
+
+static void secp256k1_gej_double_var(secp256k1_gej_t *r, const secp256k1_gej_t *a) {
+ /* Operations: 3 mul, 4 sqr, 0 normalize, 12 mul_int/add/negate */
+ secp256k1_fe_t t1,t2,t3,t4;
+ /** For secp256k1, 2Q is infinity if and only if Q is infinity. This is because if 2Q = infinity,
+ * Q must equal -Q, or that Q.y == -(Q.y), or Q.y is 0. For a point on y^2 = x^3 + 7 to have
+ * y=0, x^3 must be -7 mod p. However, -7 has no cube root mod p.
+ */
+ r->infinity = a->infinity;
+ if (r->infinity) {
+ return;
+ }
+
+ secp256k1_fe_mul(&r->z, &a->z, &a->y);
+ secp256k1_fe_mul_int(&r->z, 2); /* Z' = 2*Y*Z (2) */
+ secp256k1_fe_sqr(&t1, &a->x);
+ secp256k1_fe_mul_int(&t1, 3); /* T1 = 3*X^2 (3) */
+ secp256k1_fe_sqr(&t2, &t1); /* T2 = 9*X^4 (1) */
+ secp256k1_fe_sqr(&t3, &a->y);
+ secp256k1_fe_mul_int(&t3, 2); /* T3 = 2*Y^2 (2) */
+ secp256k1_fe_sqr(&t4, &t3);
+ secp256k1_fe_mul_int(&t4, 2); /* T4 = 8*Y^4 (2) */
+ secp256k1_fe_mul(&t3, &t3, &a->x); /* T3 = 2*X*Y^2 (1) */
+ r->x = t3;
+ secp256k1_fe_mul_int(&r->x, 4); /* X' = 8*X*Y^2 (4) */
+ secp256k1_fe_negate(&r->x, &r->x, 4); /* X' = -8*X*Y^2 (5) */
+ secp256k1_fe_add(&r->x, &t2); /* X' = 9*X^4 - 8*X*Y^2 (6) */
+ secp256k1_fe_negate(&t2, &t2, 1); /* T2 = -9*X^4 (2) */
+ secp256k1_fe_mul_int(&t3, 6); /* T3 = 12*X*Y^2 (6) */
+ secp256k1_fe_add(&t3, &t2); /* T3 = 12*X*Y^2 - 9*X^4 (8) */
+ secp256k1_fe_mul(&r->y, &t1, &t3); /* Y' = 36*X^3*Y^2 - 27*X^6 (1) */
+ secp256k1_fe_negate(&t2, &t4, 2); /* T2 = -8*Y^4 (3) */
+ secp256k1_fe_add(&r->y, &t2); /* Y' = 36*X^3*Y^2 - 27*X^6 - 8*Y^4 (4) */
+}
+
+static void secp256k1_gej_add_var(secp256k1_gej_t *r, const secp256k1_gej_t *a, const secp256k1_gej_t *b) {
+ /* Operations: 12 mul, 4 sqr, 2 normalize, 12 mul_int/add/negate */
+ secp256k1_fe_t z22, z12, u1, u2, s1, s2, h, i, i2, h2, h3, t;
+ if (a->infinity) {
+ *r = *b;
+ return;
+ }
+ if (b->infinity) {
+ *r = *a;
+ return;
+ }
+ r->infinity = 0;
+ secp256k1_fe_sqr(&z22, &b->z);
+ secp256k1_fe_sqr(&z12, &a->z);
+ secp256k1_fe_mul(&u1, &a->x, &z22);
+ secp256k1_fe_mul(&u2, &b->x, &z12);
+ secp256k1_fe_mul(&s1, &a->y, &z22); secp256k1_fe_mul(&s1, &s1, &b->z);
+ secp256k1_fe_mul(&s2, &b->y, &z12); secp256k1_fe_mul(&s2, &s2, &a->z);
+ secp256k1_fe_negate(&h, &u1, 1); secp256k1_fe_add(&h, &u2);
+ secp256k1_fe_negate(&i, &s1, 1); secp256k1_fe_add(&i, &s2);
+ if (secp256k1_fe_normalizes_to_zero_var(&h)) {
+ if (secp256k1_fe_normalizes_to_zero_var(&i)) {
+ secp256k1_gej_double_var(r, a);
+ } else {
+ r->infinity = 1;
+ }
+ return;
+ }
+ secp256k1_fe_sqr(&i2, &i);
+ secp256k1_fe_sqr(&h2, &h);
+ secp256k1_fe_mul(&h3, &h, &h2);
+ secp256k1_fe_mul(&r->z, &a->z, &b->z); secp256k1_fe_mul(&r->z, &r->z, &h);
+ secp256k1_fe_mul(&t, &u1, &h2);
+ r->x = t; secp256k1_fe_mul_int(&r->x, 2); secp256k1_fe_add(&r->x, &h3); secp256k1_fe_negate(&r->x, &r->x, 3); secp256k1_fe_add(&r->x, &i2);
+ secp256k1_fe_negate(&r->y, &r->x, 5); secp256k1_fe_add(&r->y, &t); secp256k1_fe_mul(&r->y, &r->y, &i);
+ secp256k1_fe_mul(&h3, &h3, &s1); secp256k1_fe_negate(&h3, &h3, 1);
+ secp256k1_fe_add(&r->y, &h3);
+}
+
+static void secp256k1_gej_add_ge_var(secp256k1_gej_t *r, const secp256k1_gej_t *a, const secp256k1_ge_t *b) {
+ /* 8 mul, 3 sqr, 4 normalize, 12 mul_int/add/negate */
+ secp256k1_fe_t z12, u1, u2, s1, s2, h, i, i2, h2, h3, t;
+ if (a->infinity) {
+ r->infinity = b->infinity;
+ r->x = b->x;
+ r->y = b->y;
+ secp256k1_fe_set_int(&r->z, 1);
+ return;
+ }
+ if (b->infinity) {
+ *r = *a;
+ return;
+ }
+ r->infinity = 0;
+ secp256k1_fe_sqr(&z12, &a->z);
+ u1 = a->x; secp256k1_fe_normalize_weak(&u1);
+ secp256k1_fe_mul(&u2, &b->x, &z12);
+ s1 = a->y; secp256k1_fe_normalize_weak(&s1);
+ secp256k1_fe_mul(&s2, &b->y, &z12); secp256k1_fe_mul(&s2, &s2, &a->z);
+ secp256k1_fe_negate(&h, &u1, 1); secp256k1_fe_add(&h, &u2);
+ secp256k1_fe_negate(&i, &s1, 1); secp256k1_fe_add(&i, &s2);
+ if (secp256k1_fe_normalizes_to_zero_var(&h)) {
+ if (secp256k1_fe_normalizes_to_zero_var(&i)) {
+ secp256k1_gej_double_var(r, a);
+ } else {
+ r->infinity = 1;
+ }
+ return;
+ }
+ secp256k1_fe_sqr(&i2, &i);
+ secp256k1_fe_sqr(&h2, &h);
+ secp256k1_fe_mul(&h3, &h, &h2);
+ r->z = a->z; secp256k1_fe_mul(&r->z, &r->z, &h);
+ secp256k1_fe_mul(&t, &u1, &h2);
+ r->x = t; secp256k1_fe_mul_int(&r->x, 2); secp256k1_fe_add(&r->x, &h3); secp256k1_fe_negate(&r->x, &r->x, 3); secp256k1_fe_add(&r->x, &i2);
+ secp256k1_fe_negate(&r->y, &r->x, 5); secp256k1_fe_add(&r->y, &t); secp256k1_fe_mul(&r->y, &r->y, &i);
+ secp256k1_fe_mul(&h3, &h3, &s1); secp256k1_fe_negate(&h3, &h3, 1);
+ secp256k1_fe_add(&r->y, &h3);
+}
+
+static void secp256k1_gej_add_ge(secp256k1_gej_t *r, const secp256k1_gej_t *a, const secp256k1_ge_t *b) {
+ /* Operations: 7 mul, 5 sqr, 5 normalize, 19 mul_int/add/negate */
+ secp256k1_fe_t zz, u1, u2, s1, s2, z, t, m, n, q, rr;
+ int infinity;
+ VERIFY_CHECK(!b->infinity);
+ VERIFY_CHECK(a->infinity == 0 || a->infinity == 1);
+
+ /** In:
+ * Eric Brier and Marc Joye, Weierstrass Elliptic Curves and Side-Channel Attacks.
+ * In D. Naccache and P. Paillier, Eds., Public Key Cryptography, vol. 2274 of Lecture Notes in Computer Science, pages 335-345. Springer-Verlag, 2002.
+ * we find as solution for a unified addition/doubling formula:
+ * lambda = ((x1 + x2)^2 - x1 * x2 + a) / (y1 + y2), with a = 0 for secp256k1's curve equation.
+ * x3 = lambda^2 - (x1 + x2)
+ * 2*y3 = lambda * (x1 + x2 - 2 * x3) - (y1 + y2).
+ *
+ * Substituting x_i = Xi / Zi^2 and yi = Yi / Zi^3, for i=1,2,3, gives:
+ * U1 = X1*Z2^2, U2 = X2*Z1^2
+ * S1 = Y1*Z2^3, S2 = Y2*Z1^3
+ * Z = Z1*Z2
+ * T = U1+U2
+ * M = S1+S2
+ * Q = T*M^2
+ * R = T^2-U1*U2
+ * X3 = 4*(R^2-Q)
+ * Y3 = 4*(R*(3*Q-2*R^2)-M^4)
+ * Z3 = 2*M*Z
+ * (Note that the paper uses xi = Xi / Zi and yi = Yi / Zi instead.)
+ */
+
+ secp256k1_fe_sqr(&zz, &a->z); /* z = Z1^2 */
+ u1 = a->x; secp256k1_fe_normalize_weak(&u1); /* u1 = U1 = X1*Z2^2 (1) */
+ secp256k1_fe_mul(&u2, &b->x, &zz); /* u2 = U2 = X2*Z1^2 (1) */
+ s1 = a->y; secp256k1_fe_normalize_weak(&s1); /* s1 = S1 = Y1*Z2^3 (1) */
+ secp256k1_fe_mul(&s2, &b->y, &zz); /* s2 = Y2*Z2^2 (1) */
+ secp256k1_fe_mul(&s2, &s2, &a->z); /* s2 = S2 = Y2*Z1^3 (1) */
+ z = a->z; /* z = Z = Z1*Z2 (8) */
+ t = u1; secp256k1_fe_add(&t, &u2); /* t = T = U1+U2 (2) */
+ m = s1; secp256k1_fe_add(&m, &s2); /* m = M = S1+S2 (2) */
+ secp256k1_fe_sqr(&n, &m); /* n = M^2 (1) */
+ secp256k1_fe_mul(&q, &n, &t); /* q = Q = T*M^2 (1) */
+ secp256k1_fe_sqr(&n, &n); /* n = M^4 (1) */
+ secp256k1_fe_sqr(&rr, &t); /* rr = T^2 (1) */
+ secp256k1_fe_mul(&t, &u1, &u2); secp256k1_fe_negate(&t, &t, 1); /* t = -U1*U2 (2) */
+ secp256k1_fe_add(&rr, &t); /* rr = R = T^2-U1*U2 (3) */
+ secp256k1_fe_sqr(&t, &rr); /* t = R^2 (1) */
+ secp256k1_fe_mul(&r->z, &m, &z); /* r->z = M*Z (1) */
+ infinity = secp256k1_fe_normalizes_to_zero(&r->z) * (1 - a->infinity);
+ secp256k1_fe_mul_int(&r->z, 2 * (1 - a->infinity)); /* r->z = Z3 = 2*M*Z (2) */
+ r->x = t; /* r->x = R^2 (1) */
+ secp256k1_fe_negate(&q, &q, 1); /* q = -Q (2) */
+ secp256k1_fe_add(&r->x, &q); /* r->x = R^2-Q (3) */
+ secp256k1_fe_normalize(&r->x);
+ secp256k1_fe_mul_int(&q, 3); /* q = -3*Q (6) */
+ secp256k1_fe_mul_int(&t, 2); /* t = 2*R^2 (2) */
+ secp256k1_fe_add(&t, &q); /* t = 2*R^2-3*Q (8) */
+ secp256k1_fe_mul(&t, &t, &rr); /* t = R*(2*R^2-3*Q) (1) */
+ secp256k1_fe_add(&t, &n); /* t = R*(2*R^2-3*Q)+M^4 (2) */
+ secp256k1_fe_negate(&r->y, &t, 2); /* r->y = R*(3*Q-2*R^2)-M^4 (3) */
+ secp256k1_fe_normalize_weak(&r->y);
+ secp256k1_fe_mul_int(&r->x, 4 * (1 - a->infinity)); /* r->x = X3 = 4*(R^2-Q) */
+ secp256k1_fe_mul_int(&r->y, 4 * (1 - a->infinity)); /* r->y = Y3 = 4*R*(3*Q-2*R^2)-4*M^4 (4) */
+
+ /** In case a->infinity == 1, the above code results in r->x, r->y, and r->z all equal to 0.
+ * Add b->x to x, b->y to y, and 1 to z in that case.
+ */
+ t = b->x; secp256k1_fe_mul_int(&t, a->infinity);
+ secp256k1_fe_add(&r->x, &t);
+ t = b->y; secp256k1_fe_mul_int(&t, a->infinity);
+ secp256k1_fe_add(&r->y, &t);
+ secp256k1_fe_set_int(&t, a->infinity);
+ secp256k1_fe_add(&r->z, &t);
+ r->infinity = infinity;
+}
+
+static void secp256k1_ge_to_storage(secp256k1_ge_storage_t *r, const secp256k1_ge_t *a) {
+ secp256k1_fe_t x, y;
+ VERIFY_CHECK(!a->infinity);
+ x = a->x;
+ secp256k1_fe_normalize(&x);
+ y = a->y;
+ secp256k1_fe_normalize(&y);
+ secp256k1_fe_to_storage(&r->x, &x);
+ secp256k1_fe_to_storage(&r->y, &y);
+}
+
+static void secp256k1_ge_from_storage(secp256k1_ge_t *r, const secp256k1_ge_storage_t *a) {
+ secp256k1_fe_from_storage(&r->x, &a->x);
+ secp256k1_fe_from_storage(&r->y, &a->y);
+ r->infinity = 0;
+}
+
+static SECP256K1_INLINE void secp256k1_ge_storage_cmov(secp256k1_ge_storage_t *r, const secp256k1_ge_storage_t *a, int flag) {
+ secp256k1_fe_storage_cmov(&r->x, &a->x, flag);
+ secp256k1_fe_storage_cmov(&r->y, &a->y, flag);
+}
+
+#ifdef USE_ENDOMORPHISM
+static void secp256k1_gej_mul_lambda(secp256k1_gej_t *r, const secp256k1_gej_t *a) {
+ static const secp256k1_fe_t beta = SECP256K1_FE_CONST(
+ 0x7ae96a2bul, 0x657c0710ul, 0x6e64479eul, 0xac3434e9ul,
+ 0x9cf04975ul, 0x12f58995ul, 0xc1396c28ul, 0x719501eeul
+ );
+ *r = *a;
+ secp256k1_fe_mul(&r->x, &r->x, &beta);
+}
+#endif
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/hash.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/hash.h
new file mode 100644
index 0000000000000000000000000000000000000000..843423d7f70ab6958ba5ef22d28fb92823d5e2eb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/hash.h
@@ -0,0 +1,41 @@
+/**********************************************************************
+ * Copyright (c) 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_HASH_
+#define _SECP256K1_HASH_
+
+#include <stdlib.h>
+#include <stdint.h>
+
+typedef struct {
+ uint32_t s[32];
+ uint32_t buf[16]; /* In big endian */
+ size_t bytes;
+} secp256k1_sha256_t;
+
+static void secp256k1_sha256_initialize(secp256k1_sha256_t *hash);
+static void secp256k1_sha256_write(secp256k1_sha256_t *hash, const unsigned char *data, size_t size);
+static void secp256k1_sha256_finalize(secp256k1_sha256_t *hash, unsigned char *out32);
+
+typedef struct {
+ secp256k1_sha256_t inner, outer;
+} secp256k1_hmac_sha256_t;
+
+static void secp256k1_hmac_sha256_initialize(secp256k1_hmac_sha256_t *hash, const unsigned char *key, size_t size);
+static void secp256k1_hmac_sha256_write(secp256k1_hmac_sha256_t *hash, const unsigned char *data, size_t size);
+static void secp256k1_hmac_sha256_finalize(secp256k1_hmac_sha256_t *hash, unsigned char *out32);
+
+typedef struct {
+ unsigned char v[32];
+ unsigned char k[32];
+ int retry;
+} secp256k1_rfc6979_hmac_sha256_t;
+
+static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha256_t *rng, const unsigned char *key, size_t keylen, const unsigned char *msg, size_t msglen, const unsigned char *rnd, size_t rndlen);
+static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hmac_sha256_t *rng, unsigned char *out, size_t outlen);
+static void secp256k1_rfc6979_hmac_sha256_finalize(secp256k1_rfc6979_hmac_sha256_t *rng);
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/hash_impl.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/hash_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..9828827bcdb2d872478b57e33a671e20ea906d2c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/hash_impl.h
@@ -0,0 +1,293 @@
+/**********************************************************************
+ * Copyright (c) 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_HASH_IMPL_H_
+#define _SECP256K1_HASH_IMPL_H_
+
+#include "hash.h"
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#define Ch(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
+#define Maj(x,y,z) (((x) & (y)) | ((z) & ((x) | (y))))
+#define Sigma0(x) (((x) >> 2 | (x) << 30) ^ ((x) >> 13 | (x) << 19) ^ ((x) >> 22 | (x) << 10))
+#define Sigma1(x) (((x) >> 6 | (x) << 26) ^ ((x) >> 11 | (x) << 21) ^ ((x) >> 25 | (x) << 7))
+#define sigma0(x) (((x) >> 7 | (x) << 25) ^ ((x) >> 18 | (x) << 14) ^ ((x) >> 3))
+#define sigma1(x) (((x) >> 17 | (x) << 15) ^ ((x) >> 19 | (x) << 13) ^ ((x) >> 10))
+
+#define Round(a,b,c,d,e,f,g,h,k,w) do { \
+ uint32_t t1 = (h) + Sigma1(e) + Ch((e), (f), (g)) + (k) + (w); \
+ uint32_t t2 = Sigma0(a) + Maj((a), (b), (c)); \
+ (d) += t1; \
+ (h) = t1 + t2; \
+} while(0)
+
+#ifdef WORDS_BIGENDIAN
+#define BE32(x) (x)
+#else
+#define BE32(p) ((((p) & 0xFF) << 24) | (((p) & 0xFF00) << 8) | (((p) & 0xFF0000) >> 8) | (((p) & 0xFF000000) >> 24))
+#endif
+
+static void secp256k1_sha256_initialize(secp256k1_sha256_t *hash) {
+ hash->s[0] = 0x6a09e667ul;
+ hash->s[1] = 0xbb67ae85ul;
+ hash->s[2] = 0x3c6ef372ul;
+ hash->s[3] = 0xa54ff53aul;
+ hash->s[4] = 0x510e527ful;
+ hash->s[5] = 0x9b05688cul;
+ hash->s[6] = 0x1f83d9abul;
+ hash->s[7] = 0x5be0cd19ul;
+ hash->bytes = 0;
+}
+
+/** Perform one SHA-256 transformation, processing 16 big endian 32-bit words. */
+static void secp256k1_sha256_transform(uint32_t* s, const uint32_t* chunk) {
+ uint32_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4], f = s[5], g = s[6], h = s[7];
+ uint32_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
+
+ Round(a, b, c, d, e, f, g, h, 0x428a2f98, w0 = BE32(chunk[0]));
+ Round(h, a, b, c, d, e, f, g, 0x71374491, w1 = BE32(chunk[1]));
+ Round(g, h, a, b, c, d, e, f, 0xb5c0fbcf, w2 = BE32(chunk[2]));
+ Round(f, g, h, a, b, c, d, e, 0xe9b5dba5, w3 = BE32(chunk[3]));
+ Round(e, f, g, h, a, b, c, d, 0x3956c25b, w4 = BE32(chunk[4]));
+ Round(d, e, f, g, h, a, b, c, 0x59f111f1, w5 = BE32(chunk[5]));
+ Round(c, d, e, f, g, h, a, b, 0x923f82a4, w6 = BE32(chunk[6]));
+ Round(b, c, d, e, f, g, h, a, 0xab1c5ed5, w7 = BE32(chunk[7]));
+ Round(a, b, c, d, e, f, g, h, 0xd807aa98, w8 = BE32(chunk[8]));
+ Round(h, a, b, c, d, e, f, g, 0x12835b01, w9 = BE32(chunk[9]));
+ Round(g, h, a, b, c, d, e, f, 0x243185be, w10 = BE32(chunk[10]));
+ Round(f, g, h, a, b, c, d, e, 0x550c7dc3, w11 = BE32(chunk[11]));
+ Round(e, f, g, h, a, b, c, d, 0x72be5d74, w12 = BE32(chunk[12]));
+ Round(d, e, f, g, h, a, b, c, 0x80deb1fe, w13 = BE32(chunk[13]));
+ Round(c, d, e, f, g, h, a, b, 0x9bdc06a7, w14 = BE32(chunk[14]));
+ Round(b, c, d, e, f, g, h, a, 0xc19bf174, w15 = BE32(chunk[15]));
+
+ Round(a, b, c, d, e, f, g, h, 0xe49b69c1, w0 += sigma1(w14) + w9 + sigma0(w1));
+ Round(h, a, b, c, d, e, f, g, 0xefbe4786, w1 += sigma1(w15) + w10 + sigma0(w2));
+ Round(g, h, a, b, c, d, e, f, 0x0fc19dc6, w2 += sigma1(w0) + w11 + sigma0(w3));
+ Round(f, g, h, a, b, c, d, e, 0x240ca1cc, w3 += sigma1(w1) + w12 + sigma0(w4));
+ Round(e, f, g, h, a, b, c, d, 0x2de92c6f, w4 += sigma1(w2) + w13 + sigma0(w5));
+ Round(d, e, f, g, h, a, b, c, 0x4a7484aa, w5 += sigma1(w3) + w14 + sigma0(w6));
+ Round(c, d, e, f, g, h, a, b, 0x5cb0a9dc, w6 += sigma1(w4) + w15 + sigma0(w7));
+ Round(b, c, d, e, f, g, h, a, 0x76f988da, w7 += sigma1(w5) + w0 + sigma0(w8));
+ Round(a, b, c, d, e, f, g, h, 0x983e5152, w8 += sigma1(w6) + w1 + sigma0(w9));
+ Round(h, a, b, c, d, e, f, g, 0xa831c66d, w9 += sigma1(w7) + w2 + sigma0(w10));
+ Round(g, h, a, b, c, d, e, f, 0xb00327c8, w10 += sigma1(w8) + w3 + sigma0(w11));
+ Round(f, g, h, a, b, c, d, e, 0xbf597fc7, w11 += sigma1(w9) + w4 + sigma0(w12));
+ Round(e, f, g, h, a, b, c, d, 0xc6e00bf3, w12 += sigma1(w10) + w5 + sigma0(w13));
+ Round(d, e, f, g, h, a, b, c, 0xd5a79147, w13 += sigma1(w11) + w6 + sigma0(w14));
+ Round(c, d, e, f, g, h, a, b, 0x06ca6351, w14 += sigma1(w12) + w7 + sigma0(w15));
+ Round(b, c, d, e, f, g, h, a, 0x14292967, w15 += sigma1(w13) + w8 + sigma0(w0));
+
+ Round(a, b, c, d, e, f, g, h, 0x27b70a85, w0 += sigma1(w14) + w9 + sigma0(w1));
+ Round(h, a, b, c, d, e, f, g, 0x2e1b2138, w1 += sigma1(w15) + w10 + sigma0(w2));
+ Round(g, h, a, b, c, d, e, f, 0x4d2c6dfc, w2 += sigma1(w0) + w11 + sigma0(w3));
+ Round(f, g, h, a, b, c, d, e, 0x53380d13, w3 += sigma1(w1) + w12 + sigma0(w4));
+ Round(e, f, g, h, a, b, c, d, 0x650a7354, w4 += sigma1(w2) + w13 + sigma0(w5));
+ Round(d, e, f, g, h, a, b, c, 0x766a0abb, w5 += sigma1(w3) + w14 + sigma0(w6));
+ Round(c, d, e, f, g, h, a, b, 0x81c2c92e, w6 += sigma1(w4) + w15 + sigma0(w7));
+ Round(b, c, d, e, f, g, h, a, 0x92722c85, w7 += sigma1(w5) + w0 + sigma0(w8));
+ Round(a, b, c, d, e, f, g, h, 0xa2bfe8a1, w8 += sigma1(w6) + w1 + sigma0(w9));
+ Round(h, a, b, c, d, e, f, g, 0xa81a664b, w9 += sigma1(w7) + w2 + sigma0(w10));
+ Round(g, h, a, b, c, d, e, f, 0xc24b8b70, w10 += sigma1(w8) + w3 + sigma0(w11));
+ Round(f, g, h, a, b, c, d, e, 0xc76c51a3, w11 += sigma1(w9) + w4 + sigma0(w12));
+ Round(e, f, g, h, a, b, c, d, 0xd192e819, w12 += sigma1(w10) + w5 + sigma0(w13));
+ Round(d, e, f, g, h, a, b, c, 0xd6990624, w13 += sigma1(w11) + w6 + sigma0(w14));
+ Round(c, d, e, f, g, h, a, b, 0xf40e3585, w14 += sigma1(w12) + w7 + sigma0(w15));
+ Round(b, c, d, e, f, g, h, a, 0x106aa070, w15 += sigma1(w13) + w8 + sigma0(w0));
+
+ Round(a, b, c, d, e, f, g, h, 0x19a4c116, w0 += sigma1(w14) + w9 + sigma0(w1));
+ Round(h, a, b, c, d, e, f, g, 0x1e376c08, w1 += sigma1(w15) + w10 + sigma0(w2));
+ Round(g, h, a, b, c, d, e, f, 0x2748774c, w2 += sigma1(w0) + w11 + sigma0(w3));
+ Round(f, g, h, a, b, c, d, e, 0x34b0bcb5, w3 += sigma1(w1) + w12 + sigma0(w4));
+ Round(e, f, g, h, a, b, c, d, 0x391c0cb3, w4 += sigma1(w2) + w13 + sigma0(w5));
+ Round(d, e, f, g, h, a, b, c, 0x4ed8aa4a, w5 += sigma1(w3) + w14 + sigma0(w6));
+ Round(c, d, e, f, g, h, a, b, 0x5b9cca4f, w6 += sigma1(w4) + w15 + sigma0(w7));
+ Round(b, c, d, e, f, g, h, a, 0x682e6ff3, w7 += sigma1(w5) + w0 + sigma0(w8));
+ Round(a, b, c, d, e, f, g, h, 0x748f82ee, w8 += sigma1(w6) + w1 + sigma0(w9));
+ Round(h, a, b, c, d, e, f, g, 0x78a5636f, w9 += sigma1(w7) + w2 + sigma0(w10));
+ Round(g, h, a, b, c, d, e, f, 0x84c87814, w10 += sigma1(w8) + w3 + sigma0(w11));
+ Round(f, g, h, a, b, c, d, e, 0x8cc70208, w11 += sigma1(w9) + w4 + sigma0(w12));
+ Round(e, f, g, h, a, b, c, d, 0x90befffa, w12 += sigma1(w10) + w5 + sigma0(w13));
+ Round(d, e, f, g, h, a, b, c, 0xa4506ceb, w13 += sigma1(w11) + w6 + sigma0(w14));
+ Round(c, d, e, f, g, h, a, b, 0xbef9a3f7, w14 + sigma1(w12) + w7 + sigma0(w15));
+ Round(b, c, d, e, f, g, h, a, 0xc67178f2, w15 + sigma1(w13) + w8 + sigma0(w0));
+
+ s[0] += a;
+ s[1] += b;
+ s[2] += c;
+ s[3] += d;
+ s[4] += e;
+ s[5] += f;
+ s[6] += g;
+ s[7] += h;
+}
+
+static void secp256k1_sha256_write(secp256k1_sha256_t *hash, const unsigned char *data, size_t len) {
+ size_t bufsize = hash->bytes & 0x3F;
+ hash->bytes += len;
+ while (bufsize + len >= 64) {
+ /* Fill the buffer, and process it. */
+ memcpy(((unsigned char*)hash->buf) + bufsize, data, 64 - bufsize);
+ data += 64 - bufsize;
+ len -= 64 - bufsize;
+ secp256k1_sha256_transform(hash->s, hash->buf);
+ bufsize = 0;
+ }
+ if (len) {
+ /* Fill the buffer with what remains. */
+ memcpy(((unsigned char*)hash->buf) + bufsize, data, len);
+ }
+}
+
+static void secp256k1_sha256_finalize(secp256k1_sha256_t *hash, unsigned char *out32) {
+ static const unsigned char pad[64] = {0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+ uint32_t sizedesc[2];
+ uint32_t out[8];
+ int i = 0;
+ sizedesc[0] = BE32(hash->bytes >> 29);
+ sizedesc[1] = BE32(hash->bytes << 3);
+ secp256k1_sha256_write(hash, pad, 1 + ((119 - (hash->bytes % 64)) % 64));
+ secp256k1_sha256_write(hash, (const unsigned char*)sizedesc, 8);
+ for (i = 0; i < 8; i++) {
+ out[i] = BE32(hash->s[i]);
+ hash->s[i] = 0;
+ }
+ memcpy(out32, (const unsigned char*)out, 32);
+}
+
+static void secp256k1_hmac_sha256_initialize(secp256k1_hmac_sha256_t *hash, const unsigned char *key, size_t keylen) {
+ int n;
+ unsigned char rkey[64];
+ if (keylen <= 64) {
+ memcpy(rkey, key, keylen);
+ memset(rkey + keylen, 0, 64 - keylen);
+ } else {
+ secp256k1_sha256_t sha256;
+ secp256k1_sha256_initialize(&sha256);
+ secp256k1_sha256_write(&sha256, key, keylen);
+ secp256k1_sha256_finalize(&sha256, rkey);
+ memset(rkey + 32, 0, 32);
+ }
+
+ secp256k1_sha256_initialize(&hash->outer);
+ for (n = 0; n < 64; n++) {
+ rkey[n] ^= 0x5c;
+ }
+ secp256k1_sha256_write(&hash->outer, rkey, 64);
+
+ secp256k1_sha256_initialize(&hash->inner);
+ for (n = 0; n < 64; n++) {
+ rkey[n] ^= 0x5c ^ 0x36;
+ }
+ secp256k1_sha256_write(&hash->inner, rkey, 64);
+ memset(rkey, 0, 64);
+}
+
+static void secp256k1_hmac_sha256_write(secp256k1_hmac_sha256_t *hash, const unsigned char *data, size_t size) {
+ secp256k1_sha256_write(&hash->inner, data, size);
+}
+
+static void secp256k1_hmac_sha256_finalize(secp256k1_hmac_sha256_t *hash, unsigned char *out32) {
+ unsigned char temp[32];
+ secp256k1_sha256_finalize(&hash->inner, temp);
+ secp256k1_sha256_write(&hash->outer, temp, 32);
+ memset(temp, 0, 32);
+ secp256k1_sha256_finalize(&hash->outer, out32);
+}
+
+
+static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha256_t *rng, const unsigned char *key, size_t keylen, const unsigned char *msg, size_t msglen, const unsigned char *rnd, size_t rndlen) {
+ secp256k1_hmac_sha256_t hmac;
+ static const unsigned char zero[1] = {0x00};
+ static const unsigned char one[1] = {0x01};
+
+ memset(rng->v, 0x01, 32); /* RFC6979 3.2.b. */
+ memset(rng->k, 0x00, 32); /* RFC6979 3.2.c. */
+
+ /* RFC6979 3.2.d. */
+ secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
+ secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
+ secp256k1_hmac_sha256_write(&hmac, zero, 1);
+ secp256k1_hmac_sha256_write(&hmac, key, keylen);
+ secp256k1_hmac_sha256_write(&hmac, msg, msglen);
+ if (rnd && rndlen) {
+ /* RFC6979 3.6 "Additional data". */
+ secp256k1_hmac_sha256_write(&hmac, rnd, rndlen);
+ }
+ secp256k1_hmac_sha256_finalize(&hmac, rng->k);
+ secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
+ secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
+ secp256k1_hmac_sha256_finalize(&hmac, rng->v);
+
+ /* RFC6979 3.2.f. */
+ secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
+ secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
+ secp256k1_hmac_sha256_write(&hmac, one, 1);
+ secp256k1_hmac_sha256_write(&hmac, key, keylen);
+ secp256k1_hmac_sha256_write(&hmac, msg, msglen);
+ if (rnd && rndlen) {
+ /* RFC6979 3.6 "Additional data". */
+ secp256k1_hmac_sha256_write(&hmac, rnd, rndlen);
+ }
+ secp256k1_hmac_sha256_finalize(&hmac, rng->k);
+ secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
+ secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
+ secp256k1_hmac_sha256_finalize(&hmac, rng->v);
+ rng->retry = 0;
+}
+
+static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hmac_sha256_t *rng, unsigned char *out, size_t outlen) {
+ /* RFC6979 3.2.h. */
+ static const unsigned char zero[1] = {0x00};
+ if (rng->retry) {
+ secp256k1_hmac_sha256_t hmac;
+ secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
+ secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
+ secp256k1_hmac_sha256_write(&hmac, zero, 1);
+ secp256k1_hmac_sha256_finalize(&hmac, rng->k);
+ secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
+ secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
+ secp256k1_hmac_sha256_finalize(&hmac, rng->v);
+ }
+
+ while (outlen > 0) {
+ secp256k1_hmac_sha256_t hmac;
+ int now = outlen;
+ secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
+ secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
+ secp256k1_hmac_sha256_finalize(&hmac, rng->v);
+ if (now > 32) {
+ now = 32;
+ }
+ memcpy(out, rng->v, now);
+ out += now;
+ outlen -= now;
+ }
+
+ rng->retry = 1;
+}
+
+static void secp256k1_rfc6979_hmac_sha256_finalize(secp256k1_rfc6979_hmac_sha256_t *rng) {
+ memset(rng->k, 0, 32);
+ memset(rng->v, 0, 32);
+ rng->retry = 0;
+}
+
+
+#undef Round
+#undef sigma0
+#undef sigma1
+#undef Sigma0
+#undef Sigma1
+#undef Ch
+#undef Maj
+#undef ReadBE32
+#undef WriteBE32
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/java/org/bitcoin/NativeSecp256k1.java b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/java/org/bitcoin/NativeSecp256k1.java
new file mode 100644
index 0000000000000000000000000000000000000000..90a498eaa2c40ba17b627a4406fc8af6521e2e0b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/java/org/bitcoin/NativeSecp256k1.java
@@ -0,0 +1,60 @@
+package org.bitcoin;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import com.google.common.base.Preconditions;
+
+
+/**
+ * This class holds native methods to handle ECDSA verification.
+ * You can find an example library that can be used for this at
+ * https://github.com/sipa/secp256k1
+ */
+public class NativeSecp256k1 {
+ public static final boolean enabled;
+ static {
+ boolean isEnabled = true;
+ try {
+ System.loadLibrary("javasecp256k1");
+ } catch (UnsatisfiedLinkError e) {
+ isEnabled = false;
+ }
+ enabled = isEnabled;
+ }
+
+ private static ThreadLocal<ByteBuffer> nativeECDSABuffer = new ThreadLocal<ByteBuffer>();
+ /**
+ * Verifies the given secp256k1 signature in native code.
+ * Calling when enabled == false is undefined (probably library not loaded)
+ *
+ * @param data The data which was signed, must be exactly 32 bytes
+ * @param signature The signature
+ * @param pub The public key which did the signing
+ */
+ public static boolean verify(byte[] data, byte[] signature, byte[] pub) {
+ Preconditions.checkArgument(data.length == 32 && signature.length <= 520 && pub.length <= 520);
+
+ ByteBuffer byteBuff = nativeECDSABuffer.get();
+ if (byteBuff == null) {
+ byteBuff = ByteBuffer.allocateDirect(32 + 8 + 520 + 520);
+ byteBuff.order(ByteOrder.nativeOrder());
+ nativeECDSABuffer.set(byteBuff);
+ }
+ byteBuff.rewind();
+ byteBuff.put(data);
+ byteBuff.putInt(signature.length);
+ byteBuff.putInt(pub.length);
+ byteBuff.put(signature);
+ byteBuff.put(pub);
+ return secp256k1_ecdsa_verify(byteBuff) == 1;
+ }
+
+ /**
+ * @param byteBuff signature format is byte[32] data,
+ * native-endian int signatureLength, native-endian int pubkeyLength,
+ * byte[signatureLength] signature, byte[pubkeyLength] pub
+ * @returns 1 for valid signature, anything else for invalid
+ */
+ private static native int secp256k1_ecdsa_verify(ByteBuffer byteBuff);
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/java/org_bitcoin_NativeSecp256k1.c b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/java/org_bitcoin_NativeSecp256k1.c
new file mode 100644
index 0000000000000000000000000000000000000000..bb4cd707280a68f1377e90f7a9d434e194bfa6db
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/java/org_bitcoin_NativeSecp256k1.c
@@ -0,0 +1,23 @@
+#include "org_bitcoin_NativeSecp256k1.h"
+#include "include/secp256k1.h"
+
+JNIEXPORT jint JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdsa_1verify
+ (JNIEnv* env, jclass classObject, jobject byteBufferObject)
+{
+ unsigned char* data = (unsigned char*) (*env)->GetDirectBufferAddress(env, byteBufferObject);
+ int sigLen = *((int*)(data + 32));
+ int pubLen = *((int*)(data + 32 + 4));
+
+ return secp256k1_ecdsa_verify(data, 32, data+32+8, sigLen, data+32+8+sigLen, pubLen);
+}
+
+static void __javasecp256k1_attach(void) __attribute__((constructor));
+static void __javasecp256k1_detach(void) __attribute__((destructor));
+
+static void __javasecp256k1_attach(void) {
+ secp256k1_start(SECP256K1_START_VERIFY);
+}
+
+static void __javasecp256k1_detach(void) {
+ secp256k1_stop();
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/java/org_bitcoin_NativeSecp256k1.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/java/org_bitcoin_NativeSecp256k1.h
new file mode 100644
index 0000000000000000000000000000000000000000..d7fb004fa841ede0fb2e919aa567d092e8fc2d5a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/java/org_bitcoin_NativeSecp256k1.h
@@ -0,0 +1,21 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class org_bitcoin_NativeSecp256k1 */
+
+#ifndef _Included_org_bitcoin_NativeSecp256k1
+#define _Included_org_bitcoin_NativeSecp256k1
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class: org_bitcoin_NativeSecp256k1
+ * Method: secp256k1_ecdsa_verify
+ * Signature: (Ljava/nio/ByteBuffer;)I
+ */
+JNIEXPORT jint JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdsa_1verify
+ (JNIEnv *, jclass, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/num.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/num.h
new file mode 100644
index 0000000000000000000000000000000000000000..339b6bb6ec2c2a2ee2d2d75473f2c1b44eaa9a3f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/num.h
@@ -0,0 +1,68 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_NUM_
+#define _SECP256K1_NUM_
+
+#ifndef USE_NUM_NONE
+
+#if defined HAVE_CONFIG_H
+#include "libsecp256k1-config.h"
+#endif
+
+#if defined(USE_NUM_GMP)
+#include "num_gmp.h"
+#else
+#error "Please select num implementation"
+#endif
+
+/** Copy a number. */
+static void secp256k1_num_copy(secp256k1_num_t *r, const secp256k1_num_t *a);
+
+/** Convert a number's absolute value to a binary big-endian string.
+ * There must be enough place. */
+static void secp256k1_num_get_bin(unsigned char *r, unsigned int rlen, const secp256k1_num_t *a);
+
+/** Set a number to the value of a binary big-endian string. */
+static void secp256k1_num_set_bin(secp256k1_num_t *r, const unsigned char *a, unsigned int alen);
+
+/** Compute a modular inverse. The input must be less than the modulus. */
+static void secp256k1_num_mod_inverse(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *m);
+
+/** Compare the absolute value of two numbers. */
+static int secp256k1_num_cmp(const secp256k1_num_t *a, const secp256k1_num_t *b);
+
+/** Test whether two number are equal (including sign). */
+static int secp256k1_num_eq(const secp256k1_num_t *a, const secp256k1_num_t *b);
+
+/** Add two (signed) numbers. */
+static void secp256k1_num_add(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b);
+
+/** Subtract two (signed) numbers. */
+static void secp256k1_num_sub(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b);
+
+/** Multiply two (signed) numbers. */
+static void secp256k1_num_mul(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b);
+
+/** Replace a number by its remainder modulo m. M's sign is ignored. The result is a number between 0 and m-1,
+ even if r was negative. */
+static void secp256k1_num_mod(secp256k1_num_t *r, const secp256k1_num_t *m);
+
+/** Right-shift the passed number by bits bits. */
+static void secp256k1_num_shift(secp256k1_num_t *r, int bits);
+
+/** Check whether a number is zero. */
+static int secp256k1_num_is_zero(const secp256k1_num_t *a);
+
+/** Check whether a number is strictly negative. */
+static int secp256k1_num_is_neg(const secp256k1_num_t *a);
+
+/** Change a number's sign. */
+static void secp256k1_num_negate(secp256k1_num_t *r);
+
+#endif
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/num_gmp.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/num_gmp.h
new file mode 100644
index 0000000000000000000000000000000000000000..baa1f2bf2e4d56260d15c570fe04f47f3c60141b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/num_gmp.h
@@ -0,0 +1,20 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_NUM_REPR_
+#define _SECP256K1_NUM_REPR_
+
+#include <gmp.h>
+
+#define NUM_LIMBS ((256+GMP_NUMB_BITS-1)/GMP_NUMB_BITS)
+
+typedef struct {
+ mp_limb_t data[2*NUM_LIMBS];
+ int neg;
+ int limbs;
+} secp256k1_num_t;
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/num_gmp_impl.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/num_gmp_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..dbbc458d5ddc7d1cea67a14e1678e9dc81881bf2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/num_gmp_impl.h
@@ -0,0 +1,260 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_NUM_REPR_IMPL_H_
+#define _SECP256K1_NUM_REPR_IMPL_H_
+
+#include <string.h>
+#include <stdlib.h>
+#include <gmp.h>
+
+#include "util.h"
+#include "num.h"
+
+#ifdef VERIFY
+static void secp256k1_num_sanity(const secp256k1_num_t *a) {
+ VERIFY_CHECK(a->limbs == 1 || (a->limbs > 1 && a->data[a->limbs-1] != 0));
+}
+#else
+#define secp256k1_num_sanity(a) do { } while(0)
+#endif
+
+static void secp256k1_num_copy(secp256k1_num_t *r, const secp256k1_num_t *a) {
+ *r = *a;
+}
+
+static void secp256k1_num_get_bin(unsigned char *r, unsigned int rlen, const secp256k1_num_t *a) {
+ unsigned char tmp[65];
+ int len = 0;
+ int shift = 0;
+ if (a->limbs>1 || a->data[0] != 0) {
+ len = mpn_get_str(tmp, 256, (mp_limb_t*)a->data, a->limbs);
+ }
+ while (shift < len && tmp[shift] == 0) shift++;
+ VERIFY_CHECK(len-shift <= (int)rlen);
+ memset(r, 0, rlen - len + shift);
+ if (len > shift) {
+ memcpy(r + rlen - len + shift, tmp + shift, len - shift);
+ }
+ memset(tmp, 0, sizeof(tmp));
+}
+
+static void secp256k1_num_set_bin(secp256k1_num_t *r, const unsigned char *a, unsigned int alen) {
+ int len;
+ VERIFY_CHECK(alen > 0);
+ VERIFY_CHECK(alen <= 64);
+ len = mpn_set_str(r->data, a, alen, 256);
+ if (len == 0) {
+ r->data[0] = 0;
+ len = 1;
+ }
+ VERIFY_CHECK(len <= NUM_LIMBS*2);
+ r->limbs = len;
+ r->neg = 0;
+ while (r->limbs > 1 && r->data[r->limbs-1]==0) {
+ r->limbs--;
+ }
+}
+
+static void secp256k1_num_add_abs(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b) {
+ mp_limb_t c = mpn_add(r->data, a->data, a->limbs, b->data, b->limbs);
+ r->limbs = a->limbs;
+ if (c != 0) {
+ VERIFY_CHECK(r->limbs < 2*NUM_LIMBS);
+ r->data[r->limbs++] = c;
+ }
+}
+
+static void secp256k1_num_sub_abs(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b) {
+ mp_limb_t c = mpn_sub(r->data, a->data, a->limbs, b->data, b->limbs);
+ VERIFY_CHECK(c == 0);
+ r->limbs = a->limbs;
+ while (r->limbs > 1 && r->data[r->limbs-1]==0) {
+ r->limbs--;
+ }
+}
+
+static void secp256k1_num_mod(secp256k1_num_t *r, const secp256k1_num_t *m) {
+ secp256k1_num_sanity(r);
+ secp256k1_num_sanity(m);
+
+ if (r->limbs >= m->limbs) {
+ mp_limb_t t[2*NUM_LIMBS];
+ mpn_tdiv_qr(t, r->data, 0, r->data, r->limbs, m->data, m->limbs);
+ memset(t, 0, sizeof(t));
+ r->limbs = m->limbs;
+ while (r->limbs > 1 && r->data[r->limbs-1]==0) {
+ r->limbs--;
+ }
+ }
+
+ if (r->neg && (r->limbs > 1 || r->data[0] != 0)) {
+ secp256k1_num_sub_abs(r, m, r);
+ r->neg = 0;
+ }
+}
+
+static void secp256k1_num_mod_inverse(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *m) {
+ int i;
+ mp_limb_t g[NUM_LIMBS+1];
+ mp_limb_t u[NUM_LIMBS+1];
+ mp_limb_t v[NUM_LIMBS+1];
+ mp_size_t sn;
+ mp_size_t gn;
+ secp256k1_num_sanity(a);
+ secp256k1_num_sanity(m);
+
+ /** mpn_gcdext computes: (G,S) = gcdext(U,V), where
+ * * G = gcd(U,V)
+ * * G = U*S + V*T
+ * * U has equal or more limbs than V, and V has no padding
+ * If we set U to be (a padded version of) a, and V = m:
+ * G = a*S + m*T
+ * G = a*S mod m
+ * Assuming G=1:
+ * S = 1/a mod m
+ */
+ VERIFY_CHECK(m->limbs <= NUM_LIMBS);
+ VERIFY_CHECK(m->data[m->limbs-1] != 0);
+ for (i = 0; i < m->limbs; i++) {
+ u[i] = (i < a->limbs) ? a->data[i] : 0;
+ v[i] = m->data[i];
+ }
+ sn = NUM_LIMBS+1;
+ gn = mpn_gcdext(g, r->data, &sn, u, m->limbs, v, m->limbs);
+ VERIFY_CHECK(gn == 1);
+ VERIFY_CHECK(g[0] == 1);
+ r->neg = a->neg ^ m->neg;
+ if (sn < 0) {
+ mpn_sub(r->data, m->data, m->limbs, r->data, -sn);
+ r->limbs = m->limbs;
+ while (r->limbs > 1 && r->data[r->limbs-1]==0) {
+ r->limbs--;
+ }
+ } else {
+ r->limbs = sn;
+ }
+ memset(g, 0, sizeof(g));
+ memset(u, 0, sizeof(u));
+ memset(v, 0, sizeof(v));
+}
+
+static int secp256k1_num_is_zero(const secp256k1_num_t *a) {
+ return (a->limbs == 1 && a->data[0] == 0);
+}
+
+static int secp256k1_num_is_neg(const secp256k1_num_t *a) {
+ return (a->limbs > 1 || a->data[0] != 0) && a->neg;
+}
+
+static int secp256k1_num_cmp(const secp256k1_num_t *a, const secp256k1_num_t *b) {
+ if (a->limbs > b->limbs) {
+ return 1;
+ }
+ if (a->limbs < b->limbs) {
+ return -1;
+ }
+ return mpn_cmp(a->data, b->data, a->limbs);
+}
+
+static int secp256k1_num_eq(const secp256k1_num_t *a, const secp256k1_num_t *b) {
+ if (a->limbs > b->limbs) {
+ return 0;
+ }
+ if (a->limbs < b->limbs) {
+ return 0;
+ }
+ if ((a->neg && !secp256k1_num_is_zero(a)) != (b->neg && !secp256k1_num_is_zero(b))) {
+ return 0;
+ }
+ return mpn_cmp(a->data, b->data, a->limbs) == 0;
+}
+
+static void secp256k1_num_subadd(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b, int bneg) {
+ if (!(b->neg ^ bneg ^ a->neg)) { /* a and b have the same sign */
+ r->neg = a->neg;
+ if (a->limbs >= b->limbs) {
+ secp256k1_num_add_abs(r, a, b);
+ } else {
+ secp256k1_num_add_abs(r, b, a);
+ }
+ } else {
+ if (secp256k1_num_cmp(a, b) > 0) {
+ r->neg = a->neg;
+ secp256k1_num_sub_abs(r, a, b);
+ } else {
+ r->neg = b->neg ^ bneg;
+ secp256k1_num_sub_abs(r, b, a);
+ }
+ }
+}
+
+static void secp256k1_num_add(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b) {
+ secp256k1_num_sanity(a);
+ secp256k1_num_sanity(b);
+ secp256k1_num_subadd(r, a, b, 0);
+}
+
+static void secp256k1_num_sub(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b) {
+ secp256k1_num_sanity(a);
+ secp256k1_num_sanity(b);
+ secp256k1_num_subadd(r, a, b, 1);
+}
+
+static void secp256k1_num_mul(secp256k1_num_t *r, const secp256k1_num_t *a, const secp256k1_num_t *b) {
+ mp_limb_t tmp[2*NUM_LIMBS+1];
+ secp256k1_num_sanity(a);
+ secp256k1_num_sanity(b);
+
+ VERIFY_CHECK(a->limbs + b->limbs <= 2*NUM_LIMBS+1);
+ if ((a->limbs==1 && a->data[0]==0) || (b->limbs==1 && b->data[0]==0)) {
+ r->limbs = 1;
+ r->neg = 0;
+ r->data[0] = 0;
+ return;
+ }
+ if (a->limbs >= b->limbs) {
+ mpn_mul(tmp, a->data, a->limbs, b->data, b->limbs);
+ } else {
+ mpn_mul(tmp, b->data, b->limbs, a->data, a->limbs);
+ }
+ r->limbs = a->limbs + b->limbs;
+ if (r->limbs > 1 && tmp[r->limbs - 1]==0) {
+ r->limbs--;
+ }
+ VERIFY_CHECK(r->limbs <= 2*NUM_LIMBS);
+ mpn_copyi(r->data, tmp, r->limbs);
+ r->neg = a->neg ^ b->neg;
+ memset(tmp, 0, sizeof(tmp));
+}
+
+static void secp256k1_num_shift(secp256k1_num_t *r, int bits) {
+ int i;
+ if (bits % GMP_NUMB_BITS) {
+ /* Shift within limbs. */
+ mpn_rshift(r->data, r->data, r->limbs, bits % GMP_NUMB_BITS);
+ }
+ if (bits >= GMP_NUMB_BITS) {
+ /* Shift full limbs. */
+ for (i = 0; i < r->limbs; i++) {
+ int index = i + (bits / GMP_NUMB_BITS);
+ if (index < r->limbs && index < 2*NUM_LIMBS) {
+ r->data[i] = r->data[index];
+ } else {
+ r->data[i] = 0;
+ }
+ }
+ }
+ while (r->limbs>1 && r->data[r->limbs-1]==0) {
+ r->limbs--;
+ }
+}
+
+static void secp256k1_num_negate(secp256k1_num_t *r) {
+ r->neg ^= 1;
+}
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/num_impl.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/num_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..0b0e3a072a15ac5ddd1575d1968578c0ffce9400
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/num_impl.h
@@ -0,0 +1,24 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_NUM_IMPL_H_
+#define _SECP256K1_NUM_IMPL_H_
+
+#if defined HAVE_CONFIG_H
+#include "libsecp256k1-config.h"
+#endif
+
+#include "num.h"
+
+#if defined(USE_NUM_GMP)
+#include "num_gmp_impl.h"
+#elif defined(USE_NUM_NONE)
+/* Nothing. */
+#else
+#error "Please select num implementation"
+#endif
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/scalar.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/scalar.h
new file mode 100644
index 0000000000000000000000000000000000000000..f5d09f8d474af52153d16108656176285c953e28
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/scalar.h
@@ -0,0 +1,93 @@
+/**********************************************************************
+ * Copyright (c) 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_SCALAR_
+#define _SECP256K1_SCALAR_
+
+#include "num.h"
+
+#if defined HAVE_CONFIG_H
+#include "libsecp256k1-config.h"
+#endif
+
+#if defined(USE_SCALAR_4X64)
+#include "scalar_4x64.h"
+#elif defined(USE_SCALAR_8X32)
+#include "scalar_8x32.h"
+#else
+#error "Please select scalar implementation"
+#endif
+
+/** Clear a scalar to prevent the leak of sensitive data. */
+static void secp256k1_scalar_clear(secp256k1_scalar_t *r);
+
+/** Access bits from a scalar. All requested bits must belong to the same 32-bit limb. */
+static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar_t *a, unsigned int offset, unsigned int count);
+
+/** Access bits from a scalar. Not constant time. */
+static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar_t *a, unsigned int offset, unsigned int count);
+
+/** Set a scalar from a big endian byte array. */
+static void secp256k1_scalar_set_b32(secp256k1_scalar_t *r, const unsigned char *bin, int *overflow);
+
+/** Set a scalar to an unsigned integer. */
+static void secp256k1_scalar_set_int(secp256k1_scalar_t *r, unsigned int v);
+
+/** Convert a scalar to a byte array. */
+static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar_t* a);
+
+/** Add two scalars together (modulo the group order). Returns whether it overflowed. */
+static int secp256k1_scalar_add(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b);
+
+/** Add a power of two to a scalar. The result is not allowed to overflow. */
+static void secp256k1_scalar_add_bit(secp256k1_scalar_t *r, unsigned int bit);
+
+/** Multiply two scalars (modulo the group order). */
+static void secp256k1_scalar_mul(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b);
+
+/** Compute the square of a scalar (modulo the group order). */
+static void secp256k1_scalar_sqr(secp256k1_scalar_t *r, const secp256k1_scalar_t *a);
+
+/** Compute the inverse of a scalar (modulo the group order). */
+static void secp256k1_scalar_inverse(secp256k1_scalar_t *r, const secp256k1_scalar_t *a);
+
+/** Compute the inverse of a scalar (modulo the group order), without constant-time guarantee. */
+static void secp256k1_scalar_inverse_var(secp256k1_scalar_t *r, const secp256k1_scalar_t *a);
+
+/** Compute the complement of a scalar (modulo the group order). */
+static void secp256k1_scalar_negate(secp256k1_scalar_t *r, const secp256k1_scalar_t *a);
+
+/** Check whether a scalar equals zero. */
+static int secp256k1_scalar_is_zero(const secp256k1_scalar_t *a);
+
+/** Check whether a scalar equals one. */
+static int secp256k1_scalar_is_one(const secp256k1_scalar_t *a);
+
+/** Check whether a scalar is higher than the group order divided by 2. */
+static int secp256k1_scalar_is_high(const secp256k1_scalar_t *a);
+
+#ifndef USE_NUM_NONE
+/** Convert a scalar to a number. */
+static void secp256k1_scalar_get_num(secp256k1_num_t *r, const secp256k1_scalar_t *a);
+
+/** Get the order of the group as a number. */
+static void secp256k1_scalar_order_get_num(secp256k1_num_t *r);
+#endif
+
+/** Compare two scalars. */
+static int secp256k1_scalar_eq(const secp256k1_scalar_t *a, const secp256k1_scalar_t *b);
+
+#ifdef USE_ENDOMORPHISM
+/** Find r1 and r2 such that r1+r2*2^128 = a. */
+static void secp256k1_scalar_split_128(secp256k1_scalar_t *r1, secp256k1_scalar_t *r2, const secp256k1_scalar_t *a);
+/** Find r1 and r2 such that r1+r2*lambda = a, and r1 and r2 are maximum 128 bits long (see secp256k1_gej_mul_lambda). */
+static void secp256k1_scalar_split_lambda_var(secp256k1_scalar_t *r1, secp256k1_scalar_t *r2, const secp256k1_scalar_t *a);
+#endif
+
+/** Multiply a and b (without taking the modulus!), divide by 2**shift, and round to the nearest integer. Shift must be at least 256. */
+static void secp256k1_scalar_mul_shift_var(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b, unsigned int shift);
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/scalar_4x64.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/scalar_4x64.h
new file mode 100644
index 0000000000000000000000000000000000000000..82899aa7b047ae8a5f4ce7d9bc2054b3045160d3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/scalar_4x64.h
@@ -0,0 +1,19 @@
+/**********************************************************************
+ * Copyright (c) 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_SCALAR_REPR_
+#define _SECP256K1_SCALAR_REPR_
+
+#include <stdint.h>
+
+/** A scalar modulo the group order of the secp256k1 curve. */
+typedef struct {
+ uint64_t d[4];
+} secp256k1_scalar_t;
+
+#define SECP256K1_SCALAR_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{((uint64_t)(d1)) << 32 | (d0), ((uint64_t)(d3)) << 32 | (d2), ((uint64_t)(d5)) << 32 | (d4), ((uint64_t)(d7)) << 32 | (d6)}}
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/scalar_4x64_impl.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/scalar_4x64_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..ff365292f86f0f2237e4948f0b11c52fac1881d9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/scalar_4x64_impl.h
@@ -0,0 +1,920 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_SCALAR_REPR_IMPL_H_
+#define _SECP256K1_SCALAR_REPR_IMPL_H_
+
+/* Limbs of the secp256k1 order. */
+#define SECP256K1_N_0 ((uint64_t)0xBFD25E8CD0364141ULL)
+#define SECP256K1_N_1 ((uint64_t)0xBAAEDCE6AF48A03BULL)
+#define SECP256K1_N_2 ((uint64_t)0xFFFFFFFFFFFFFFFEULL)
+#define SECP256K1_N_3 ((uint64_t)0xFFFFFFFFFFFFFFFFULL)
+
+/* Limbs of 2^256 minus the secp256k1 order. */
+#define SECP256K1_N_C_0 (~SECP256K1_N_0 + 1)
+#define SECP256K1_N_C_1 (~SECP256K1_N_1)
+#define SECP256K1_N_C_2 (1)
+
+/* Limbs of half the secp256k1 order. */
+#define SECP256K1_N_H_0 ((uint64_t)0xDFE92F46681B20A0ULL)
+#define SECP256K1_N_H_1 ((uint64_t)0x5D576E7357A4501DULL)
+#define SECP256K1_N_H_2 ((uint64_t)0xFFFFFFFFFFFFFFFFULL)
+#define SECP256K1_N_H_3 ((uint64_t)0x7FFFFFFFFFFFFFFFULL)
+
+SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar_t *r) {
+ r->d[0] = 0;
+ r->d[1] = 0;
+ r->d[2] = 0;
+ r->d[3] = 0;
+}
+
+SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar_t *r, unsigned int v) {
+ r->d[0] = v;
+ r->d[1] = 0;
+ r->d[2] = 0;
+ r->d[3] = 0;
+}
+
+SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar_t *a, unsigned int offset, unsigned int count) {
+ VERIFY_CHECK((offset + count - 1) >> 6 == offset >> 6);
+ return (a->d[offset >> 6] >> (offset & 0x3F)) & ((((uint64_t)1) << count) - 1);
+}
+
+SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar_t *a, unsigned int offset, unsigned int count) {
+ VERIFY_CHECK(count < 32);
+ VERIFY_CHECK(offset + count <= 256);
+ if ((offset + count - 1) >> 6 == offset >> 6) {
+ return secp256k1_scalar_get_bits(a, offset, count);
+ } else {
+ VERIFY_CHECK((offset >> 6) + 1 < 4);
+ return ((a->d[offset >> 6] >> (offset & 0x3F)) | (a->d[(offset >> 6) + 1] << (64 - (offset & 0x3F)))) & ((((uint64_t)1) << count) - 1);
+ }
+}
+
+SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp256k1_scalar_t *a) {
+ int yes = 0;
+ int no = 0;
+ no |= (a->d[3] < SECP256K1_N_3); /* No need for a > check. */
+ no |= (a->d[2] < SECP256K1_N_2);
+ yes |= (a->d[2] > SECP256K1_N_2) & ~no;
+ no |= (a->d[1] < SECP256K1_N_1);
+ yes |= (a->d[1] > SECP256K1_N_1) & ~no;
+ yes |= (a->d[0] >= SECP256K1_N_0) & ~no;
+ return yes;
+}
+
+SECP256K1_INLINE static int secp256k1_scalar_reduce(secp256k1_scalar_t *r, unsigned int overflow) {
+ uint128_t t;
+ VERIFY_CHECK(overflow <= 1);
+ t = (uint128_t)r->d[0] + overflow * SECP256K1_N_C_0;
+ r->d[0] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
+ t += (uint128_t)r->d[1] + overflow * SECP256K1_N_C_1;
+ r->d[1] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
+ t += (uint128_t)r->d[2] + overflow * SECP256K1_N_C_2;
+ r->d[2] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
+ t += (uint64_t)r->d[3];
+ r->d[3] = t & 0xFFFFFFFFFFFFFFFFULL;
+ return overflow;
+}
+
+static int secp256k1_scalar_add(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
+ int overflow;
+ uint128_t t = (uint128_t)a->d[0] + b->d[0];
+ r->d[0] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
+ t += (uint128_t)a->d[1] + b->d[1];
+ r->d[1] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
+ t += (uint128_t)a->d[2] + b->d[2];
+ r->d[2] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
+ t += (uint128_t)a->d[3] + b->d[3];
+ r->d[3] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
+ overflow = t + secp256k1_scalar_check_overflow(r);
+ VERIFY_CHECK(overflow == 0 || overflow == 1);
+ secp256k1_scalar_reduce(r, overflow);
+ return overflow;
+}
+
+static void secp256k1_scalar_add_bit(secp256k1_scalar_t *r, unsigned int bit) {
+ uint128_t t;
+ VERIFY_CHECK(bit < 256);
+ t = (uint128_t)r->d[0] + (((uint64_t)((bit >> 6) == 0)) << (bit & 0x3F));
+ r->d[0] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
+ t += (uint128_t)r->d[1] + (((uint64_t)((bit >> 6) == 1)) << (bit & 0x3F));
+ r->d[1] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
+ t += (uint128_t)r->d[2] + (((uint64_t)((bit >> 6) == 2)) << (bit & 0x3F));
+ r->d[2] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
+ t += (uint128_t)r->d[3] + (((uint64_t)((bit >> 6) == 3)) << (bit & 0x3F));
+ r->d[3] = t & 0xFFFFFFFFFFFFFFFFULL;
+#ifdef VERIFY
+ VERIFY_CHECK((t >> 64) == 0);
+ VERIFY_CHECK(secp256k1_scalar_check_overflow(r) == 0);
+#endif
+}
+
+static void secp256k1_scalar_set_b32(secp256k1_scalar_t *r, const unsigned char *b32, int *overflow) {
+ int over;
+ r->d[0] = (uint64_t)b32[31] | (uint64_t)b32[30] << 8 | (uint64_t)b32[29] << 16 | (uint64_t)b32[28] << 24 | (uint64_t)b32[27] << 32 | (uint64_t)b32[26] << 40 | (uint64_t)b32[25] << 48 | (uint64_t)b32[24] << 56;
+ r->d[1] = (uint64_t)b32[23] | (uint64_t)b32[22] << 8 | (uint64_t)b32[21] << 16 | (uint64_t)b32[20] << 24 | (uint64_t)b32[19] << 32 | (uint64_t)b32[18] << 40 | (uint64_t)b32[17] << 48 | (uint64_t)b32[16] << 56;
+ r->d[2] = (uint64_t)b32[15] | (uint64_t)b32[14] << 8 | (uint64_t)b32[13] << 16 | (uint64_t)b32[12] << 24 | (uint64_t)b32[11] << 32 | (uint64_t)b32[10] << 40 | (uint64_t)b32[9] << 48 | (uint64_t)b32[8] << 56;
+ r->d[3] = (uint64_t)b32[7] | (uint64_t)b32[6] << 8 | (uint64_t)b32[5] << 16 | (uint64_t)b32[4] << 24 | (uint64_t)b32[3] << 32 | (uint64_t)b32[2] << 40 | (uint64_t)b32[1] << 48 | (uint64_t)b32[0] << 56;
+ over = secp256k1_scalar_reduce(r, secp256k1_scalar_check_overflow(r));
+ if (overflow) {
+ *overflow = over;
+ }
+}
+
+static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar_t* a) {
+ bin[0] = a->d[3] >> 56; bin[1] = a->d[3] >> 48; bin[2] = a->d[3] >> 40; bin[3] = a->d[3] >> 32; bin[4] = a->d[3] >> 24; bin[5] = a->d[3] >> 16; bin[6] = a->d[3] >> 8; bin[7] = a->d[3];
+ bin[8] = a->d[2] >> 56; bin[9] = a->d[2] >> 48; bin[10] = a->d[2] >> 40; bin[11] = a->d[2] >> 32; bin[12] = a->d[2] >> 24; bin[13] = a->d[2] >> 16; bin[14] = a->d[2] >> 8; bin[15] = a->d[2];
+ bin[16] = a->d[1] >> 56; bin[17] = a->d[1] >> 48; bin[18] = a->d[1] >> 40; bin[19] = a->d[1] >> 32; bin[20] = a->d[1] >> 24; bin[21] = a->d[1] >> 16; bin[22] = a->d[1] >> 8; bin[23] = a->d[1];
+ bin[24] = a->d[0] >> 56; bin[25] = a->d[0] >> 48; bin[26] = a->d[0] >> 40; bin[27] = a->d[0] >> 32; bin[28] = a->d[0] >> 24; bin[29] = a->d[0] >> 16; bin[30] = a->d[0] >> 8; bin[31] = a->d[0];
+}
+
+SECP256K1_INLINE static int secp256k1_scalar_is_zero(const secp256k1_scalar_t *a) {
+ return (a->d[0] | a->d[1] | a->d[2] | a->d[3]) == 0;
+}
+
+static void secp256k1_scalar_negate(secp256k1_scalar_t *r, const secp256k1_scalar_t *a) {
+ uint64_t nonzero = 0xFFFFFFFFFFFFFFFFULL * (secp256k1_scalar_is_zero(a) == 0);
+ uint128_t t = (uint128_t)(~a->d[0]) + SECP256K1_N_0 + 1;
+ r->d[0] = t & nonzero; t >>= 64;
+ t += (uint128_t)(~a->d[1]) + SECP256K1_N_1;
+ r->d[1] = t & nonzero; t >>= 64;
+ t += (uint128_t)(~a->d[2]) + SECP256K1_N_2;
+ r->d[2] = t & nonzero; t >>= 64;
+ t += (uint128_t)(~a->d[3]) + SECP256K1_N_3;
+ r->d[3] = t & nonzero;
+}
+
+SECP256K1_INLINE static int secp256k1_scalar_is_one(const secp256k1_scalar_t *a) {
+ return ((a->d[0] ^ 1) | a->d[1] | a->d[2] | a->d[3]) == 0;
+}
+
+static int secp256k1_scalar_is_high(const secp256k1_scalar_t *a) {
+ int yes = 0;
+ int no = 0;
+ no |= (a->d[3] < SECP256K1_N_H_3);
+ yes |= (a->d[3] > SECP256K1_N_H_3) & ~no;
+ no |= (a->d[2] < SECP256K1_N_H_2) & ~yes; /* No need for a > check. */
+ no |= (a->d[1] < SECP256K1_N_H_1) & ~yes;
+ yes |= (a->d[1] > SECP256K1_N_H_1) & ~no;
+ yes |= (a->d[0] > SECP256K1_N_H_0) & ~no;
+ return yes;
+}
+
+/* Inspired by the macros in OpenSSL's crypto/bn/asm/x86_64-gcc.c. */
+
+/** Add a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
+#define muladd(a,b) { \
+ uint64_t tl, th; \
+ { \
+ uint128_t t = (uint128_t)a * b; \
+ th = t >> 64; /* at most 0xFFFFFFFFFFFFFFFE */ \
+ tl = t; \
+ } \
+ c0 += tl; /* overflow is handled on the next line */ \
+ th += (c0 < tl) ? 1 : 0; /* at most 0xFFFFFFFFFFFFFFFF */ \
+ c1 += th; /* overflow is handled on the next line */ \
+ c2 += (c1 < th) ? 1 : 0; /* never overflows by contract (verified in the next line) */ \
+ VERIFY_CHECK((c1 >= th) || (c2 != 0)); \
+}
+
+/** Add a*b to the number defined by (c0,c1). c1 must never overflow. */
+#define muladd_fast(a,b) { \
+ uint64_t tl, th; \
+ { \
+ uint128_t t = (uint128_t)a * b; \
+ th = t >> 64; /* at most 0xFFFFFFFFFFFFFFFE */ \
+ tl = t; \
+ } \
+ c0 += tl; /* overflow is handled on the next line */ \
+ th += (c0 < tl) ? 1 : 0; /* at most 0xFFFFFFFFFFFFFFFF */ \
+ c1 += th; /* never overflows by contract (verified in the next line) */ \
+ VERIFY_CHECK(c1 >= th); \
+}
+
+/** Add 2*a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
+#define muladd2(a,b) { \
+ uint64_t tl, th, th2, tl2; \
+ { \
+ uint128_t t = (uint128_t)a * b; \
+ th = t >> 64; /* at most 0xFFFFFFFFFFFFFFFE */ \
+ tl = t; \
+ } \
+ th2 = th + th; /* at most 0xFFFFFFFFFFFFFFFE (in case th was 0x7FFFFFFFFFFFFFFF) */ \
+ c2 += (th2 < th) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
+ VERIFY_CHECK((th2 >= th) || (c2 != 0)); \
+ tl2 = tl + tl; /* at most 0xFFFFFFFFFFFFFFFE (in case the lowest 63 bits of tl were 0x7FFFFFFFFFFFFFFF) */ \
+ th2 += (tl2 < tl) ? 1 : 0; /* at most 0xFFFFFFFFFFFFFFFF */ \
+ c0 += tl2; /* overflow is handled on the next line */ \
+ th2 += (c0 < tl2) ? 1 : 0; /* second overflow is handled on the next line */ \
+ c2 += (c0 < tl2) & (th2 == 0); /* never overflows by contract (verified the next line) */ \
+ VERIFY_CHECK((c0 >= tl2) || (th2 != 0) || (c2 != 0)); \
+ c1 += th2; /* overflow is handled on the next line */ \
+ c2 += (c1 < th2) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
+ VERIFY_CHECK((c1 >= th2) || (c2 != 0)); \
+}
+
+/** Add a to the number defined by (c0,c1,c2). c2 must never overflow. */
+#define sumadd(a) { \
+ unsigned int over; \
+ c0 += (a); /* overflow is handled on the next line */ \
+ over = (c0 < (a)) ? 1 : 0; \
+ c1 += over; /* overflow is handled on the next line */ \
+ c2 += (c1 < over) ? 1 : 0; /* never overflows by contract */ \
+}
+
+/** Add a to the number defined by (c0,c1). c1 must never overflow, c2 must be zero. */
+#define sumadd_fast(a) { \
+ c0 += (a); /* overflow is handled on the next line */ \
+ c1 += (c0 < (a)) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
+ VERIFY_CHECK((c1 != 0) | (c0 >= (a))); \
+ VERIFY_CHECK(c2 == 0); \
+}
+
+/** Extract the lowest 64 bits of (c0,c1,c2) into n, and left shift the number 64 bits. */
+#define extract(n) { \
+ (n) = c0; \
+ c0 = c1; \
+ c1 = c2; \
+ c2 = 0; \
+}
+
+/** Extract the lowest 64 bits of (c0,c1,c2) into n, and left shift the number 64 bits. c2 is required to be zero. */
+#define extract_fast(n) { \
+ (n) = c0; \
+ c0 = c1; \
+ c1 = 0; \
+ VERIFY_CHECK(c2 == 0); \
+}
+
+static void secp256k1_scalar_reduce_512(secp256k1_scalar_t *r, const uint64_t *l) {
+#ifdef USE_ASM_X86_64
+ /* Reduce 512 bits into 385. */
+ uint64_t m0, m1, m2, m3, m4, m5, m6;
+ uint64_t p0, p1, p2, p3, p4;
+ uint64_t c;
+
+ __asm__ __volatile__(
+ /* Preload. */
+ "movq 32(%%rsi), %%r11\n"
+ "movq 40(%%rsi), %%r12\n"
+ "movq 48(%%rsi), %%r13\n"
+ "movq 56(%%rsi), %%r14\n"
+ /* Initialize r8,r9,r10 */
+ "movq 0(%%rsi), %%r8\n"
+ "movq $0, %%r9\n"
+ "movq $0, %%r10\n"
+ /* (r8,r9) += n0 * c0 */
+ "movq %8, %%rax\n"
+ "mulq %%r11\n"
+ "addq %%rax, %%r8\n"
+ "adcq %%rdx, %%r9\n"
+ /* extract m0 */
+ "movq %%r8, %q0\n"
+ "movq $0, %%r8\n"
+ /* (r9,r10) += l1 */
+ "addq 8(%%rsi), %%r9\n"
+ "adcq $0, %%r10\n"
+ /* (r9,r10,r8) += n1 * c0 */
+ "movq %8, %%rax\n"
+ "mulq %%r12\n"
+ "addq %%rax, %%r9\n"
+ "adcq %%rdx, %%r10\n"
+ "adcq $0, %%r8\n"
+ /* (r9,r10,r8) += n0 * c1 */
+ "movq %9, %%rax\n"
+ "mulq %%r11\n"
+ "addq %%rax, %%r9\n"
+ "adcq %%rdx, %%r10\n"
+ "adcq $0, %%r8\n"
+ /* extract m1 */
+ "movq %%r9, %q1\n"
+ "movq $0, %%r9\n"
+ /* (r10,r8,r9) += l2 */
+ "addq 16(%%rsi), %%r10\n"
+ "adcq $0, %%r8\n"
+ "adcq $0, %%r9\n"
+ /* (r10,r8,r9) += n2 * c0 */
+ "movq %8, %%rax\n"
+ "mulq %%r13\n"
+ "addq %%rax, %%r10\n"
+ "adcq %%rdx, %%r8\n"
+ "adcq $0, %%r9\n"
+ /* (r10,r8,r9) += n1 * c1 */
+ "movq %9, %%rax\n"
+ "mulq %%r12\n"
+ "addq %%rax, %%r10\n"
+ "adcq %%rdx, %%r8\n"
+ "adcq $0, %%r9\n"
+ /* (r10,r8,r9) += n0 */
+ "addq %%r11, %%r10\n"
+ "adcq $0, %%r8\n"
+ "adcq $0, %%r9\n"
+ /* extract m2 */
+ "movq %%r10, %q2\n"
+ "movq $0, %%r10\n"
+ /* (r8,r9,r10) += l3 */
+ "addq 24(%%rsi), %%r8\n"
+ "adcq $0, %%r9\n"
+ "adcq $0, %%r10\n"
+ /* (r8,r9,r10) += n3 * c0 */
+ "movq %8, %%rax\n"
+ "mulq %%r14\n"
+ "addq %%rax, %%r8\n"
+ "adcq %%rdx, %%r9\n"
+ "adcq $0, %%r10\n"
+ /* (r8,r9,r10) += n2 * c1 */
+ "movq %9, %%rax\n"
+ "mulq %%r13\n"
+ "addq %%rax, %%r8\n"
+ "adcq %%rdx, %%r9\n"
+ "adcq $0, %%r10\n"
+ /* (r8,r9,r10) += n1 */
+ "addq %%r12, %%r8\n"
+ "adcq $0, %%r9\n"
+ "adcq $0, %%r10\n"
+ /* extract m3 */
+ "movq %%r8, %q3\n"
+ "movq $0, %%r8\n"
+ /* (r9,r10,r8) += n3 * c1 */
+ "movq %9, %%rax\n"
+ "mulq %%r14\n"
+ "addq %%rax, %%r9\n"
+ "adcq %%rdx, %%r10\n"
+ "adcq $0, %%r8\n"
+ /* (r9,r10,r8) += n2 */
+ "addq %%r13, %%r9\n"
+ "adcq $0, %%r10\n"
+ "adcq $0, %%r8\n"
+ /* extract m4 */
+ "movq %%r9, %q4\n"
+ /* (r10,r8) += n3 */
+ "addq %%r14, %%r10\n"
+ "adcq $0, %%r8\n"
+ /* extract m5 */
+ "movq %%r10, %q5\n"
+ /* extract m6 */
+ "movq %%r8, %q6\n"
+ : "=g"(m0), "=g"(m1), "=g"(m2), "=g"(m3), "=g"(m4), "=g"(m5), "=g"(m6)
+ : "S"(l), "n"(SECP256K1_N_C_0), "n"(SECP256K1_N_C_1)
+ : "rax", "rdx", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "cc");
+
+ /* Reduce 385 bits into 258. */
+ __asm__ __volatile__(
+ /* Preload */
+ "movq %q9, %%r11\n"
+ "movq %q10, %%r12\n"
+ "movq %q11, %%r13\n"
+ /* Initialize (r8,r9,r10) */
+ "movq %q5, %%r8\n"
+ "movq $0, %%r9\n"
+ "movq $0, %%r10\n"
+ /* (r8,r9) += m4 * c0 */
+ "movq %12, %%rax\n"
+ "mulq %%r11\n"
+ "addq %%rax, %%r8\n"
+ "adcq %%rdx, %%r9\n"
+ /* extract p0 */
+ "movq %%r8, %q0\n"
+ "movq $0, %%r8\n"
+ /* (r9,r10) += m1 */
+ "addq %q6, %%r9\n"
+ "adcq $0, %%r10\n"
+ /* (r9,r10,r8) += m5 * c0 */
+ "movq %12, %%rax\n"
+ "mulq %%r12\n"
+ "addq %%rax, %%r9\n"
+ "adcq %%rdx, %%r10\n"
+ "adcq $0, %%r8\n"
+ /* (r9,r10,r8) += m4 * c1 */
+ "movq %13, %%rax\n"
+ "mulq %%r11\n"
+ "addq %%rax, %%r9\n"
+ "adcq %%rdx, %%r10\n"
+ "adcq $0, %%r8\n"
+ /* extract p1 */
+ "movq %%r9, %q1\n"
+ "movq $0, %%r9\n"
+ /* (r10,r8,r9) += m2 */
+ "addq %q7, %%r10\n"
+ "adcq $0, %%r8\n"
+ "adcq $0, %%r9\n"
+ /* (r10,r8,r9) += m6 * c0 */
+ "movq %12, %%rax\n"
+ "mulq %%r13\n"
+ "addq %%rax, %%r10\n"
+ "adcq %%rdx, %%r8\n"
+ "adcq $0, %%r9\n"
+ /* (r10,r8,r9) += m5 * c1 */
+ "movq %13, %%rax\n"
+ "mulq %%r12\n"
+ "addq %%rax, %%r10\n"
+ "adcq %%rdx, %%r8\n"
+ "adcq $0, %%r9\n"
+ /* (r10,r8,r9) += m4 */
+ "addq %%r11, %%r10\n"
+ "adcq $0, %%r8\n"
+ "adcq $0, %%r9\n"
+ /* extract p2 */
+ "movq %%r10, %q2\n"
+ /* (r8,r9) += m3 */
+ "addq %q8, %%r8\n"
+ "adcq $0, %%r9\n"
+ /* (r8,r9) += m6 * c1 */
+ "movq %13, %%rax\n"
+ "mulq %%r13\n"
+ "addq %%rax, %%r8\n"
+ "adcq %%rdx, %%r9\n"
+ /* (r8,r9) += m5 */
+ "addq %%r12, %%r8\n"
+ "adcq $0, %%r9\n"
+ /* extract p3 */
+ "movq %%r8, %q3\n"
+ /* (r9) += m6 */
+ "addq %%r13, %%r9\n"
+ /* extract p4 */
+ "movq %%r9, %q4\n"
+ : "=&g"(p0), "=&g"(p1), "=&g"(p2), "=g"(p3), "=g"(p4)
+ : "g"(m0), "g"(m1), "g"(m2), "g"(m3), "g"(m4), "g"(m5), "g"(m6), "n"(SECP256K1_N_C_0), "n"(SECP256K1_N_C_1)
+ : "rax", "rdx", "r8", "r9", "r10", "r11", "r12", "r13", "cc");
+
+ /* Reduce 258 bits into 256. */
+ __asm__ __volatile__(
+ /* Preload */
+ "movq %q5, %%r10\n"
+ /* (rax,rdx) = p4 * c0 */
+ "movq %7, %%rax\n"
+ "mulq %%r10\n"
+ /* (rax,rdx) += p0 */
+ "addq %q1, %%rax\n"
+ "adcq $0, %%rdx\n"
+ /* extract r0 */
+ "movq %%rax, 0(%q6)\n"
+ /* Move to (r8,r9) */
+ "movq %%rdx, %%r8\n"
+ "movq $0, %%r9\n"
+ /* (r8,r9) += p1 */
+ "addq %q2, %%r8\n"
+ "adcq $0, %%r9\n"
+ /* (r8,r9) += p4 * c1 */
+ "movq %8, %%rax\n"
+ "mulq %%r10\n"
+ "addq %%rax, %%r8\n"
+ "adcq %%rdx, %%r9\n"
+ /* Extract r1 */
+ "movq %%r8, 8(%q6)\n"
+ "movq $0, %%r8\n"
+ /* (r9,r8) += p4 */
+ "addq %%r10, %%r9\n"
+ "adcq $0, %%r8\n"
+ /* (r9,r8) += p2 */
+ "addq %q3, %%r9\n"
+ "adcq $0, %%r8\n"
+ /* Extract r2 */
+ "movq %%r9, 16(%q6)\n"
+ "movq $0, %%r9\n"
+ /* (r8,r9) += p3 */
+ "addq %q4, %%r8\n"
+ "adcq $0, %%r9\n"
+ /* Extract r3 */
+ "movq %%r8, 24(%q6)\n"
+ /* Extract c */
+ "movq %%r9, %q0\n"
+ : "=g"(c)
+ : "g"(p0), "g"(p1), "g"(p2), "g"(p3), "g"(p4), "D"(r), "n"(SECP256K1_N_C_0), "n"(SECP256K1_N_C_1)
+ : "rax", "rdx", "r8", "r9", "r10", "cc", "memory");
+#else
+ uint128_t c;
+ uint64_t c0, c1, c2;
+ uint64_t n0 = l[4], n1 = l[5], n2 = l[6], n3 = l[7];
+ uint64_t m0, m1, m2, m3, m4, m5;
+ uint32_t m6;
+ uint64_t p0, p1, p2, p3;
+ uint32_t p4;
+
+ /* Reduce 512 bits into 385. */
+ /* m[0..6] = l[0..3] + n[0..3] * SECP256K1_N_C. */
+ c0 = l[0]; c1 = 0; c2 = 0;
+ muladd_fast(n0, SECP256K1_N_C_0);
+ extract_fast(m0);
+ sumadd_fast(l[1]);
+ muladd(n1, SECP256K1_N_C_0);
+ muladd(n0, SECP256K1_N_C_1);
+ extract(m1);
+ sumadd(l[2]);
+ muladd(n2, SECP256K1_N_C_0);
+ muladd(n1, SECP256K1_N_C_1);
+ sumadd(n0);
+ extract(m2);
+ sumadd(l[3]);
+ muladd(n3, SECP256K1_N_C_0);
+ muladd(n2, SECP256K1_N_C_1);
+ sumadd(n1);
+ extract(m3);
+ muladd(n3, SECP256K1_N_C_1);
+ sumadd(n2);
+ extract(m4);
+ sumadd_fast(n3);
+ extract_fast(m5);
+ VERIFY_CHECK(c0 <= 1);
+ m6 = c0;
+
+ /* Reduce 385 bits into 258. */
+ /* p[0..4] = m[0..3] + m[4..6] * SECP256K1_N_C. */
+ c0 = m0; c1 = 0; c2 = 0;
+ muladd_fast(m4, SECP256K1_N_C_0);
+ extract_fast(p0);
+ sumadd_fast(m1);
+ muladd(m5, SECP256K1_N_C_0);
+ muladd(m4, SECP256K1_N_C_1);
+ extract(p1);
+ sumadd(m2);
+ muladd(m6, SECP256K1_N_C_0);
+ muladd(m5, SECP256K1_N_C_1);
+ sumadd(m4);
+ extract(p2);
+ sumadd_fast(m3);
+ muladd_fast(m6, SECP256K1_N_C_1);
+ sumadd_fast(m5);
+ extract_fast(p3);
+ p4 = c0 + m6;
+ VERIFY_CHECK(p4 <= 2);
+
+ /* Reduce 258 bits into 256. */
+ /* r[0..3] = p[0..3] + p[4] * SECP256K1_N_C. */
+ c = p0 + (uint128_t)SECP256K1_N_C_0 * p4;
+ r->d[0] = c & 0xFFFFFFFFFFFFFFFFULL; c >>= 64;
+ c += p1 + (uint128_t)SECP256K1_N_C_1 * p4;
+ r->d[1] = c & 0xFFFFFFFFFFFFFFFFULL; c >>= 64;
+ c += p2 + (uint128_t)p4;
+ r->d[2] = c & 0xFFFFFFFFFFFFFFFFULL; c >>= 64;
+ c += p3;
+ r->d[3] = c & 0xFFFFFFFFFFFFFFFFULL; c >>= 64;
+#endif
+
+ /* Final reduction of r. */
+ secp256k1_scalar_reduce(r, c + secp256k1_scalar_check_overflow(r));
+}
+
+static void secp256k1_scalar_mul_512(uint64_t l[8], const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
+#ifdef USE_ASM_X86_64
+ const uint64_t *pb = b->d;
+ __asm__ __volatile__(
+ /* Preload */
+ "movq 0(%%rdi), %%r15\n"
+ "movq 8(%%rdi), %%rbx\n"
+ "movq 16(%%rdi), %%rcx\n"
+ "movq 0(%%rdx), %%r11\n"
+ "movq 8(%%rdx), %%r12\n"
+ "movq 16(%%rdx), %%r13\n"
+ "movq 24(%%rdx), %%r14\n"
+ /* (rax,rdx) = a0 * b0 */
+ "movq %%r15, %%rax\n"
+ "mulq %%r11\n"
+ /* Extract l0 */
+ "movq %%rax, 0(%%rsi)\n"
+ /* (r8,r9,r10) = (rdx) */
+ "movq %%rdx, %%r8\n"
+ "xorq %%r9, %%r9\n"
+ "xorq %%r10, %%r10\n"
+ /* (r8,r9,r10) += a0 * b1 */
+ "movq %%r15, %%rax\n"
+ "mulq %%r12\n"
+ "addq %%rax, %%r8\n"
+ "adcq %%rdx, %%r9\n"
+ "adcq $0, %%r10\n"
+ /* (r8,r9,r10) += a1 * b0 */
+ "movq %%rbx, %%rax\n"
+ "mulq %%r11\n"
+ "addq %%rax, %%r8\n"
+ "adcq %%rdx, %%r9\n"
+ "adcq $0, %%r10\n"
+ /* Extract l1 */
+ "movq %%r8, 8(%%rsi)\n"
+ "xorq %%r8, %%r8\n"
+ /* (r9,r10,r8) += a0 * b2 */
+ "movq %%r15, %%rax\n"
+ "mulq %%r13\n"
+ "addq %%rax, %%r9\n"
+ "adcq %%rdx, %%r10\n"
+ "adcq $0, %%r8\n"
+ /* (r9,r10,r8) += a1 * b1 */
+ "movq %%rbx, %%rax\n"
+ "mulq %%r12\n"
+ "addq %%rax, %%r9\n"
+ "adcq %%rdx, %%r10\n"
+ "adcq $0, %%r8\n"
+ /* (r9,r10,r8) += a2 * b0 */
+ "movq %%rcx, %%rax\n"
+ "mulq %%r11\n"
+ "addq %%rax, %%r9\n"
+ "adcq %%rdx, %%r10\n"
+ "adcq $0, %%r8\n"
+ /* Extract l2 */
+ "movq %%r9, 16(%%rsi)\n"
+ "xorq %%r9, %%r9\n"
+ /* (r10,r8,r9) += a0 * b3 */
+ "movq %%r15, %%rax\n"
+ "mulq %%r14\n"
+ "addq %%rax, %%r10\n"
+ "adcq %%rdx, %%r8\n"
+ "adcq $0, %%r9\n"
+ /* Preload a3 */
+ "movq 24(%%rdi), %%r15\n"
+ /* (r10,r8,r9) += a1 * b2 */
+ "movq %%rbx, %%rax\n"
+ "mulq %%r13\n"
+ "addq %%rax, %%r10\n"
+ "adcq %%rdx, %%r8\n"
+ "adcq $0, %%r9\n"
+ /* (r10,r8,r9) += a2 * b1 */
+ "movq %%rcx, %%rax\n"
+ "mulq %%r12\n"
+ "addq %%rax, %%r10\n"
+ "adcq %%rdx, %%r8\n"
+ "adcq $0, %%r9\n"
+ /* (r10,r8,r9) += a3 * b0 */
+ "movq %%r15, %%rax\n"
+ "mulq %%r11\n"
+ "addq %%rax, %%r10\n"
+ "adcq %%rdx, %%r8\n"
+ "adcq $0, %%r9\n"
+ /* Extract l3 */
+ "movq %%r10, 24(%%rsi)\n"
+ "xorq %%r10, %%r10\n"
+ /* (r8,r9,r10) += a1 * b3 */
+ "movq %%rbx, %%rax\n"
+ "mulq %%r14\n"
+ "addq %%rax, %%r8\n"
+ "adcq %%rdx, %%r9\n"
+ "adcq $0, %%r10\n"
+ /* (r8,r9,r10) += a2 * b2 */
+ "movq %%rcx, %%rax\n"
+ "mulq %%r13\n"
+ "addq %%rax, %%r8\n"
+ "adcq %%rdx, %%r9\n"
+ "adcq $0, %%r10\n"
+ /* (r8,r9,r10) += a3 * b1 */
+ "movq %%r15, %%rax\n"
+ "mulq %%r12\n"
+ "addq %%rax, %%r8\n"
+ "adcq %%rdx, %%r9\n"
+ "adcq $0, %%r10\n"
+ /* Extract l4 */
+ "movq %%r8, 32(%%rsi)\n"
+ "xorq %%r8, %%r8\n"
+ /* (r9,r10,r8) += a2 * b3 */
+ "movq %%rcx, %%rax\n"
+ "mulq %%r14\n"
+ "addq %%rax, %%r9\n"
+ "adcq %%rdx, %%r10\n"
+ "adcq $0, %%r8\n"
+ /* (r9,r10,r8) += a3 * b2 */
+ "movq %%r15, %%rax\n"
+ "mulq %%r13\n"
+ "addq %%rax, %%r9\n"
+ "adcq %%rdx, %%r10\n"
+ "adcq $0, %%r8\n"
+ /* Extract l5 */
+ "movq %%r9, 40(%%rsi)\n"
+ /* (r10,r8) += a3 * b3 */
+ "movq %%r15, %%rax\n"
+ "mulq %%r14\n"
+ "addq %%rax, %%r10\n"
+ "adcq %%rdx, %%r8\n"
+ /* Extract l6 */
+ "movq %%r10, 48(%%rsi)\n"
+ /* Extract l7 */
+ "movq %%r8, 56(%%rsi)\n"
+ : "+d"(pb)
+ : "S"(l), "D"(a->d)
+ : "rax", "rbx", "rcx", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", "cc", "memory");
+#else
+ /* 160 bit accumulator. */
+ uint64_t c0 = 0, c1 = 0;
+ uint32_t c2 = 0;
+
+ /* l[0..7] = a[0..3] * b[0..3]. */
+ muladd_fast(a->d[0], b->d[0]);
+ extract_fast(l[0]);
+ muladd(a->d[0], b->d[1]);
+ muladd(a->d[1], b->d[0]);
+ extract(l[1]);
+ muladd(a->d[0], b->d[2]);
+ muladd(a->d[1], b->d[1]);
+ muladd(a->d[2], b->d[0]);
+ extract(l[2]);
+ muladd(a->d[0], b->d[3]);
+ muladd(a->d[1], b->d[2]);
+ muladd(a->d[2], b->d[1]);
+ muladd(a->d[3], b->d[0]);
+ extract(l[3]);
+ muladd(a->d[1], b->d[3]);
+ muladd(a->d[2], b->d[2]);
+ muladd(a->d[3], b->d[1]);
+ extract(l[4]);
+ muladd(a->d[2], b->d[3]);
+ muladd(a->d[3], b->d[2]);
+ extract(l[5]);
+ muladd_fast(a->d[3], b->d[3]);
+ extract_fast(l[6]);
+ VERIFY_CHECK(c1 <= 0);
+ l[7] = c0;
+#endif
+}
+
+static void secp256k1_scalar_sqr_512(uint64_t l[8], const secp256k1_scalar_t *a) {
+#ifdef USE_ASM_X86_64
+ __asm__ __volatile__(
+ /* Preload */
+ "movq 0(%%rdi), %%r11\n"
+ "movq 8(%%rdi), %%r12\n"
+ "movq 16(%%rdi), %%r13\n"
+ "movq 24(%%rdi), %%r14\n"
+ /* (rax,rdx) = a0 * a0 */
+ "movq %%r11, %%rax\n"
+ "mulq %%r11\n"
+ /* Extract l0 */
+ "movq %%rax, 0(%%rsi)\n"
+ /* (r8,r9,r10) = (rdx,0) */
+ "movq %%rdx, %%r8\n"
+ "xorq %%r9, %%r9\n"
+ "xorq %%r10, %%r10\n"
+ /* (r8,r9,r10) += 2 * a0 * a1 */
+ "movq %%r11, %%rax\n"
+ "mulq %%r12\n"
+ "addq %%rax, %%r8\n"
+ "adcq %%rdx, %%r9\n"
+ "adcq $0, %%r10\n"
+ "addq %%rax, %%r8\n"
+ "adcq %%rdx, %%r9\n"
+ "adcq $0, %%r10\n"
+ /* Extract l1 */
+ "movq %%r8, 8(%%rsi)\n"
+ "xorq %%r8, %%r8\n"
+ /* (r9,r10,r8) += 2 * a0 * a2 */
+ "movq %%r11, %%rax\n"
+ "mulq %%r13\n"
+ "addq %%rax, %%r9\n"
+ "adcq %%rdx, %%r10\n"
+ "adcq $0, %%r8\n"
+ "addq %%rax, %%r9\n"
+ "adcq %%rdx, %%r10\n"
+ "adcq $0, %%r8\n"
+ /* (r9,r10,r8) += a1 * a1 */
+ "movq %%r12, %%rax\n"
+ "mulq %%r12\n"
+ "addq %%rax, %%r9\n"
+ "adcq %%rdx, %%r10\n"
+ "adcq $0, %%r8\n"
+ /* Extract l2 */
+ "movq %%r9, 16(%%rsi)\n"
+ "xorq %%r9, %%r9\n"
+ /* (r10,r8,r9) += 2 * a0 * a3 */
+ "movq %%r11, %%rax\n"
+ "mulq %%r14\n"
+ "addq %%rax, %%r10\n"
+ "adcq %%rdx, %%r8\n"
+ "adcq $0, %%r9\n"
+ "addq %%rax, %%r10\n"
+ "adcq %%rdx, %%r8\n"
+ "adcq $0, %%r9\n"
+ /* (r10,r8,r9) += 2 * a1 * a2 */
+ "movq %%r12, %%rax\n"
+ "mulq %%r13\n"
+ "addq %%rax, %%r10\n"
+ "adcq %%rdx, %%r8\n"
+ "adcq $0, %%r9\n"
+ "addq %%rax, %%r10\n"
+ "adcq %%rdx, %%r8\n"
+ "adcq $0, %%r9\n"
+ /* Extract l3 */
+ "movq %%r10, 24(%%rsi)\n"
+ "xorq %%r10, %%r10\n"
+ /* (r8,r9,r10) += 2 * a1 * a3 */
+ "movq %%r12, %%rax\n"
+ "mulq %%r14\n"
+ "addq %%rax, %%r8\n"
+ "adcq %%rdx, %%r9\n"
+ "adcq $0, %%r10\n"
+ "addq %%rax, %%r8\n"
+ "adcq %%rdx, %%r9\n"
+ "adcq $0, %%r10\n"
+ /* (r8,r9,r10) += a2 * a2 */
+ "movq %%r13, %%rax\n"
+ "mulq %%r13\n"
+ "addq %%rax, %%r8\n"
+ "adcq %%rdx, %%r9\n"
+ "adcq $0, %%r10\n"
+ /* Extract l4 */
+ "movq %%r8, 32(%%rsi)\n"
+ "xorq %%r8, %%r8\n"
+ /* (r9,r10,r8) += 2 * a2 * a3 */
+ "movq %%r13, %%rax\n"
+ "mulq %%r14\n"
+ "addq %%rax, %%r9\n"
+ "adcq %%rdx, %%r10\n"
+ "adcq $0, %%r8\n"
+ "addq %%rax, %%r9\n"
+ "adcq %%rdx, %%r10\n"
+ "adcq $0, %%r8\n"
+ /* Extract l5 */
+ "movq %%r9, 40(%%rsi)\n"
+ /* (r10,r8) += a3 * a3 */
+ "movq %%r14, %%rax\n"
+ "mulq %%r14\n"
+ "addq %%rax, %%r10\n"
+ "adcq %%rdx, %%r8\n"
+ /* Extract l6 */
+ "movq %%r10, 48(%%rsi)\n"
+ /* Extract l7 */
+ "movq %%r8, 56(%%rsi)\n"
+ :
+ : "S"(l), "D"(a->d)
+ : "rax", "rdx", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "cc", "memory");
+#else
+ /* 160 bit accumulator. */
+ uint64_t c0 = 0, c1 = 0;
+ uint32_t c2 = 0;
+
+ /* l[0..7] = a[0..3] * b[0..3]. */
+ muladd_fast(a->d[0], a->d[0]);
+ extract_fast(l[0]);
+ muladd2(a->d[0], a->d[1]);
+ extract(l[1]);
+ muladd2(a->d[0], a->d[2]);
+ muladd(a->d[1], a->d[1]);
+ extract(l[2]);
+ muladd2(a->d[0], a->d[3]);
+ muladd2(a->d[1], a->d[2]);
+ extract(l[3]);
+ muladd2(a->d[1], a->d[3]);
+ muladd(a->d[2], a->d[2]);
+ extract(l[4]);
+ muladd2(a->d[2], a->d[3]);
+ extract(l[5]);
+ muladd_fast(a->d[3], a->d[3]);
+ extract_fast(l[6]);
+ VERIFY_CHECK(c1 == 0);
+ l[7] = c0;
+#endif
+}
+
+#undef sumadd
+#undef sumadd_fast
+#undef muladd
+#undef muladd_fast
+#undef muladd2
+#undef extract
+#undef extract_fast
+
+static void secp256k1_scalar_mul(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
+ uint64_t l[8];
+ secp256k1_scalar_mul_512(l, a, b);
+ secp256k1_scalar_reduce_512(r, l);
+}
+
+static void secp256k1_scalar_sqr(secp256k1_scalar_t *r, const secp256k1_scalar_t *a) {
+ uint64_t l[8];
+ secp256k1_scalar_sqr_512(l, a);
+ secp256k1_scalar_reduce_512(r, l);
+}
+
+static void secp256k1_scalar_split_128(secp256k1_scalar_t *r1, secp256k1_scalar_t *r2, const secp256k1_scalar_t *a) {
+ r1->d[0] = a->d[0];
+ r1->d[1] = a->d[1];
+ r1->d[2] = 0;
+ r1->d[3] = 0;
+ r2->d[0] = a->d[2];
+ r2->d[1] = a->d[3];
+ r2->d[2] = 0;
+ r2->d[3] = 0;
+}
+
+SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
+ return ((a->d[0] ^ b->d[0]) | (a->d[1] ^ b->d[1]) | (a->d[2] ^ b->d[2]) | (a->d[3] ^ b->d[3])) == 0;
+}
+
+SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b, unsigned int shift) {
+ uint64_t l[8];
+ unsigned int shiftlimbs;
+ unsigned int shiftlow;
+ unsigned int shifthigh;
+ VERIFY_CHECK(shift >= 256);
+ secp256k1_scalar_mul_512(l, a, b);
+ shiftlimbs = shift >> 6;
+ shiftlow = shift & 0x3F;
+ shifthigh = 64 - shiftlow;
+ r->d[0] = shift < 512 ? (l[0 + shiftlimbs] >> shiftlow | (shift < 448 && shiftlow ? (l[1 + shiftlimbs] << shifthigh) : 0)) : 0;
+ r->d[1] = shift < 448 ? (l[1 + shiftlimbs] >> shiftlow | (shift < 384 && shiftlow ? (l[2 + shiftlimbs] << shifthigh) : 0)) : 0;
+ r->d[2] = shift < 384 ? (l[2 + shiftlimbs] >> shiftlow | (shift < 320 && shiftlow ? (l[3 + shiftlimbs] << shifthigh) : 0)) : 0;
+ r->d[3] = shift < 320 ? (l[3 + shiftlimbs] >> shiftlow) : 0;
+ if ((l[(shift - 1) >> 6] >> ((shift - 1) & 0x3f)) & 1) {
+ secp256k1_scalar_add_bit(r, 0);
+ }
+}
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/scalar_8x32.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/scalar_8x32.h
new file mode 100644
index 0000000000000000000000000000000000000000..f17017e24e202557990c94bb809233efcfb018c2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/scalar_8x32.h
@@ -0,0 +1,19 @@
+/**********************************************************************
+ * Copyright (c) 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_SCALAR_REPR_
+#define _SECP256K1_SCALAR_REPR_
+
+#include <stdint.h>
+
+/** A scalar modulo the group order of the secp256k1 curve. */
+typedef struct {
+ uint32_t d[8];
+} secp256k1_scalar_t;
+
+#define SECP256K1_SCALAR_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{(d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7)}}
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/scalar_8x32_impl.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/scalar_8x32_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..22b31d41125daeb942d2db22f80089856b611af1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/scalar_8x32_impl.h
@@ -0,0 +1,681 @@
+/**********************************************************************
+ * Copyright (c) 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_SCALAR_REPR_IMPL_H_
+#define _SECP256K1_SCALAR_REPR_IMPL_H_
+
+/* Limbs of the secp256k1 order. */
+#define SECP256K1_N_0 ((uint32_t)0xD0364141UL)
+#define SECP256K1_N_1 ((uint32_t)0xBFD25E8CUL)
+#define SECP256K1_N_2 ((uint32_t)0xAF48A03BUL)
+#define SECP256K1_N_3 ((uint32_t)0xBAAEDCE6UL)
+#define SECP256K1_N_4 ((uint32_t)0xFFFFFFFEUL)
+#define SECP256K1_N_5 ((uint32_t)0xFFFFFFFFUL)
+#define SECP256K1_N_6 ((uint32_t)0xFFFFFFFFUL)
+#define SECP256K1_N_7 ((uint32_t)0xFFFFFFFFUL)
+
+/* Limbs of 2^256 minus the secp256k1 order. */
+#define SECP256K1_N_C_0 (~SECP256K1_N_0 + 1)
+#define SECP256K1_N_C_1 (~SECP256K1_N_1)
+#define SECP256K1_N_C_2 (~SECP256K1_N_2)
+#define SECP256K1_N_C_3 (~SECP256K1_N_3)
+#define SECP256K1_N_C_4 (1)
+
+/* Limbs of half the secp256k1 order. */
+#define SECP256K1_N_H_0 ((uint32_t)0x681B20A0UL)
+#define SECP256K1_N_H_1 ((uint32_t)0xDFE92F46UL)
+#define SECP256K1_N_H_2 ((uint32_t)0x57A4501DUL)
+#define SECP256K1_N_H_3 ((uint32_t)0x5D576E73UL)
+#define SECP256K1_N_H_4 ((uint32_t)0xFFFFFFFFUL)
+#define SECP256K1_N_H_5 ((uint32_t)0xFFFFFFFFUL)
+#define SECP256K1_N_H_6 ((uint32_t)0xFFFFFFFFUL)
+#define SECP256K1_N_H_7 ((uint32_t)0x7FFFFFFFUL)
+
+SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar_t *r) {
+ r->d[0] = 0;
+ r->d[1] = 0;
+ r->d[2] = 0;
+ r->d[3] = 0;
+ r->d[4] = 0;
+ r->d[5] = 0;
+ r->d[6] = 0;
+ r->d[7] = 0;
+}
+
+SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar_t *r, unsigned int v) {
+ r->d[0] = v;
+ r->d[1] = 0;
+ r->d[2] = 0;
+ r->d[3] = 0;
+ r->d[4] = 0;
+ r->d[5] = 0;
+ r->d[6] = 0;
+ r->d[7] = 0;
+}
+
+SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar_t *a, unsigned int offset, unsigned int count) {
+ VERIFY_CHECK((offset + count - 1) >> 5 == offset >> 5);
+ return (a->d[offset >> 5] >> (offset & 0x1F)) & ((1 << count) - 1);
+}
+
+SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar_t *a, unsigned int offset, unsigned int count) {
+ VERIFY_CHECK(count < 32);
+ VERIFY_CHECK(offset + count <= 256);
+ if ((offset + count - 1) >> 5 == offset >> 5) {
+ return secp256k1_scalar_get_bits(a, offset, count);
+ } else {
+ VERIFY_CHECK((offset >> 5) + 1 < 8);
+ return ((a->d[offset >> 5] >> (offset & 0x1F)) | (a->d[(offset >> 5) + 1] << (32 - (offset & 0x1F)))) & ((((uint32_t)1) << count) - 1);
+ }
+}
+
+SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp256k1_scalar_t *a) {
+ int yes = 0;
+ int no = 0;
+ no |= (a->d[7] < SECP256K1_N_7); /* No need for a > check. */
+ no |= (a->d[6] < SECP256K1_N_6); /* No need for a > check. */
+ no |= (a->d[5] < SECP256K1_N_5); /* No need for a > check. */
+ no |= (a->d[4] < SECP256K1_N_4);
+ yes |= (a->d[4] > SECP256K1_N_4) & ~no;
+ no |= (a->d[3] < SECP256K1_N_3) & ~yes;
+ yes |= (a->d[3] > SECP256K1_N_3) & ~no;
+ no |= (a->d[2] < SECP256K1_N_2) & ~yes;
+ yes |= (a->d[2] > SECP256K1_N_2) & ~no;
+ no |= (a->d[1] < SECP256K1_N_1) & ~yes;
+ yes |= (a->d[1] > SECP256K1_N_1) & ~no;
+ yes |= (a->d[0] >= SECP256K1_N_0) & ~no;
+ return yes;
+}
+
+SECP256K1_INLINE static int secp256k1_scalar_reduce(secp256k1_scalar_t *r, uint32_t overflow) {
+ uint64_t t;
+ VERIFY_CHECK(overflow <= 1);
+ t = (uint64_t)r->d[0] + overflow * SECP256K1_N_C_0;
+ r->d[0] = t & 0xFFFFFFFFUL; t >>= 32;
+ t += (uint64_t)r->d[1] + overflow * SECP256K1_N_C_1;
+ r->d[1] = t & 0xFFFFFFFFUL; t >>= 32;
+ t += (uint64_t)r->d[2] + overflow * SECP256K1_N_C_2;
+ r->d[2] = t & 0xFFFFFFFFUL; t >>= 32;
+ t += (uint64_t)r->d[3] + overflow * SECP256K1_N_C_3;
+ r->d[3] = t & 0xFFFFFFFFUL; t >>= 32;
+ t += (uint64_t)r->d[4] + overflow * SECP256K1_N_C_4;
+ r->d[4] = t & 0xFFFFFFFFUL; t >>= 32;
+ t += (uint64_t)r->d[5];
+ r->d[5] = t & 0xFFFFFFFFUL; t >>= 32;
+ t += (uint64_t)r->d[6];
+ r->d[6] = t & 0xFFFFFFFFUL; t >>= 32;
+ t += (uint64_t)r->d[7];
+ r->d[7] = t & 0xFFFFFFFFUL;
+ return overflow;
+}
+
+static int secp256k1_scalar_add(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
+ int overflow;
+ uint64_t t = (uint64_t)a->d[0] + b->d[0];
+ r->d[0] = t & 0xFFFFFFFFULL; t >>= 32;
+ t += (uint64_t)a->d[1] + b->d[1];
+ r->d[1] = t & 0xFFFFFFFFULL; t >>= 32;
+ t += (uint64_t)a->d[2] + b->d[2];
+ r->d[2] = t & 0xFFFFFFFFULL; t >>= 32;
+ t += (uint64_t)a->d[3] + b->d[3];
+ r->d[3] = t & 0xFFFFFFFFULL; t >>= 32;
+ t += (uint64_t)a->d[4] + b->d[4];
+ r->d[4] = t & 0xFFFFFFFFULL; t >>= 32;
+ t += (uint64_t)a->d[5] + b->d[5];
+ r->d[5] = t & 0xFFFFFFFFULL; t >>= 32;
+ t += (uint64_t)a->d[6] + b->d[6];
+ r->d[6] = t & 0xFFFFFFFFULL; t >>= 32;
+ t += (uint64_t)a->d[7] + b->d[7];
+ r->d[7] = t & 0xFFFFFFFFULL; t >>= 32;
+ overflow = t + secp256k1_scalar_check_overflow(r);
+ VERIFY_CHECK(overflow == 0 || overflow == 1);
+ secp256k1_scalar_reduce(r, overflow);
+ return overflow;
+}
+
+static void secp256k1_scalar_add_bit(secp256k1_scalar_t *r, unsigned int bit) {
+ uint64_t t;
+ VERIFY_CHECK(bit < 256);
+ t = (uint64_t)r->d[0] + (((uint32_t)((bit >> 5) == 0)) << (bit & 0x1F));
+ r->d[0] = t & 0xFFFFFFFFULL; t >>= 32;
+ t += (uint64_t)r->d[1] + (((uint32_t)((bit >> 5) == 1)) << (bit & 0x1F));
+ r->d[1] = t & 0xFFFFFFFFULL; t >>= 32;
+ t += (uint64_t)r->d[2] + (((uint32_t)((bit >> 5) == 2)) << (bit & 0x1F));
+ r->d[2] = t & 0xFFFFFFFFULL; t >>= 32;
+ t += (uint64_t)r->d[3] + (((uint32_t)((bit >> 5) == 3)) << (bit & 0x1F));
+ r->d[3] = t & 0xFFFFFFFFULL; t >>= 32;
+ t += (uint64_t)r->d[4] + (((uint32_t)((bit >> 5) == 4)) << (bit & 0x1F));
+ r->d[4] = t & 0xFFFFFFFFULL; t >>= 32;
+ t += (uint64_t)r->d[5] + (((uint32_t)((bit >> 5) == 5)) << (bit & 0x1F));
+ r->d[5] = t & 0xFFFFFFFFULL; t >>= 32;
+ t += (uint64_t)r->d[6] + (((uint32_t)((bit >> 5) == 6)) << (bit & 0x1F));
+ r->d[6] = t & 0xFFFFFFFFULL; t >>= 32;
+ t += (uint64_t)r->d[7] + (((uint32_t)((bit >> 5) == 7)) << (bit & 0x1F));
+ r->d[7] = t & 0xFFFFFFFFULL;
+#ifdef VERIFY
+ VERIFY_CHECK((t >> 32) == 0);
+ VERIFY_CHECK(secp256k1_scalar_check_overflow(r) == 0);
+#endif
+}
+
+static void secp256k1_scalar_set_b32(secp256k1_scalar_t *r, const unsigned char *b32, int *overflow) {
+ int over;
+ r->d[0] = (uint32_t)b32[31] | (uint32_t)b32[30] << 8 | (uint32_t)b32[29] << 16 | (uint32_t)b32[28] << 24;
+ r->d[1] = (uint32_t)b32[27] | (uint32_t)b32[26] << 8 | (uint32_t)b32[25] << 16 | (uint32_t)b32[24] << 24;
+ r->d[2] = (uint32_t)b32[23] | (uint32_t)b32[22] << 8 | (uint32_t)b32[21] << 16 | (uint32_t)b32[20] << 24;
+ r->d[3] = (uint32_t)b32[19] | (uint32_t)b32[18] << 8 | (uint32_t)b32[17] << 16 | (uint32_t)b32[16] << 24;
+ r->d[4] = (uint32_t)b32[15] | (uint32_t)b32[14] << 8 | (uint32_t)b32[13] << 16 | (uint32_t)b32[12] << 24;
+ r->d[5] = (uint32_t)b32[11] | (uint32_t)b32[10] << 8 | (uint32_t)b32[9] << 16 | (uint32_t)b32[8] << 24;
+ r->d[6] = (uint32_t)b32[7] | (uint32_t)b32[6] << 8 | (uint32_t)b32[5] << 16 | (uint32_t)b32[4] << 24;
+ r->d[7] = (uint32_t)b32[3] | (uint32_t)b32[2] << 8 | (uint32_t)b32[1] << 16 | (uint32_t)b32[0] << 24;
+ over = secp256k1_scalar_reduce(r, secp256k1_scalar_check_overflow(r));
+ if (overflow) {
+ *overflow = over;
+ }
+}
+
+static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar_t* a) {
+ bin[0] = a->d[7] >> 24; bin[1] = a->d[7] >> 16; bin[2] = a->d[7] >> 8; bin[3] = a->d[7];
+ bin[4] = a->d[6] >> 24; bin[5] = a->d[6] >> 16; bin[6] = a->d[6] >> 8; bin[7] = a->d[6];
+ bin[8] = a->d[5] >> 24; bin[9] = a->d[5] >> 16; bin[10] = a->d[5] >> 8; bin[11] = a->d[5];
+ bin[12] = a->d[4] >> 24; bin[13] = a->d[4] >> 16; bin[14] = a->d[4] >> 8; bin[15] = a->d[4];
+ bin[16] = a->d[3] >> 24; bin[17] = a->d[3] >> 16; bin[18] = a->d[3] >> 8; bin[19] = a->d[3];
+ bin[20] = a->d[2] >> 24; bin[21] = a->d[2] >> 16; bin[22] = a->d[2] >> 8; bin[23] = a->d[2];
+ bin[24] = a->d[1] >> 24; bin[25] = a->d[1] >> 16; bin[26] = a->d[1] >> 8; bin[27] = a->d[1];
+ bin[28] = a->d[0] >> 24; bin[29] = a->d[0] >> 16; bin[30] = a->d[0] >> 8; bin[31] = a->d[0];
+}
+
+SECP256K1_INLINE static int secp256k1_scalar_is_zero(const secp256k1_scalar_t *a) {
+ return (a->d[0] | a->d[1] | a->d[2] | a->d[3] | a->d[4] | a->d[5] | a->d[6] | a->d[7]) == 0;
+}
+
+static void secp256k1_scalar_negate(secp256k1_scalar_t *r, const secp256k1_scalar_t *a) {
+ uint32_t nonzero = 0xFFFFFFFFUL * (secp256k1_scalar_is_zero(a) == 0);
+ uint64_t t = (uint64_t)(~a->d[0]) + SECP256K1_N_0 + 1;
+ r->d[0] = t & nonzero; t >>= 32;
+ t += (uint64_t)(~a->d[1]) + SECP256K1_N_1;
+ r->d[1] = t & nonzero; t >>= 32;
+ t += (uint64_t)(~a->d[2]) + SECP256K1_N_2;
+ r->d[2] = t & nonzero; t >>= 32;
+ t += (uint64_t)(~a->d[3]) + SECP256K1_N_3;
+ r->d[3] = t & nonzero; t >>= 32;
+ t += (uint64_t)(~a->d[4]) + SECP256K1_N_4;
+ r->d[4] = t & nonzero; t >>= 32;
+ t += (uint64_t)(~a->d[5]) + SECP256K1_N_5;
+ r->d[5] = t & nonzero; t >>= 32;
+ t += (uint64_t)(~a->d[6]) + SECP256K1_N_6;
+ r->d[6] = t & nonzero; t >>= 32;
+ t += (uint64_t)(~a->d[7]) + SECP256K1_N_7;
+ r->d[7] = t & nonzero;
+}
+
+SECP256K1_INLINE static int secp256k1_scalar_is_one(const secp256k1_scalar_t *a) {
+ return ((a->d[0] ^ 1) | a->d[1] | a->d[2] | a->d[3] | a->d[4] | a->d[5] | a->d[6] | a->d[7]) == 0;
+}
+
+static int secp256k1_scalar_is_high(const secp256k1_scalar_t *a) {
+ int yes = 0;
+ int no = 0;
+ no |= (a->d[7] < SECP256K1_N_H_7);
+ yes |= (a->d[7] > SECP256K1_N_H_7) & ~no;
+ no |= (a->d[6] < SECP256K1_N_H_6) & ~yes; /* No need for a > check. */
+ no |= (a->d[5] < SECP256K1_N_H_5) & ~yes; /* No need for a > check. */
+ no |= (a->d[4] < SECP256K1_N_H_4) & ~yes; /* No need for a > check. */
+ no |= (a->d[3] < SECP256K1_N_H_3) & ~yes;
+ yes |= (a->d[3] > SECP256K1_N_H_3) & ~no;
+ no |= (a->d[2] < SECP256K1_N_H_2) & ~yes;
+ yes |= (a->d[2] > SECP256K1_N_H_2) & ~no;
+ no |= (a->d[1] < SECP256K1_N_H_1) & ~yes;
+ yes |= (a->d[1] > SECP256K1_N_H_1) & ~no;
+ yes |= (a->d[0] > SECP256K1_N_H_0) & ~no;
+ return yes;
+}
+
+/* Inspired by the macros in OpenSSL's crypto/bn/asm/x86_64-gcc.c. */
+
+/** Add a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
+#define muladd(a,b) { \
+ uint32_t tl, th; \
+ { \
+ uint64_t t = (uint64_t)a * b; \
+ th = t >> 32; /* at most 0xFFFFFFFE */ \
+ tl = t; \
+ } \
+ c0 += tl; /* overflow is handled on the next line */ \
+ th += (c0 < tl) ? 1 : 0; /* at most 0xFFFFFFFF */ \
+ c1 += th; /* overflow is handled on the next line */ \
+ c2 += (c1 < th) ? 1 : 0; /* never overflows by contract (verified in the next line) */ \
+ VERIFY_CHECK((c1 >= th) || (c2 != 0)); \
+}
+
+/** Add a*b to the number defined by (c0,c1). c1 must never overflow. */
+#define muladd_fast(a,b) { \
+ uint32_t tl, th; \
+ { \
+ uint64_t t = (uint64_t)a * b; \
+ th = t >> 32; /* at most 0xFFFFFFFE */ \
+ tl = t; \
+ } \
+ c0 += tl; /* overflow is handled on the next line */ \
+ th += (c0 < tl) ? 1 : 0; /* at most 0xFFFFFFFF */ \
+ c1 += th; /* never overflows by contract (verified in the next line) */ \
+ VERIFY_CHECK(c1 >= th); \
+}
+
+/** Add 2*a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
+#define muladd2(a,b) { \
+ uint32_t tl, th, th2, tl2; \
+ { \
+ uint64_t t = (uint64_t)a * b; \
+ th = t >> 32; /* at most 0xFFFFFFFE */ \
+ tl = t; \
+ } \
+ th2 = th + th; /* at most 0xFFFFFFFE (in case th was 0x7FFFFFFF) */ \
+ c2 += (th2 < th) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
+ VERIFY_CHECK((th2 >= th) || (c2 != 0)); \
+ tl2 = tl + tl; /* at most 0xFFFFFFFE (in case the lowest 63 bits of tl were 0x7FFFFFFF) */ \
+ th2 += (tl2 < tl) ? 1 : 0; /* at most 0xFFFFFFFF */ \
+ c0 += tl2; /* overflow is handled on the next line */ \
+ th2 += (c0 < tl2) ? 1 : 0; /* second overflow is handled on the next line */ \
+ c2 += (c0 < tl2) & (th2 == 0); /* never overflows by contract (verified the next line) */ \
+ VERIFY_CHECK((c0 >= tl2) || (th2 != 0) || (c2 != 0)); \
+ c1 += th2; /* overflow is handled on the next line */ \
+ c2 += (c1 < th2) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
+ VERIFY_CHECK((c1 >= th2) || (c2 != 0)); \
+}
+
+/** Add a to the number defined by (c0,c1,c2). c2 must never overflow. */
+#define sumadd(a) { \
+ unsigned int over; \
+ c0 += (a); /* overflow is handled on the next line */ \
+ over = (c0 < (a)) ? 1 : 0; \
+ c1 += over; /* overflow is handled on the next line */ \
+ c2 += (c1 < over) ? 1 : 0; /* never overflows by contract */ \
+}
+
+/** Add a to the number defined by (c0,c1). c1 must never overflow, c2 must be zero. */
+#define sumadd_fast(a) { \
+ c0 += (a); /* overflow is handled on the next line */ \
+ c1 += (c0 < (a)) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
+ VERIFY_CHECK((c1 != 0) | (c0 >= (a))); \
+ VERIFY_CHECK(c2 == 0); \
+}
+
+/** Extract the lowest 32 bits of (c0,c1,c2) into n, and left shift the number 32 bits. */
+#define extract(n) { \
+ (n) = c0; \
+ c0 = c1; \
+ c1 = c2; \
+ c2 = 0; \
+}
+
+/** Extract the lowest 32 bits of (c0,c1,c2) into n, and left shift the number 32 bits. c2 is required to be zero. */
+#define extract_fast(n) { \
+ (n) = c0; \
+ c0 = c1; \
+ c1 = 0; \
+ VERIFY_CHECK(c2 == 0); \
+}
+
+static void secp256k1_scalar_reduce_512(secp256k1_scalar_t *r, const uint32_t *l) {
+ uint64_t c;
+ uint32_t n0 = l[8], n1 = l[9], n2 = l[10], n3 = l[11], n4 = l[12], n5 = l[13], n6 = l[14], n7 = l[15];
+ uint32_t m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12;
+ uint32_t p0, p1, p2, p3, p4, p5, p6, p7, p8;
+
+ /* 96 bit accumulator. */
+ uint32_t c0, c1, c2;
+
+ /* Reduce 512 bits into 385. */
+ /* m[0..12] = l[0..7] + n[0..7] * SECP256K1_N_C. */
+ c0 = l[0]; c1 = 0; c2 = 0;
+ muladd_fast(n0, SECP256K1_N_C_0);
+ extract_fast(m0);
+ sumadd_fast(l[1]);
+ muladd(n1, SECP256K1_N_C_0);
+ muladd(n0, SECP256K1_N_C_1);
+ extract(m1);
+ sumadd(l[2]);
+ muladd(n2, SECP256K1_N_C_0);
+ muladd(n1, SECP256K1_N_C_1);
+ muladd(n0, SECP256K1_N_C_2);
+ extract(m2);
+ sumadd(l[3]);
+ muladd(n3, SECP256K1_N_C_0);
+ muladd(n2, SECP256K1_N_C_1);
+ muladd(n1, SECP256K1_N_C_2);
+ muladd(n0, SECP256K1_N_C_3);
+ extract(m3);
+ sumadd(l[4]);
+ muladd(n4, SECP256K1_N_C_0);
+ muladd(n3, SECP256K1_N_C_1);
+ muladd(n2, SECP256K1_N_C_2);
+ muladd(n1, SECP256K1_N_C_3);
+ sumadd(n0);
+ extract(m4);
+ sumadd(l[5]);
+ muladd(n5, SECP256K1_N_C_0);
+ muladd(n4, SECP256K1_N_C_1);
+ muladd(n3, SECP256K1_N_C_2);
+ muladd(n2, SECP256K1_N_C_3);
+ sumadd(n1);
+ extract(m5);
+ sumadd(l[6]);
+ muladd(n6, SECP256K1_N_C_0);
+ muladd(n5, SECP256K1_N_C_1);
+ muladd(n4, SECP256K1_N_C_2);
+ muladd(n3, SECP256K1_N_C_3);
+ sumadd(n2);
+ extract(m6);
+ sumadd(l[7]);
+ muladd(n7, SECP256K1_N_C_0);
+ muladd(n6, SECP256K1_N_C_1);
+ muladd(n5, SECP256K1_N_C_2);
+ muladd(n4, SECP256K1_N_C_3);
+ sumadd(n3);
+ extract(m7);
+ muladd(n7, SECP256K1_N_C_1);
+ muladd(n6, SECP256K1_N_C_2);
+ muladd(n5, SECP256K1_N_C_3);
+ sumadd(n4);
+ extract(m8);
+ muladd(n7, SECP256K1_N_C_2);
+ muladd(n6, SECP256K1_N_C_3);
+ sumadd(n5);
+ extract(m9);
+ muladd(n7, SECP256K1_N_C_3);
+ sumadd(n6);
+ extract(m10);
+ sumadd_fast(n7);
+ extract_fast(m11);
+ VERIFY_CHECK(c0 <= 1);
+ m12 = c0;
+
+ /* Reduce 385 bits into 258. */
+ /* p[0..8] = m[0..7] + m[8..12] * SECP256K1_N_C. */
+ c0 = m0; c1 = 0; c2 = 0;
+ muladd_fast(m8, SECP256K1_N_C_0);
+ extract_fast(p0);
+ sumadd_fast(m1);
+ muladd(m9, SECP256K1_N_C_0);
+ muladd(m8, SECP256K1_N_C_1);
+ extract(p1);
+ sumadd(m2);
+ muladd(m10, SECP256K1_N_C_0);
+ muladd(m9, SECP256K1_N_C_1);
+ muladd(m8, SECP256K1_N_C_2);
+ extract(p2);
+ sumadd(m3);
+ muladd(m11, SECP256K1_N_C_0);
+ muladd(m10, SECP256K1_N_C_1);
+ muladd(m9, SECP256K1_N_C_2);
+ muladd(m8, SECP256K1_N_C_3);
+ extract(p3);
+ sumadd(m4);
+ muladd(m12, SECP256K1_N_C_0);
+ muladd(m11, SECP256K1_N_C_1);
+ muladd(m10, SECP256K1_N_C_2);
+ muladd(m9, SECP256K1_N_C_3);
+ sumadd(m8);
+ extract(p4);
+ sumadd(m5);
+ muladd(m12, SECP256K1_N_C_1);
+ muladd(m11, SECP256K1_N_C_2);
+ muladd(m10, SECP256K1_N_C_3);
+ sumadd(m9);
+ extract(p5);
+ sumadd(m6);
+ muladd(m12, SECP256K1_N_C_2);
+ muladd(m11, SECP256K1_N_C_3);
+ sumadd(m10);
+ extract(p6);
+ sumadd_fast(m7);
+ muladd_fast(m12, SECP256K1_N_C_3);
+ sumadd_fast(m11);
+ extract_fast(p7);
+ p8 = c0 + m12;
+ VERIFY_CHECK(p8 <= 2);
+
+ /* Reduce 258 bits into 256. */
+ /* r[0..7] = p[0..7] + p[8] * SECP256K1_N_C. */
+ c = p0 + (uint64_t)SECP256K1_N_C_0 * p8;
+ r->d[0] = c & 0xFFFFFFFFUL; c >>= 32;
+ c += p1 + (uint64_t)SECP256K1_N_C_1 * p8;
+ r->d[1] = c & 0xFFFFFFFFUL; c >>= 32;
+ c += p2 + (uint64_t)SECP256K1_N_C_2 * p8;
+ r->d[2] = c & 0xFFFFFFFFUL; c >>= 32;
+ c += p3 + (uint64_t)SECP256K1_N_C_3 * p8;
+ r->d[3] = c & 0xFFFFFFFFUL; c >>= 32;
+ c += p4 + (uint64_t)p8;
+ r->d[4] = c & 0xFFFFFFFFUL; c >>= 32;
+ c += p5;
+ r->d[5] = c & 0xFFFFFFFFUL; c >>= 32;
+ c += p6;
+ r->d[6] = c & 0xFFFFFFFFUL; c >>= 32;
+ c += p7;
+ r->d[7] = c & 0xFFFFFFFFUL; c >>= 32;
+
+ /* Final reduction of r. */
+ secp256k1_scalar_reduce(r, c + secp256k1_scalar_check_overflow(r));
+}
+
+static void secp256k1_scalar_mul_512(uint32_t *l, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
+ /* 96 bit accumulator. */
+ uint32_t c0 = 0, c1 = 0, c2 = 0;
+
+ /* l[0..15] = a[0..7] * b[0..7]. */
+ muladd_fast(a->d[0], b->d[0]);
+ extract_fast(l[0]);
+ muladd(a->d[0], b->d[1]);
+ muladd(a->d[1], b->d[0]);
+ extract(l[1]);
+ muladd(a->d[0], b->d[2]);
+ muladd(a->d[1], b->d[1]);
+ muladd(a->d[2], b->d[0]);
+ extract(l[2]);
+ muladd(a->d[0], b->d[3]);
+ muladd(a->d[1], b->d[2]);
+ muladd(a->d[2], b->d[1]);
+ muladd(a->d[3], b->d[0]);
+ extract(l[3]);
+ muladd(a->d[0], b->d[4]);
+ muladd(a->d[1], b->d[3]);
+ muladd(a->d[2], b->d[2]);
+ muladd(a->d[3], b->d[1]);
+ muladd(a->d[4], b->d[0]);
+ extract(l[4]);
+ muladd(a->d[0], b->d[5]);
+ muladd(a->d[1], b->d[4]);
+ muladd(a->d[2], b->d[3]);
+ muladd(a->d[3], b->d[2]);
+ muladd(a->d[4], b->d[1]);
+ muladd(a->d[5], b->d[0]);
+ extract(l[5]);
+ muladd(a->d[0], b->d[6]);
+ muladd(a->d[1], b->d[5]);
+ muladd(a->d[2], b->d[4]);
+ muladd(a->d[3], b->d[3]);
+ muladd(a->d[4], b->d[2]);
+ muladd(a->d[5], b->d[1]);
+ muladd(a->d[6], b->d[0]);
+ extract(l[6]);
+ muladd(a->d[0], b->d[7]);
+ muladd(a->d[1], b->d[6]);
+ muladd(a->d[2], b->d[5]);
+ muladd(a->d[3], b->d[4]);
+ muladd(a->d[4], b->d[3]);
+ muladd(a->d[5], b->d[2]);
+ muladd(a->d[6], b->d[1]);
+ muladd(a->d[7], b->d[0]);
+ extract(l[7]);
+ muladd(a->d[1], b->d[7]);
+ muladd(a->d[2], b->d[6]);
+ muladd(a->d[3], b->d[5]);
+ muladd(a->d[4], b->d[4]);
+ muladd(a->d[5], b->d[3]);
+ muladd(a->d[6], b->d[2]);
+ muladd(a->d[7], b->d[1]);
+ extract(l[8]);
+ muladd(a->d[2], b->d[7]);
+ muladd(a->d[3], b->d[6]);
+ muladd(a->d[4], b->d[5]);
+ muladd(a->d[5], b->d[4]);
+ muladd(a->d[6], b->d[3]);
+ muladd(a->d[7], b->d[2]);
+ extract(l[9]);
+ muladd(a->d[3], b->d[7]);
+ muladd(a->d[4], b->d[6]);
+ muladd(a->d[5], b->d[5]);
+ muladd(a->d[6], b->d[4]);
+ muladd(a->d[7], b->d[3]);
+ extract(l[10]);
+ muladd(a->d[4], b->d[7]);
+ muladd(a->d[5], b->d[6]);
+ muladd(a->d[6], b->d[5]);
+ muladd(a->d[7], b->d[4]);
+ extract(l[11]);
+ muladd(a->d[5], b->d[7]);
+ muladd(a->d[6], b->d[6]);
+ muladd(a->d[7], b->d[5]);
+ extract(l[12]);
+ muladd(a->d[6], b->d[7]);
+ muladd(a->d[7], b->d[6]);
+ extract(l[13]);
+ muladd_fast(a->d[7], b->d[7]);
+ extract_fast(l[14]);
+ VERIFY_CHECK(c1 == 0);
+ l[15] = c0;
+}
+
+static void secp256k1_scalar_sqr_512(uint32_t *l, const secp256k1_scalar_t *a) {
+ /* 96 bit accumulator. */
+ uint32_t c0 = 0, c1 = 0, c2 = 0;
+
+ /* l[0..15] = a[0..7]^2. */
+ muladd_fast(a->d[0], a->d[0]);
+ extract_fast(l[0]);
+ muladd2(a->d[0], a->d[1]);
+ extract(l[1]);
+ muladd2(a->d[0], a->d[2]);
+ muladd(a->d[1], a->d[1]);
+ extract(l[2]);
+ muladd2(a->d[0], a->d[3]);
+ muladd2(a->d[1], a->d[2]);
+ extract(l[3]);
+ muladd2(a->d[0], a->d[4]);
+ muladd2(a->d[1], a->d[3]);
+ muladd(a->d[2], a->d[2]);
+ extract(l[4]);
+ muladd2(a->d[0], a->d[5]);
+ muladd2(a->d[1], a->d[4]);
+ muladd2(a->d[2], a->d[3]);
+ extract(l[5]);
+ muladd2(a->d[0], a->d[6]);
+ muladd2(a->d[1], a->d[5]);
+ muladd2(a->d[2], a->d[4]);
+ muladd(a->d[3], a->d[3]);
+ extract(l[6]);
+ muladd2(a->d[0], a->d[7]);
+ muladd2(a->d[1], a->d[6]);
+ muladd2(a->d[2], a->d[5]);
+ muladd2(a->d[3], a->d[4]);
+ extract(l[7]);
+ muladd2(a->d[1], a->d[7]);
+ muladd2(a->d[2], a->d[6]);
+ muladd2(a->d[3], a->d[5]);
+ muladd(a->d[4], a->d[4]);
+ extract(l[8]);
+ muladd2(a->d[2], a->d[7]);
+ muladd2(a->d[3], a->d[6]);
+ muladd2(a->d[4], a->d[5]);
+ extract(l[9]);
+ muladd2(a->d[3], a->d[7]);
+ muladd2(a->d[4], a->d[6]);
+ muladd(a->d[5], a->d[5]);
+ extract(l[10]);
+ muladd2(a->d[4], a->d[7]);
+ muladd2(a->d[5], a->d[6]);
+ extract(l[11]);
+ muladd2(a->d[5], a->d[7]);
+ muladd(a->d[6], a->d[6]);
+ extract(l[12]);
+ muladd2(a->d[6], a->d[7]);
+ extract(l[13]);
+ muladd_fast(a->d[7], a->d[7]);
+ extract_fast(l[14]);
+ VERIFY_CHECK(c1 == 0);
+ l[15] = c0;
+}
+
+#undef sumadd
+#undef sumadd_fast
+#undef muladd
+#undef muladd_fast
+#undef muladd2
+#undef extract
+#undef extract_fast
+
+static void secp256k1_scalar_mul(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
+ uint32_t l[16];
+ secp256k1_scalar_mul_512(l, a, b);
+ secp256k1_scalar_reduce_512(r, l);
+}
+
+static void secp256k1_scalar_sqr(secp256k1_scalar_t *r, const secp256k1_scalar_t *a) {
+ uint32_t l[16];
+ secp256k1_scalar_sqr_512(l, a);
+ secp256k1_scalar_reduce_512(r, l);
+}
+
+#ifdef USE_ENDOMORPHISM
+static void secp256k1_scalar_split_128(secp256k1_scalar_t *r1, secp256k1_scalar_t *r2, const secp256k1_scalar_t *a) {
+ r1->d[0] = a->d[0];
+ r1->d[1] = a->d[1];
+ r1->d[2] = a->d[2];
+ r1->d[3] = a->d[3];
+ r1->d[4] = 0;
+ r1->d[5] = 0;
+ r1->d[6] = 0;
+ r1->d[7] = 0;
+ r2->d[0] = a->d[4];
+ r2->d[1] = a->d[5];
+ r2->d[2] = a->d[6];
+ r2->d[3] = a->d[7];
+ r2->d[4] = 0;
+ r2->d[5] = 0;
+ r2->d[6] = 0;
+ r2->d[7] = 0;
+}
+#endif
+
+SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar_t *a, const secp256k1_scalar_t *b) {
+ return ((a->d[0] ^ b->d[0]) | (a->d[1] ^ b->d[1]) | (a->d[2] ^ b->d[2]) | (a->d[3] ^ b->d[3]) | (a->d[4] ^ b->d[4]) | (a->d[5] ^ b->d[5]) | (a->d[6] ^ b->d[6]) | (a->d[7] ^ b->d[7])) == 0;
+}
+
+SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_scalar_t *r, const secp256k1_scalar_t *a, const secp256k1_scalar_t *b, unsigned int shift) {
+ uint32_t l[16];
+ unsigned int shiftlimbs;
+ unsigned int shiftlow;
+ unsigned int shifthigh;
+ VERIFY_CHECK(shift >= 256);
+ secp256k1_scalar_mul_512(l, a, b);
+ shiftlimbs = shift >> 5;
+ shiftlow = shift & 0x1F;
+ shifthigh = 32 - shiftlow;
+ r->d[0] = shift < 512 ? (l[0 + shiftlimbs] >> shiftlow | (shift < 480 && shiftlow ? (l[1 + shiftlimbs] << shifthigh) : 0)) : 0;
+ r->d[1] = shift < 480 ? (l[1 + shiftlimbs] >> shiftlow | (shift < 448 && shiftlow ? (l[2 + shiftlimbs] << shifthigh) : 0)) : 0;
+ r->d[2] = shift < 448 ? (l[2 + shiftlimbs] >> shiftlow | (shift < 416 && shiftlow ? (l[3 + shiftlimbs] << shifthigh) : 0)) : 0;
+ r->d[3] = shift < 416 ? (l[3 + shiftlimbs] >> shiftlow | (shift < 384 && shiftlow ? (l[4 + shiftlimbs] << shifthigh) : 0)) : 0;
+ r->d[4] = shift < 384 ? (l[4 + shiftlimbs] >> shiftlow | (shift < 352 && shiftlow ? (l[5 + shiftlimbs] << shifthigh) : 0)) : 0;
+ r->d[5] = shift < 352 ? (l[5 + shiftlimbs] >> shiftlow | (shift < 320 && shiftlow ? (l[6 + shiftlimbs] << shifthigh) : 0)) : 0;
+ r->d[6] = shift < 320 ? (l[6 + shiftlimbs] >> shiftlow | (shift < 288 && shiftlow ? (l[7 + shiftlimbs] << shifthigh) : 0)) : 0;
+ r->d[7] = shift < 288 ? (l[7 + shiftlimbs] >> shiftlow) : 0;
+ if ((l[(shift - 1) >> 5] >> ((shift - 1) & 0x1f)) & 1) {
+ secp256k1_scalar_add_bit(r, 0);
+ }
+}
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/scalar_impl.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/scalar_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..33824983e4d529c345f4d9c0f2ae222d24777b3f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/scalar_impl.h
@@ -0,0 +1,327 @@
+/**********************************************************************
+ * Copyright (c) 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_SCALAR_IMPL_H_
+#define _SECP256K1_SCALAR_IMPL_H_
+
+#include <string.h>
+
+#include "group.h"
+#include "scalar.h"
+
+#if defined HAVE_CONFIG_H
+#include "libsecp256k1-config.h"
+#endif
+
+#if defined(USE_SCALAR_4X64)
+#include "scalar_4x64_impl.h"
+#elif defined(USE_SCALAR_8X32)
+#include "scalar_8x32_impl.h"
+#else
+#error "Please select scalar implementation"
+#endif
+
+#ifndef USE_NUM_NONE
+static void secp256k1_scalar_get_num(secp256k1_num_t *r, const secp256k1_scalar_t *a) {
+ unsigned char c[32];
+ secp256k1_scalar_get_b32(c, a);
+ secp256k1_num_set_bin(r, c, 32);
+}
+
+/** secp256k1 curve order, see secp256k1_ecdsa_const_order_as_fe in ecdsa_impl.h */
+static void secp256k1_scalar_order_get_num(secp256k1_num_t *r) {
+ static const unsigned char order[32] = {
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,
+ 0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,
+ 0xBF,0xD2,0x5E,0x8C,0xD0,0x36,0x41,0x41
+ };
+ secp256k1_num_set_bin(r, order, 32);
+}
+#endif
+
+static void secp256k1_scalar_inverse(secp256k1_scalar_t *r, const secp256k1_scalar_t *x) {
+ secp256k1_scalar_t *t;
+ int i;
+ /* First compute x ^ (2^N - 1) for some values of N. */
+ secp256k1_scalar_t x2, x3, x4, x6, x7, x8, x15, x30, x60, x120, x127;
+
+ secp256k1_scalar_sqr(&x2, x);
+ secp256k1_scalar_mul(&x2, &x2, x);
+
+ secp256k1_scalar_sqr(&x3, &x2);
+ secp256k1_scalar_mul(&x3, &x3, x);
+
+ secp256k1_scalar_sqr(&x4, &x3);
+ secp256k1_scalar_mul(&x4, &x4, x);
+
+ secp256k1_scalar_sqr(&x6, &x4);
+ secp256k1_scalar_sqr(&x6, &x6);
+ secp256k1_scalar_mul(&x6, &x6, &x2);
+
+ secp256k1_scalar_sqr(&x7, &x6);
+ secp256k1_scalar_mul(&x7, &x7, x);
+
+ secp256k1_scalar_sqr(&x8, &x7);
+ secp256k1_scalar_mul(&x8, &x8, x);
+
+ secp256k1_scalar_sqr(&x15, &x8);
+ for (i = 0; i < 6; i++) {
+ secp256k1_scalar_sqr(&x15, &x15);
+ }
+ secp256k1_scalar_mul(&x15, &x15, &x7);
+
+ secp256k1_scalar_sqr(&x30, &x15);
+ for (i = 0; i < 14; i++) {
+ secp256k1_scalar_sqr(&x30, &x30);
+ }
+ secp256k1_scalar_mul(&x30, &x30, &x15);
+
+ secp256k1_scalar_sqr(&x60, &x30);
+ for (i = 0; i < 29; i++) {
+ secp256k1_scalar_sqr(&x60, &x60);
+ }
+ secp256k1_scalar_mul(&x60, &x60, &x30);
+
+ secp256k1_scalar_sqr(&x120, &x60);
+ for (i = 0; i < 59; i++) {
+ secp256k1_scalar_sqr(&x120, &x120);
+ }
+ secp256k1_scalar_mul(&x120, &x120, &x60);
+
+ secp256k1_scalar_sqr(&x127, &x120);
+ for (i = 0; i < 6; i++) {
+ secp256k1_scalar_sqr(&x127, &x127);
+ }
+ secp256k1_scalar_mul(&x127, &x127, &x7);
+
+ /* Then accumulate the final result (t starts at x127). */
+ t = &x127;
+ for (i = 0; i < 2; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, x); /* 1 */
+ for (i = 0; i < 4; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, &x3); /* 111 */
+ for (i = 0; i < 2; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, x); /* 1 */
+ for (i = 0; i < 2; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, x); /* 1 */
+ for (i = 0; i < 2; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, x); /* 1 */
+ for (i = 0; i < 4; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, &x3); /* 111 */
+ for (i = 0; i < 3; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, &x2); /* 11 */
+ for (i = 0; i < 4; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, &x3); /* 111 */
+ for (i = 0; i < 5; i++) { /* 00 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, &x3); /* 111 */
+ for (i = 0; i < 4; i++) { /* 00 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, &x2); /* 11 */
+ for (i = 0; i < 2; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, x); /* 1 */
+ for (i = 0; i < 2; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, x); /* 1 */
+ for (i = 0; i < 5; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, &x4); /* 1111 */
+ for (i = 0; i < 2; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, x); /* 1 */
+ for (i = 0; i < 3; i++) { /* 00 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, x); /* 1 */
+ for (i = 0; i < 4; i++) { /* 000 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, x); /* 1 */
+ for (i = 0; i < 2; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, x); /* 1 */
+ for (i = 0; i < 10; i++) { /* 0000000 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, &x3); /* 111 */
+ for (i = 0; i < 4; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, &x3); /* 111 */
+ for (i = 0; i < 9; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, &x8); /* 11111111 */
+ for (i = 0; i < 2; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, x); /* 1 */
+ for (i = 0; i < 3; i++) { /* 00 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, x); /* 1 */
+ for (i = 0; i < 3; i++) { /* 00 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, x); /* 1 */
+ for (i = 0; i < 5; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, &x4); /* 1111 */
+ for (i = 0; i < 2; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, x); /* 1 */
+ for (i = 0; i < 5; i++) { /* 000 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, &x2); /* 11 */
+ for (i = 0; i < 4; i++) { /* 00 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, &x2); /* 11 */
+ for (i = 0; i < 2; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, x); /* 1 */
+ for (i = 0; i < 8; i++) { /* 000000 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, &x2); /* 11 */
+ for (i = 0; i < 3; i++) { /* 0 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, &x2); /* 11 */
+ for (i = 0; i < 3; i++) { /* 00 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, x); /* 1 */
+ for (i = 0; i < 6; i++) { /* 00000 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(t, t, x); /* 1 */
+ for (i = 0; i < 8; i++) { /* 00 */
+ secp256k1_scalar_sqr(t, t);
+ }
+ secp256k1_scalar_mul(r, t, &x6); /* 111111 */
+}
+
+static void secp256k1_scalar_inverse_var(secp256k1_scalar_t *r, const secp256k1_scalar_t *x) {
+#if defined(USE_SCALAR_INV_BUILTIN)
+ secp256k1_scalar_inverse(r, x);
+#elif defined(USE_SCALAR_INV_NUM)
+ unsigned char b[32];
+ secp256k1_num_t n, m;
+ secp256k1_scalar_get_b32(b, x);
+ secp256k1_num_set_bin(&n, b, 32);
+ secp256k1_scalar_order_get_num(&m);
+ secp256k1_num_mod_inverse(&n, &n, &m);
+ secp256k1_num_get_bin(b, 32, &n);
+ secp256k1_scalar_set_b32(r, b, NULL);
+#else
+#error "Please select scalar inverse implementation"
+#endif
+}
+
+#ifdef USE_ENDOMORPHISM
+/**
+ * The Secp256k1 curve has an endomorphism, where lambda * (x, y) = (beta * x, y), where
+ * lambda is {0x53,0x63,0xad,0x4c,0xc0,0x5c,0x30,0xe0,0xa5,0x26,0x1c,0x02,0x88,0x12,0x64,0x5a,
+ * 0x12,0x2e,0x22,0xea,0x20,0x81,0x66,0x78,0xdf,0x02,0x96,0x7c,0x1b,0x23,0xbd,0x72}
+ *
+ * "Guide to Elliptic Curve Cryptography" (Hankerson, Menezes, Vanstone) gives an algorithm
+ * (algorithm 3.74) to find k1 and k2 given k, such that k1 + k2 * lambda == k mod n, and k1
+ * and k2 have a small size.
+ * It relies on constants a1, b1, a2, b2. These constants for the value of lambda above are:
+ *
+ * - a1 = {0x30,0x86,0xd2,0x21,0xa7,0xd4,0x6b,0xcd,0xe8,0x6c,0x90,0xe4,0x92,0x84,0xeb,0x15}
+ * - b1 = -{0xe4,0x43,0x7e,0xd6,0x01,0x0e,0x88,0x28,0x6f,0x54,0x7f,0xa9,0x0a,0xbf,0xe4,0xc3}
+ * - a2 = {0x01,0x14,0xca,0x50,0xf7,0xa8,0xe2,0xf3,0xf6,0x57,0xc1,0x10,0x8d,0x9d,0x44,0xcf,0xd8}
+ * - b2 = {0x30,0x86,0xd2,0x21,0xa7,0xd4,0x6b,0xcd,0xe8,0x6c,0x90,0xe4,0x92,0x84,0xeb,0x15}
+ *
+ * The algorithm then computes c1 = round(b1 * k / n) and c2 = round(b2 * k / n), and gives
+ * k1 = k - (c1*a1 + c2*a2) and k2 = -(c1*b1 + c2*b2). Instead, we use modular arithmetic, and
+ * compute k1 as k - k2 * lambda, avoiding the need for constants a1 and a2.
+ *
+ * g1, g2 are precomputed constants used to replace division with a rounded multiplication
+ * when decomposing the scalar for an endomorphism-based point multiplication.
+ *
+ * The possibility of using precomputed estimates is mentioned in "Guide to Elliptic Curve
+ * Cryptography" (Hankerson, Menezes, Vanstone) in section 3.5.
+ *
+ * The derivation is described in the paper "Efficient Software Implementation of Public-Key
+ * Cryptography on Sensor Networks Using the MSP430X Microcontroller" (Gouvea, Oliveira, Lopez),
+ * Section 4.3 (here we use a somewhat higher-precision estimate):
+ * d = a1*b2 - b1*a2
+ * g1 = round((2^272)*b2/d)
+ * g2 = round((2^272)*b1/d)
+ *
+ * (Note that 'd' is also equal to the curve order here because [a1,b1] and [a2,b2] are found
+ * as outputs of the Extended Euclidean Algorithm on inputs 'order' and 'lambda').
+ *
+ * The function below splits a in r1 and r2, such that r1 + lambda * r2 == a (mod order).
+ */
+
+static void secp256k1_scalar_split_lambda_var(secp256k1_scalar_t *r1, secp256k1_scalar_t *r2, const secp256k1_scalar_t *a) {
+ secp256k1_scalar_t c1, c2;
+ static const secp256k1_scalar_t minus_lambda = SECP256K1_SCALAR_CONST(
+ 0xAC9C52B3UL, 0x3FA3CF1FUL, 0x5AD9E3FDUL, 0x77ED9BA4UL,
+ 0xA880B9FCUL, 0x8EC739C2UL, 0xE0CFC810UL, 0xB51283CFUL
+ );
+ static const secp256k1_scalar_t minus_b1 = SECP256K1_SCALAR_CONST(
+ 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,
+ 0xE4437ED6UL, 0x010E8828UL, 0x6F547FA9UL, 0x0ABFE4C3UL
+ );
+ static const secp256k1_scalar_t minus_b2 = SECP256K1_SCALAR_CONST(
+ 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFEUL,
+ 0x8A280AC5UL, 0x0774346DUL, 0xD765CDA8UL, 0x3DB1562CUL
+ );
+ static const secp256k1_scalar_t g1 = SECP256K1_SCALAR_CONST(
+ 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00003086UL,
+ 0xD221A7D4UL, 0x6BCDE86CUL, 0x90E49284UL, 0xEB153DABUL
+ );
+ static const secp256k1_scalar_t g2 = SECP256K1_SCALAR_CONST(
+ 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x0000E443UL,
+ 0x7ED6010EUL, 0x88286F54UL, 0x7FA90ABFUL, 0xE4C42212UL
+ );
+ VERIFY_CHECK(r1 != a);
+ VERIFY_CHECK(r2 != a);
+ secp256k1_scalar_mul_shift_var(&c1, a, &g1, 272);
+ secp256k1_scalar_mul_shift_var(&c2, a, &g2, 272);
+ secp256k1_scalar_mul(&c1, &c1, &minus_b1);
+ secp256k1_scalar_mul(&c2, &c2, &minus_b2);
+ secp256k1_scalar_add(r2, &c1, &c2);
+ secp256k1_scalar_mul(r1, r2, &minus_lambda);
+ secp256k1_scalar_add(r1, r1, a);
+}
+#endif
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/secp256k1.c b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/secp256k1.c
new file mode 100644
index 0000000000000000000000000000000000000000..c1320172f065b5d898ee3d35acfb1c03750067ec
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/secp256k1.c
@@ -0,0 +1,372 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#define SECP256K1_BUILD (1)
+
+#include "include/secp256k1.h"
+
+#include "util.h"
+#include "num_impl.h"
+#include "field_impl.h"
+#include "scalar_impl.h"
+#include "group_impl.h"
+#include "ecmult_impl.h"
+#include "ecmult_gen_impl.h"
+#include "ecdsa_impl.h"
+#include "eckey_impl.h"
+#include "hash_impl.h"
+
+void secp256k1_start(unsigned int flags) {
+ if (flags & SECP256K1_START_SIGN) {
+ secp256k1_ecmult_gen_start();
+ }
+ if (flags & SECP256K1_START_VERIFY) {
+ secp256k1_ecmult_start();
+ }
+}
+
+void secp256k1_stop(void) {
+ secp256k1_ecmult_stop();
+ secp256k1_ecmult_gen_stop();
+}
+
+int secp256k1_ecdsa_verify(const unsigned char *msg32, const unsigned char *sig, int siglen, const unsigned char *pubkey, int pubkeylen) {
+ secp256k1_ge_t q;
+ secp256k1_ecdsa_sig_t s;
+ secp256k1_scalar_t m;
+ int ret = -3;
+ DEBUG_CHECK(secp256k1_ecmult_consts != NULL);
+ DEBUG_CHECK(msg32 != NULL);
+ DEBUG_CHECK(sig != NULL);
+ DEBUG_CHECK(pubkey != NULL);
+
+ secp256k1_scalar_set_b32(&m, msg32, NULL);
+
+ if (secp256k1_eckey_pubkey_parse(&q, pubkey, pubkeylen)) {
+ if (secp256k1_ecdsa_sig_parse(&s, sig, siglen)) {
+ if (secp256k1_ecdsa_sig_verify(&s, &q, &m)) {
+ /* success is 1, all other values are fail */
+ ret = 1;
+ } else {
+ ret = 0;
+ }
+ } else {
+ ret = -2;
+ }
+ } else {
+ ret = -1;
+ }
+
+ return ret;
+}
+
+static int nonce_function_rfc6979(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, unsigned int counter, const void *data) {
+ secp256k1_rfc6979_hmac_sha256_t rng;
+ unsigned int i;
+ secp256k1_rfc6979_hmac_sha256_initialize(&rng, key32, 32, msg32, 32, (const unsigned char*)data, data != NULL ? 32 : 0);
+ for (i = 0; i <= counter; i++) {
+ secp256k1_rfc6979_hmac_sha256_generate(&rng, nonce32, 32);
+ }
+ secp256k1_rfc6979_hmac_sha256_finalize(&rng);
+ return 1;
+}
+
+const secp256k1_nonce_function_t secp256k1_nonce_function_rfc6979 = nonce_function_rfc6979;
+const secp256k1_nonce_function_t secp256k1_nonce_function_default = nonce_function_rfc6979;
+
+int secp256k1_ecdsa_sign(const unsigned char *msg32, unsigned char *signature, int *signaturelen, const unsigned char *seckey, secp256k1_nonce_function_t noncefp, const void* noncedata) {
+ secp256k1_ecdsa_sig_t sig;
+ secp256k1_scalar_t sec, non, msg;
+ int ret = 0;
+ int overflow = 0;
+ unsigned int count = 0;
+ DEBUG_CHECK(secp256k1_ecmult_gen_consts != NULL);
+ DEBUG_CHECK(msg32 != NULL);
+ DEBUG_CHECK(signature != NULL);
+ DEBUG_CHECK(signaturelen != NULL);
+ DEBUG_CHECK(seckey != NULL);
+ if (noncefp == NULL) {
+ noncefp = secp256k1_nonce_function_default;
+ }
+
+ secp256k1_scalar_set_b32(&sec, seckey, &overflow);
+ /* Fail if the secret key is invalid. */
+ if (!overflow && !secp256k1_scalar_is_zero(&sec)) {
+ secp256k1_scalar_set_b32(&msg, msg32, NULL);
+ while (1) {
+ unsigned char nonce32[32];
+ ret = noncefp(nonce32, msg32, seckey, count, noncedata);
+ if (!ret) {
+ break;
+ }
+ secp256k1_scalar_set_b32(&non, nonce32, &overflow);
+ memset(nonce32, 0, 32);
+ if (!secp256k1_scalar_is_zero(&non) && !overflow) {
+ if (secp256k1_ecdsa_sig_sign(&sig, &sec, &msg, &non, NULL)) {
+ break;
+ }
+ }
+ count++;
+ }
+ if (ret) {
+ ret = secp256k1_ecdsa_sig_serialize(signature, signaturelen, &sig);
+ }
+ secp256k1_scalar_clear(&msg);
+ secp256k1_scalar_clear(&non);
+ secp256k1_scalar_clear(&sec);
+ }
+ if (!ret) {
+ *signaturelen = 0;
+ }
+ return ret;
+}
+
+int secp256k1_ecdsa_sign_compact(const unsigned char *msg32, unsigned char *sig64, const unsigned char *seckey, secp256k1_nonce_function_t noncefp, const void* noncedata, int *recid) {
+ secp256k1_ecdsa_sig_t sig;
+ secp256k1_scalar_t sec, non, msg;
+ int ret = 0;
+ int overflow = 0;
+ unsigned int count = 0;
+ DEBUG_CHECK(secp256k1_ecmult_gen_consts != NULL);
+ DEBUG_CHECK(msg32 != NULL);
+ DEBUG_CHECK(sig64 != NULL);
+ DEBUG_CHECK(seckey != NULL);
+ if (noncefp == NULL) {
+ noncefp = secp256k1_nonce_function_default;
+ }
+
+ secp256k1_scalar_set_b32(&sec, seckey, &overflow);
+ /* Fail if the secret key is invalid. */
+ if (!overflow && !secp256k1_scalar_is_zero(&sec)) {
+ secp256k1_scalar_set_b32(&msg, msg32, NULL);
+ while (1) {
+ unsigned char nonce32[32];
+ ret = noncefp(nonce32, msg32, seckey, count, noncedata);
+ if (!ret) {
+ break;
+ }
+ secp256k1_scalar_set_b32(&non, nonce32, &overflow);
+ memset(nonce32, 0, 32);
+ if (!secp256k1_scalar_is_zero(&non) && !overflow) {
+ if (secp256k1_ecdsa_sig_sign(&sig, &sec, &msg, &non, recid)) {
+ break;
+ }
+ }
+ count++;
+ }
+ if (ret) {
+ secp256k1_scalar_get_b32(sig64, &sig.r);
+ secp256k1_scalar_get_b32(sig64 + 32, &sig.s);
+ }
+ secp256k1_scalar_clear(&msg);
+ secp256k1_scalar_clear(&non);
+ secp256k1_scalar_clear(&sec);
+ }
+ if (!ret) {
+ memset(sig64, 0, 64);
+ }
+ return ret;
+}
+
+int secp256k1_ecdsa_recover_compact(const unsigned char *msg32, const unsigned char *sig64, unsigned char *pubkey, int *pubkeylen, int compressed, int recid) {
+ secp256k1_ge_t q;
+ secp256k1_ecdsa_sig_t sig;
+ secp256k1_scalar_t m;
+ int ret = 0;
+ int overflow = 0;
+ DEBUG_CHECK(secp256k1_ecmult_consts != NULL);
+ DEBUG_CHECK(msg32 != NULL);
+ DEBUG_CHECK(sig64 != NULL);
+ DEBUG_CHECK(pubkey != NULL);
+ DEBUG_CHECK(pubkeylen != NULL);
+ DEBUG_CHECK(recid >= 0 && recid <= 3);
+
+ secp256k1_scalar_set_b32(&sig.r, sig64, &overflow);
+ if (!overflow) {
+ secp256k1_scalar_set_b32(&sig.s, sig64 + 32, &overflow);
+ if (!overflow) {
+ secp256k1_scalar_set_b32(&m, msg32, NULL);
+
+ if (secp256k1_ecdsa_sig_recover(&sig, &q, &m, recid)) {
+ ret = secp256k1_eckey_pubkey_serialize(&q, pubkey, pubkeylen, compressed);
+ }
+ }
+ }
+ return ret;
+}
+
+int secp256k1_ec_seckey_verify(const unsigned char *seckey) {
+ secp256k1_scalar_t sec;
+ int ret;
+ int overflow;
+ DEBUG_CHECK(seckey != NULL);
+
+ secp256k1_scalar_set_b32(&sec, seckey, &overflow);
+ ret = !secp256k1_scalar_is_zero(&sec) && !overflow;
+ secp256k1_scalar_clear(&sec);
+ return ret;
+}
+
+int secp256k1_ec_pubkey_verify(const unsigned char *pubkey, int pubkeylen) {
+ secp256k1_ge_t q;
+ DEBUG_CHECK(pubkey != NULL);
+
+ return secp256k1_eckey_pubkey_parse(&q, pubkey, pubkeylen);
+}
+
+int secp256k1_ec_pubkey_create(unsigned char *pubkey, int *pubkeylen, const unsigned char *seckey, int compressed) {
+ secp256k1_gej_t pj;
+ secp256k1_ge_t p;
+ secp256k1_scalar_t sec;
+ int overflow;
+ int ret = 0;
+ DEBUG_CHECK(secp256k1_ecmult_gen_consts != NULL);
+ DEBUG_CHECK(pubkey != NULL);
+ DEBUG_CHECK(pubkeylen != NULL);
+ DEBUG_CHECK(seckey != NULL);
+
+ secp256k1_scalar_set_b32(&sec, seckey, &overflow);
+ if (!overflow) {
+ secp256k1_ecmult_gen(&pj, &sec);
+ secp256k1_scalar_clear(&sec);
+ secp256k1_ge_set_gej(&p, &pj);
+ ret = secp256k1_eckey_pubkey_serialize(&p, pubkey, pubkeylen, compressed);
+ }
+ if (!ret) {
+ *pubkeylen = 0;
+ }
+ return ret;
+}
+
+int secp256k1_ec_pubkey_decompress(unsigned char *pubkey, int *pubkeylen) {
+ secp256k1_ge_t p;
+ int ret = 0;
+ DEBUG_CHECK(pubkey != NULL);
+ DEBUG_CHECK(pubkeylen != NULL);
+
+ if (secp256k1_eckey_pubkey_parse(&p, pubkey, *pubkeylen)) {
+ ret = secp256k1_eckey_pubkey_serialize(&p, pubkey, pubkeylen, 0);
+ }
+ return ret;
+}
+
+int secp256k1_ec_privkey_tweak_add(unsigned char *seckey, const unsigned char *tweak) {
+ secp256k1_scalar_t term;
+ secp256k1_scalar_t sec;
+ int ret = 0;
+ int overflow = 0;
+ DEBUG_CHECK(seckey != NULL);
+ DEBUG_CHECK(tweak != NULL);
+
+ secp256k1_scalar_set_b32(&term, tweak, &overflow);
+ secp256k1_scalar_set_b32(&sec, seckey, NULL);
+
+ ret = secp256k1_eckey_privkey_tweak_add(&sec, &term) && !overflow;
+ if (ret) {
+ secp256k1_scalar_get_b32(seckey, &sec);
+ }
+
+ secp256k1_scalar_clear(&sec);
+ secp256k1_scalar_clear(&term);
+ return ret;
+}
+
+int secp256k1_ec_pubkey_tweak_add(unsigned char *pubkey, int pubkeylen, const unsigned char *tweak) {
+ secp256k1_ge_t p;
+ secp256k1_scalar_t term;
+ int ret = 0;
+ int overflow = 0;
+ DEBUG_CHECK(secp256k1_ecmult_consts != NULL);
+ DEBUG_CHECK(pubkey != NULL);
+ DEBUG_CHECK(tweak != NULL);
+
+ secp256k1_scalar_set_b32(&term, tweak, &overflow);
+ if (!overflow) {
+ ret = secp256k1_eckey_pubkey_parse(&p, pubkey, pubkeylen);
+ if (ret) {
+ ret = secp256k1_eckey_pubkey_tweak_add(&p, &term);
+ }
+ if (ret) {
+ int oldlen = pubkeylen;
+ ret = secp256k1_eckey_pubkey_serialize(&p, pubkey, &pubkeylen, oldlen <= 33);
+ VERIFY_CHECK(pubkeylen == oldlen);
+ }
+ }
+
+ return ret;
+}
+
+int secp256k1_ec_privkey_tweak_mul(unsigned char *seckey, const unsigned char *tweak) {
+ secp256k1_scalar_t factor;
+ secp256k1_scalar_t sec;
+ int ret = 0;
+ int overflow = 0;
+ DEBUG_CHECK(seckey != NULL);
+ DEBUG_CHECK(tweak != NULL);
+
+ secp256k1_scalar_set_b32(&factor, tweak, &overflow);
+ secp256k1_scalar_set_b32(&sec, seckey, NULL);
+ ret = secp256k1_eckey_privkey_tweak_mul(&sec, &factor) && !overflow;
+ if (ret) {
+ secp256k1_scalar_get_b32(seckey, &sec);
+ }
+
+ secp256k1_scalar_clear(&sec);
+ secp256k1_scalar_clear(&factor);
+ return ret;
+}
+
+int secp256k1_ec_pubkey_tweak_mul(unsigned char *pubkey, int pubkeylen, const unsigned char *tweak) {
+ secp256k1_ge_t p;
+ secp256k1_scalar_t factor;
+ int ret = 0;
+ int overflow = 0;
+ DEBUG_CHECK(secp256k1_ecmult_consts != NULL);
+ DEBUG_CHECK(pubkey != NULL);
+ DEBUG_CHECK(tweak != NULL);
+
+ secp256k1_scalar_set_b32(&factor, tweak, &overflow);
+ if (!overflow) {
+ ret = secp256k1_eckey_pubkey_parse(&p, pubkey, pubkeylen);
+ if (ret) {
+ ret = secp256k1_eckey_pubkey_tweak_mul(&p, &factor);
+ }
+ if (ret) {
+ int oldlen = pubkeylen;
+ ret = secp256k1_eckey_pubkey_serialize(&p, pubkey, &pubkeylen, oldlen <= 33);
+ VERIFY_CHECK(pubkeylen == oldlen);
+ }
+ }
+
+ return ret;
+}
+
+int secp256k1_ec_privkey_export(const unsigned char *seckey, unsigned char *privkey, int *privkeylen, int compressed) {
+ secp256k1_scalar_t key;
+ int ret = 0;
+ DEBUG_CHECK(seckey != NULL);
+ DEBUG_CHECK(privkey != NULL);
+ DEBUG_CHECK(privkeylen != NULL);
+
+ secp256k1_scalar_set_b32(&key, seckey, NULL);
+ ret = secp256k1_eckey_privkey_serialize(privkey, privkeylen, &key, compressed);
+ secp256k1_scalar_clear(&key);
+ return ret;
+}
+
+int secp256k1_ec_privkey_import(unsigned char *seckey, const unsigned char *privkey, int privkeylen) {
+ secp256k1_scalar_t key;
+ int ret = 0;
+ DEBUG_CHECK(seckey != NULL);
+ DEBUG_CHECK(privkey != NULL);
+
+ ret = secp256k1_eckey_privkey_parse(&key, privkey, privkeylen);
+ if (ret) {
+ secp256k1_scalar_get_b32(seckey, &key);
+ }
+ secp256k1_scalar_clear(&key);
+ return ret;
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/testrand.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/testrand.h
new file mode 100644
index 0000000000000000000000000000000000000000..041bb92c47aa52b5f4d94357bcf0d1f0115a7d3c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/testrand.h
@@ -0,0 +1,28 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_TESTRAND_H_
+#define _SECP256K1_TESTRAND_H_
+
+#if defined HAVE_CONFIG_H
+#include "libsecp256k1-config.h"
+#endif
+
+/* A non-cryptographic RNG used only for test infrastructure. */
+
+/** Seed the pseudorandom number generator for testing. */
+SECP256K1_INLINE static void secp256k1_rand_seed(const unsigned char *seed16);
+
+/** Generate a pseudorandom 32-bit number. */
+static uint32_t secp256k1_rand32(void);
+
+/** Generate a pseudorandom 32-byte array. */
+static void secp256k1_rand256(unsigned char *b32);
+
+/** Generate a pseudorandom 32-byte array with long sequences of zero and one bits. */
+static void secp256k1_rand256_test(unsigned char *b32);
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/testrand_impl.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/testrand_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..21c69f1c51eb45b277290f611521e489a20ee9ff
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/testrand_impl.h
@@ -0,0 +1,60 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_TESTRAND_IMPL_H_
+#define _SECP256K1_TESTRAND_IMPL_H_
+
+#include <stdint.h>
+#include <string.h>
+
+#include "testrand.h"
+#include "hash.h"
+
+static secp256k1_rfc6979_hmac_sha256_t secp256k1_test_rng;
+static uint32_t secp256k1_test_rng_precomputed[8];
+static int secp256k1_test_rng_precomputed_used = 8;
+
+SECP256K1_INLINE static void secp256k1_rand_seed(const unsigned char *seed16) {
+ secp256k1_rfc6979_hmac_sha256_initialize(&secp256k1_test_rng, (const unsigned char*)"TestRNG", 7, seed16, 16, NULL, 0);
+}
+
+SECP256K1_INLINE static uint32_t secp256k1_rand32(void) {
+ if (secp256k1_test_rng_precomputed_used == 8) {
+ secp256k1_rfc6979_hmac_sha256_generate(&secp256k1_test_rng, (unsigned char*)(&secp256k1_test_rng_precomputed[0]), sizeof(secp256k1_test_rng_precomputed));
+ secp256k1_test_rng_precomputed_used = 0;
+ }
+ return secp256k1_test_rng_precomputed[secp256k1_test_rng_precomputed_used++];
+}
+
+static void secp256k1_rand256(unsigned char *b32) {
+ secp256k1_rfc6979_hmac_sha256_generate(&secp256k1_test_rng, b32, 32);
+}
+
+static void secp256k1_rand256_test(unsigned char *b32) {
+ int bits=0;
+ uint64_t ent = 0;
+ int entleft = 0;
+ memset(b32, 0, 32);
+ while (bits < 256) {
+ int now;
+ uint32_t val;
+ if (entleft < 12) {
+ ent |= ((uint64_t)secp256k1_rand32()) << entleft;
+ entleft += 32;
+ }
+ now = 1 + ((ent % 64)*((ent >> 6) % 32)+16)/31;
+ val = 1 & (ent >> 11);
+ ent >>= 12;
+ entleft -= 12;
+ while (now > 0 && bits < 256) {
+ b32[bits / 8] |= val << (bits % 8);
+ now--;
+ bits++;
+ }
+ }
+}
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/tests.c b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/tests.c
new file mode 100644
index 0000000000000000000000000000000000000000..6c473a0c1423794c582c7d6a0de2b59543501806
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/tests.c
@@ -0,0 +1,1917 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#if defined HAVE_CONFIG_H
+#include "libsecp256k1-config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <time.h>
+
+#include "secp256k1.c"
+#include "testrand_impl.h"
+
+#ifdef ENABLE_OPENSSL_TESTS
+#include "openssl/bn.h"
+#include "openssl/ec.h"
+#include "openssl/ecdsa.h"
+#include "openssl/obj_mac.h"
+#endif
+
+static int count = 64;
+
+void random_field_element_test(secp256k1_fe_t *fe) {
+ do {
+ unsigned char b32[32];
+ secp256k1_rand256_test(b32);
+ if (secp256k1_fe_set_b32(fe, b32)) {
+ break;
+ }
+ } while(1);
+}
+
+void random_field_element_magnitude(secp256k1_fe_t *fe) {
+ secp256k1_fe_t zero;
+ int n = secp256k1_rand32() % 9;
+ secp256k1_fe_normalize(fe);
+ if (n == 0) {
+ return;
+ }
+ secp256k1_fe_clear(&zero);
+ secp256k1_fe_negate(&zero, &zero, 0);
+ secp256k1_fe_mul_int(&zero, n - 1);
+ secp256k1_fe_add(fe, &zero);
+#ifdef VERIFY
+ CHECK(fe->magnitude == n);
+#endif
+}
+
+void random_group_element_test(secp256k1_ge_t *ge) {
+ secp256k1_fe_t fe;
+ do {
+ random_field_element_test(&fe);
+ if (secp256k1_ge_set_xo_var(ge, &fe, secp256k1_rand32() & 1)) {
+ break;
+ }
+ } while(1);
+}
+
+void random_group_element_jacobian_test(secp256k1_gej_t *gej, const secp256k1_ge_t *ge) {
+ secp256k1_fe_t z2, z3;
+ do {
+ random_field_element_test(&gej->z);
+ if (!secp256k1_fe_is_zero(&gej->z)) {
+ break;
+ }
+ } while(1);
+ secp256k1_fe_sqr(&z2, &gej->z);
+ secp256k1_fe_mul(&z3, &z2, &gej->z);
+ secp256k1_fe_mul(&gej->x, &ge->x, &z2);
+ secp256k1_fe_mul(&gej->y, &ge->y, &z3);
+ gej->infinity = ge->infinity;
+}
+
+void random_scalar_order_test(secp256k1_scalar_t *num) {
+ do {
+ unsigned char b32[32];
+ int overflow = 0;
+ secp256k1_rand256_test(b32);
+ secp256k1_scalar_set_b32(num, b32, &overflow);
+ if (overflow || secp256k1_scalar_is_zero(num)) {
+ continue;
+ }
+ break;
+ } while(1);
+}
+
+void random_scalar_order(secp256k1_scalar_t *num) {
+ do {
+ unsigned char b32[32];
+ int overflow = 0;
+ secp256k1_rand256(b32);
+ secp256k1_scalar_set_b32(num, b32, &overflow);
+ if (overflow || secp256k1_scalar_is_zero(num)) {
+ continue;
+ }
+ break;
+ } while(1);
+}
+
+/***** HASH TESTS *****/
+
+void run_sha256_tests(void) {
+ static const char *inputs[8] = {
+ "", "abc", "message digest", "secure hash algorithm", "SHA256 is considered to be safe",
+ "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+ "For this sample, this 63-byte string will be used as input data",
+ "This is exactly 64 bytes long, not counting the terminating byte"
+ };
+ static const unsigned char outputs[8][32] = {
+ {0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55},
+ {0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23, 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c, 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad},
+ {0xf7, 0x84, 0x6f, 0x55, 0xcf, 0x23, 0xe1, 0x4e, 0xeb, 0xea, 0xb5, 0xb4, 0xe1, 0x55, 0x0c, 0xad, 0x5b, 0x50, 0x9e, 0x33, 0x48, 0xfb, 0xc4, 0xef, 0xa3, 0xa1, 0x41, 0x3d, 0x39, 0x3c, 0xb6, 0x50},
+ {0xf3, 0x0c, 0xeb, 0x2b, 0xb2, 0x82, 0x9e, 0x79, 0xe4, 0xca, 0x97, 0x53, 0xd3, 0x5a, 0x8e, 0xcc, 0x00, 0x26, 0x2d, 0x16, 0x4c, 0xc0, 0x77, 0x08, 0x02, 0x95, 0x38, 0x1c, 0xbd, 0x64, 0x3f, 0x0d},
+ {0x68, 0x19, 0xd9, 0x15, 0xc7, 0x3f, 0x4d, 0x1e, 0x77, 0xe4, 0xe1, 0xb5, 0x2d, 0x1f, 0xa0, 0xf9, 0xcf, 0x9b, 0xea, 0xea, 0xd3, 0x93, 0x9f, 0x15, 0x87, 0x4b, 0xd9, 0x88, 0xe2, 0xa2, 0x36, 0x30},
+ {0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8, 0xe5, 0xc0, 0x26, 0x93, 0x0c, 0x3e, 0x60, 0x39, 0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff, 0x21, 0x67, 0xf6, 0xec, 0xed, 0xd4, 0x19, 0xdb, 0x06, 0xc1},
+ {0xf0, 0x8a, 0x78, 0xcb, 0xba, 0xee, 0x08, 0x2b, 0x05, 0x2a, 0xe0, 0x70, 0x8f, 0x32, 0xfa, 0x1e, 0x50, 0xc5, 0xc4, 0x21, 0xaa, 0x77, 0x2b, 0xa5, 0xdb, 0xb4, 0x06, 0xa2, 0xea, 0x6b, 0xe3, 0x42},
+ {0xab, 0x64, 0xef, 0xf7, 0xe8, 0x8e, 0x2e, 0x46, 0x16, 0x5e, 0x29, 0xf2, 0xbc, 0xe4, 0x18, 0x26, 0xbd, 0x4c, 0x7b, 0x35, 0x52, 0xf6, 0xb3, 0x82, 0xa9, 0xe7, 0xd3, 0xaf, 0x47, 0xc2, 0x45, 0xf8}
+ };
+ int i;
+ for (i = 0; i < 8; i++) {
+ unsigned char out[32];
+ secp256k1_sha256_t hasher;
+ secp256k1_sha256_initialize(&hasher);
+ secp256k1_sha256_write(&hasher, (const unsigned char*)(inputs[i]), strlen(inputs[i]));
+ secp256k1_sha256_finalize(&hasher, out);
+ CHECK(memcmp(out, outputs[i], 32) == 0);
+ if (strlen(inputs[i]) > 0) {
+ int split = secp256k1_rand32() % strlen(inputs[i]);
+ secp256k1_sha256_initialize(&hasher);
+ secp256k1_sha256_write(&hasher, (const unsigned char*)(inputs[i]), split);
+ secp256k1_sha256_write(&hasher, (const unsigned char*)(inputs[i] + split), strlen(inputs[i]) - split);
+ secp256k1_sha256_finalize(&hasher, out);
+ CHECK(memcmp(out, outputs[i], 32) == 0);
+ }
+ }
+}
+
+void run_hmac_sha256_tests(void) {
+ static const char *keys[6] = {
+ "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
+ "\x4a\x65\x66\x65",
+ "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
+ "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
+ "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
+ "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
+ };
+ static const char *inputs[6] = {
+ "\x48\x69\x20\x54\x68\x65\x72\x65",
+ "\x77\x68\x61\x74\x20\x64\x6f\x20\x79\x61\x20\x77\x61\x6e\x74\x20\x66\x6f\x72\x20\x6e\x6f\x74\x68\x69\x6e\x67\x3f",
+ "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd",
+ "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd",
+ "\x54\x65\x73\x74\x20\x55\x73\x69\x6e\x67\x20\x4c\x61\x72\x67\x65\x72\x20\x54\x68\x61\x6e\x20\x42\x6c\x6f\x63\x6b\x2d\x53\x69\x7a\x65\x20\x4b\x65\x79\x20\x2d\x20\x48\x61\x73\x68\x20\x4b\x65\x79\x20\x46\x69\x72\x73\x74",
+ "\x54\x68\x69\x73\x20\x69\x73\x20\x61\x20\x74\x65\x73\x74\x20\x75\x73\x69\x6e\x67\x20\x61\x20\x6c\x61\x72\x67\x65\x72\x20\x74\x68\x61\x6e\x20\x62\x6c\x6f\x63\x6b\x2d\x73\x69\x7a\x65\x20\x6b\x65\x79\x20\x61\x6e\x64\x20\x61\x20\x6c\x61\x72\x67\x65\x72\x20\x74\x68\x61\x6e\x20\x62\x6c\x6f\x63\x6b\x2d\x73\x69\x7a\x65\x20\x64\x61\x74\x61\x2e\x20\x54\x68\x65\x20\x6b\x65\x79\x20\x6e\x65\x65\x64\x73\x20\x74\x6f\x20\x62\x65\x20\x68\x61\x73\x68\x65\x64\x20\x62\x65\x66\x6f\x72\x65\x20\x62\x65\x69\x6e\x67\x20\x75\x73\x65\x64\x20\x62\x79\x20\x74\x68\x65\x20\x48\x4d\x41\x43\x20\x61\x6c\x67\x6f\x72\x69\x74\x68\x6d\x2e"
+ };
+ static const unsigned char outputs[6][32] = {
+ {0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53, 0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0x0b, 0xf1, 0x2b, 0x88, 0x1d, 0xc2, 0x00, 0xc9, 0x83, 0x3d, 0xa7, 0x26, 0xe9, 0x37, 0x6c, 0x2e, 0x32, 0xcf, 0xf7},
+ {0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e, 0x6a, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xc7, 0x5a, 0x00, 0x3f, 0x08, 0x9d, 0x27, 0x39, 0x83, 0x9d, 0xec, 0x58, 0xb9, 0x64, 0xec, 0x38, 0x43},
+ {0x77, 0x3e, 0xa9, 0x1e, 0x36, 0x80, 0x0e, 0x46, 0x85, 0x4d, 0xb8, 0xeb, 0xd0, 0x91, 0x81, 0xa7, 0x29, 0x59, 0x09, 0x8b, 0x3e, 0xf8, 0xc1, 0x22, 0xd9, 0x63, 0x55, 0x14, 0xce, 0xd5, 0x65, 0xfe},
+ {0x82, 0x55, 0x8a, 0x38, 0x9a, 0x44, 0x3c, 0x0e, 0xa4, 0xcc, 0x81, 0x98, 0x99, 0xf2, 0x08, 0x3a, 0x85, 0xf0, 0xfa, 0xa3, 0xe5, 0x78, 0xf8, 0x07, 0x7a, 0x2e, 0x3f, 0xf4, 0x67, 0x29, 0x66, 0x5b},
+ {0x60, 0xe4, 0x31, 0x59, 0x1e, 0xe0, 0xb6, 0x7f, 0x0d, 0x8a, 0x26, 0xaa, 0xcb, 0xf5, 0xb7, 0x7f, 0x8e, 0x0b, 0xc6, 0x21, 0x37, 0x28, 0xc5, 0x14, 0x05, 0x46, 0x04, 0x0f, 0x0e, 0xe3, 0x7f, 0x54},
+ {0x9b, 0x09, 0xff, 0xa7, 0x1b, 0x94, 0x2f, 0xcb, 0x27, 0x63, 0x5f, 0xbc, 0xd5, 0xb0, 0xe9, 0x44, 0xbf, 0xdc, 0x63, 0x64, 0x4f, 0x07, 0x13, 0x93, 0x8a, 0x7f, 0x51, 0x53, 0x5c, 0x3a, 0x35, 0xe2}
+ };
+ int i;
+ for (i = 0; i < 6; i++) {
+ secp256k1_hmac_sha256_t hasher;
+ unsigned char out[32];
+ secp256k1_hmac_sha256_initialize(&hasher, (const unsigned char*)(keys[i]), strlen(keys[i]));
+ secp256k1_hmac_sha256_write(&hasher, (const unsigned char*)(inputs[i]), strlen(inputs[i]));
+ secp256k1_hmac_sha256_finalize(&hasher, out);
+ CHECK(memcmp(out, outputs[i], 32) == 0);
+ if (strlen(inputs[i]) > 0) {
+ int split = secp256k1_rand32() % strlen(inputs[i]);
+ secp256k1_hmac_sha256_initialize(&hasher, (const unsigned char*)(keys[i]), strlen(keys[i]));
+ secp256k1_hmac_sha256_write(&hasher, (const unsigned char*)(inputs[i]), split);
+ secp256k1_hmac_sha256_write(&hasher, (const unsigned char*)(inputs[i] + split), strlen(inputs[i]) - split);
+ secp256k1_hmac_sha256_finalize(&hasher, out);
+ CHECK(memcmp(out, outputs[i], 32) == 0);
+ }
+ }
+}
+
+void run_rfc6979_hmac_sha256_tests(void) {
+ static const unsigned char key1[32] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x00};
+ static const unsigned char msg1[32] = {0x4b, 0xf5, 0x12, 0x2f, 0x34, 0x45, 0x54, 0xc5, 0x3b, 0xde, 0x2e, 0xbb, 0x8c, 0xd2, 0xb7, 0xe3, 0xd1, 0x60, 0x0a, 0xd6, 0x31, 0xc3, 0x85, 0xa5, 0xd7, 0xcc, 0xe2, 0x3c, 0x77, 0x85, 0x45, 0x9a};
+ static const unsigned char out1[3][32] = {
+ {0x4f, 0xe2, 0x95, 0x25, 0xb2, 0x08, 0x68, 0x09, 0x15, 0x9a, 0xcd, 0xf0, 0x50, 0x6e, 0xfb, 0x86, 0xb0, 0xec, 0x93, 0x2c, 0x7b, 0xa4, 0x42, 0x56, 0xab, 0x32, 0x1e, 0x42, 0x1e, 0x67, 0xe9, 0xfb},
+ {0x2b, 0xf0, 0xff, 0xf1, 0xd3, 0xc3, 0x78, 0xa2, 0x2d, 0xc5, 0xde, 0x1d, 0x85, 0x65, 0x22, 0x32, 0x5c, 0x65, 0xb5, 0x04, 0x49, 0x1a, 0x0c, 0xbd, 0x01, 0xcb, 0x8f, 0x3a, 0xa6, 0x7f, 0xfd, 0x4a},
+ {0xf5, 0x28, 0xb4, 0x10, 0xcb, 0x54, 0x1f, 0x77, 0x00, 0x0d, 0x7a, 0xfb, 0x6c, 0x5b, 0x53, 0xc5, 0xc4, 0x71, 0xea, 0xb4, 0x3e, 0x46, 0x6d, 0x9a, 0xc5, 0x19, 0x0c, 0x39, 0xc8, 0x2f, 0xd8, 0x2e}
+ };
+
+ static const unsigned char key2[32] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+ static const unsigned char msg2[32] = {0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55};
+ static const unsigned char out2[3][32] = {
+ {0x9c, 0x23, 0x6c, 0x16, 0x5b, 0x82, 0xae, 0x0c, 0xd5, 0x90, 0x65, 0x9e, 0x10, 0x0b, 0x6b, 0xab, 0x30, 0x36, 0xe7, 0xba, 0x8b, 0x06, 0x74, 0x9b, 0xaf, 0x69, 0x81, 0xe1, 0x6f, 0x1a, 0x2b, 0x95},
+ {0xdf, 0x47, 0x10, 0x61, 0x62, 0x5b, 0xc0, 0xea, 0x14, 0xb6, 0x82, 0xfe, 0xee, 0x2c, 0x9c, 0x02, 0xf2, 0x35, 0xda, 0x04, 0x20, 0x4c, 0x1d, 0x62, 0xa1, 0x53, 0x6c, 0x6e, 0x17, 0xae, 0xd7, 0xa9},
+ {0x75, 0x97, 0x88, 0x7c, 0xbd, 0x76, 0x32, 0x1f, 0x32, 0xe3, 0x04, 0x40, 0x67, 0x9a, 0x22, 0xcf, 0x7f, 0x8d, 0x9d, 0x2e, 0xac, 0x39, 0x0e, 0x58, 0x1f, 0xea, 0x09, 0x1c, 0xe2, 0x02, 0xba, 0x94}
+ };
+
+ secp256k1_rfc6979_hmac_sha256_t rng;
+ unsigned char out[32];
+ unsigned char zero[1] = {0};
+ int i;
+
+ secp256k1_rfc6979_hmac_sha256_initialize(&rng, key1, 32, msg1, 32, NULL, 1);
+ for (i = 0; i < 3; i++) {
+ secp256k1_rfc6979_hmac_sha256_generate(&rng, out, 32);
+ CHECK(memcmp(out, out1[i], 32) == 0);
+ }
+ secp256k1_rfc6979_hmac_sha256_finalize(&rng);
+
+ secp256k1_rfc6979_hmac_sha256_initialize(&rng, key1, 32, msg1, 32, zero, 1);
+ for (i = 0; i < 3; i++) {
+ secp256k1_rfc6979_hmac_sha256_generate(&rng, out, 32);
+ CHECK(memcmp(out, out1[i], 32) != 0);
+ }
+ secp256k1_rfc6979_hmac_sha256_finalize(&rng);
+
+ secp256k1_rfc6979_hmac_sha256_initialize(&rng, key2, 32, msg2, 32, zero, 0);
+ for (i = 0; i < 3; i++) {
+ secp256k1_rfc6979_hmac_sha256_generate(&rng, out, 32);
+ CHECK(memcmp(out, out2[i], 32) == 0);
+ }
+ secp256k1_rfc6979_hmac_sha256_finalize(&rng);
+}
+
+/***** NUM TESTS *****/
+
+#ifndef USE_NUM_NONE
+void random_num_negate(secp256k1_num_t *num) {
+ if (secp256k1_rand32() & 1) {
+ secp256k1_num_negate(num);
+ }
+}
+
+void random_num_order_test(secp256k1_num_t *num) {
+ secp256k1_scalar_t sc;
+ random_scalar_order_test(&sc);
+ secp256k1_scalar_get_num(num, &sc);
+}
+
+void random_num_order(secp256k1_num_t *num) {
+ secp256k1_scalar_t sc;
+ random_scalar_order(&sc);
+ secp256k1_scalar_get_num(num, &sc);
+}
+
+void test_num_negate(void) {
+ secp256k1_num_t n1;
+ secp256k1_num_t n2;
+ random_num_order_test(&n1); /* n1 = R */
+ random_num_negate(&n1);
+ secp256k1_num_copy(&n2, &n1); /* n2 = R */
+ secp256k1_num_sub(&n1, &n2, &n1); /* n1 = n2-n1 = 0 */
+ CHECK(secp256k1_num_is_zero(&n1));
+ secp256k1_num_copy(&n1, &n2); /* n1 = R */
+ secp256k1_num_negate(&n1); /* n1 = -R */
+ CHECK(!secp256k1_num_is_zero(&n1));
+ secp256k1_num_add(&n1, &n2, &n1); /* n1 = n2+n1 = 0 */
+ CHECK(secp256k1_num_is_zero(&n1));
+ secp256k1_num_copy(&n1, &n2); /* n1 = R */
+ secp256k1_num_negate(&n1); /* n1 = -R */
+ CHECK(secp256k1_num_is_neg(&n1) != secp256k1_num_is_neg(&n2));
+ secp256k1_num_negate(&n1); /* n1 = R */
+ CHECK(secp256k1_num_eq(&n1, &n2));
+}
+
+void test_num_add_sub(void) {
+ secp256k1_num_t n1;
+ secp256k1_num_t n2;
+ secp256k1_num_t n1p2, n2p1, n1m2, n2m1;
+ int r = secp256k1_rand32();
+ random_num_order_test(&n1); /* n1 = R1 */
+ if (r & 1) {
+ random_num_negate(&n1);
+ }
+ random_num_order_test(&n2); /* n2 = R2 */
+ if (r & 2) {
+ random_num_negate(&n2);
+ }
+ secp256k1_num_add(&n1p2, &n1, &n2); /* n1p2 = R1 + R2 */
+ secp256k1_num_add(&n2p1, &n2, &n1); /* n2p1 = R2 + R1 */
+ secp256k1_num_sub(&n1m2, &n1, &n2); /* n1m2 = R1 - R2 */
+ secp256k1_num_sub(&n2m1, &n2, &n1); /* n2m1 = R2 - R1 */
+ CHECK(secp256k1_num_eq(&n1p2, &n2p1));
+ CHECK(!secp256k1_num_eq(&n1p2, &n1m2));
+ secp256k1_num_negate(&n2m1); /* n2m1 = -R2 + R1 */
+ CHECK(secp256k1_num_eq(&n2m1, &n1m2));
+ CHECK(!secp256k1_num_eq(&n2m1, &n1));
+ secp256k1_num_add(&n2m1, &n2m1, &n2); /* n2m1 = -R2 + R1 + R2 = R1 */
+ CHECK(secp256k1_num_eq(&n2m1, &n1));
+ CHECK(!secp256k1_num_eq(&n2p1, &n1));
+ secp256k1_num_sub(&n2p1, &n2p1, &n2); /* n2p1 = R2 + R1 - R2 = R1 */
+ CHECK(secp256k1_num_eq(&n2p1, &n1));
+}
+
+void run_num_smalltests(void) {
+ int i;
+ for (i = 0; i < 100*count; i++) {
+ test_num_negate();
+ test_num_add_sub();
+ }
+}
+#endif
+
+/***** SCALAR TESTS *****/
+
+void scalar_test(void) {
+ secp256k1_scalar_t s;
+ secp256k1_scalar_t s1;
+ secp256k1_scalar_t s2;
+#ifndef USE_NUM_NONE
+ secp256k1_num_t snum, s1num, s2num;
+ secp256k1_num_t order, half_order;
+#endif
+ unsigned char c[32];
+
+ /* Set 's' to a random scalar, with value 'snum'. */
+ random_scalar_order_test(&s);
+
+ /* Set 's1' to a random scalar, with value 's1num'. */
+ random_scalar_order_test(&s1);
+
+ /* Set 's2' to a random scalar, with value 'snum2', and byte array representation 'c'. */
+ random_scalar_order_test(&s2);
+ secp256k1_scalar_get_b32(c, &s2);
+
+#ifndef USE_NUM_NONE
+ secp256k1_scalar_get_num(&snum, &s);
+ secp256k1_scalar_get_num(&s1num, &s1);
+ secp256k1_scalar_get_num(&s2num, &s2);
+
+ secp256k1_scalar_order_get_num(&order);
+ half_order = order;
+ secp256k1_num_shift(&half_order, 1);
+#endif
+
+ {
+ int i;
+ /* Test that fetching groups of 4 bits from a scalar and recursing n(i)=16*n(i-1)+p(i) reconstructs it. */
+ secp256k1_scalar_t n;
+ secp256k1_scalar_set_int(&n, 0);
+ for (i = 0; i < 256; i += 4) {
+ secp256k1_scalar_t t;
+ int j;
+ secp256k1_scalar_set_int(&t, secp256k1_scalar_get_bits(&s, 256 - 4 - i, 4));
+ for (j = 0; j < 4; j++) {
+ secp256k1_scalar_add(&n, &n, &n);
+ }
+ secp256k1_scalar_add(&n, &n, &t);
+ }
+ CHECK(secp256k1_scalar_eq(&n, &s));
+ }
+
+ {
+ /* Test that fetching groups of randomly-sized bits from a scalar and recursing n(i)=b*n(i-1)+p(i) reconstructs it. */
+ secp256k1_scalar_t n;
+ int i = 0;
+ secp256k1_scalar_set_int(&n, 0);
+ while (i < 256) {
+ secp256k1_scalar_t t;
+ int j;
+ int now = (secp256k1_rand32() % 15) + 1;
+ if (now + i > 256) {
+ now = 256 - i;
+ }
+ secp256k1_scalar_set_int(&t, secp256k1_scalar_get_bits_var(&s, 256 - now - i, now));
+ for (j = 0; j < now; j++) {
+ secp256k1_scalar_add(&n, &n, &n);
+ }
+ secp256k1_scalar_add(&n, &n, &t);
+ i += now;
+ }
+ CHECK(secp256k1_scalar_eq(&n, &s));
+ }
+
+#ifndef USE_NUM_NONE
+ {
+ /* Test that adding the scalars together is equal to adding their numbers together modulo the order. */
+ secp256k1_num_t rnum;
+ secp256k1_num_t r2num;
+ secp256k1_scalar_t r;
+ secp256k1_num_add(&rnum, &snum, &s2num);
+ secp256k1_num_mod(&rnum, &order);
+ secp256k1_scalar_add(&r, &s, &s2);
+ secp256k1_scalar_get_num(&r2num, &r);
+ CHECK(secp256k1_num_eq(&rnum, &r2num));
+ }
+
+ {
+ /* Test that multipying the scalars is equal to multiplying their numbers modulo the order. */
+ secp256k1_scalar_t r;
+ secp256k1_num_t r2num;
+ secp256k1_num_t rnum;
+ secp256k1_num_mul(&rnum, &snum, &s2num);
+ secp256k1_num_mod(&rnum, &order);
+ secp256k1_scalar_mul(&r, &s, &s2);
+ secp256k1_scalar_get_num(&r2num, &r);
+ CHECK(secp256k1_num_eq(&rnum, &r2num));
+ /* The result can only be zero if at least one of the factors was zero. */
+ CHECK(secp256k1_scalar_is_zero(&r) == (secp256k1_scalar_is_zero(&s) || secp256k1_scalar_is_zero(&s2)));
+ /* The results can only be equal to one of the factors if that factor was zero, or the other factor was one. */
+ CHECK(secp256k1_num_eq(&rnum, &snum) == (secp256k1_scalar_is_zero(&s) || secp256k1_scalar_is_one(&s2)));
+ CHECK(secp256k1_num_eq(&rnum, &s2num) == (secp256k1_scalar_is_zero(&s2) || secp256k1_scalar_is_one(&s)));
+ }
+
+ {
+ secp256k1_scalar_t neg;
+ secp256k1_num_t negnum;
+ secp256k1_num_t negnum2;
+ /* Check that comparison with zero matches comparison with zero on the number. */
+ CHECK(secp256k1_num_is_zero(&snum) == secp256k1_scalar_is_zero(&s));
+ /* Check that comparison with the half order is equal to testing for high scalar. */
+ CHECK(secp256k1_scalar_is_high(&s) == (secp256k1_num_cmp(&snum, &half_order) > 0));
+ secp256k1_scalar_negate(&neg, &s);
+ secp256k1_num_sub(&negnum, &order, &snum);
+ secp256k1_num_mod(&negnum, &order);
+ /* Check that comparison with the half order is equal to testing for high scalar after negation. */
+ CHECK(secp256k1_scalar_is_high(&neg) == (secp256k1_num_cmp(&negnum, &half_order) > 0));
+ /* Negating should change the high property, unless the value was already zero. */
+ CHECK((secp256k1_scalar_is_high(&s) == secp256k1_scalar_is_high(&neg)) == secp256k1_scalar_is_zero(&s));
+ secp256k1_scalar_get_num(&negnum2, &neg);
+ /* Negating a scalar should be equal to (order - n) mod order on the number. */
+ CHECK(secp256k1_num_eq(&negnum, &negnum2));
+ secp256k1_scalar_add(&neg, &neg, &s);
+ /* Adding a number to its negation should result in zero. */
+ CHECK(secp256k1_scalar_is_zero(&neg));
+ secp256k1_scalar_negate(&neg, &neg);
+ /* Negating zero should still result in zero. */
+ CHECK(secp256k1_scalar_is_zero(&neg));
+ }
+
+ {
+ /* Test secp256k1_scalar_mul_shift_var. */
+ secp256k1_scalar_t r;
+ secp256k1_num_t one;
+ secp256k1_num_t rnum;
+ secp256k1_num_t rnum2;
+ unsigned char cone[1] = {0x01};
+ unsigned int shift = 256 + (secp256k1_rand32() % 257);
+ secp256k1_scalar_mul_shift_var(&r, &s1, &s2, shift);
+ secp256k1_num_mul(&rnum, &s1num, &s2num);
+ secp256k1_num_shift(&rnum, shift - 1);
+ secp256k1_num_set_bin(&one, cone, 1);
+ secp256k1_num_add(&rnum, &rnum, &one);
+ secp256k1_num_shift(&rnum, 1);
+ secp256k1_scalar_get_num(&rnum2, &r);
+ CHECK(secp256k1_num_eq(&rnum, &rnum2));
+ }
+#endif
+
+ {
+ /* Test that scalar inverses are equal to the inverse of their number modulo the order. */
+ if (!secp256k1_scalar_is_zero(&s)) {
+ secp256k1_scalar_t inv;
+#ifndef USE_NUM_NONE
+ secp256k1_num_t invnum;
+ secp256k1_num_t invnum2;
+#endif
+ secp256k1_scalar_inverse(&inv, &s);
+#ifndef USE_NUM_NONE
+ secp256k1_num_mod_inverse(&invnum, &snum, &order);
+ secp256k1_scalar_get_num(&invnum2, &inv);
+ CHECK(secp256k1_num_eq(&invnum, &invnum2));
+#endif
+ secp256k1_scalar_mul(&inv, &inv, &s);
+ /* Multiplying a scalar with its inverse must result in one. */
+ CHECK(secp256k1_scalar_is_one(&inv));
+ secp256k1_scalar_inverse(&inv, &inv);
+ /* Inverting one must result in one. */
+ CHECK(secp256k1_scalar_is_one(&inv));
+ }
+ }
+
+ {
+ /* Test commutativity of add. */
+ secp256k1_scalar_t r1, r2;
+ secp256k1_scalar_add(&r1, &s1, &s2);
+ secp256k1_scalar_add(&r2, &s2, &s1);
+ CHECK(secp256k1_scalar_eq(&r1, &r2));
+ }
+
+ {
+ secp256k1_scalar_t r1, r2;
+ secp256k1_scalar_t b;
+ int i;
+ /* Test add_bit. */
+ int bit = secp256k1_rand32() % 256;
+ secp256k1_scalar_set_int(&b, 1);
+ CHECK(secp256k1_scalar_is_one(&b));
+ for (i = 0; i < bit; i++) {
+ secp256k1_scalar_add(&b, &b, &b);
+ }
+ r1 = s1;
+ r2 = s1;
+ if (!secp256k1_scalar_add(&r1, &r1, &b)) {
+ /* No overflow happened. */
+ secp256k1_scalar_add_bit(&r2, bit);
+ CHECK(secp256k1_scalar_eq(&r1, &r2));
+ }
+ }
+
+ {
+ /* Test commutativity of mul. */
+ secp256k1_scalar_t r1, r2;
+ secp256k1_scalar_mul(&r1, &s1, &s2);
+ secp256k1_scalar_mul(&r2, &s2, &s1);
+ CHECK(secp256k1_scalar_eq(&r1, &r2));
+ }
+
+ {
+ /* Test associativity of add. */
+ secp256k1_scalar_t r1, r2;
+ secp256k1_scalar_add(&r1, &s1, &s2);
+ secp256k1_scalar_add(&r1, &r1, &s);
+ secp256k1_scalar_add(&r2, &s2, &s);
+ secp256k1_scalar_add(&r2, &s1, &r2);
+ CHECK(secp256k1_scalar_eq(&r1, &r2));
+ }
+
+ {
+ /* Test associativity of mul. */
+ secp256k1_scalar_t r1, r2;
+ secp256k1_scalar_mul(&r1, &s1, &s2);
+ secp256k1_scalar_mul(&r1, &r1, &s);
+ secp256k1_scalar_mul(&r2, &s2, &s);
+ secp256k1_scalar_mul(&r2, &s1, &r2);
+ CHECK(secp256k1_scalar_eq(&r1, &r2));
+ }
+
+ {
+ /* Test distributitivity of mul over add. */
+ secp256k1_scalar_t r1, r2, t;
+ secp256k1_scalar_add(&r1, &s1, &s2);
+ secp256k1_scalar_mul(&r1, &r1, &s);
+ secp256k1_scalar_mul(&r2, &s1, &s);
+ secp256k1_scalar_mul(&t, &s2, &s);
+ secp256k1_scalar_add(&r2, &r2, &t);
+ CHECK(secp256k1_scalar_eq(&r1, &r2));
+ }
+
+ {
+ /* Test square. */
+ secp256k1_scalar_t r1, r2;
+ secp256k1_scalar_sqr(&r1, &s1);
+ secp256k1_scalar_mul(&r2, &s1, &s1);
+ CHECK(secp256k1_scalar_eq(&r1, &r2));
+ }
+
+ {
+ /* Test multiplicative identity. */
+ secp256k1_scalar_t r1, v1;
+ secp256k1_scalar_set_int(&v1,1);
+ secp256k1_scalar_mul(&r1, &s1, &v1);
+ CHECK(secp256k1_scalar_eq(&r1, &s1));
+ }
+
+ {
+ /* Test additive identity. */
+ secp256k1_scalar_t r1, v0;
+ secp256k1_scalar_set_int(&v0,0);
+ secp256k1_scalar_add(&r1, &s1, &v0);
+ CHECK(secp256k1_scalar_eq(&r1, &s1));
+ }
+
+ {
+ /* Test zero product property. */
+ secp256k1_scalar_t r1, v0;
+ secp256k1_scalar_set_int(&v0,0);
+ secp256k1_scalar_mul(&r1, &s1, &v0);
+ CHECK(secp256k1_scalar_eq(&r1, &v0));
+ }
+
+}
+
+void run_scalar_tests(void) {
+ int i;
+ for (i = 0; i < 128 * count; i++) {
+ scalar_test();
+ }
+
+ {
+ /* (-1)+1 should be zero. */
+ secp256k1_scalar_t s, o;
+ secp256k1_scalar_set_int(&s, 1);
+ CHECK(secp256k1_scalar_is_one(&s));
+ secp256k1_scalar_negate(&o, &s);
+ secp256k1_scalar_add(&o, &o, &s);
+ CHECK(secp256k1_scalar_is_zero(&o));
+ secp256k1_scalar_negate(&o, &o);
+ CHECK(secp256k1_scalar_is_zero(&o));
+ }
+
+#ifndef USE_NUM_NONE
+ {
+ /* A scalar with value of the curve order should be 0. */
+ secp256k1_num_t order;
+ secp256k1_scalar_t zero;
+ unsigned char bin[32];
+ int overflow = 0;
+ secp256k1_scalar_order_get_num(&order);
+ secp256k1_num_get_bin(bin, 32, &order);
+ secp256k1_scalar_set_b32(&zero, bin, &overflow);
+ CHECK(overflow == 1);
+ CHECK(secp256k1_scalar_is_zero(&zero));
+ }
+#endif
+}
+
+/***** FIELD TESTS *****/
+
+void random_fe(secp256k1_fe_t *x) {
+ unsigned char bin[32];
+ do {
+ secp256k1_rand256(bin);
+ if (secp256k1_fe_set_b32(x, bin)) {
+ return;
+ }
+ } while(1);
+}
+
+void random_fe_non_zero(secp256k1_fe_t *nz) {
+ int tries = 10;
+ while (--tries >= 0) {
+ random_fe(nz);
+ secp256k1_fe_normalize(nz);
+ if (!secp256k1_fe_is_zero(nz)) {
+ break;
+ }
+ }
+ /* Infinitesimal probability of spurious failure here */
+ CHECK(tries >= 0);
+}
+
+void random_fe_non_square(secp256k1_fe_t *ns) {
+ secp256k1_fe_t r;
+ random_fe_non_zero(ns);
+ if (secp256k1_fe_sqrt_var(&r, ns)) {
+ secp256k1_fe_negate(ns, ns, 1);
+ }
+}
+
+int check_fe_equal(const secp256k1_fe_t *a, const secp256k1_fe_t *b) {
+ secp256k1_fe_t an = *a;
+ secp256k1_fe_t bn = *b;
+ secp256k1_fe_normalize_weak(&an);
+ secp256k1_fe_normalize_var(&bn);
+ return secp256k1_fe_equal_var(&an, &bn);
+}
+
+int check_fe_inverse(const secp256k1_fe_t *a, const secp256k1_fe_t *ai) {
+ secp256k1_fe_t x;
+ secp256k1_fe_t one = SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 1);
+ secp256k1_fe_mul(&x, a, ai);
+ return check_fe_equal(&x, &one);
+}
+
+void run_field_convert(void) {
+ static const unsigned char b32[32] = {
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
+ 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29,
+ 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x40
+ };
+ static const secp256k1_fe_storage_t fes = SECP256K1_FE_STORAGE_CONST(
+ 0x00010203UL, 0x04050607UL, 0x11121314UL, 0x15161718UL,
+ 0x22232425UL, 0x26272829UL, 0x33343536UL, 0x37383940UL
+ );
+ static const secp256k1_fe_t fe = SECP256K1_FE_CONST(
+ 0x00010203UL, 0x04050607UL, 0x11121314UL, 0x15161718UL,
+ 0x22232425UL, 0x26272829UL, 0x33343536UL, 0x37383940UL
+ );
+ secp256k1_fe_t fe2;
+ unsigned char b322[32];
+ secp256k1_fe_storage_t fes2;
+ /* Check conversions to fe. */
+ CHECK(secp256k1_fe_set_b32(&fe2, b32));
+ CHECK(secp256k1_fe_equal_var(&fe, &fe2));
+ secp256k1_fe_from_storage(&fe2, &fes);
+ CHECK(secp256k1_fe_equal_var(&fe, &fe2));
+ /* Check conversion from fe. */
+ secp256k1_fe_get_b32(b322, &fe);
+ CHECK(memcmp(b322, b32, 32) == 0);
+ secp256k1_fe_to_storage(&fes2, &fe);
+ CHECK(memcmp(&fes2, &fes, sizeof(fes)) == 0);
+}
+
+void run_field_misc(void) {
+ secp256k1_fe_t x;
+ secp256k1_fe_t y;
+ secp256k1_fe_t z;
+ secp256k1_fe_t q;
+ secp256k1_fe_t fe5 = SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 5);
+ int i;
+ for (i = 0; i < 5*count; i++) {
+ secp256k1_fe_storage_t xs, ys, zs;
+ random_fe(&x);
+ random_fe_non_zero(&y);
+ /* Test the fe equality and comparison operations. */
+ CHECK(secp256k1_fe_cmp_var(&x, &x) == 0);
+ CHECK(secp256k1_fe_equal_var(&x, &x));
+ z = x;
+ secp256k1_fe_add(&z,&y);
+ secp256k1_fe_normalize(&z);
+ /* Test storage conversion and conditional moves. */
+ secp256k1_fe_to_storage(&xs, &x);
+ secp256k1_fe_to_storage(&ys, &y);
+ secp256k1_fe_to_storage(&zs, &z);
+ secp256k1_fe_storage_cmov(&zs, &xs, 0);
+ CHECK(memcmp(&xs, &zs, sizeof(xs)) != 0);
+ secp256k1_fe_storage_cmov(&ys, &xs, 1);
+ CHECK(memcmp(&xs, &ys, sizeof(xs)) == 0);
+ secp256k1_fe_from_storage(&x, &xs);
+ secp256k1_fe_from_storage(&y, &ys);
+ secp256k1_fe_from_storage(&z, &zs);
+ /* Test that mul_int, mul, and add agree. */
+ secp256k1_fe_add(&y, &x);
+ secp256k1_fe_add(&y, &x);
+ z = x;
+ secp256k1_fe_mul_int(&z, 3);
+ CHECK(check_fe_equal(&y, &z));
+ secp256k1_fe_add(&y, &x);
+ secp256k1_fe_add(&z, &x);
+ CHECK(check_fe_equal(&z, &y));
+ z = x;
+ secp256k1_fe_mul_int(&z, 5);
+ secp256k1_fe_mul(&q, &x, &fe5);
+ CHECK(check_fe_equal(&z, &q));
+ secp256k1_fe_negate(&x, &x, 1);
+ secp256k1_fe_add(&z, &x);
+ secp256k1_fe_add(&q, &x);
+ CHECK(check_fe_equal(&y, &z));
+ CHECK(check_fe_equal(&q, &y));
+ }
+}
+
+void run_field_inv(void) {
+ secp256k1_fe_t x, xi, xii;
+ int i;
+ for (i = 0; i < 10*count; i++) {
+ random_fe_non_zero(&x);
+ secp256k1_fe_inv(&xi, &x);
+ CHECK(check_fe_inverse(&x, &xi));
+ secp256k1_fe_inv(&xii, &xi);
+ CHECK(check_fe_equal(&x, &xii));
+ }
+}
+
+void run_field_inv_var(void) {
+ secp256k1_fe_t x, xi, xii;
+ int i;
+ for (i = 0; i < 10*count; i++) {
+ random_fe_non_zero(&x);
+ secp256k1_fe_inv_var(&xi, &x);
+ CHECK(check_fe_inverse(&x, &xi));
+ secp256k1_fe_inv_var(&xii, &xi);
+ CHECK(check_fe_equal(&x, &xii));
+ }
+}
+
+void run_field_inv_all_var(void) {
+ secp256k1_fe_t x[16], xi[16], xii[16];
+ int i;
+ /* Check it's safe to call for 0 elements */
+ secp256k1_fe_inv_all_var(0, xi, x);
+ for (i = 0; i < count; i++) {
+ size_t j;
+ size_t len = (secp256k1_rand32() & 15) + 1;
+ for (j = 0; j < len; j++) {
+ random_fe_non_zero(&x[j]);
+ }
+ secp256k1_fe_inv_all_var(len, xi, x);
+ for (j = 0; j < len; j++) {
+ CHECK(check_fe_inverse(&x[j], &xi[j]));
+ }
+ secp256k1_fe_inv_all_var(len, xii, xi);
+ for (j = 0; j < len; j++) {
+ CHECK(check_fe_equal(&x[j], &xii[j]));
+ }
+ }
+}
+
+void run_sqr(void) {
+ secp256k1_fe_t x, s;
+
+ {
+ int i;
+ secp256k1_fe_set_int(&x, 1);
+ secp256k1_fe_negate(&x, &x, 1);
+
+ for (i = 1; i <= 512; ++i) {
+ secp256k1_fe_mul_int(&x, 2);
+ secp256k1_fe_normalize(&x);
+ secp256k1_fe_sqr(&s, &x);
+ }
+ }
+}
+
+void test_sqrt(const secp256k1_fe_t *a, const secp256k1_fe_t *k) {
+ secp256k1_fe_t r1, r2;
+ int v = secp256k1_fe_sqrt_var(&r1, a);
+ CHECK((v == 0) == (k == NULL));
+
+ if (k != NULL) {
+ /* Check that the returned root is +/- the given known answer */
+ secp256k1_fe_negate(&r2, &r1, 1);
+ secp256k1_fe_add(&r1, k); secp256k1_fe_add(&r2, k);
+ secp256k1_fe_normalize(&r1); secp256k1_fe_normalize(&r2);
+ CHECK(secp256k1_fe_is_zero(&r1) || secp256k1_fe_is_zero(&r2));
+ }
+}
+
+void run_sqrt(void) {
+ secp256k1_fe_t ns, x, s, t;
+ int i;
+
+ /* Check sqrt(0) is 0 */
+ secp256k1_fe_set_int(&x, 0);
+ secp256k1_fe_sqr(&s, &x);
+ test_sqrt(&s, &x);
+
+ /* Check sqrt of small squares (and their negatives) */
+ for (i = 1; i <= 100; i++) {
+ secp256k1_fe_set_int(&x, i);
+ secp256k1_fe_sqr(&s, &x);
+ test_sqrt(&s, &x);
+ secp256k1_fe_negate(&t, &s, 1);
+ test_sqrt(&t, NULL);
+ }
+
+ /* Consistency checks for large random values */
+ for (i = 0; i < 10; i++) {
+ int j;
+ random_fe_non_square(&ns);
+ for (j = 0; j < count; j++) {
+ random_fe(&x);
+ secp256k1_fe_sqr(&s, &x);
+ test_sqrt(&s, &x);
+ secp256k1_fe_negate(&t, &s, 1);
+ test_sqrt(&t, NULL);
+ secp256k1_fe_mul(&t, &s, &ns);
+ test_sqrt(&t, NULL);
+ }
+ }
+}
+
+/***** GROUP TESTS *****/
+
+void ge_equals_ge(const secp256k1_ge_t *a, const secp256k1_ge_t *b) {
+ CHECK(a->infinity == b->infinity);
+ if (a->infinity) {
+ return;
+ }
+ CHECK(secp256k1_fe_equal_var(&a->x, &b->x));
+ CHECK(secp256k1_fe_equal_var(&b->y, &b->y));
+}
+
+void ge_equals_gej(const secp256k1_ge_t *a, const secp256k1_gej_t *b) {
+ secp256k1_fe_t z2s;
+ secp256k1_fe_t u1, u2, s1, s2;
+ CHECK(a->infinity == b->infinity);
+ if (a->infinity) {
+ return;
+ }
+ /* Check a.x * b.z^2 == b.x && a.y * b.z^3 == b.y, to avoid inverses. */
+ secp256k1_fe_sqr(&z2s, &b->z);
+ secp256k1_fe_mul(&u1, &a->x, &z2s);
+ u2 = b->x; secp256k1_fe_normalize_weak(&u2);
+ secp256k1_fe_mul(&s1, &a->y, &z2s); secp256k1_fe_mul(&s1, &s1, &b->z);
+ s2 = b->y; secp256k1_fe_normalize_weak(&s2);
+ CHECK(secp256k1_fe_equal_var(&u1, &u2));
+ CHECK(secp256k1_fe_equal_var(&s1, &s2));
+}
+
+void test_ge(void) {
+ int i, i1;
+ int runs = 4;
+ /* Points: (infinity, p1, p1, -p1, -p1, p2, p2, -p2, -p2, p3, p3, -p3, -p3, p4, p4, -p4, -p4).
+ * The second in each pair of identical points uses a random Z coordinate in the Jacobian form.
+ * All magnitudes are randomized.
+ * All 17*17 combinations of points are added to eachother, using all applicable methods.
+ */
+ secp256k1_ge_t *ge = (secp256k1_ge_t *)malloc(sizeof(secp256k1_ge_t) * (1 + 4 * runs));
+ secp256k1_gej_t *gej = (secp256k1_gej_t *)malloc(sizeof(secp256k1_gej_t) * (1 + 4 * runs));
+ secp256k1_gej_set_infinity(&gej[0]);
+ secp256k1_ge_clear(&ge[0]);
+ secp256k1_ge_set_gej_var(&ge[0], &gej[0]);
+ for (i = 0; i < runs; i++) {
+ int j;
+ secp256k1_ge_t g;
+ random_group_element_test(&g);
+ ge[1 + 4 * i] = g;
+ ge[2 + 4 * i] = g;
+ secp256k1_ge_neg(&ge[3 + 4 * i], &g);
+ secp256k1_ge_neg(&ge[4 + 4 * i], &g);
+ secp256k1_gej_set_ge(&gej[1 + 4 * i], &ge[1 + 4 * i]);
+ random_group_element_jacobian_test(&gej[2 + 4 * i], &ge[2 + 4 * i]);
+ secp256k1_gej_set_ge(&gej[3 + 4 * i], &ge[3 + 4 * i]);
+ random_group_element_jacobian_test(&gej[4 + 4 * i], &ge[4 + 4 * i]);
+ for (j = 0; j < 4; j++) {
+ random_field_element_magnitude(&ge[1 + j + 4 * i].x);
+ random_field_element_magnitude(&ge[1 + j + 4 * i].y);
+ random_field_element_magnitude(&gej[1 + j + 4 * i].x);
+ random_field_element_magnitude(&gej[1 + j + 4 * i].y);
+ random_field_element_magnitude(&gej[1 + j + 4 * i].z);
+ }
+ }
+
+ for (i1 = 0; i1 < 1 + 4 * runs; i1++) {
+ int i2;
+ for (i2 = 0; i2 < 1 + 4 * runs; i2++) {
+ /* Compute reference result using gej + gej (var). */
+ secp256k1_gej_t refj, resj;
+ secp256k1_ge_t ref;
+ secp256k1_gej_add_var(&refj, &gej[i1], &gej[i2]);
+ secp256k1_ge_set_gej_var(&ref, &refj);
+
+ /* Test gej + ge (var). */
+ secp256k1_gej_add_ge_var(&resj, &gej[i1], &ge[i2]);
+ ge_equals_gej(&ref, &resj);
+
+ /* Test gej + ge (const). */
+ if (i2 != 0) {
+ /* secp256k1_gej_add_ge does not support its second argument being infinity. */
+ secp256k1_gej_add_ge(&resj, &gej[i1], &ge[i2]);
+ ge_equals_gej(&ref, &resj);
+ }
+
+ /* Test doubling (var). */
+ if ((i1 == 0 && i2 == 0) || ((i1 + 3)/4 == (i2 + 3)/4 && ((i1 + 3)%4)/2 == ((i2 + 3)%4)/2)) {
+ /* Normal doubling. */
+ secp256k1_gej_double_var(&resj, &gej[i1]);
+ ge_equals_gej(&ref, &resj);
+ secp256k1_gej_double_var(&resj, &gej[i2]);
+ ge_equals_gej(&ref, &resj);
+ }
+
+ /* Test adding opposites. */
+ if ((i1 == 0 && i2 == 0) || ((i1 + 3)/4 == (i2 + 3)/4 && ((i1 + 3)%4)/2 != ((i2 + 3)%4)/2)) {
+ CHECK(secp256k1_ge_is_infinity(&ref));
+ }
+
+ /* Test adding infinity. */
+ if (i1 == 0) {
+ CHECK(secp256k1_ge_is_infinity(&ge[i1]));
+ CHECK(secp256k1_gej_is_infinity(&gej[i1]));
+ ge_equals_gej(&ref, &gej[i2]);
+ }
+ if (i2 == 0) {
+ CHECK(secp256k1_ge_is_infinity(&ge[i2]));
+ CHECK(secp256k1_gej_is_infinity(&gej[i2]));
+ ge_equals_gej(&ref, &gej[i1]);
+ }
+ }
+ }
+
+ /* Test adding all points together in random order equals infinity. */
+ {
+ secp256k1_gej_t sum = SECP256K1_GEJ_CONST_INFINITY;
+ secp256k1_gej_t *gej_shuffled = (secp256k1_gej_t *)malloc((4 * runs + 1) * sizeof(secp256k1_gej_t));
+ for (i = 0; i < 4 * runs + 1; i++) {
+ gej_shuffled[i] = gej[i];
+ }
+ for (i = 0; i < 4 * runs + 1; i++) {
+ int swap = i + secp256k1_rand32() % (4 * runs + 1 - i);
+ if (swap != i) {
+ secp256k1_gej_t t = gej_shuffled[i];
+ gej_shuffled[i] = gej_shuffled[swap];
+ gej_shuffled[swap] = t;
+ }
+ }
+ for (i = 0; i < 4 * runs + 1; i++) {
+ secp256k1_gej_add_var(&sum, &sum, &gej_shuffled[i]);
+ }
+ CHECK(secp256k1_gej_is_infinity(&sum));
+ free(gej_shuffled);
+ }
+
+ /* Test batch gej -> ge conversion. */
+ {
+ secp256k1_ge_t *ge_set_all = (secp256k1_ge_t *)malloc((4 * runs + 1) * sizeof(secp256k1_ge_t));
+ secp256k1_ge_set_all_gej_var(4 * runs + 1, ge_set_all, gej);
+ for (i = 0; i < 4 * runs + 1; i++) {
+ ge_equals_gej(&ge_set_all[i], &gej[i]);
+ }
+ free(ge_set_all);
+ }
+
+ free(ge);
+ free(gej);
+}
+
+void run_ge(void) {
+ int i;
+ for (i = 0; i < count * 32; i++) {
+ test_ge();
+ }
+}
+
+/***** ECMULT TESTS *****/
+
+void run_ecmult_chain(void) {
+ /* random starting point A (on the curve) */
+ secp256k1_gej_t a = SECP256K1_GEJ_CONST(
+ 0x8b30bbe9, 0xae2a9906, 0x96b22f67, 0x0709dff3,
+ 0x727fd8bc, 0x04d3362c, 0x6c7bf458, 0xe2846004,
+ 0xa357ae91, 0x5c4a6528, 0x1309edf2, 0x0504740f,
+ 0x0eb33439, 0x90216b4f, 0x81063cb6, 0x5f2f7e0f
+ );
+ /* two random initial factors xn and gn */
+ secp256k1_scalar_t xn = SECP256K1_SCALAR_CONST(
+ 0x84cc5452, 0xf7fde1ed, 0xb4d38a8c, 0xe9b1b84c,
+ 0xcef31f14, 0x6e569be9, 0x705d357a, 0x42985407
+ );
+ secp256k1_scalar_t gn = SECP256K1_SCALAR_CONST(
+ 0xa1e58d22, 0x553dcd42, 0xb2398062, 0x5d4c57a9,
+ 0x6e9323d4, 0x2b3152e5, 0xca2c3990, 0xedc7c9de
+ );
+ /* two small multipliers to be applied to xn and gn in every iteration: */
+ static const secp256k1_scalar_t xf = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0x1337);
+ static const secp256k1_scalar_t gf = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0x7113);
+ /* accumulators with the resulting coefficients to A and G */
+ secp256k1_scalar_t ae = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 1);
+ secp256k1_scalar_t ge = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0);
+ /* actual points */
+ secp256k1_gej_t x = a;
+ secp256k1_gej_t x2;
+ int i;
+
+ /* the point being computed */
+ x = a;
+ for (i = 0; i < 200*count; i++) {
+ /* in each iteration, compute X = xn*X + gn*G; */
+ secp256k1_ecmult(&x, &x, &xn, &gn);
+ /* also compute ae and ge: the actual accumulated factors for A and G */
+ /* if X was (ae*A+ge*G), xn*X + gn*G results in (xn*ae*A + (xn*ge+gn)*G) */
+ secp256k1_scalar_mul(&ae, &ae, &xn);
+ secp256k1_scalar_mul(&ge, &ge, &xn);
+ secp256k1_scalar_add(&ge, &ge, &gn);
+ /* modify xn and gn */
+ secp256k1_scalar_mul(&xn, &xn, &xf);
+ secp256k1_scalar_mul(&gn, &gn, &gf);
+
+ /* verify */
+ if (i == 19999) {
+ /* expected result after 19999 iterations */
+ secp256k1_gej_t rp = SECP256K1_GEJ_CONST(
+ 0xD6E96687, 0xF9B10D09, 0x2A6F3543, 0x9D86CEBE,
+ 0xA4535D0D, 0x409F5358, 0x6440BD74, 0xB933E830,
+ 0xB95CBCA2, 0xC77DA786, 0x539BE8FD, 0x53354D2D,
+ 0x3B4F566A, 0xE6580454, 0x07ED6015, 0xEE1B2A88
+ );
+
+ secp256k1_gej_neg(&rp, &rp);
+ secp256k1_gej_add_var(&rp, &rp, &x);
+ CHECK(secp256k1_gej_is_infinity(&rp));
+ }
+ }
+ /* redo the computation, but directly with the resulting ae and ge coefficients: */
+ secp256k1_ecmult(&x2, &a, &ae, &ge);
+ secp256k1_gej_neg(&x2, &x2);
+ secp256k1_gej_add_var(&x2, &x2, &x);
+ CHECK(secp256k1_gej_is_infinity(&x2));
+}
+
+void test_point_times_order(const secp256k1_gej_t *point) {
+ /* X * (point + G) + (order-X) * (pointer + G) = 0 */
+ secp256k1_scalar_t x;
+ secp256k1_scalar_t nx;
+ secp256k1_gej_t res1, res2;
+ secp256k1_ge_t res3;
+ unsigned char pub[65];
+ int psize = 65;
+ random_scalar_order_test(&x);
+ secp256k1_scalar_negate(&nx, &x);
+ secp256k1_ecmult(&res1, point, &x, &x); /* calc res1 = x * point + x * G; */
+ secp256k1_ecmult(&res2, point, &nx, &nx); /* calc res2 = (order - x) * point + (order - x) * G; */
+ secp256k1_gej_add_var(&res1, &res1, &res2);
+ CHECK(secp256k1_gej_is_infinity(&res1));
+ CHECK(secp256k1_gej_is_valid_var(&res1) == 0);
+ secp256k1_ge_set_gej(&res3, &res1);
+ CHECK(secp256k1_ge_is_infinity(&res3));
+ CHECK(secp256k1_ge_is_valid_var(&res3) == 0);
+ CHECK(secp256k1_eckey_pubkey_serialize(&res3, pub, &psize, 0) == 0);
+ psize = 65;
+ CHECK(secp256k1_eckey_pubkey_serialize(&res3, pub, &psize, 1) == 0);
+}
+
+void run_point_times_order(void) {
+ int i;
+ secp256k1_fe_t x = SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 2);
+ static const secp256k1_fe_t xr = SECP256K1_FE_CONST(
+ 0x7603CB59, 0xB0EF6C63, 0xFE608479, 0x2A0C378C,
+ 0xDB3233A8, 0x0F8A9A09, 0xA877DEAD, 0x31B38C45
+ );
+ for (i = 0; i < 500; i++) {
+ secp256k1_ge_t p;
+ if (secp256k1_ge_set_xo_var(&p, &x, 1)) {
+ secp256k1_gej_t j;
+ CHECK(secp256k1_ge_is_valid_var(&p));
+ secp256k1_gej_set_ge(&j, &p);
+ CHECK(secp256k1_gej_is_valid_var(&j));
+ test_point_times_order(&j);
+ }
+ secp256k1_fe_sqr(&x, &x);
+ }
+ secp256k1_fe_normalize_var(&x);
+ CHECK(secp256k1_fe_equal_var(&x, &xr));
+}
+
+void test_wnaf(const secp256k1_scalar_t *number, int w) {
+ secp256k1_scalar_t x, two, t;
+ int wnaf[256];
+ int zeroes = -1;
+ int i;
+ int bits;
+ secp256k1_scalar_set_int(&x, 0);
+ secp256k1_scalar_set_int(&two, 2);
+ bits = secp256k1_ecmult_wnaf(wnaf, number, w);
+ CHECK(bits <= 256);
+ for (i = bits-1; i >= 0; i--) {
+ int v = wnaf[i];
+ secp256k1_scalar_mul(&x, &x, &two);
+ if (v) {
+ CHECK(zeroes == -1 || zeroes >= w-1); /* check that distance between non-zero elements is at least w-1 */
+ zeroes=0;
+ CHECK((v & 1) == 1); /* check non-zero elements are odd */
+ CHECK(v <= (1 << (w-1)) - 1); /* check range below */
+ CHECK(v >= -(1 << (w-1)) - 1); /* check range above */
+ } else {
+ CHECK(zeroes != -1); /* check that no unnecessary zero padding exists */
+ zeroes++;
+ }
+ if (v >= 0) {
+ secp256k1_scalar_set_int(&t, v);
+ } else {
+ secp256k1_scalar_set_int(&t, -v);
+ secp256k1_scalar_negate(&t, &t);
+ }
+ secp256k1_scalar_add(&x, &x, &t);
+ }
+ CHECK(secp256k1_scalar_eq(&x, number)); /* check that wnaf represents number */
+}
+
+void run_wnaf(void) {
+ int i;
+ secp256k1_scalar_t n;
+ for (i = 0; i < count; i++) {
+ random_scalar_order(&n);
+ test_wnaf(&n, 4+(i%10));
+ }
+}
+
+void random_sign(secp256k1_ecdsa_sig_t *sig, const secp256k1_scalar_t *key, const secp256k1_scalar_t *msg, int *recid) {
+ secp256k1_scalar_t nonce;
+ do {
+ random_scalar_order_test(&nonce);
+ } while(!secp256k1_ecdsa_sig_sign(sig, key, msg, &nonce, recid));
+}
+
+void test_ecdsa_sign_verify(void) {
+ secp256k1_gej_t pubj;
+ secp256k1_ge_t pub;
+ secp256k1_scalar_t one;
+ secp256k1_scalar_t msg, key;
+ secp256k1_ecdsa_sig_t sig;
+ int recid;
+ int getrec;
+ random_scalar_order_test(&msg);
+ random_scalar_order_test(&key);
+ secp256k1_ecmult_gen(&pubj, &key);
+ secp256k1_ge_set_gej(&pub, &pubj);
+ getrec = secp256k1_rand32()&1;
+ random_sign(&sig, &key, &msg, getrec?&recid:NULL);
+ if (getrec) {
+ CHECK(recid >= 0 && recid < 4);
+ }
+ CHECK(secp256k1_ecdsa_sig_verify(&sig, &pub, &msg));
+ secp256k1_scalar_set_int(&one, 1);
+ secp256k1_scalar_add(&msg, &msg, &one);
+ CHECK(!secp256k1_ecdsa_sig_verify(&sig, &pub, &msg));
+}
+
+void run_ecdsa_sign_verify(void) {
+ int i;
+ for (i = 0; i < 10*count; i++) {
+ test_ecdsa_sign_verify();
+ }
+}
+
+/** Dummy nonce generation function that just uses a precomputed nonce, and fails if it is not accepted. Use only for testing. */
+static int precomputed_nonce_function(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, unsigned int counter, const void *data) {
+ (void)msg32;
+ (void)key32;
+ memcpy(nonce32, data, 32);
+ return (counter == 0);
+}
+
+static int nonce_function_test_fail(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, unsigned int counter, const void *data) {
+ /* Dummy nonce generator that has a fatal error on the first counter value. */
+ if (counter == 0) {
+ return 0;
+ }
+ return nonce_function_rfc6979(nonce32, msg32, key32, counter - 1, data);
+}
+
+static int nonce_function_test_retry(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, unsigned int counter, const void *data) {
+ /* Dummy nonce generator that produces unacceptable nonces for the first several counter values. */
+ if (counter < 3) {
+ memset(nonce32, counter==0 ? 0 : 255, 32);
+ if (counter == 2) {
+ nonce32[31]--;
+ }
+ return 1;
+ }
+ if (counter < 5) {
+ static const unsigned char order[] = {
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,
+ 0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,
+ 0xBF,0xD2,0x5E,0x8C,0xD0,0x36,0x41,0x41
+ };
+ memcpy(nonce32, order, 32);
+ if (counter == 4) {
+ nonce32[31]++;
+ }
+ return 1;
+ }
+ /* Retry rate of 6979 is negligible esp. as we only call this in determinstic tests. */
+ /* If someone does fine a case where it retries for secp256k1, we'd like to know. */
+ if (counter > 5) {
+ return 0;
+ }
+ return nonce_function_rfc6979(nonce32, msg32, key32, counter - 5, data);
+}
+
+int is_empty_compact_signature(const unsigned char *sig64) {
+ static const unsigned char res[64] = {0};
+ return memcmp(sig64, res, 64) == 0;
+}
+
+void test_ecdsa_end_to_end(void) {
+ unsigned char extra[32] = {0x00};
+ unsigned char privkey[32];
+ unsigned char message[32];
+ unsigned char privkey2[32];
+ unsigned char csignature[64];
+ unsigned char signature[72];
+ unsigned char signature2[72];
+ unsigned char signature3[72];
+ unsigned char signature4[72];
+ unsigned char pubkey[65];
+ unsigned char recpubkey[65];
+ unsigned char seckey[300];
+ int signaturelen = 72;
+ int signaturelen2 = 72;
+ int signaturelen3 = 72;
+ int signaturelen4 = 72;
+ int recid = 0;
+ int recpubkeylen = 0;
+ int pubkeylen = 65;
+ int seckeylen = 300;
+
+ /* Generate a random key and message. */
+ {
+ secp256k1_scalar_t msg, key;
+ random_scalar_order_test(&msg);
+ random_scalar_order_test(&key);
+ secp256k1_scalar_get_b32(privkey, &key);
+ secp256k1_scalar_get_b32(message, &msg);
+ }
+
+ /* Construct and verify corresponding public key. */
+ CHECK(secp256k1_ec_seckey_verify(privkey) == 1);
+ CHECK(secp256k1_ec_pubkey_create(pubkey, &pubkeylen, privkey, (secp256k1_rand32() & 3) != 0) == 1);
+ if (secp256k1_rand32() & 1) {
+ CHECK(secp256k1_ec_pubkey_decompress(pubkey, &pubkeylen));
+ }
+ CHECK(secp256k1_ec_pubkey_verify(pubkey, pubkeylen));
+
+ /* Verify private key import and export. */
+ CHECK(secp256k1_ec_privkey_export(privkey, seckey, &seckeylen, secp256k1_rand32() % 2) == 1);
+ CHECK(secp256k1_ec_privkey_import(privkey2, seckey, seckeylen) == 1);
+ CHECK(memcmp(privkey, privkey2, 32) == 0);
+
+ /* Optionally tweak the keys using addition. */
+ if (secp256k1_rand32() % 3 == 0) {
+ int ret1;
+ int ret2;
+ unsigned char rnd[32];
+ unsigned char pubkey2[65];
+ int pubkeylen2 = 65;
+ secp256k1_rand256_test(rnd);
+ ret1 = secp256k1_ec_privkey_tweak_add(privkey, rnd);
+ ret2 = secp256k1_ec_pubkey_tweak_add(pubkey, pubkeylen, rnd);
+ CHECK(ret1 == ret2);
+ if (ret1 == 0) {
+ return;
+ }
+ CHECK(secp256k1_ec_pubkey_create(pubkey2, &pubkeylen2, privkey, pubkeylen == 33) == 1);
+ CHECK(memcmp(pubkey, pubkey2, pubkeylen) == 0);
+ }
+
+ /* Optionally tweak the keys using multiplication. */
+ if (secp256k1_rand32() % 3 == 0) {
+ int ret1;
+ int ret2;
+ unsigned char rnd[32];
+ unsigned char pubkey2[65];
+ int pubkeylen2 = 65;
+ secp256k1_rand256_test(rnd);
+ ret1 = secp256k1_ec_privkey_tweak_mul(privkey, rnd);
+ ret2 = secp256k1_ec_pubkey_tweak_mul(pubkey, pubkeylen, rnd);
+ CHECK(ret1 == ret2);
+ if (ret1 == 0) {
+ return;
+ }
+ CHECK(secp256k1_ec_pubkey_create(pubkey2, &pubkeylen2, privkey, pubkeylen == 33) == 1);
+ CHECK(memcmp(pubkey, pubkey2, pubkeylen) == 0);
+ }
+
+ /* Sign. */
+ CHECK(secp256k1_ecdsa_sign(message, signature, &signaturelen, privkey, NULL, NULL) == 1);
+ CHECK(signaturelen > 0);
+ CHECK(secp256k1_ecdsa_sign(message, signature2, &signaturelen2, privkey, NULL, extra) == 1);
+ CHECK(signaturelen2 > 0);
+ extra[31] = 1;
+ CHECK(secp256k1_ecdsa_sign(message, signature3, &signaturelen3, privkey, NULL, extra) == 1);
+ CHECK(signaturelen3 > 0);
+ extra[31] = 0;
+ extra[0] = 1;
+ CHECK(secp256k1_ecdsa_sign(message, signature4, &signaturelen4, privkey, NULL, extra) == 1);
+ CHECK(signaturelen3 > 0);
+ CHECK((signaturelen != signaturelen2) || (memcmp(signature, signature2, signaturelen) != 0));
+ CHECK((signaturelen != signaturelen3) || (memcmp(signature, signature3, signaturelen) != 0));
+ CHECK((signaturelen3 != signaturelen2) || (memcmp(signature3, signature2, signaturelen3) != 0));
+ CHECK((signaturelen4 != signaturelen3) || (memcmp(signature4, signature3, signaturelen4) != 0));
+ CHECK((signaturelen4 != signaturelen2) || (memcmp(signature4, signature2, signaturelen4) != 0));
+ CHECK((signaturelen4 != signaturelen) || (memcmp(signature4, signature, signaturelen4) != 0));
+ /* Verify. */
+ CHECK(secp256k1_ecdsa_verify(message, signature, signaturelen, pubkey, pubkeylen) == 1);
+ CHECK(secp256k1_ecdsa_verify(message, signature2, signaturelen2, pubkey, pubkeylen) == 1);
+ CHECK(secp256k1_ecdsa_verify(message, signature3, signaturelen3, pubkey, pubkeylen) == 1);
+ CHECK(secp256k1_ecdsa_verify(message, signature4, signaturelen4, pubkey, pubkeylen) == 1);
+ /* Destroy signature and verify again. */
+ signature[signaturelen - 1 - secp256k1_rand32() % 20] += 1 + (secp256k1_rand32() % 255);
+ CHECK(secp256k1_ecdsa_verify(message, signature, signaturelen, pubkey, pubkeylen) != 1);
+
+ /* Compact sign. */
+ CHECK(secp256k1_ecdsa_sign_compact(message, csignature, privkey, NULL, NULL, &recid) == 1);
+ CHECK(!is_empty_compact_signature(csignature));
+ /* Recover. */
+ CHECK(secp256k1_ecdsa_recover_compact(message, csignature, recpubkey, &recpubkeylen, pubkeylen == 33, recid) == 1);
+ CHECK(recpubkeylen == pubkeylen);
+ CHECK(memcmp(pubkey, recpubkey, pubkeylen) == 0);
+ /* Destroy signature and verify again. */
+ csignature[secp256k1_rand32() % 64] += 1 + (secp256k1_rand32() % 255);
+ CHECK(secp256k1_ecdsa_recover_compact(message, csignature, recpubkey, &recpubkeylen, pubkeylen == 33, recid) != 1 ||
+ memcmp(pubkey, recpubkey, pubkeylen) != 0);
+ CHECK(recpubkeylen == pubkeylen);
+
+}
+
+void test_random_pubkeys(void) {
+ secp256k1_ge_t elem;
+ secp256k1_ge_t elem2;
+ unsigned char in[65];
+ /* Generate some randomly sized pubkeys. */
+ uint32_t r = secp256k1_rand32();
+ int len = (r & 3) == 0 ? 65 : 33;
+ r>>=2;
+ if ((r & 3) == 0) {
+ len = (r & 252) >> 3;
+ }
+ r>>=8;
+ if (len == 65) {
+ in[0] = (r & 2) ? 4 : (r & 1? 6 : 7);
+ } else {
+ in[0] = (r & 1) ? 2 : 3;
+ }
+ r>>=2;
+ if ((r & 7) == 0) {
+ in[0] = (r & 2040) >> 3;
+ }
+ r>>=11;
+ if (len > 1) {
+ secp256k1_rand256(&in[1]);
+ }
+ if (len > 33) {
+ secp256k1_rand256(&in[33]);
+ }
+ if (secp256k1_eckey_pubkey_parse(&elem, in, len)) {
+ unsigned char out[65];
+ unsigned char firstb;
+ int res;
+ int size = len;
+ firstb = in[0];
+ /* If the pubkey can be parsed, it should round-trip... */
+ CHECK(secp256k1_eckey_pubkey_serialize(&elem, out, &size, len == 33));
+ CHECK(size == len);
+ CHECK(memcmp(&in[1], &out[1], len-1) == 0);
+ /* ... except for the type of hybrid inputs. */
+ if ((in[0] != 6) && (in[0] != 7)) {
+ CHECK(in[0] == out[0]);
+ }
+ size = 65;
+ CHECK(secp256k1_eckey_pubkey_serialize(&elem, in, &size, 0));
+ CHECK(size == 65);
+ CHECK(secp256k1_eckey_pubkey_parse(&elem2, in, size));
+ ge_equals_ge(&elem,&elem2);
+ /* Check that the X9.62 hybrid type is checked. */
+ in[0] = (r & 1) ? 6 : 7;
+ res = secp256k1_eckey_pubkey_parse(&elem2, in, size);
+ if (firstb == 2 || firstb == 3) {
+ if (in[0] == firstb + 4) {
+ CHECK(res);
+ } else {
+ CHECK(!res);
+ }
+ }
+ if (res) {
+ ge_equals_ge(&elem,&elem2);
+ CHECK(secp256k1_eckey_pubkey_serialize(&elem, out, &size, 0));
+ CHECK(memcmp(&in[1], &out[1], 64) == 0);
+ }
+ }
+}
+
+void run_random_pubkeys(void) {
+ int i;
+ for (i = 0; i < 10*count; i++) {
+ test_random_pubkeys();
+ }
+}
+
+void run_ecdsa_end_to_end(void) {
+ int i;
+ for (i = 0; i < 64*count; i++) {
+ test_ecdsa_end_to_end();
+ }
+}
+
+/* Tests several edge cases. */
+void test_ecdsa_edge_cases(void) {
+ const unsigned char msg32[32] = {
+ 'T', 'h', 'i', 's', ' ', 'i', 's', ' ',
+ 'a', ' ', 'v', 'e', 'r', 'y', ' ', 's',
+ 'e', 'c', 'r', 'e', 't', ' ', 'm', 'e',
+ 's', 's', 'a', 'g', 'e', '.', '.', '.'
+ };
+ const unsigned char sig64[64] = {
+ /* Generated by signing the above message with nonce 'This is the nonce we will use...'
+ * and secret key 0 (which is not valid), resulting in recid 0. */
+ 0x67, 0xCB, 0x28, 0x5F, 0x9C, 0xD1, 0x94, 0xE8,
+ 0x40, 0xD6, 0x29, 0x39, 0x7A, 0xF5, 0x56, 0x96,
+ 0x62, 0xFD, 0xE4, 0x46, 0x49, 0x99, 0x59, 0x63,
+ 0x17, 0x9A, 0x7D, 0xD1, 0x7B, 0xD2, 0x35, 0x32,
+ 0x4B, 0x1B, 0x7D, 0xF3, 0x4C, 0xE1, 0xF6, 0x8E,
+ 0x69, 0x4F, 0xF6, 0xF1, 0x1A, 0xC7, 0x51, 0xDD,
+ 0x7D, 0xD7, 0x3E, 0x38, 0x7E, 0xE4, 0xFC, 0x86,
+ 0x6E, 0x1B, 0xE8, 0xEC, 0xC7, 0xDD, 0x95, 0x57
+ };
+ unsigned char pubkey[65];
+ int t;
+ int pubkeylen = 65;
+ /* signature (r,s) = (4,4), which can be recovered with all 4 recids. */
+ const unsigned char sigb64[64] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+ };
+ unsigned char pubkeyb[33];
+ int pubkeyblen = 33;
+ int recid;
+
+ CHECK(!secp256k1_ecdsa_recover_compact(msg32, sig64, pubkey, &pubkeylen, 0, 0));
+ CHECK(secp256k1_ecdsa_recover_compact(msg32, sig64, pubkey, &pubkeylen, 0, 1));
+ CHECK(!secp256k1_ecdsa_recover_compact(msg32, sig64, pubkey, &pubkeylen, 0, 2));
+ CHECK(!secp256k1_ecdsa_recover_compact(msg32, sig64, pubkey, &pubkeylen, 0, 3));
+
+ for (recid = 0; recid < 4; recid++) {
+ int i;
+ int recid2;
+ /* (4,4) encoded in DER. */
+ unsigned char sigbder[8] = {0x30, 0x06, 0x02, 0x01, 0x04, 0x02, 0x01, 0x04};
+ unsigned char sigcder_zr[7] = {0x30, 0x05, 0x02, 0x00, 0x02, 0x01, 0x01};
+ unsigned char sigcder_zs[7] = {0x30, 0x05, 0x02, 0x01, 0x01, 0x02, 0x00};
+ unsigned char sigbderalt1[39] = {
+ 0x30, 0x25, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x04, 0x02, 0x01, 0x04,
+ };
+ unsigned char sigbderalt2[39] = {
+ 0x30, 0x25, 0x02, 0x01, 0x04, 0x02, 0x20, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+ };
+ unsigned char sigbderalt3[40] = {
+ 0x30, 0x26, 0x02, 0x21, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x01, 0x04,
+ };
+ unsigned char sigbderalt4[40] = {
+ 0x30, 0x26, 0x02, 0x01, 0x04, 0x02, 0x21, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+ };
+ /* (order + r,4) encoded in DER. */
+ unsigned char sigbderlong[40] = {
+ 0x30, 0x26, 0x02, 0x21, 0x00, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xBA, 0xAE, 0xDC,
+ 0xE6, 0xAF, 0x48, 0xA0, 0x3B, 0xBF, 0xD2, 0x5E,
+ 0x8C, 0xD0, 0x36, 0x41, 0x45, 0x02, 0x01, 0x04
+ };
+ CHECK(secp256k1_ecdsa_recover_compact(msg32, sigb64, pubkeyb, &pubkeyblen, 1, recid));
+ CHECK(secp256k1_ecdsa_verify(msg32, sigbder, sizeof(sigbder), pubkeyb, pubkeyblen) == 1);
+ for (recid2 = 0; recid2 < 4; recid2++) {
+ unsigned char pubkey2b[33];
+ int pubkey2blen = 33;
+ CHECK(secp256k1_ecdsa_recover_compact(msg32, sigb64, pubkey2b, &pubkey2blen, 1, recid2));
+ /* Verifying with (order + r,4) should always fail. */
+ CHECK(secp256k1_ecdsa_verify(msg32, sigbderlong, sizeof(sigbderlong), pubkey2b, pubkey2blen) != 1);
+ }
+ /* DER parsing tests. */
+ /* Zero length r/s. */
+ CHECK(secp256k1_ecdsa_verify(msg32, sigcder_zr, sizeof(sigcder_zr), pubkeyb, pubkeyblen) == -2);
+ CHECK(secp256k1_ecdsa_verify(msg32, sigcder_zs, sizeof(sigcder_zs), pubkeyb, pubkeyblen) == -2);
+ /* Leading zeros. */
+ CHECK(secp256k1_ecdsa_verify(msg32, sigbderalt1, sizeof(sigbderalt1), pubkeyb, pubkeyblen) == 1);
+ CHECK(secp256k1_ecdsa_verify(msg32, sigbderalt2, sizeof(sigbderalt2), pubkeyb, pubkeyblen) == 1);
+ CHECK(secp256k1_ecdsa_verify(msg32, sigbderalt3, sizeof(sigbderalt3), pubkeyb, pubkeyblen) == 1);
+ CHECK(secp256k1_ecdsa_verify(msg32, sigbderalt4, sizeof(sigbderalt4), pubkeyb, pubkeyblen) == 1);
+ sigbderalt3[4] = 1;
+ CHECK(secp256k1_ecdsa_verify(msg32, sigbderalt3, sizeof(sigbderalt3), pubkeyb, pubkeyblen) == -2);
+ sigbderalt4[7] = 1;
+ CHECK(secp256k1_ecdsa_verify(msg32, sigbderalt4, sizeof(sigbderalt4), pubkeyb, pubkeyblen) == -2);
+ /* Damage signature. */
+ sigbder[7]++;
+ CHECK(secp256k1_ecdsa_verify(msg32, sigbder, sizeof(sigbder), pubkeyb, pubkeyblen) == 0);
+ sigbder[7]--;
+ CHECK(secp256k1_ecdsa_verify(msg32, sigbder, 6, pubkeyb, pubkeyblen) == -2);
+ CHECK(secp256k1_ecdsa_verify(msg32, sigbder, sizeof(sigbder)-1, pubkeyb, pubkeyblen) == -2);
+ for(i = 0; i < 8; i++) {
+ int c;
+ unsigned char orig = sigbder[i];
+ /*Try every single-byte change.*/
+ for (c = 0; c < 256; c++) {
+ if (c == orig ) {
+ continue;
+ }
+ sigbder[i] = c;
+ CHECK(secp256k1_ecdsa_verify(msg32, sigbder, sizeof(sigbder), pubkeyb, pubkeyblen) ==
+ (i==4 || i==7) ? 0 : -2 );
+ }
+ sigbder[i] = orig;
+ }
+ }
+
+ /* Test the case where ECDSA recomputes a point that is infinity. */
+ {
+ secp256k1_gej_t keyj;
+ secp256k1_ge_t key;
+ secp256k1_scalar_t msg;
+ secp256k1_ecdsa_sig_t sig;
+ secp256k1_scalar_set_int(&sig.s, 1);
+ secp256k1_scalar_negate(&sig.s, &sig.s);
+ secp256k1_scalar_inverse(&sig.s, &sig.s);
+ secp256k1_scalar_set_int(&sig.r, 1);
+ secp256k1_ecmult_gen(&keyj, &sig.r);
+ secp256k1_ge_set_gej(&key, &keyj);
+ msg = sig.s;
+ CHECK(secp256k1_ecdsa_sig_verify(&sig, &key, &msg) == 0);
+ }
+
+ /* Test r/s equal to zero */
+ {
+ /* (1,1) encoded in DER. */
+ unsigned char sigcder[8] = {0x30, 0x06, 0x02, 0x01, 0x01, 0x02, 0x01, 0x01};
+ unsigned char sigc64[64] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ };
+ unsigned char pubkeyc[65];
+ int pubkeyclen = 65;
+ CHECK(secp256k1_ecdsa_recover_compact(msg32, sigc64, pubkeyc, &pubkeyclen, 0, 0) == 1);
+ CHECK(secp256k1_ecdsa_verify(msg32, sigcder, sizeof(sigcder), pubkeyc, pubkeyclen) == 1);
+ sigcder[4] = 0;
+ sigc64[31] = 0;
+ CHECK(secp256k1_ecdsa_recover_compact(msg32, sigc64, pubkeyb, &pubkeyblen, 1, 0) == 0);
+ CHECK(secp256k1_ecdsa_verify(msg32, sigcder, sizeof(sigcder), pubkeyc, pubkeyclen) == 0);
+ sigcder[4] = 1;
+ sigcder[7] = 0;
+ sigc64[31] = 1;
+ sigc64[63] = 0;
+ CHECK(secp256k1_ecdsa_recover_compact(msg32, sigc64, pubkeyb, &pubkeyblen, 1, 0) == 0);
+ CHECK(secp256k1_ecdsa_verify(msg32, sigcder, sizeof(sigcder), pubkeyc, pubkeyclen) == 0);
+ }
+
+ /*Signature where s would be zero.*/
+ {
+ const unsigned char nonce[32] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ };
+ static const unsigned char nonce2[32] = {
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,
+ 0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,
+ 0xBF,0xD2,0x5E,0x8C,0xD0,0x36,0x41,0x40
+ };
+ const unsigned char key[32] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ };
+ unsigned char msg[32] = {
+ 0x86, 0x41, 0x99, 0x81, 0x06, 0x23, 0x44, 0x53,
+ 0xaa, 0x5f, 0x9d, 0x6a, 0x31, 0x78, 0xf4, 0xf7,
+ 0xb8, 0x12, 0xe0, 0x0b, 0x81, 0x7a, 0x77, 0x62,
+ 0x65, 0xdf, 0xdd, 0x31, 0xb9, 0x3e, 0x29, 0xa9,
+ };
+ unsigned char sig[72];
+ int siglen = 72;
+ CHECK(secp256k1_ecdsa_sign(msg, sig, &siglen, key, precomputed_nonce_function, nonce) == 0);
+ CHECK(siglen == 0);
+ CHECK(secp256k1_ecdsa_sign(msg, sig, &siglen, key, precomputed_nonce_function, nonce2) == 0);
+ CHECK(siglen == 0);
+ msg[31] = 0xaa;
+ siglen = 72;
+ CHECK(secp256k1_ecdsa_sign(msg, sig, &siglen, key, precomputed_nonce_function, nonce) == 1);
+ CHECK(siglen > 0);
+ CHECK(secp256k1_ecdsa_sign(msg, sig, &siglen, key, precomputed_nonce_function, nonce2) == 1);
+ CHECK(siglen > 0);
+ siglen = 10;
+ CHECK(secp256k1_ecdsa_sign(msg, sig, &siglen, key, precomputed_nonce_function, nonce) != 1);
+ CHECK(siglen == 0);
+ }
+
+ /* Nonce function corner cases. */
+ for (t = 0; t < 2; t++) {
+ static const unsigned char zero[32] = {0x00};
+ int i;
+ unsigned char key[32];
+ unsigned char msg[32];
+ unsigned char sig[72];
+ unsigned char sig2[72];
+ secp256k1_ecdsa_sig_t s[512];
+ int siglen = 72;
+ int siglen2 = 72;
+ int recid2;
+ const unsigned char *extra;
+ extra = t == 0 ? NULL : zero;
+ memset(msg, 0, 32);
+ msg[31] = 1;
+ /* High key results in signature failure. */
+ memset(key, 0xFF, 32);
+ CHECK(secp256k1_ecdsa_sign(msg, sig, &siglen, key, NULL, extra) == 0);
+ CHECK(siglen == 0);
+ /* Zero key results in signature failure. */
+ memset(key, 0, 32);
+ CHECK(secp256k1_ecdsa_sign(msg, sig, &siglen, key, NULL, extra) == 0);
+ CHECK(siglen == 0);
+ /* Nonce function failure results in signature failure. */
+ key[31] = 1;
+ CHECK(secp256k1_ecdsa_sign(msg, sig, &siglen, key, nonce_function_test_fail, extra) == 0);
+ CHECK(siglen == 0);
+ CHECK(secp256k1_ecdsa_sign_compact(msg, sig, key, nonce_function_test_fail, extra, &recid) == 0);
+ CHECK(is_empty_compact_signature(sig));
+ /* The retry loop successfully makes its way to the first good value. */
+ siglen = 72;
+ CHECK(secp256k1_ecdsa_sign(msg, sig, &siglen, key, nonce_function_test_retry, extra) == 1);
+ CHECK(siglen > 0);
+ CHECK(secp256k1_ecdsa_sign(msg, sig2, &siglen2, key, nonce_function_rfc6979, extra) == 1);
+ CHECK(siglen > 0);
+ CHECK((siglen == siglen2) && (memcmp(sig, sig2, siglen) == 0));
+ CHECK(secp256k1_ecdsa_sign_compact(msg, sig, key, nonce_function_test_retry, extra, &recid) == 1);
+ CHECK(!is_empty_compact_signature(sig));
+ CHECK(secp256k1_ecdsa_sign_compact(msg, sig2, key, nonce_function_rfc6979, extra, &recid2) == 1);
+ CHECK(!is_empty_compact_signature(sig2));
+ CHECK((recid == recid2) && (memcmp(sig, sig2, 64) == 0));
+ /* The default nonce function is determinstic. */
+ siglen = 72;
+ siglen2 = 72;
+ CHECK(secp256k1_ecdsa_sign(msg, sig, &siglen, key, NULL, extra) == 1);
+ CHECK(siglen > 0);
+ CHECK(secp256k1_ecdsa_sign(msg, sig2, &siglen2, key, NULL, extra) == 1);
+ CHECK(siglen2 > 0);
+ CHECK((siglen == siglen2) && (memcmp(sig, sig2, siglen) == 0));
+ CHECK(secp256k1_ecdsa_sign_compact(msg, sig, key, NULL, extra, &recid) == 1);
+ CHECK(!is_empty_compact_signature(sig));
+ CHECK(secp256k1_ecdsa_sign_compact(msg, sig2, key, NULL, extra, &recid2) == 1);
+ CHECK(!is_empty_compact_signature(sig));
+ CHECK((recid == recid2) && (memcmp(sig, sig2, 64) == 0));
+ /* The default nonce function changes output with different messages. */
+ for(i = 0; i < 256; i++) {
+ int j;
+ siglen2 = 72;
+ msg[0] = i;
+ CHECK(secp256k1_ecdsa_sign(msg, sig2, &siglen2, key, NULL, extra) == 1);
+ CHECK(!is_empty_compact_signature(sig));
+ CHECK(secp256k1_ecdsa_sig_parse(&s[i], sig2, siglen2));
+ for (j = 0; j < i; j++) {
+ CHECK(!secp256k1_scalar_eq(&s[i].r, &s[j].r));
+ }
+ }
+ msg[0] = 0;
+ msg[31] = 2;
+ /* The default nonce function changes output with different keys. */
+ for(i = 256; i < 512; i++) {
+ int j;
+ siglen2 = 72;
+ key[0] = i - 256;
+ CHECK(secp256k1_ecdsa_sign(msg, sig2, &siglen2, key, NULL, extra) == 1);
+ CHECK(secp256k1_ecdsa_sig_parse(&s[i], sig2, siglen2));
+ for (j = 0; j < i; j++) {
+ CHECK(!secp256k1_scalar_eq(&s[i].r, &s[j].r));
+ }
+ }
+ key[0] = 0;
+ }
+
+ /* Privkey export where pubkey is the point at infinity. */
+ {
+ unsigned char privkey[300];
+ unsigned char seckey[32] = {
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
+ 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
+ 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41,
+ };
+ int outlen = 300;
+ CHECK(!secp256k1_ec_privkey_export(seckey, privkey, &outlen, 0));
+ CHECK(!secp256k1_ec_privkey_export(seckey, privkey, &outlen, 1));
+ }
+}
+
+void run_ecdsa_edge_cases(void) {
+ test_ecdsa_edge_cases();
+}
+
+#ifdef ENABLE_OPENSSL_TESTS
+EC_KEY *get_openssl_key(const secp256k1_scalar_t *key) {
+ unsigned char privkey[300];
+ int privkeylen;
+ const unsigned char* pbegin = privkey;
+ int compr = secp256k1_rand32() & 1;
+ EC_KEY *ec_key = EC_KEY_new_by_curve_name(NID_secp256k1);
+ CHECK(secp256k1_eckey_privkey_serialize(privkey, &privkeylen, key, compr));
+ CHECK(d2i_ECPrivateKey(&ec_key, &pbegin, privkeylen));
+ CHECK(EC_KEY_check_key(ec_key));
+ return ec_key;
+}
+
+void test_ecdsa_openssl(void) {
+ secp256k1_gej_t qj;
+ secp256k1_ge_t q;
+ secp256k1_ecdsa_sig_t sig;
+ secp256k1_scalar_t one;
+ secp256k1_scalar_t msg2;
+ secp256k1_scalar_t key, msg;
+ EC_KEY *ec_key;
+ unsigned int sigsize = 80;
+ int secp_sigsize = 80;
+ unsigned char message[32];
+ unsigned char signature[80];
+ secp256k1_rand256_test(message);
+ secp256k1_scalar_set_b32(&msg, message, NULL);
+ random_scalar_order_test(&key);
+ secp256k1_ecmult_gen(&qj, &key);
+ secp256k1_ge_set_gej(&q, &qj);
+ ec_key = get_openssl_key(&key);
+ CHECK(ec_key);
+ CHECK(ECDSA_sign(0, message, sizeof(message), signature, &sigsize, ec_key));
+ CHECK(secp256k1_ecdsa_sig_parse(&sig, signature, sigsize));
+ CHECK(secp256k1_ecdsa_sig_verify(&sig, &q, &msg));
+ secp256k1_scalar_set_int(&one, 1);
+ secp256k1_scalar_add(&msg2, &msg, &one);
+ CHECK(!secp256k1_ecdsa_sig_verify(&sig, &q, &msg2));
+
+ random_sign(&sig, &key, &msg, NULL);
+ CHECK(secp256k1_ecdsa_sig_serialize(signature, &secp_sigsize, &sig));
+ CHECK(ECDSA_verify(0, message, sizeof(message), signature, secp_sigsize, ec_key) == 1);
+
+ EC_KEY_free(ec_key);
+}
+
+void run_ecdsa_openssl(void) {
+ int i;
+ for (i = 0; i < 10*count; i++) {
+ test_ecdsa_openssl();
+ }
+}
+#endif
+
+int main(int argc, char **argv) {
+ unsigned char seed16[16] = {0};
+ unsigned char run32[32] = {0};
+ /* find iteration count */
+ if (argc > 1) {
+ count = strtol(argv[1], NULL, 0);
+ }
+
+ /* find random seed */
+ if (argc > 2) {
+ int pos = 0;
+ const char* ch = argv[2];
+ while (pos < 16 && ch[0] != 0 && ch[1] != 0) {
+ unsigned short sh;
+ if (sscanf(ch, "%2hx", &sh)) {
+ seed16[pos] = sh;
+ } else {
+ break;
+ }
+ ch += 2;
+ pos++;
+ }
+ } else {
+ FILE *frand = fopen("/dev/urandom", "r");
+ if (!frand || !fread(&seed16, sizeof(seed16), 1, frand)) {
+ uint64_t t = time(NULL) * (uint64_t)1337;
+ seed16[0] ^= t;
+ seed16[1] ^= t >> 8;
+ seed16[2] ^= t >> 16;
+ seed16[3] ^= t >> 24;
+ seed16[4] ^= t >> 32;
+ seed16[5] ^= t >> 40;
+ seed16[6] ^= t >> 48;
+ seed16[7] ^= t >> 56;
+ }
+ fclose(frand);
+ }
+ secp256k1_rand_seed(seed16);
+
+ printf("test count = %i\n", count);
+ printf("random seed = %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n", seed16[0], seed16[1], seed16[2], seed16[3], seed16[4], seed16[5], seed16[6], seed16[7], seed16[8], seed16[9], seed16[10], seed16[11], seed16[12], seed16[13], seed16[14], seed16[15]);
+
+ /* initialize */
+ secp256k1_start(SECP256K1_START_SIGN | SECP256K1_START_VERIFY);
+
+ /* initializing a second time shouldn't cause any harm or memory leaks. */
+ secp256k1_start(SECP256K1_START_SIGN | SECP256K1_START_VERIFY);
+
+ run_sha256_tests();
+ run_hmac_sha256_tests();
+ run_rfc6979_hmac_sha256_tests();
+
+#ifndef USE_NUM_NONE
+ /* num tests */
+ run_num_smalltests();
+#endif
+
+ /* scalar tests */
+ run_scalar_tests();
+
+ /* field tests */
+ run_field_inv();
+ run_field_inv_var();
+ run_field_inv_all_var();
+ run_field_misc();
+ run_field_convert();
+ run_sqr();
+ run_sqrt();
+
+ /* group tests */
+ run_ge();
+
+ /* ecmult tests */
+ run_wnaf();
+ run_point_times_order();
+ run_ecmult_chain();
+
+ /* ecdsa tests */
+ run_random_pubkeys();
+ run_ecdsa_sign_verify();
+ run_ecdsa_end_to_end();
+ run_ecdsa_edge_cases();
+#ifdef ENABLE_OPENSSL_TESTS
+ run_ecdsa_openssl();
+#endif
+
+ secp256k1_rand256(run32);
+ printf("random run = %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n", run32[0], run32[1], run32[2], run32[3], run32[4], run32[5], run32[6], run32[7], run32[8], run32[9], run32[10], run32[11], run32[12], run32[13], run32[14], run32[15]);
+
+ /* shutdown */
+ secp256k1_stop();
+
+ /* shutting down twice shouldn't cause any double frees. */
+ secp256k1_stop();
+ return 0;
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/util.h b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/util.h
new file mode 100644
index 0000000000000000000000000000000000000000..ae98639f7ca31ae4621b497017fb6d9b32b81dba
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/secp256k1/secp256k1/src/util.h
@@ -0,0 +1,104 @@
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#ifndef _SECP256K1_UTIL_H_
+#define _SECP256K1_UTIL_H_
+
+#if defined HAVE_CONFIG_H
+#include "libsecp256k1-config.h"
+#endif
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#ifdef DETERMINISTIC
+#define TEST_FAILURE(msg) do { \
+ fprintf(stderr, "%s\n", msg); \
+ abort(); \
+} while(0);
+#else
+#define TEST_FAILURE(msg) do { \
+ fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, msg); \
+ abort(); \
+} while(0)
+#endif
+
+#ifdef HAVE_BUILTIN_EXPECT
+#define EXPECT(x,c) __builtin_expect((x),(c))
+#else
+#define EXPECT(x,c) (x)
+#endif
+
+#ifdef DETERMINISTIC
+#define CHECK(cond) do { \
+ if (EXPECT(!(cond), 0)) { \
+ TEST_FAILURE("test condition failed"); \
+ } \
+} while(0)
+#else
+#define CHECK(cond) do { \
+ if (EXPECT(!(cond), 0)) { \
+ TEST_FAILURE("test condition failed: " #cond); \
+ } \
+} while(0)
+#endif
+
+/* Like assert(), but safe to use on expressions with side effects. */
+#ifndef NDEBUG
+#define DEBUG_CHECK CHECK
+#else
+#define DEBUG_CHECK(cond) do { (void)(cond); } while(0)
+#endif
+
+/* Like DEBUG_CHECK(), but when VERIFY is defined instead of NDEBUG not defined. */
+#ifdef VERIFY
+#define VERIFY_CHECK CHECK
+#else
+#define VERIFY_CHECK(cond) do { (void)(cond); } while(0)
+#endif
+
+static SECP256K1_INLINE void *checked_malloc(size_t size) {
+ void *ret = malloc(size);
+ CHECK(ret != NULL);
+ return ret;
+}
+
+/* Macro for restrict, when available and not in a VERIFY build. */
+#if defined(SECP256K1_BUILD) && defined(VERIFY)
+# define SECP256K1_RESTRICT
+#else
+# if (!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) )
+# if SECP256K1_GNUC_PREREQ(3,0)
+# define SECP256K1_RESTRICT __restrict__
+# elif (defined(_MSC_VER) && _MSC_VER >= 1400)
+# define SECP256K1_RESTRICT __restrict
+# else
+# define SECP256K1_RESTRICT
+# endif
+# else
+# define SECP256K1_RESTRICT restrict
+# endif
+#endif
+
+#if defined(_WIN32)
+# define I64FORMAT "I64d"
+# define I64uFORMAT "I64u"
+#else
+# define I64FORMAT "lld"
+# define I64uFORMAT "llu"
+#endif
+
+#if defined(HAVE___INT128)
+# if defined(__GNUC__)
+# define SECP256K1_GNUC_EXT __extension__
+# else
+# define SECP256K1_GNUC_EXT
+# endif
+SECP256K1_GNUC_EXT typedef unsigned __int128 uint128_t;
+#endif
+
+#endif
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/sha3/keccakf.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/sha3/keccakf.go
new file mode 100644
index 0000000000000000000000000000000000000000..3baf13ba3d89ff1b0274711182f008dc971cb937
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/sha3/keccakf.go
@@ -0,0 +1,171 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package sha3
+
+// This file implements the core Keccak permutation function necessary for computing SHA3.
+// This is implemented in a separate file to allow for replacement by an optimized implementation.
+// Nothing in this package is exported.
+// For the detailed specification, refer to the Keccak web site (http://keccak.noekeon.org/).
+
+// rc stores the round constants for use in the ι step.
+var rc = [...]uint64{
+ 0x0000000000000001,
+ 0x0000000000008082,
+ 0x800000000000808A,
+ 0x8000000080008000,
+ 0x000000000000808B,
+ 0x0000000080000001,
+ 0x8000000080008081,
+ 0x8000000000008009,
+ 0x000000000000008A,
+ 0x0000000000000088,
+ 0x0000000080008009,
+ 0x000000008000000A,
+ 0x000000008000808B,
+ 0x800000000000008B,
+ 0x8000000000008089,
+ 0x8000000000008003,
+ 0x8000000000008002,
+ 0x8000000000000080,
+ 0x000000000000800A,
+ 0x800000008000000A,
+ 0x8000000080008081,
+ 0x8000000000008080,
+ 0x0000000080000001,
+ 0x8000000080008008,
+}
+
+// ro_xx represent the rotation offsets for use in the χ step.
+// Defining them as const instead of in an array allows the compiler to insert constant shifts.
+const (
+ ro_00 = 0
+ ro_01 = 36
+ ro_02 = 3
+ ro_03 = 41
+ ro_04 = 18
+ ro_05 = 1
+ ro_06 = 44
+ ro_07 = 10
+ ro_08 = 45
+ ro_09 = 2
+ ro_10 = 62
+ ro_11 = 6
+ ro_12 = 43
+ ro_13 = 15
+ ro_14 = 61
+ ro_15 = 28
+ ro_16 = 55
+ ro_17 = 25
+ ro_18 = 21
+ ro_19 = 56
+ ro_20 = 27
+ ro_21 = 20
+ ro_22 = 39
+ ro_23 = 8
+ ro_24 = 14
+)
+
+// keccakF computes the complete Keccak-f function consisting of 24 rounds with a different
+// constant (rc) in each round. This implementation fully unrolls the round function to avoid
+// inner loops, as well as pre-calculating shift offsets.
+func (d *digest) keccakF() {
+ for _, roundConstant := range rc {
+ // θ step
+ d.c[0] = d.a[0] ^ d.a[5] ^ d.a[10] ^ d.a[15] ^ d.a[20]
+ d.c[1] = d.a[1] ^ d.a[6] ^ d.a[11] ^ d.a[16] ^ d.a[21]
+ d.c[2] = d.a[2] ^ d.a[7] ^ d.a[12] ^ d.a[17] ^ d.a[22]
+ d.c[3] = d.a[3] ^ d.a[8] ^ d.a[13] ^ d.a[18] ^ d.a[23]
+ d.c[4] = d.a[4] ^ d.a[9] ^ d.a[14] ^ d.a[19] ^ d.a[24]
+
+ d.d[0] = d.c[4] ^ (d.c[1]<<1 ^ d.c[1]>>63)
+ d.d[1] = d.c[0] ^ (d.c[2]<<1 ^ d.c[2]>>63)
+ d.d[2] = d.c[1] ^ (d.c[3]<<1 ^ d.c[3]>>63)
+ d.d[3] = d.c[2] ^ (d.c[4]<<1 ^ d.c[4]>>63)
+ d.d[4] = d.c[3] ^ (d.c[0]<<1 ^ d.c[0]>>63)
+
+ d.a[0] ^= d.d[0]
+ d.a[1] ^= d.d[1]
+ d.a[2] ^= d.d[2]
+ d.a[3] ^= d.d[3]
+ d.a[4] ^= d.d[4]
+ d.a[5] ^= d.d[0]
+ d.a[6] ^= d.d[1]
+ d.a[7] ^= d.d[2]
+ d.a[8] ^= d.d[3]
+ d.a[9] ^= d.d[4]
+ d.a[10] ^= d.d[0]
+ d.a[11] ^= d.d[1]
+ d.a[12] ^= d.d[2]
+ d.a[13] ^= d.d[3]
+ d.a[14] ^= d.d[4]
+ d.a[15] ^= d.d[0]
+ d.a[16] ^= d.d[1]
+ d.a[17] ^= d.d[2]
+ d.a[18] ^= d.d[3]
+ d.a[19] ^= d.d[4]
+ d.a[20] ^= d.d[0]
+ d.a[21] ^= d.d[1]
+ d.a[22] ^= d.d[2]
+ d.a[23] ^= d.d[3]
+ d.a[24] ^= d.d[4]
+
+ // Ï and Ï€ steps
+ d.b[0] = d.a[0]
+ d.b[1] = d.a[6]<<ro_06 ^ d.a[6]>>(64-ro_06)
+ d.b[2] = d.a[12]<<ro_12 ^ d.a[12]>>(64-ro_12)
+ d.b[3] = d.a[18]<<ro_18 ^ d.a[18]>>(64-ro_18)
+ d.b[4] = d.a[24]<<ro_24 ^ d.a[24]>>(64-ro_24)
+ d.b[5] = d.a[3]<<ro_15 ^ d.a[3]>>(64-ro_15)
+ d.b[6] = d.a[9]<<ro_21 ^ d.a[9]>>(64-ro_21)
+ d.b[7] = d.a[10]<<ro_02 ^ d.a[10]>>(64-ro_02)
+ d.b[8] = d.a[16]<<ro_08 ^ d.a[16]>>(64-ro_08)
+ d.b[9] = d.a[22]<<ro_14 ^ d.a[22]>>(64-ro_14)
+ d.b[10] = d.a[1]<<ro_05 ^ d.a[1]>>(64-ro_05)
+ d.b[11] = d.a[7]<<ro_11 ^ d.a[7]>>(64-ro_11)
+ d.b[12] = d.a[13]<<ro_17 ^ d.a[13]>>(64-ro_17)
+ d.b[13] = d.a[19]<<ro_23 ^ d.a[19]>>(64-ro_23)
+ d.b[14] = d.a[20]<<ro_04 ^ d.a[20]>>(64-ro_04)
+ d.b[15] = d.a[4]<<ro_20 ^ d.a[4]>>(64-ro_20)
+ d.b[16] = d.a[5]<<ro_01 ^ d.a[5]>>(64-ro_01)
+ d.b[17] = d.a[11]<<ro_07 ^ d.a[11]>>(64-ro_07)
+ d.b[18] = d.a[17]<<ro_13 ^ d.a[17]>>(64-ro_13)
+ d.b[19] = d.a[23]<<ro_19 ^ d.a[23]>>(64-ro_19)
+ d.b[20] = d.a[2]<<ro_10 ^ d.a[2]>>(64-ro_10)
+ d.b[21] = d.a[8]<<ro_16 ^ d.a[8]>>(64-ro_16)
+ d.b[22] = d.a[14]<<ro_22 ^ d.a[14]>>(64-ro_22)
+ d.b[23] = d.a[15]<<ro_03 ^ d.a[15]>>(64-ro_03)
+ d.b[24] = d.a[21]<<ro_09 ^ d.a[21]>>(64-ro_09)
+
+ // χ step
+ d.a[0] = d.b[0] ^ (^d.b[1] & d.b[2])
+ d.a[1] = d.b[1] ^ (^d.b[2] & d.b[3])
+ d.a[2] = d.b[2] ^ (^d.b[3] & d.b[4])
+ d.a[3] = d.b[3] ^ (^d.b[4] & d.b[0])
+ d.a[4] = d.b[4] ^ (^d.b[0] & d.b[1])
+ d.a[5] = d.b[5] ^ (^d.b[6] & d.b[7])
+ d.a[6] = d.b[6] ^ (^d.b[7] & d.b[8])
+ d.a[7] = d.b[7] ^ (^d.b[8] & d.b[9])
+ d.a[8] = d.b[8] ^ (^d.b[9] & d.b[5])
+ d.a[9] = d.b[9] ^ (^d.b[5] & d.b[6])
+ d.a[10] = d.b[10] ^ (^d.b[11] & d.b[12])
+ d.a[11] = d.b[11] ^ (^d.b[12] & d.b[13])
+ d.a[12] = d.b[12] ^ (^d.b[13] & d.b[14])
+ d.a[13] = d.b[13] ^ (^d.b[14] & d.b[10])
+ d.a[14] = d.b[14] ^ (^d.b[10] & d.b[11])
+ d.a[15] = d.b[15] ^ (^d.b[16] & d.b[17])
+ d.a[16] = d.b[16] ^ (^d.b[17] & d.b[18])
+ d.a[17] = d.b[17] ^ (^d.b[18] & d.b[19])
+ d.a[18] = d.b[18] ^ (^d.b[19] & d.b[15])
+ d.a[19] = d.b[19] ^ (^d.b[15] & d.b[16])
+ d.a[20] = d.b[20] ^ (^d.b[21] & d.b[22])
+ d.a[21] = d.b[21] ^ (^d.b[22] & d.b[23])
+ d.a[22] = d.b[22] ^ (^d.b[23] & d.b[24])
+ d.a[23] = d.b[23] ^ (^d.b[24] & d.b[20])
+ d.a[24] = d.b[24] ^ (^d.b[20] & d.b[21])
+
+ // ι step
+ d.a[0] ^= roundConstant
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/sha3/sha3.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/sha3/sha3.go
new file mode 100644
index 0000000000000000000000000000000000000000..da6b381f40da8a51c39aeffd5ca7791d3e74dd66
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/sha3/sha3.go
@@ -0,0 +1,224 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package sha3 implements the SHA3 hash algorithm (formerly called Keccak) chosen by NIST in 2012.
+// This file provides a SHA3 implementation which implements the standard hash.Hash interface.
+// Writing input data, including padding, and reading output data are computed in this file.
+// Note that the current implementation can compute the hash of an integral number of bytes only.
+// This is a consequence of the hash interface in which a buffer of bytes is passed in.
+// The internals of the Keccak-f function are computed in keccakf.go.
+// For the detailed specification, refer to the Keccak web site (http://keccak.noekeon.org/).
+package sha3
+
+import (
+ "encoding/binary"
+ "hash"
+)
+
+// laneSize is the size in bytes of each "lane" of the internal state of SHA3 (5 * 5 * 8).
+// Note that changing this size would requires using a type other than uint64 to store each lane.
+const laneSize = 8
+
+// sliceSize represents the dimensions of the internal state, a square matrix of
+// sliceSize ** 2 lanes. This is the size of both the "rows" and "columns" dimensions in the
+// terminology of the SHA3 specification.
+const sliceSize = 5
+
+// numLanes represents the total number of lanes in the state.
+const numLanes = sliceSize * sliceSize
+
+// stateSize is the size in bytes of the internal state of SHA3 (5 * 5 * WSize).
+const stateSize = laneSize * numLanes
+
+// digest represents the partial evaluation of a checksum.
+// Note that capacity, and not outputSize, is the critical security parameter, as SHA3 can output
+// an arbitrary number of bytes for any given capacity. The Keccak proposal recommends that
+// capacity = 2*outputSize to ensure that finding a collision of size outputSize requires
+// O(2^{outputSize/2}) computations (the birthday lower bound). Future standards may modify the
+// capacity/outputSize ratio to allow for more output with lower cryptographic security.
+type digest struct {
+ a [numLanes]uint64 // main state of the hash
+ b [numLanes]uint64 // intermediate states
+ c [sliceSize]uint64 // intermediate states
+ d [sliceSize]uint64 // intermediate states
+ outputSize int // desired output size in bytes
+ capacity int // number of bytes to leave untouched during squeeze/absorb
+ absorbed int // number of bytes absorbed thus far
+}
+
+// minInt returns the lesser of two integer arguments, to simplify the absorption routine.
+func minInt(v1, v2 int) int {
+ if v1 <= v2 {
+ return v1
+ }
+ return v2
+}
+
+// rate returns the number of bytes of the internal state which can be absorbed or squeezed
+// in between calls to the permutation function.
+func (d *digest) rate() int {
+ return stateSize - d.capacity
+}
+
+// Reset clears the internal state by zeroing bytes in the state buffer.
+// This can be skipped for a newly-created hash state; the default zero-allocated state is correct.
+func (d *digest) Reset() {
+ d.absorbed = 0
+ for i := range d.a {
+ d.a[i] = 0
+ }
+}
+
+// BlockSize, required by the hash.Hash interface, does not have a standard intepretation
+// for a sponge-based construction like SHA3. We return the data rate: the number of bytes which
+// can be absorbed per invocation of the permutation function. For Merkle-Damgård based hashes
+// (ie SHA1, SHA2, MD5) the output size of the internal compression function is returned.
+// We consider this to be roughly equivalent because it represents the number of bytes of output
+// produced per cryptographic operation.
+func (d *digest) BlockSize() int { return d.rate() }
+
+// Size returns the output size of the hash function in bytes.
+func (d *digest) Size() int {
+ return d.outputSize
+}
+
+// unalignedAbsorb is a helper function for Write, which absorbs data that isn't aligned with an
+// 8-byte lane. This requires shifting the individual bytes into position in a uint64.
+func (d *digest) unalignedAbsorb(p []byte) {
+ var t uint64
+ for i := len(p) - 1; i >= 0; i-- {
+ t <<= 8
+ t |= uint64(p[i])
+ }
+ offset := (d.absorbed) % d.rate()
+ t <<= 8 * uint(offset%laneSize)
+ d.a[offset/laneSize] ^= t
+ d.absorbed += len(p)
+}
+
+// Write "absorbs" bytes into the state of the SHA3 hash, updating as needed when the sponge
+// "fills up" with rate() bytes. Since lanes are stored internally as type uint64, this requires
+// converting the incoming bytes into uint64s using a little endian interpretation. This
+// implementation is optimized for large, aligned writes of multiples of 8 bytes (laneSize).
+// Non-aligned or uneven numbers of bytes require shifting and are slower.
+func (d *digest) Write(p []byte) (int, error) {
+ // An initial offset is needed if the we aren't absorbing to the first lane initially.
+ offset := d.absorbed % d.rate()
+ toWrite := len(p)
+
+ // The first lane may need to absorb unaligned and/or incomplete data.
+ if (offset%laneSize != 0 || len(p) < 8) && len(p) > 0 {
+ toAbsorb := minInt(laneSize-(offset%laneSize), len(p))
+ d.unalignedAbsorb(p[:toAbsorb])
+ p = p[toAbsorb:]
+ offset = (d.absorbed) % d.rate()
+
+ // For every rate() bytes absorbed, the state must be permuted via the F Function.
+ if (d.absorbed)%d.rate() == 0 {
+ d.keccakF()
+ }
+ }
+
+ // This loop should absorb the bulk of the data into full, aligned lanes.
+ // It will call the update function as necessary.
+ for len(p) > 7 {
+ firstLane := offset / laneSize
+ lastLane := minInt(d.rate()/laneSize, firstLane+len(p)/laneSize)
+
+ // This inner loop absorbs input bytes into the state in groups of 8, converted to uint64s.
+ for lane := firstLane; lane < lastLane; lane++ {
+ d.a[lane] ^= binary.LittleEndian.Uint64(p[:laneSize])
+ p = p[laneSize:]
+ }
+ d.absorbed += (lastLane - firstLane) * laneSize
+ // For every rate() bytes absorbed, the state must be permuted via the F Function.
+ if (d.absorbed)%d.rate() == 0 {
+ d.keccakF()
+ }
+
+ offset = 0
+ }
+
+ // If there are insufficient bytes to fill the final lane, an unaligned absorption.
+ // This should always start at a correct lane boundary though, or else it would be caught
+ // by the uneven opening lane case above.
+ if len(p) > 0 {
+ d.unalignedAbsorb(p)
+ }
+
+ return toWrite, nil
+}
+
+// pad computes the SHA3 padding scheme based on the number of bytes absorbed.
+// The padding is a 1 bit, followed by an arbitrary number of 0s and then a final 1 bit, such that
+// the input bits plus padding bits are a multiple of rate(). Adding the padding simply requires
+// xoring an opening and closing bit into the appropriate lanes.
+func (d *digest) pad() {
+ offset := d.absorbed % d.rate()
+ // The opening pad bit must be shifted into position based on the number of bytes absorbed
+ padOpenLane := offset / laneSize
+ d.a[padOpenLane] ^= 0x0000000000000001 << uint(8*(offset%laneSize))
+ // The closing padding bit is always in the last position
+ padCloseLane := (d.rate() / laneSize) - 1
+ d.a[padCloseLane] ^= 0x8000000000000000
+}
+
+// finalize prepares the hash to output data by padding and one final permutation of the state.
+func (d *digest) finalize() {
+ d.pad()
+ d.keccakF()
+}
+
+// squeeze outputs an arbitrary number of bytes from the hash state.
+// Squeezing can require multiple calls to the F function (one per rate() bytes squeezed),
+// although this is not the case for standard SHA3 parameters. This implementation only supports
+// squeezing a single time, subsequent squeezes may lose alignment. Future implementations
+// may wish to support multiple squeeze calls, for example to support use as a PRNG.
+func (d *digest) squeeze(in []byte, toSqueeze int) []byte {
+ // Because we read in blocks of laneSize, we need enough room to read
+ // an integral number of lanes
+ needed := toSqueeze + (laneSize-toSqueeze%laneSize)%laneSize
+ if cap(in)-len(in) < needed {
+ newIn := make([]byte, len(in), len(in)+needed)
+ copy(newIn, in)
+ in = newIn
+ }
+ out := in[len(in) : len(in)+needed]
+
+ for len(out) > 0 {
+ for i := 0; i < d.rate() && len(out) > 0; i += laneSize {
+ binary.LittleEndian.PutUint64(out[:], d.a[i/laneSize])
+ out = out[laneSize:]
+ }
+ if len(out) > 0 {
+ d.keccakF()
+ }
+ }
+ return in[:len(in)+toSqueeze] // Re-slice in case we wrote extra data.
+}
+
+// Sum applies padding to the hash state and then squeezes out the desired nubmer of output bytes.
+func (d *digest) Sum(in []byte) []byte {
+ // Make a copy of the original hash so that caller can keep writing and summing.
+ dup := *d
+ dup.finalize()
+ return dup.squeeze(in, dup.outputSize)
+}
+
+// The NewKeccakX constructors enable initializing a hash in any of the four recommend sizes
+// from the Keccak specification, all of which set capacity=2*outputSize. Note that the final
+// NIST standard for SHA3 may specify different input/output lengths.
+// The output size is indicated in bits but converted into bytes internally.
+func NewKeccak224() hash.Hash { return &digest{outputSize: 224 / 8, capacity: 2 * 224 / 8} }
+func NewKeccak256() hash.Hash { return &digest{outputSize: 256 / 8, capacity: 2 * 256 / 8} }
+func NewKeccak384() hash.Hash { return &digest{outputSize: 384 / 8, capacity: 2 * 384 / 8} }
+func NewKeccak512() hash.Hash { return &digest{outputSize: 512 / 8, capacity: 2 * 512 / 8} }
+
+func Sha3(data ...[]byte) []byte {
+ d := NewKeccak256()
+ for _, b := range data {
+ d.Write(b)
+ }
+ return d.Sum(nil)
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/stack.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/stack.go
new file mode 100644
index 0000000000000000000000000000000000000000..7dd7d1743f2239ae8906817f22b22bcb404e7a32
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/stack.go
@@ -0,0 +1,121 @@
+package vm
+
+import (
+ "fmt"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+// Not goroutine safe
+type Stack struct {
+ data []Word256
+ ptr int
+
+ gas *uint64
+ err *error
+}
+
+func NewStack(capacity int, gas *uint64, err *error) *Stack {
+ return &Stack{
+ data: make([]Word256, capacity),
+ ptr: 0,
+ gas: gas,
+ err: err,
+ }
+}
+
+func (st *Stack) useGas(gasToUse uint64) {
+ if *st.gas > gasToUse {
+ *st.gas -= gasToUse
+ } else {
+ st.setErr(ErrInsufficientGas)
+ }
+}
+
+func (st *Stack) setErr(err error) {
+ if *st.err == nil {
+ *st.err = err
+ }
+}
+
+func (st *Stack) Push(d Word256) {
+ st.useGas(GasStackOp)
+ if st.ptr == cap(st.data) {
+ st.setErr(ErrDataStackOverflow)
+ return
+ }
+ st.data[st.ptr] = d
+ st.ptr++
+}
+
+func (st *Stack) PushBytes(bz []byte) {
+ if len(bz) != 32 {
+ panic("Invalid bytes size: expected 32")
+ }
+ st.Push(LeftPadWord256(bz))
+}
+
+func (st *Stack) Push64(i uint64) {
+ st.Push(Uint64ToWord256(i))
+}
+
+func (st *Stack) Pop() Word256 {
+ st.useGas(GasStackOp)
+ if st.ptr == 0 {
+ st.setErr(ErrDataStackUnderflow)
+ return Zero256
+ }
+ st.ptr--
+ return st.data[st.ptr]
+}
+
+func (st *Stack) PopBytes() []byte {
+ return st.Pop().Bytes()
+}
+
+func (st *Stack) Pop64() uint64 {
+ d := st.Pop()
+ return Uint64FromWord256(d)
+}
+
+func (st *Stack) Len() int {
+ return st.ptr
+}
+
+func (st *Stack) Swap(n int) {
+ st.useGas(GasStackOp)
+ if st.ptr < n {
+ st.setErr(ErrDataStackUnderflow)
+ return
+ }
+ st.data[st.ptr-n], st.data[st.ptr-1] = st.data[st.ptr-1], st.data[st.ptr-n]
+ return
+}
+
+func (st *Stack) Dup(n int) {
+ st.useGas(GasStackOp)
+ if st.ptr < n {
+ st.setErr(ErrDataStackUnderflow)
+ return
+ }
+ st.Push(st.data[st.ptr-n])
+ return
+}
+
+// Not an opcode, costs no gas.
+func (st *Stack) Peek() Word256 {
+ return st.data[st.ptr-1]
+}
+
+func (st *Stack) Print(n int) {
+ fmt.Println("### stack ###")
+ if st.ptr > 0 {
+ nn := MinInt(n, st.ptr)
+ for j, i := 0, st.ptr-1; i > st.ptr-1-nn; i-- {
+ fmt.Printf("%-3d %X\n", j, st.data[i])
+ j += 1
+ }
+ } else {
+ fmt.Println("-- empty --")
+ }
+ fmt.Println("#############")
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/test/fake_app_state.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/test/fake_app_state.go
new file mode 100644
index 0000000000000000000000000000000000000000..71fadbde416995976cfb42999f2a1e2a294d1131
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/test/fake_app_state.go
@@ -0,0 +1,85 @@
+package vm
+
+import (
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/vm"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/sha3"
+)
+
+type FakeAppState struct {
+ accounts map[string]*Account
+ storage map[string]Word256
+ logs []*Log
+}
+
+func (fas *FakeAppState) GetAccount(addr Word256) *Account {
+ account := fas.accounts[addr.String()]
+ return account
+}
+
+func (fas *FakeAppState) UpdateAccount(account *Account) {
+ fas.accounts[account.Address.String()] = account
+}
+
+func (fas *FakeAppState) RemoveAccount(account *Account) {
+ _, ok := fas.accounts[account.Address.String()]
+ if !ok {
+ panic(Fmt("Invalid account addr: %X", account.Address))
+ } else {
+ // Remove account
+ delete(fas.accounts, account.Address.String())
+ }
+}
+
+func (fas *FakeAppState) CreateAccount(creator *Account) *Account {
+ addr := createAddress(creator)
+ account := fas.accounts[addr.String()]
+ if account == nil {
+ return &Account{
+ Address: addr,
+ Balance: 0,
+ Code: nil,
+ Nonce: 0,
+ StorageRoot: Zero256,
+ }
+ } else {
+ panic(Fmt("Invalid account addr: %X", addr))
+ }
+}
+
+func (fas *FakeAppState) GetStorage(addr Word256, key Word256) Word256 {
+ _, ok := fas.accounts[addr.String()]
+ if !ok {
+ panic(Fmt("Invalid account addr: %X", addr))
+ }
+
+ value, ok := fas.storage[addr.String()+key.String()]
+ if ok {
+ return value
+ } else {
+ return Zero256
+ }
+}
+
+func (fas *FakeAppState) SetStorage(addr Word256, key Word256, value Word256) {
+ _, ok := fas.accounts[addr.String()]
+ if !ok {
+ panic(Fmt("Invalid account addr: %X", addr))
+ }
+
+ fas.storage[addr.String()+key.String()] = value
+}
+
+func (fas *FakeAppState) AddLog(log *Log) {
+ fas.logs = append(fas.logs, log)
+}
+
+// Creates a 20 byte address and bumps the nonce.
+func createAddress(creator *Account) Word256 {
+ nonce := creator.Nonce
+ creator.Nonce += 1
+ temp := make([]byte, 32+8)
+ copy(temp, creator.Address[:])
+ PutUint64BE(temp[32:], nonce)
+ return LeftPadWord256(sha3.Sha3(temp)[:20])
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/test/vm_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/test/vm_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..246782316ba7e0afb40456f56df434b9478a7a99
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/test/vm_test.go
@@ -0,0 +1,202 @@
+package vm
+
+import (
+ "crypto/rand"
+ "encoding/hex"
+ "fmt"
+ "strings"
+ "testing"
+ "time"
+
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/events"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/vm"
+)
+
+func newAppState() *FakeAppState {
+ return &FakeAppState{
+ accounts: make(map[string]*Account),
+ storage: make(map[string]Word256),
+ logs: nil,
+ }
+}
+
+func newParams() Params {
+ return Params{
+ BlockHeight: 0,
+ BlockHash: Zero256,
+ BlockTime: 0,
+ GasLimit: 0,
+ }
+}
+
+func makeBytes(n int) []byte {
+ b := make([]byte, n)
+ rand.Read(b)
+ return b
+}
+
+// Runs a basic loop
+func TestVM(t *testing.T) {
+ ourVm := NewVM(newAppState(), newParams(), Zero256, nil)
+
+ // Create accounts
+ account1 := &Account{
+ Address: Uint64ToWord256(100),
+ }
+ account2 := &Account{
+ Address: Uint64ToWord256(101),
+ }
+
+ var gas uint64 = 100000
+ N := []byte{0x0f, 0x0f}
+ // Loop N times
+ code := []byte{0x60, 0x00, 0x60, 0x20, 0x52, 0x5B, byte(0x60 + len(N) - 1)}
+ for i := 0; i < len(N); i++ {
+ code = append(code, N[i])
+ }
+ code = append(code, []byte{0x60, 0x20, 0x51, 0x12, 0x15, 0x60, byte(0x1b + len(N)), 0x57, 0x60, 0x01, 0x60, 0x20, 0x51, 0x01, 0x60, 0x20, 0x52, 0x60, 0x05, 0x56, 0x5B}...)
+ start := time.Now()
+ output, err := ourVm.Call(account1, account2, code, []byte{}, 0, &gas)
+ fmt.Printf("Output: %v Error: %v\n", output, err)
+ fmt.Println("Call took:", time.Since(start))
+ if err != nil {
+ t.Fatal(err)
+ }
+}
+
+// Tests the code for a subcurrency contract compiled by serpent
+func TestSubcurrency(t *testing.T) {
+ st := newAppState()
+ // Create accounts
+ account1 := &Account{
+ Address: LeftPadWord256(makeBytes(20)),
+ }
+ account2 := &Account{
+ Address: LeftPadWord256(makeBytes(20)),
+ }
+ st.accounts[account1.Address.String()] = account1
+ st.accounts[account2.Address.String()] = account2
+
+ ourVm := NewVM(st, newParams(), Zero256, nil)
+
+ var gas uint64 = 1000
+ code_parts := []string{"620f42403355",
+ "7c0100000000000000000000000000000000000000000000000000000000",
+ "600035046315cf268481141561004657",
+ "6004356040526040515460605260206060f35b63693200ce81141561008757",
+ "60043560805260243560a052335460c0523360e05260a05160c05112151561008657",
+ "60a05160c0510360e0515560a0516080515401608051555b5b505b6000f3"}
+ code, _ := hex.DecodeString(strings.Join(code_parts, ""))
+ fmt.Printf("Code: %x\n", code)
+ data, _ := hex.DecodeString("693200CE0000000000000000000000004B4363CDE27C2EB05E66357DB05BC5C88F850C1A0000000000000000000000000000000000000000000000000000000000000005")
+ output, err := ourVm.Call(account1, account2, code, data, 0, &gas)
+ fmt.Printf("Output: %v Error: %v\n", output, err)
+ if err != nil {
+ t.Fatal(err)
+ }
+}
+
+// Test sending tokens from a contract to another account
+func TestSendCall(t *testing.T) {
+ fakeAppState := newAppState()
+ ourVm := NewVM(fakeAppState, newParams(), Zero256, nil)
+
+ // Create accounts
+ account1 := &Account{
+ Address: Uint64ToWord256(100),
+ }
+ account2 := &Account{
+ Address: Uint64ToWord256(101),
+ }
+ account3 := &Account{
+ Address: Uint64ToWord256(102),
+ }
+
+ // account1 will call account2 which will trigger CALL opcode to account3
+ addr := account3.Address.Postfix(20)
+ contractCode := callContractCode(addr)
+
+ //----------------------------------------------
+ // account2 has insufficient balance, should fail
+
+ exception := runVMWaitEvents(t, ourVm, account1, account2, addr, contractCode, 1000)
+ if exception == "" {
+ t.Fatal("Expected exception")
+ }
+
+ //----------------------------------------------
+ // give account2 sufficient balance, should pass
+
+ account2.Balance = 100000
+ exception = runVMWaitEvents(t, ourVm, account1, account2, addr, contractCode, 1000)
+ if exception != "" {
+ t.Fatal("Unexpected exception", exception)
+ }
+
+ //----------------------------------------------
+ // insufficient gas, should fail
+
+ account2.Balance = 100000
+ exception = runVMWaitEvents(t, ourVm, account1, account2, addr, contractCode, 100)
+ if exception == "" {
+ t.Fatal("Expected exception")
+ }
+}
+
+// subscribes to an AccReceive, runs the vm, returns the exception
+func runVMWaitEvents(t *testing.T, ourVm *VM, caller, callee *Account, subscribeAddr, contractCode []byte, gas uint64) string {
+ // we need to catch the event from the CALL to check for exceptions
+ evsw := new(events.EventSwitch)
+ evsw.Start()
+ ch := make(chan interface{})
+ fmt.Printf("subscribe to %x\n", subscribeAddr)
+ evsw.AddListenerForEvent("test", types.EventStringAccReceive(subscribeAddr), func(msg interface{}) {
+ ch <- msg
+ })
+ evc := events.NewEventCache(evsw)
+ ourVm.SetFireable(evc)
+ go func() {
+ start := time.Now()
+ output, err := ourVm.Call(caller, callee, contractCode, []byte{}, 0, &gas)
+ fmt.Printf("Output: %v Error: %v\n", output, err)
+ fmt.Println("Call took:", time.Since(start))
+ if err != nil {
+ ch <- err.Error()
+ }
+ evc.Flush()
+ }()
+ msg := <-ch
+ switch ev := msg.(type) {
+ case types.EventMsgCallTx:
+ return ev.Exception
+ case types.EventMsgCall:
+ return ev.Exception
+ case string:
+ return ev
+ }
+ return ""
+}
+
+// this is code to call another contract (hardcoded as addr)
+func callContractCode(addr []byte) []byte {
+ gas1, gas2 := byte(0x1), byte(0x1)
+ value := byte(0x69)
+ inOff, inSize := byte(0x0), byte(0x0) // no call data
+ retOff, retSize := byte(0x0), byte(0x20)
+ // this is the code we want to run (send funds to an account and return)
+ contractCode := []byte{0x60, retSize, 0x60, retOff, 0x60, inSize, 0x60, inOff, 0x60, value, 0x73}
+ contractCode = append(contractCode, addr...)
+ contractCode = append(contractCode, []byte{0x61, gas1, gas2, 0xf1, 0x60, 0x20, 0x60, 0x0, 0xf3}...)
+ return contractCode
+}
+
+/*
+ // infinite loop
+ code := []byte{0x5B, 0x60, 0x00, 0x56}
+ // mstore
+ code := []byte{0x60, 0x00, 0x60, 0x20}
+ // mstore, mload
+ code := []byte{0x60, 0x01, 0x60, 0x20, 0x52, 0x60, 0x20, 0x51}
+*/
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/types.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..4aa0964b59efb68b312aae7b8d98b174fcfeee51
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/types.go
@@ -0,0 +1,53 @@
+package vm
+
+import (
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+)
+
+const (
+ defaultDataStackCapacity = 10
+)
+
+type Account struct {
+ Address Word256
+ Balance uint64
+ Code []byte
+ Nonce uint64
+ StorageRoot Word256
+ Other interface{} // For holding all other data.
+}
+
+func (acc *Account) String() string {
+ return Fmt("VMAccount{%X B:%v C:%X N:%v S:%X}",
+ acc.Address, acc.Balance, acc.Code, acc.Nonce, acc.StorageRoot)
+}
+
+type Log struct {
+ Address Word256
+ Topics []Word256
+ Data []byte
+ Height uint64
+}
+
+type AppState interface {
+
+ // Accounts
+ GetAccount(addr Word256) *Account
+ UpdateAccount(*Account)
+ RemoveAccount(*Account)
+ CreateAccount(*Account) *Account
+
+ // Storage
+ GetStorage(Word256, Word256) Word256
+ SetStorage(Word256, Word256, Word256) // Setting to Zero is deleting.
+
+ // Logs
+ AddLog(*Log)
+}
+
+type Params struct {
+ BlockHeight uint64
+ BlockHash Word256
+ BlockTime int64
+ GasLimit uint64
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/vm.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/vm.go
new file mode 100644
index 0000000000000000000000000000000000000000..abfd855251c4e10e68fd465ea6004b5b7e8a9013
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/vm.go
@@ -0,0 +1,859 @@
+package vm
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "math/big"
+
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/events"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/vm/sha3"
+)
+
+var (
+ ErrUnknownAddress = errors.New("Unknown address")
+ ErrInsufficientBalance = errors.New("Insufficient balance")
+ ErrInvalidJumpDest = errors.New("Invalid jump dest")
+ ErrInsufficientGas = errors.New("Insuffient gas")
+ ErrMemoryOutOfBounds = errors.New("Memory out of bounds")
+ ErrCodeOutOfBounds = errors.New("Code out of bounds")
+ ErrInputOutOfBounds = errors.New("Input out of bounds")
+ ErrCallStackOverflow = errors.New("Call stack overflow")
+ ErrCallStackUnderflow = errors.New("Call stack underflow")
+ ErrDataStackOverflow = errors.New("Data stack overflow")
+ ErrDataStackUnderflow = errors.New("Data stack underflow")
+ ErrInvalidContract = errors.New("Invalid contract")
+)
+
+type Debug bool
+
+const (
+ dataStackCapacity = 1024
+ callStackCapacity = 100 // TODO ensure usage.
+ memoryCapacity = 1024 * 1024 // 1 MB
+ dbg Debug = true
+)
+
+func (d Debug) Printf(s string, a ...interface{}) {
+ if d {
+ fmt.Printf(s, a...)
+ }
+}
+
+type VM struct {
+ appState AppState
+ params Params
+ origin Word256
+ txid []byte
+
+ callDepth int
+
+ evc events.Fireable
+}
+
+func NewVM(appState AppState, params Params, origin Word256, txid []byte) *VM {
+ return &VM{
+ appState: appState,
+ params: params,
+ origin: origin,
+ callDepth: 0,
+ txid: txid,
+ }
+}
+
+// satisfies events.Eventable
+func (vm *VM) SetFireable(evc events.Fireable) {
+ vm.evc = evc
+}
+
+// CONTRACT appState is aware of caller and callee, so we can just mutate them.
+// value: To be transferred from caller to callee. Refunded upon error.
+// gas: Available gas. No refunds for gas.
+// code: May be nil, since the CALL opcode may be used to send value from contracts to accounts
+func (vm *VM) Call(caller, callee *Account, code, input []byte, value uint64, gas *uint64) (output []byte, err error) {
+
+ exception := new(string)
+ defer func() {
+ if vm.evc != nil {
+ vm.evc.FireEvent(types.EventStringAccReceive(callee.Address.Postfix(20)), types.EventMsgCall{
+ &types.CallData{caller.Address.Postfix(20), callee.Address.Postfix(20), input, value, *gas},
+ vm.origin.Postfix(20),
+ vm.txid,
+ output,
+ *exception,
+ })
+ }
+ }()
+
+ if err = transfer(caller, callee, value); err != nil {
+ *exception = err.Error()
+ return
+ }
+
+ if len(code) > 0 {
+ vm.callDepth += 1
+ output, err = vm.call(caller, callee, code, input, value, gas)
+ vm.callDepth -= 1
+ if err != nil {
+ *exception = err.Error()
+ err := transfer(callee, caller, value)
+ if err != nil {
+ panic("Could not return value to caller")
+ }
+ }
+ }
+
+ return
+}
+
+// Just like Call() but does not transfer 'value' or modify the callDepth.
+func (vm *VM) call(caller, callee *Account, code, input []byte, value uint64, gas *uint64) (output []byte, err error) {
+ dbg.Printf("(%d) (%X) %X (code=%d) gas: %v (d) %X\n", vm.callDepth, caller.Address[:4], callee.Address, len(callee.Code), *gas, input)
+
+ var (
+ pc uint64 = 0
+ stack = NewStack(dataStackCapacity, gas, &err)
+ memory = make([]byte, memoryCapacity)
+ ok = false // convenience
+ )
+
+ for {
+ // If there is an error, return
+ if err != nil {
+ return nil, err
+ }
+
+ var op = codeGetOp(code, pc)
+ dbg.Printf("(pc) %-3d (op) %-14s (st) %-4d ", pc, op.String(), stack.Len())
+
+ switch op {
+
+ case STOP: // 0x00
+ return nil, nil
+
+ case ADD: // 0x01
+ x, y := stack.Pop(), stack.Pop()
+ xb := new(big.Int).SetBytes(x[:])
+ yb := new(big.Int).SetBytes(y[:])
+ sum := new(big.Int).Add(xb, yb)
+ res := LeftPadWord256(U256(sum).Bytes())
+ stack.Push(res)
+ dbg.Printf(" %v + %v = %v (%X)\n", xb, yb, sum, res)
+
+ case MUL: // 0x02
+ x, y := stack.Pop(), stack.Pop()
+ xb := new(big.Int).SetBytes(x[:])
+ yb := new(big.Int).SetBytes(y[:])
+ prod := new(big.Int).Mul(xb, yb)
+ res := LeftPadWord256(U256(prod).Bytes())
+ stack.Push(res)
+ dbg.Printf(" %v * %v = %v (%X)\n", xb, yb, prod, res)
+
+ case SUB: // 0x03
+ x, y := stack.Pop(), stack.Pop()
+ xb := new(big.Int).SetBytes(x[:])
+ yb := new(big.Int).SetBytes(y[:])
+ diff := new(big.Int).Sub(xb, yb)
+ res := LeftPadWord256(U256(diff).Bytes())
+ stack.Push(res)
+ dbg.Printf(" %v - %v = %v (%X)\n", xb, yb, diff, res)
+
+ case DIV: // 0x04
+ x, y := stack.Pop(), stack.Pop()
+ if y.IsZero() {
+ stack.Push(Zero256)
+ dbg.Printf(" %x / %x = %v\n", x, y, 0)
+ } else {
+ xb := new(big.Int).SetBytes(x[:])
+ yb := new(big.Int).SetBytes(y[:])
+ div := new(big.Int).Div(xb, yb)
+ res := LeftPadWord256(U256(div).Bytes())
+ stack.Push(res)
+ dbg.Printf(" %v / %v = %v (%X)\n", xb, yb, div, res)
+ }
+
+ case SDIV: // 0x05
+ x, y := stack.Pop(), stack.Pop()
+ if y.IsZero() {
+ stack.Push(Zero256)
+ dbg.Printf(" %x / %x = %v\n", x, y, 0)
+ } else {
+ xb := S256(new(big.Int).SetBytes(x[:]))
+ yb := S256(new(big.Int).SetBytes(y[:]))
+ div := new(big.Int).Div(xb, yb)
+ res := LeftPadWord256(U256(div).Bytes())
+ stack.Push(res)
+ dbg.Printf(" %v / %v = %v (%X)\n", xb, yb, div, res)
+ }
+
+ case MOD: // 0x06
+ x, y := stack.Pop(), stack.Pop()
+ if y.IsZero() {
+ stack.Push(Zero256)
+ dbg.Printf(" %v %% %v = %v\n", x, y, 0)
+ } else {
+ xb := new(big.Int).SetBytes(x[:])
+ yb := new(big.Int).SetBytes(y[:])
+ mod := new(big.Int).Mod(xb, yb)
+ res := LeftPadWord256(U256(mod).Bytes())
+ stack.Push(res)
+ dbg.Printf(" %v %% %v = %v (%X)\n", xb, yb, mod, res)
+ }
+
+ case SMOD: // 0x07
+ x, y := stack.Pop(), stack.Pop()
+ if y.IsZero() {
+ stack.Push(Zero256)
+ dbg.Printf(" %v %% %v = %v\n", x, y, 0)
+ } else {
+ xb := S256(new(big.Int).SetBytes(x[:]))
+ yb := S256(new(big.Int).SetBytes(y[:]))
+ mod := new(big.Int).Mod(xb, yb)
+ res := LeftPadWord256(U256(mod).Bytes())
+ stack.Push(res)
+ dbg.Printf(" %v %% %v = %v (%X)\n", xb, yb, mod, res)
+ }
+
+ case ADDMOD: // 0x08
+ x, y, z := stack.Pop(), stack.Pop(), stack.Pop()
+ if z.IsZero() {
+ stack.Push(Zero256)
+ dbg.Printf(" %v %% %v = %v\n", x, y, 0)
+ } else {
+ xb := new(big.Int).SetBytes(x[:])
+ yb := new(big.Int).SetBytes(y[:])
+ zb := new(big.Int).SetBytes(z[:])
+ add := new(big.Int).Add(xb, yb)
+ mod := new(big.Int).Mod(add, zb)
+ res := LeftPadWord256(U256(mod).Bytes())
+ stack.Push(res)
+ dbg.Printf(" %v + %v %% %v = %v (%X)\n",
+ xb, yb, zb, mod, res)
+ }
+
+ case MULMOD: // 0x09
+ x, y, z := stack.Pop(), stack.Pop(), stack.Pop()
+ if z.IsZero() {
+ stack.Push(Zero256)
+ dbg.Printf(" %v %% %v = %v\n", x, y, 0)
+ } else {
+ xb := new(big.Int).SetBytes(x[:])
+ yb := new(big.Int).SetBytes(y[:])
+ zb := new(big.Int).SetBytes(z[:])
+ mul := new(big.Int).Mul(xb, yb)
+ mod := new(big.Int).Mod(mul, zb)
+ res := LeftPadWord256(U256(mod).Bytes())
+ stack.Push(res)
+ dbg.Printf(" %v * %v %% %v = %v (%X)\n",
+ xb, yb, zb, mod, res)
+ }
+
+ case EXP: // 0x0A
+ x, y := stack.Pop(), stack.Pop()
+ xb := new(big.Int).SetBytes(x[:])
+ yb := new(big.Int).SetBytes(y[:])
+ pow := new(big.Int).Exp(xb, yb, big.NewInt(0))
+ res := LeftPadWord256(U256(pow).Bytes())
+ stack.Push(res)
+ dbg.Printf(" %v ** %v = %v (%X)\n", xb, yb, pow, res)
+
+ case SIGNEXTEND: // 0x0B
+ back := stack.Pop()
+ backb := new(big.Int).SetBytes(back[:])
+ if backb.Cmp(big.NewInt(31)) < 0 {
+ bit := uint(backb.Uint64()*8 + 7)
+ num := stack.Pop()
+ numb := new(big.Int).SetBytes(num[:])
+ mask := new(big.Int).Lsh(big.NewInt(1), bit)
+ mask.Sub(mask, big.NewInt(1))
+ if numb.Bit(int(bit)) == 1 {
+ numb.Or(numb, mask.Not(mask))
+ } else {
+ numb.Add(numb, mask)
+ }
+ res := LeftPadWord256(U256(numb).Bytes())
+ dbg.Printf(" = %v (%X)", numb, res)
+ stack.Push(res)
+ }
+
+ case LT: // 0x10
+ x, y := stack.Pop(), stack.Pop()
+ xb := new(big.Int).SetBytes(x[:])
+ yb := new(big.Int).SetBytes(y[:])
+ if xb.Cmp(yb) < 0 {
+ stack.Push64(1)
+ dbg.Printf(" %v < %v = %v\n", xb, yb, 1)
+ } else {
+ stack.Push(Zero256)
+ dbg.Printf(" %v < %v = %v\n", xb, yb, 0)
+ }
+
+ case GT: // 0x11
+ x, y := stack.Pop(), stack.Pop()
+ xb := new(big.Int).SetBytes(x[:])
+ yb := new(big.Int).SetBytes(y[:])
+ if xb.Cmp(yb) > 0 {
+ stack.Push64(1)
+ dbg.Printf(" %v > %v = %v\n", xb, yb, 1)
+ } else {
+ stack.Push(Zero256)
+ dbg.Printf(" %v > %v = %v\n", xb, yb, 0)
+ }
+
+ case SLT: // 0x12
+ x, y := stack.Pop(), stack.Pop()
+ xb := S256(new(big.Int).SetBytes(x[:]))
+ yb := S256(new(big.Int).SetBytes(y[:]))
+ if xb.Cmp(yb) < 0 {
+ stack.Push64(1)
+ dbg.Printf(" %v < %v = %v\n", xb, yb, 1)
+ } else {
+ stack.Push(Zero256)
+ dbg.Printf(" %v < %v = %v\n", xb, yb, 0)
+ }
+
+ case SGT: // 0x13
+ x, y := stack.Pop(), stack.Pop()
+ xb := S256(new(big.Int).SetBytes(x[:]))
+ yb := S256(new(big.Int).SetBytes(y[:]))
+ if xb.Cmp(yb) > 0 {
+ stack.Push64(1)
+ dbg.Printf(" %v > %v = %v\n", xb, yb, 1)
+ } else {
+ stack.Push(Zero256)
+ dbg.Printf(" %v > %v = %v\n", xb, yb, 0)
+ }
+
+ case EQ: // 0x14
+ x, y := stack.Pop(), stack.Pop()
+ if bytes.Equal(x[:], y[:]) {
+ stack.Push64(1)
+ dbg.Printf(" %X == %X = %v\n", x, y, 1)
+ } else {
+ stack.Push(Zero256)
+ dbg.Printf(" %X == %X = %v\n", x, y, 0)
+ }
+
+ case ISZERO: // 0x15
+ x := stack.Pop()
+ if x.IsZero() {
+ stack.Push64(1)
+ dbg.Printf(" %v == 0 = %v\n", x, 1)
+ } else {
+ stack.Push(Zero256)
+ dbg.Printf(" %v == 0 = %v\n", x, 0)
+ }
+
+ case AND: // 0x16
+ x, y := stack.Pop(), stack.Pop()
+ z := [32]byte{}
+ for i := 0; i < 32; i++ {
+ z[i] = x[i] & y[i]
+ }
+ stack.Push(z)
+ dbg.Printf(" %X & %X = %X\n", x, y, z)
+
+ case OR: // 0x17
+ x, y := stack.Pop(), stack.Pop()
+ z := [32]byte{}
+ for i := 0; i < 32; i++ {
+ z[i] = x[i] | y[i]
+ }
+ stack.Push(z)
+ dbg.Printf(" %X | %X = %X\n", x, y, z)
+
+ case XOR: // 0x18
+ x, y := stack.Pop(), stack.Pop()
+ z := [32]byte{}
+ for i := 0; i < 32; i++ {
+ z[i] = x[i] ^ y[i]
+ }
+ stack.Push(z)
+ dbg.Printf(" %X ^ %X = %X\n", x, y, z)
+
+ case NOT: // 0x19
+ x := stack.Pop()
+ z := [32]byte{}
+ for i := 0; i < 32; i++ {
+ z[i] = ^x[i]
+ }
+ stack.Push(z)
+ dbg.Printf(" !%X = %X\n", x, z)
+
+ case BYTE: // 0x1A
+ idx, val := stack.Pop64(), stack.Pop()
+ res := byte(0)
+ if idx < 32 {
+ res = val[idx]
+ }
+ stack.Push64(uint64(res))
+ dbg.Printf(" => 0x%X\n", res)
+
+ case SHA3: // 0x20
+ if ok = useGas(gas, GasSha3); !ok {
+ return nil, firstErr(err, ErrInsufficientGas)
+ }
+ offset, size := stack.Pop64(), stack.Pop64()
+ data, ok := subslice(memory, offset, size)
+ if !ok {
+ return nil, firstErr(err, ErrMemoryOutOfBounds)
+ }
+ data = sha3.Sha3(data)
+ stack.PushBytes(data)
+ dbg.Printf(" => (%v) %X\n", size, data)
+
+ case ADDRESS: // 0x30
+ stack.Push(callee.Address)
+ dbg.Printf(" => %X\n", callee.Address)
+
+ case BALANCE: // 0x31
+ addr := stack.Pop()
+ if ok = useGas(gas, GasGetAccount); !ok {
+ return nil, firstErr(err, ErrInsufficientGas)
+ }
+ acc := vm.appState.GetAccount(addr)
+ if acc == nil {
+ return nil, firstErr(err, ErrUnknownAddress)
+ }
+ balance := acc.Balance
+ stack.Push64(balance)
+ dbg.Printf(" => %v (%X)\n", balance, addr)
+
+ case ORIGIN: // 0x32
+ stack.Push(vm.origin)
+ dbg.Printf(" => %X\n", vm.origin)
+
+ case CALLER: // 0x33
+ stack.Push(caller.Address)
+ dbg.Printf(" => %X\n", caller.Address)
+
+ case CALLVALUE: // 0x34
+ stack.Push64(value)
+ dbg.Printf(" => %v\n", value)
+
+ case CALLDATALOAD: // 0x35
+ offset := stack.Pop64()
+ data, ok := subslice(input, offset, 32)
+ if !ok {
+ return nil, firstErr(err, ErrInputOutOfBounds)
+ }
+ res := LeftPadWord256(data)
+ stack.Push(res)
+ dbg.Printf(" => 0x%X\n", res)
+
+ case CALLDATASIZE: // 0x36
+ stack.Push64(uint64(len(input)))
+ dbg.Printf(" => %d\n", len(input))
+
+ case CALLDATACOPY: // 0x37
+ memOff := stack.Pop64()
+ inputOff := stack.Pop64()
+ length := stack.Pop64()
+ data, ok := subslice(input, inputOff, length)
+ if !ok {
+ return nil, firstErr(err, ErrInputOutOfBounds)
+ }
+ dest, ok := subslice(memory, memOff, length)
+ if !ok {
+ return nil, firstErr(err, ErrMemoryOutOfBounds)
+ }
+ copy(dest, data)
+ dbg.Printf(" => [%v, %v, %v] %X\n", memOff, inputOff, length, data)
+
+ case CODESIZE: // 0x38
+ l := uint64(len(code))
+ stack.Push64(l)
+ dbg.Printf(" => %d\n", l)
+
+ case CODECOPY: // 0x39
+ memOff := stack.Pop64()
+ codeOff := stack.Pop64()
+ length := stack.Pop64()
+ data, ok := subslice(code, codeOff, length)
+ if !ok {
+ return nil, firstErr(err, ErrCodeOutOfBounds)
+ }
+ dest, ok := subslice(memory, memOff, length)
+ if !ok {
+ return nil, firstErr(err, ErrMemoryOutOfBounds)
+ }
+ copy(dest, data)
+ dbg.Printf(" => [%v, %v, %v] %X\n", memOff, codeOff, length, data)
+
+ case GASPRICE_DEPRECATED: // 0x3A
+ stack.Push(Zero256)
+ dbg.Printf(" => %X (GASPRICE IS DEPRECATED)\n")
+
+ case EXTCODESIZE: // 0x3B
+ addr := stack.Pop()
+ if ok = useGas(gas, GasGetAccount); !ok {
+ return nil, firstErr(err, ErrInsufficientGas)
+ }
+ acc := vm.appState.GetAccount(addr)
+ if acc == nil {
+ return nil, firstErr(err, ErrUnknownAddress)
+ }
+ code := acc.Code
+ l := uint64(len(code))
+ stack.Push64(l)
+ dbg.Printf(" => %d\n", l)
+
+ case EXTCODECOPY: // 0x3C
+ addr := stack.Pop()
+ if ok = useGas(gas, GasGetAccount); !ok {
+ return nil, firstErr(err, ErrInsufficientGas)
+ }
+ acc := vm.appState.GetAccount(addr)
+ if acc == nil {
+ return nil, firstErr(err, ErrUnknownAddress)
+ }
+ code := acc.Code
+ memOff := stack.Pop64()
+ codeOff := stack.Pop64()
+ length := stack.Pop64()
+ data, ok := subslice(code, codeOff, length)
+ if !ok {
+ return nil, firstErr(err, ErrCodeOutOfBounds)
+ }
+ dest, ok := subslice(memory, memOff, length)
+ if !ok {
+ return nil, firstErr(err, ErrMemoryOutOfBounds)
+ }
+ copy(dest, data)
+ dbg.Printf(" => [%v, %v, %v] %X\n", memOff, codeOff, length, data)
+
+ case BLOCKHASH: // 0x40
+ stack.Push(Zero256)
+ dbg.Printf(" => 0x%X (NOT SUPPORTED)\n", stack.Peek().Bytes())
+
+ case COINBASE: // 0x41
+ stack.Push(Zero256)
+ dbg.Printf(" => 0x%X (NOT SUPPORTED)\n", stack.Peek().Bytes())
+
+ case TIMESTAMP: // 0x42
+ time := vm.params.BlockTime
+ stack.Push64(uint64(time))
+ dbg.Printf(" => 0x%X\n", time)
+
+ case BLOCKHEIGHT: // 0x43
+ number := uint64(vm.params.BlockHeight)
+ stack.Push64(number)
+ dbg.Printf(" => 0x%X\n", number)
+
+ case GASLIMIT: // 0x45
+ stack.Push64(vm.params.GasLimit)
+ dbg.Printf(" => %v\n", vm.params.GasLimit)
+
+ case POP: // 0x50
+ stack.Pop()
+ dbg.Printf(" => %v\n", vm.params.GasLimit)
+
+ case MLOAD: // 0x51
+ offset := stack.Pop64()
+ data, ok := subslice(memory, offset, 32)
+ if !ok {
+ return nil, firstErr(err, ErrMemoryOutOfBounds)
+ }
+ stack.Push(LeftPadWord256(data))
+ dbg.Printf(" => 0x%X\n", data)
+
+ case MSTORE: // 0x52
+ offset, data := stack.Pop64(), stack.Pop()
+ dest, ok := subslice(memory, offset, 32)
+ if !ok {
+ return nil, firstErr(err, ErrMemoryOutOfBounds)
+ }
+ copy(dest, data[:])
+ dbg.Printf(" => 0x%X\n", data)
+
+ case MSTORE8: // 0x53
+ offset, val := stack.Pop64(), byte(stack.Pop64()&0xFF)
+ if len(memory) <= int(offset) {
+ return nil, firstErr(err, ErrMemoryOutOfBounds)
+ }
+ memory[offset] = val
+ dbg.Printf(" => [%v] 0x%X\n", offset, val)
+
+ case SLOAD: // 0x54
+ loc := stack.Pop()
+ data := vm.appState.GetStorage(callee.Address, loc)
+ stack.Push(data)
+ dbg.Printf(" {0x%X : 0x%X}\n", loc, data)
+
+ case SSTORE: // 0x55
+ loc, data := stack.Pop(), stack.Pop()
+ vm.appState.SetStorage(callee.Address, loc, data)
+ useGas(gas, GasStorageUpdate)
+ dbg.Printf(" {0x%X : 0x%X}\n", loc, data)
+
+ case JUMP: // 0x56
+ err = jump(code, stack.Pop64(), &pc)
+ continue
+
+ case JUMPI: // 0x57
+ pos, cond := stack.Pop64(), stack.Pop()
+ if !cond.IsZero() {
+ err = jump(code, pos, &pc)
+ continue
+ }
+ dbg.Printf(" ~> false\n")
+
+ case PC: // 0x58
+ stack.Push64(pc)
+
+ case MSIZE: // 0x59
+ stack.Push64(uint64(len(memory)))
+
+ case GAS: // 0x5A
+ stack.Push64(*gas)
+ dbg.Printf(" => %X\n", *gas)
+
+ case JUMPDEST: // 0x5B
+ dbg.Printf("\n")
+ // Do nothing
+
+ case PUSH1, PUSH2, PUSH3, PUSH4, PUSH5, PUSH6, PUSH7, PUSH8, PUSH9, PUSH10, PUSH11, PUSH12, PUSH13, PUSH14, PUSH15, PUSH16, PUSH17, PUSH18, PUSH19, PUSH20, PUSH21, PUSH22, PUSH23, PUSH24, PUSH25, PUSH26, PUSH27, PUSH28, PUSH29, PUSH30, PUSH31, PUSH32:
+ a := uint64(op - PUSH1 + 1)
+ codeSegment, ok := subslice(code, pc+1, a)
+ if !ok {
+ return nil, firstErr(err, ErrCodeOutOfBounds)
+ }
+ res := LeftPadWord256(codeSegment)
+ stack.Push(res)
+ pc += a
+ dbg.Printf(" => 0x%X\n", res)
+ //stack.Print(10)
+
+ case DUP1, DUP2, DUP3, DUP4, DUP5, DUP6, DUP7, DUP8, DUP9, DUP10, DUP11, DUP12, DUP13, DUP14, DUP15, DUP16:
+ n := int(op - DUP1 + 1)
+ stack.Dup(n)
+ dbg.Printf(" => [%d] 0x%X\n", n, stack.Peek().Bytes())
+
+ case SWAP1, SWAP2, SWAP3, SWAP4, SWAP5, SWAP6, SWAP7, SWAP8, SWAP9, SWAP10, SWAP11, SWAP12, SWAP13, SWAP14, SWAP15, SWAP16:
+ n := int(op - SWAP1 + 2)
+ stack.Swap(n)
+ dbg.Printf(" => [%d] %X\n", n, stack.Peek())
+ //stack.Print(10)
+
+ case LOG0, LOG1, LOG2, LOG3, LOG4:
+ n := int(op - LOG0)
+ topics := make([]Word256, n)
+ offset, size := stack.Pop64(), stack.Pop64()
+ for i := 0; i < n; i++ {
+ topics[i] = stack.Pop()
+ }
+ data, ok := subslice(memory, offset, size)
+ if !ok {
+ return nil, firstErr(err, ErrMemoryOutOfBounds)
+ }
+ log := &Log{
+ callee.Address,
+ topics,
+ data,
+ vm.params.BlockHeight,
+ }
+ vm.appState.AddLog(log)
+ dbg.Printf(" => %v\n", log)
+
+ case CREATE: // 0xF0
+ contractValue := stack.Pop64()
+ offset, size := stack.Pop64(), stack.Pop64()
+ input, ok := subslice(memory, offset, size)
+ if !ok {
+ return nil, firstErr(err, ErrMemoryOutOfBounds)
+ }
+
+ // Check balance
+ if callee.Balance < contractValue {
+ return nil, firstErr(err, ErrInsufficientBalance)
+ }
+
+ // TODO charge for gas to create account _ the code length * GasCreateByte
+
+ newAccount := vm.appState.CreateAccount(callee)
+ // Run the input to get the contract code.
+ ret, err_ := vm.Call(callee, newAccount, input, input, contractValue, gas)
+ if err_ != nil {
+ stack.Push(Zero256)
+ } else {
+ newAccount.Code = ret // Set the code
+ stack.Push(newAccount.Address)
+ }
+
+ case CALL, CALLCODE: // 0xF1, 0xF2
+ gasLimit := stack.Pop64()
+ addr, value := stack.Pop(), stack.Pop64()
+ inOffset, inSize := stack.Pop64(), stack.Pop64() // inputs
+ retOffset, retSize := stack.Pop64(), stack.Pop64() // outputs
+ dbg.Printf(" => %X\n", addr)
+
+ // Get the arguments from the memory
+ args, ok := subslice(memory, inOffset, inSize)
+ if !ok {
+ return nil, firstErr(err, ErrMemoryOutOfBounds)
+ }
+
+ // Ensure that gasLimit is reasonable
+ if *gas < gasLimit {
+ return nil, firstErr(err, ErrInsufficientGas)
+ } else {
+ *gas -= gasLimit
+ // NOTE: we will return any used gas later.
+ }
+
+ // Begin execution
+ var ret []byte
+ var err error
+ if nativeContract := nativeContracts[addr]; nativeContract != nil {
+ // Native contract
+ ret, err = nativeContract(args, &gasLimit)
+ } else {
+ // EVM contract
+ if ok = useGas(gas, GasGetAccount); !ok {
+ return nil, firstErr(err, ErrInsufficientGas)
+ }
+ acc := vm.appState.GetAccount(addr)
+ // since CALL is used also for sending funds,
+ // acc may not exist yet. This is an error for
+ // CALLCODE, but not for CALL, though I don't think
+ // ethereum actually cares
+ if op == CALLCODE {
+ if acc == nil {
+ return nil, firstErr(err, ErrUnknownAddress)
+ }
+ ret, err = vm.Call(callee, callee, acc.Code, args, value, gas)
+ } else {
+ if acc == nil {
+ // if we have not seen the account before, create it
+ // so we can send funds
+ acc = &Account{
+ Address: addr,
+ }
+ vm.appState.UpdateAccount(acc)
+ }
+ ret, err = vm.Call(callee, acc, acc.Code, args, value, gas)
+ }
+ }
+
+ // Push result
+ if err != nil {
+ dbg.Printf("error on call: %s", err.Error())
+ // TODO: fire event
+ stack.Push(Zero256)
+ } else {
+ stack.Push(One256)
+ dest, ok := subslice(memory, retOffset, retSize)
+ if !ok {
+ return nil, firstErr(err, ErrMemoryOutOfBounds)
+ }
+ copy(dest, ret)
+ }
+
+ // Handle remaining gas.
+ *gas += gasLimit
+
+ dbg.Printf("resume %X (%v)\n", callee.Address, gas)
+
+ case RETURN: // 0xF3
+ offset, size := stack.Pop64(), stack.Pop64()
+ ret, ok := subslice(memory, offset, size)
+ if !ok {
+ return nil, firstErr(err, ErrMemoryOutOfBounds)
+ }
+ dbg.Printf(" => [%v, %v] (%d) 0x%X\n", offset, size, len(ret), ret)
+ return ret, nil
+
+ case SUICIDE: // 0xFF
+ addr := stack.Pop()
+ if ok = useGas(gas, GasGetAccount); !ok {
+ return nil, firstErr(err, ErrInsufficientGas)
+ }
+ // TODO if the receiver is , then make it the fee.
+ receiver := vm.appState.GetAccount(addr)
+ if receiver == nil {
+ return nil, firstErr(err, ErrUnknownAddress)
+ }
+ balance := callee.Balance
+ receiver.Balance += balance
+ vm.appState.UpdateAccount(receiver)
+ vm.appState.RemoveAccount(callee)
+ dbg.Printf(" => (%X) %v\n", addr[:4], balance)
+ fallthrough
+
+ default:
+ dbg.Printf("(pc) %-3v Invalid opcode %X\n", pc, op)
+ panic(fmt.Errorf("Invalid opcode %X", op))
+ }
+
+ pc++
+
+ }
+}
+
+func subslice(data []byte, offset, length uint64) (ret []byte, ok bool) {
+ size := uint64(len(data))
+ if size < offset {
+ return nil, false
+ } else if size < offset+length {
+ ret, ok = data[offset:], true
+ ret = RightPadBytes(ret, 32)
+ } else {
+ ret, ok = data[offset:offset+length], true
+ }
+
+ return
+}
+
+func rightMostBytes(data []byte, n int) []byte {
+ size := MinInt(len(data), n)
+ offset := len(data) - size
+ return data[offset:]
+}
+
+func codeGetOp(code []byte, n uint64) OpCode {
+ if uint64(len(code)) <= n {
+ return OpCode(0) // stop
+ } else {
+ return OpCode(code[n])
+ }
+}
+
+func jump(code []byte, to uint64, pc *uint64) (err error) {
+ dest := codeGetOp(code, to)
+ if dest != JUMPDEST {
+ dbg.Printf(" ~> %v invalid jump dest %v\n", to, dest)
+ return ErrInvalidJumpDest
+ }
+ dbg.Printf(" ~> %v\n", to)
+ *pc = to
+ return nil
+}
+
+func firstErr(errA, errB error) error {
+ if errA != nil {
+ return errA
+ } else {
+ return errB
+ }
+}
+
+func useGas(gas *uint64, gasToUse uint64) bool {
+ if *gas > gasToUse {
+ *gas -= gasToUse
+ return true
+ } else {
+ return false
+ }
+}
+
+func transfer(from, to *Account, amount uint64) error {
+ if from.Balance < amount {
+ return ErrInsufficientBalance
+ } else {
+ from.Balance -= amount
+ to.Balance += amount
+ return nil
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tommy351/gin-cors/.gitignore b/Godeps/_workspace/src/github.com/tommy351/gin-cors/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..bf0824e596ed223ce8281e839c11e6c71d54892c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tommy351/gin-cors/.gitignore
@@ -0,0 +1 @@
+*.log
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/tommy351/gin-cors/.travis.yml b/Godeps/_workspace/src/github.com/tommy351/gin-cors/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..0ca0e1d5cb3d7241936cc4df80922ed2dba1ce47
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tommy351/gin-cors/.travis.yml
@@ -0,0 +1,11 @@
+language: go
+
+go:
+ - 1.3
+ - tip
+
+before_install:
+ - go get github.com/stretchr/testify/assert
+
+script:
+ - go test
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/tommy351/gin-cors/README.md b/Godeps/_workspace/src/github.com/tommy351/gin-cors/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..e70b108f336042699e711be3ce7edcf5eab3e6ff
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tommy351/gin-cors/README.md
@@ -0,0 +1,27 @@
+# gin-cors
+
+[](https://travis-ci.org/tommy351/gin-cors)
+
+CORS middleware for [Gin].
+
+## Installation
+
+``` bash
+$ go get github.com/tommy351/gin-cors
+```
+
+## Usage
+
+``` go
+import (
+ "github.com/gin-gonic/gin"
+ "github.com/tommy351/gin-cors"
+)
+
+func main(){
+ g := gin.New()
+ g.Use(cors.Middleware(cors.Options{}))
+}
+```
+
+[Gin]: http://gin-gonic.github.io/gin/
diff --git a/Godeps/_workspace/src/github.com/tommy351/gin-cors/cors.go b/Godeps/_workspace/src/github.com/tommy351/gin-cors/cors.go
new file mode 100644
index 0000000000000000000000000000000000000000..8c9735f1bf07cdbf0b3aa735dcd689f3324d35a0
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tommy351/gin-cors/cors.go
@@ -0,0 +1,80 @@
+package cors
+
+import (
+ "net/http"
+ "strconv"
+ "strings"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
+)
+
+var (
+ defaultAllowHeaders = []string{"Origin", "Accept", "Content-Type", "Authorization"}
+ defaultAllowMethods = []string{"GET", "POST", "PUT", "DELETE", "PATCH", "HEAD"}
+)
+
+// Options stores configurations
+type Options struct {
+ AllowOrigins []string
+ AllowCredentials bool
+ AllowMethods []string
+ AllowHeaders []string
+ ExposeHeaders []string
+ MaxAge time.Duration
+}
+
+// Middleware sets CORS headers for every request
+func Middleware(options Options) gin.HandlerFunc {
+ if options.AllowHeaders == nil {
+ options.AllowHeaders = defaultAllowHeaders
+ }
+
+ if options.AllowMethods == nil {
+ options.AllowMethods = defaultAllowMethods
+ }
+
+ return func(c *gin.Context) {
+ req := c.Request
+ res := c.Writer
+ origin := req.Header.Get("Origin")
+ requestMethod := req.Header.Get("Access-Control-Request-Method")
+ requestHeaders := req.Header.Get("Access-Control-Request-Headers")
+
+ if len(options.AllowOrigins) > 0 {
+ res.Header().Set("Access-Control-Allow-Origin", strings.Join(options.AllowOrigins, " "))
+ } else {
+ res.Header().Set("Access-Control-Allow-Origin", origin)
+ }
+
+ if options.AllowCredentials {
+ res.Header().Set("Access-Control-Allow-Credentials", "true")
+ }
+
+ if len(options.ExposeHeaders) > 0 {
+ res.Header().Set("Access-Control-Expose-Headers", strings.Join(options.ExposeHeaders, ","))
+ }
+
+ if req.Method == "OPTIONS" {
+ if len(options.AllowMethods) > 0 {
+ res.Header().Set("Access-Control-Allow-Methods", strings.Join(options.AllowMethods, ","))
+ } else if requestMethod != "" {
+ res.Header().Set("Access-Control-Allow-Methods", requestMethod)
+ }
+
+ if len(options.AllowHeaders) > 0 {
+ res.Header().Set("Access-Control-Allow-Headers", strings.Join(options.AllowHeaders, ","))
+ } else if requestHeaders != "" {
+ res.Header().Set("Access-Control-Allow-Headers", requestHeaders)
+ }
+
+ if options.MaxAge > time.Duration(0) {
+ res.Header().Set("Access-Control-Max-Age", strconv.FormatInt(int64(options.MaxAge/time.Second), 10))
+ }
+
+ c.AbortWithStatus(http.StatusOK)
+ } else {
+ c.Next()
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tommy351/gin-cors/cors_test.go b/Godeps/_workspace/src/github.com/tommy351/gin-cors/cors_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..3fca7178f7dcec3f0e18951623daa5dfb2f6406c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tommy351/gin-cors/cors_test.go
@@ -0,0 +1,249 @@
+package cors
+
+import (
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+func init() {
+ gin.SetMode(gin.TestMode)
+}
+
+type requestOptions struct {
+ Method string
+ URL string
+ Headers map[string]string
+ Body io.Reader
+}
+
+func request(server *gin.Engine, options requestOptions) *httptest.ResponseRecorder {
+ if options.Method == "" {
+ options.Method = "GET"
+ }
+
+ w := httptest.NewRecorder()
+ req, err := http.NewRequest(options.Method, options.URL, options.Body)
+
+ if options.Headers != nil {
+ for key, value := range options.Headers {
+ req.Header.Set(key, value)
+ }
+ }
+
+ server.ServeHTTP(w, req)
+
+ if err != nil {
+ panic(err)
+ }
+
+ return w
+}
+
+func newServer() *gin.Engine {
+ g := gin.New()
+ g.Use(Middleware(Options{}))
+
+ return g
+}
+
+func TestDefault(t *testing.T) {
+ g := newServer()
+ assert := assert.New(t)
+
+ g.GET("/test", func(c *gin.Context) {
+ c.String(http.StatusOK, "OK")
+ })
+
+ r := request(g, requestOptions{
+ URL: "/test",
+ Headers: map[string]string{
+ "Origin": "http://maji.moe",
+ },
+ })
+
+ assert.Equal("http://maji.moe", r.Header().Get("Access-Control-Allow-Origin"))
+ assert.Equal("OK", r.Body.String())
+}
+
+func TestAllowOrigins(t *testing.T) {
+ g := gin.New()
+ g.Use(Middleware(Options{
+ AllowOrigins: []string{"http://maji.moe", "http://example.com"},
+ }))
+ assert := assert.New(t)
+
+ g.GET("/test", func(c *gin.Context) {
+ c.String(http.StatusOK, "OK")
+ })
+
+ r := request(g, requestOptions{
+ URL: "/test",
+ Headers: map[string]string{
+ "Origin": "http://maji.moe",
+ },
+ })
+
+ assert.Equal("http://maji.moe http://example.com", r.Header().Get("Access-Control-Allow-Origin"))
+ assert.Equal("OK", r.Body.String())
+}
+
+func TestAllowCredentials(t *testing.T) {
+ g := gin.New()
+ g.Use(Middleware(Options{
+ AllowCredentials: true,
+ }))
+ assert := assert.New(t)
+
+ g.GET("/test", func(c *gin.Context) {
+ c.String(http.StatusOK, "OK")
+ })
+
+ r := request(g, requestOptions{
+ URL: "/test",
+ Headers: map[string]string{
+ "Origin": "http://maji.moe",
+ },
+ })
+
+ assert.Equal("true", r.Header().Get("Access-Control-Allow-Credentials"))
+ assert.Equal("OK", r.Body.String())
+}
+
+func TestExposeHeaders(t *testing.T) {
+ g := gin.New()
+ g.Use(Middleware(Options{
+ ExposeHeaders: []string{"Foo", "Bar"},
+ }))
+ assert := assert.New(t)
+
+ g.GET("/test", func(c *gin.Context) {
+ c.String(http.StatusOK, "OK")
+ })
+
+ r := request(g, requestOptions{
+ URL: "/test",
+ Headers: map[string]string{
+ "Origin": "http://maji.moe",
+ },
+ })
+
+ assert.Equal("Foo,Bar", r.Header().Get("Access-Control-Expose-Headers"))
+ assert.Equal("OK", r.Body.String())
+}
+
+func TestOptionsRequest(t *testing.T) {
+ g := newServer()
+ assert := assert.New(t)
+
+ r := request(g, requestOptions{
+ Method: "OPTIONS",
+ URL: "/",
+ Headers: map[string]string{
+ "Origin": "http://maji.moe",
+ },
+ })
+
+ assert.Equal("http://maji.moe", r.Header().Get("Access-Control-Allow-Origin"))
+ assert.Equal("GET,POST,PUT,DELETE,PATCH,HEAD", r.Header().Get("Access-Control-Allow-Methods"))
+ assert.Equal("Origin,Accept,Content-Type,Authorization", r.Header().Get("Access-Control-Allow-Headers"))
+ assert.Equal("", r.Body.String())
+ assert.Equal(200, r.Code)
+}
+
+func TestAllowMethods(t *testing.T) {
+ g := gin.New()
+ g.Use(Middleware(Options{
+ AllowMethods: []string{"GET", "POST", "PUT"},
+ }))
+ assert := assert.New(t)
+
+ r := request(g, requestOptions{
+ Method: "OPTIONS",
+ URL: "/",
+ Headers: map[string]string{
+ "Origin": "http://maji.moe",
+ },
+ })
+
+ assert.Equal("GET,POST,PUT", r.Header().Get("Access-Control-Allow-Methods"))
+}
+
+func TestRequestMethod(t *testing.T) {
+ g := gin.New()
+ g.Use(Middleware(Options{
+ AllowMethods: []string{},
+ }))
+ assert := assert.New(t)
+
+ r := request(g, requestOptions{
+ Method: "OPTIONS",
+ URL: "/",
+ Headers: map[string]string{
+ "Origin": "http://maji.moe",
+ "Access-Control-Request-Method": "PUT",
+ },
+ })
+
+ assert.Equal("PUT", r.Header().Get("Access-Control-Allow-Methods"))
+}
+
+func TestAllowHeaders(t *testing.T) {
+ g := gin.New()
+ g.Use(Middleware(Options{
+ AllowHeaders: []string{"X-Custom-Header", "X-Auth-Token"},
+ }))
+ assert := assert.New(t)
+
+ r := request(g, requestOptions{
+ Method: "OPTIONS",
+ URL: "/",
+ Headers: map[string]string{
+ "Origin": "http://maji.moe",
+ },
+ })
+
+ assert.Equal("X-Custom-Header,X-Auth-Token", r.Header().Get("Access-Control-Allow-Headers"))
+}
+
+func TestRequestHeaders(t *testing.T) {
+ g := gin.New()
+ g.Use(Middleware(Options{
+ AllowHeaders: []string{},
+ }))
+ assert := assert.New(t)
+
+ r := request(g, requestOptions{
+ Method: "OPTIONS",
+ URL: "/",
+ Headers: map[string]string{
+ "Origin": "http://maji.moe",
+ "Access-Control-Request-Headers": "Foo,Bar",
+ },
+ })
+
+ assert.Equal("Foo,Bar", r.Header().Get("Access-Control-Allow-Headers"))
+}
+
+func TestMaxAge(t *testing.T) {
+ g := gin.New()
+ g.Use(Middleware(Options{
+ MaxAge: time.Hour,
+ }))
+ assert := assert.New(t)
+
+ r := request(g, requestOptions{
+ Method: "OPTIONS",
+ URL: "/",
+ Headers: map[string]string{
+ "Origin": "http://maji.moe",
+ },
+ })
+
+ assert.Equal("3600", r.Header().Get("Access-Control-Max-Age"))
+}
diff --git a/Godeps/_workspace/src/golang.org/x/net/context/withtimeout_test.go b/Godeps/_workspace/src/golang.org/x/net/context/withtimeout_test.go
index a6754dc36892827e5af92fb4605edfdda3eb1a04..1a6006dc1ee5f7b76442afd3b3097578f168e697 100644
--- a/Godeps/_workspace/src/golang.org/x/net/context/withtimeout_test.go
+++ b/Godeps/_workspace/src/golang.org/x/net/context/withtimeout_test.go
@@ -8,7 +8,7 @@ import (
"fmt"
"time"
- "golang.org/x/net/context"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/golang.org/x/net/context"
)
func ExampleWithTimeout() {
diff --git a/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/graceful.go b/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/graceful.go
index 0951e08ed86f5d4de34e79c930c76e36b7d7f880..f503206c6ba47c152bde4e321e444da2c8baca4d 100644
--- a/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/graceful.go
+++ b/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/graceful.go
@@ -11,7 +11,7 @@ import (
"syscall"
"time"
- "golang.org/x/net/netutil"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/golang.org/x/net/netutil"
)
// Server wraps an http.Server with graceful connection handling.
diff --git a/README.md b/README.md
index 147a780c06cce0041097adbfa4d02068d8cc8de7..b9ccd650ff82d2a0b230b39b56d6d88ec60394c1 100644
--- a/README.md
+++ b/README.md
@@ -4,9 +4,11 @@
The server allows requests to be made over HTTP - either using JSON-RPC 2.0 or a RESTlike web-api - and websocket (JSON-RPC 2.0). The documentation can be found [here](TODO). We also have javascript bindings for the RPC methods in [erisdb-js](https://github.com/eris-ltd/erisdb-js).
-### Installation
+## Installation
-There are no binary downloads, and probably won't be before `1.0`.
+There are no binary downloads, and probably won't be before `1.0`.
+
+### Building from source
#### Ubuntu 14.04 (OSX ?)
@@ -16,18 +18,11 @@ You will also need the following libraries: `git, mercurial, libgmp3-dev`
On Ubuntu: `sudo apt-get install git mercurial libgmp3-dev`
-Then download [godep](https://github.com/tools/godep). It is needed for dependency management. It is recommended to set up a separate workspace for this project.
-
-`go get github.com/tools/godep`
-
-Next you pull in the code. It uses godep so I would recommend making a new workspace:
+Next you pull in the code:
-`go get github.com/eris-ltd/erisdb`
+`go get github.com/eris-ltd/eris-db/cmd/erisdb`
-It's gonna say no buildable sources but that's fine. Just cd into `$GOPATH/src/github.com/eris-ltd/erisdb` and run: `$ godep restore`
-
-After that, run `$ go install ./cmd/erisdb`
-This will build the `erisdb` executable and put it in `$GOPATH/bin`, which should be on your PATH. If not, then add it.
+This will build and install the `erisdb` executable and put it in `$GOPATH/bin`, which should be on your PATH. If not, then add it.
To run `erisdb`, just type `$ erisdb /path/to/working/folder`
@@ -41,7 +36,9 @@ Tendermint officially supports only 64 bit Ubuntu.
#### Docker
-There is no docker container for this library yet, but it will be added.
+Work in progress.
+
+`$ ./docker_build.sh` to build the image. After that, use ` $ ./docker_run.sh` to run with the default workdir (/home/.eris/.eris-db).
### Usage
@@ -78,6 +75,8 @@ The server configuration file looks like this:
[web_socket]
websocket_endpoint= <string>
max_websocket_sessions= <number>
+ read_buffer_size = <number>
+ write_buffer_size = <number>
[logging]
console_log_level= <string>
file_log_level= <string>
@@ -111,6 +110,8 @@ Details about the other fields and how this is implemented can be found [here](h
- `websocket_endpoint` is the name of the endpoint that is used to establish a websocket connection.
- `max_websocket_connections` is the maximum number of websocket connections that is allowed at the same time.
+- `read_buffer_size` is the size of the read buffer for each socket in bytes.
+- `read_buffer_size` is the size of the write buffer for each socket in bytes.
##### logging
@@ -145,8 +146,10 @@ json_rpc_endpoint="/rpc"
[web_socket]
websocket_endpoint="/socketrpc"
max_websocket_sessions=50
+read_buffer_size = 2048
+write_buffer_size = 2048
[logging]
-console_log_level="debug"
+console_log_level="info"
file_log_level="warn"
log_file=""
```
diff --git a/api.md b/api.md
index 4ded97652a4211c9683aea08066863352aeae255..368a4ed68b32bdd4b177f7a0011d7fa2a93d4d73 100644
--- a/api.md
+++ b/api.md
@@ -6,6 +6,7 @@ Eris DB allows remote access to its functionality over http and websocket. It cu
## TOC
+- [HTTP Requests](#http-requests)
- [JSON-RPC 2.0](#json-rpc)
- [REST-like HTTP](#rest-like)
- [Common objects and formatting](#formatting-conventions)
@@ -13,6 +14,11 @@ Eris DB allows remote access to its functionality over http and websocket. It cu
- [Methods](#methods)
- [Filters](#queries-filters)
+<a name="http-requests"></a>
+## HTTP Requests
+
+The only data format supported is JSON. All post requests needs to use `Content-Type: application/json`. The charset flag is not supported (json is utf-8 encoded by default).
+
<a name="json-rpc"></a>
## JSON RPC 2.0
@@ -448,6 +454,8 @@ Event object:
| [GetPeers](#get-peers) | erisdb.getPeers | GET | `/network/peers` |
| [GetPeer](#get-peer) | erisdb.getPeer | GET | `/network/peer/:address` |
+NOTE: Get peer is not fully implemented.
+
###Transactions
| Name | RPC method name | HTTP method | HTTP endpoint |
| :--- | :-------------- | :---------: | :------------ |
diff --git a/circle.yml b/circle.yml
new file mode 100644
index 0000000000000000000000000000000000000000..717733a9b39c4ef8619f0ab74e2fcbe2c10b4de9
--- /dev/null
+++ b/circle.yml
@@ -0,0 +1,10 @@
+dependencies:
+ pre:
+ - "sudo apt-get update && sudo apt-get install -y libgmp3-dev"
+ override:
+ - "cd ./cmd/erisdb && go build"
+ - "mv ~/eris-db/cmd/erisdb/erisdb ~/bin"
+ - chmod +x ~/bin/erisdb
+test:
+ override:
+ - go test -v ./...
diff --git a/client/ws_client.go b/client/ws_client.go
index 41ef214c7a7c8a5047eb196e37febfee1b61fa68..d07d9598bb355d928a8f9f6d2e7b4f553786e2cd 100644
--- a/client/ws_client.go
+++ b/client/ws_client.go
@@ -3,7 +3,7 @@ package client
import (
"fmt"
- "github.com/gorilla/websocket"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gorilla/websocket"
"net/http"
)
@@ -29,21 +29,21 @@ func (this *WSClient) Dial() (*http.Response, error) {
return r, err
}
this.conn = conn
-
+
return r, nil
}
// returns a channel from which messages can be pulled
// from a go routine that reads the socket.
// if the ws returns an error (eg. closes), we return
-func (this *WSClient) StartRead() <- chan []byte {
+func (this *WSClient) StartRead() <-chan []byte {
ch := make(chan []byte)
go func() {
for {
_, msg, err := this.conn.ReadMessage()
if err != nil {
if !this.closed {
- // TODO For now.
+ // TODO For now.
fmt.Println("Error: " + err.Error())
close(ch)
}
diff --git a/cmd/erisdbss/main.go b/cmd/erisdbss/main.go
index f86752014a8f070cdaa6b2afd3bb681e3cb42325..ce3283363748e31e8a612bd8b8d4a4f360aac461 100644
--- a/cmd/erisdbss/main.go
+++ b/cmd/erisdbss/main.go
@@ -1,9 +1,9 @@
package main
import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
ess "github.com/eris-ltd/eris-db/erisdb/erisdbss"
"github.com/eris-ltd/eris-db/server"
- "github.com/gin-gonic/gin"
"os"
"path"
)
diff --git a/docker_build.sh b/docker_build.sh
new file mode 100755
index 0000000000000000000000000000000000000000..d6648b85631b3cf5a7c22c8fec2019eaf6509f9f
--- /dev/null
+++ b/docker_build.sh
@@ -0,0 +1,2 @@
+#! /bin/sh
+docker build -t eris-db .
\ No newline at end of file
diff --git a/docker_run.sh b/docker_run.sh
new file mode 100755
index 0000000000000000000000000000000000000000..fee8a79b96cf289ea08b2d4f9b403489f8fc05ed
--- /dev/null
+++ b/docker_run.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+
+# Using ~/.eris on drive.
+ERIS_PATH=$HOME/.eris
+CONTAINER="eris-db"
+RUNNING=$(docker inspect --format="{{ .State.Running }}" eris-db)
+mkdir -v -p $ERIS_PATH
+
+# Run in the terminal and attach on start.
+if [ "$RUNNING" == "true" ]; then
+ echo "Container 'eris-db' already running. Exiting."
+ exit 1
+elif [ "$RUNNING" == "false" ]; then
+ echo "Container 'eris-db' found. Starting."
+ docker start --attach=true eris-db
+else
+ echo "Container 'eris-db' not found. Creating."
+ docker run --name eris-db -v $ERIS_PATH:/home/eris/.eris -p 46656:46656 -p 46657:46657 -p 1337:1337 eris-db
+fi
\ No newline at end of file
diff --git a/erisdb/codec.go b/erisdb/codec.go
index a08048bea8277e05c22083e19c8847ff232cb325..3d7bece602f1135d16d21eff23c7c31904119f1e 100644
--- a/erisdb/codec.go
+++ b/erisdb/codec.go
@@ -1,8 +1,8 @@
package erisdb
import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
rpc "github.com/eris-ltd/eris-db/rpc"
- "github.com/tendermint/tendermint/binary"
"io"
"io/ioutil"
)
diff --git a/erisdb/erisdbss/http.go b/erisdb/erisdbss/http.go
index 13573da297dcaf946e668f8919937adc455ed91d..abd0d1f310ee8a749321a47a29ff4c19a49eee71 100644
--- a/erisdb/erisdbss/http.go
+++ b/erisdb/erisdbss/http.go
@@ -3,11 +3,11 @@ package erisdbss
import (
"bytes"
"encoding/json"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
"github.com/eris-ltd/eris-db/server"
- "github.com/gin-gonic/gin"
- "github.com/tendermint/tendermint/binary"
- . "github.com/tendermint/tendermint/common"
- "github.com/tendermint/tendermint/state"
"net/http"
"os"
)
diff --git a/erisdb/erisdbss/log.go b/erisdb/erisdbss/log.go
index 719216427a0cbd239e0ae187dcfac8bf14604a72..37760e9c26334c5751d2e5da0200e196234cda2c 100644
--- a/erisdb/erisdbss/log.go
+++ b/erisdb/erisdbss/log.go
@@ -1,7 +1,7 @@
package erisdbss
import (
- "github.com/tendermint/log15"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
)
var log = log15.New("module", "eris/serverserver")
diff --git a/erisdb/erisdbss/server_manager.go b/erisdb/erisdbss/server_manager.go
index b3a617b5968256965bdacc4bff958c6199ceee8b..6ca1c37252940d18055d0637a9d39db47a194824 100644
--- a/erisdb/erisdbss/server_manager.go
+++ b/erisdb/erisdbss/server_manager.go
@@ -3,10 +3,10 @@ package erisdbss
import (
"bufio"
"fmt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
"github.com/eris-ltd/eris-db/files"
"github.com/eris-ltd/eris-db/server"
- "github.com/tendermint/tendermint/binary"
- . "github.com/tendermint/tendermint/common"
"os"
"os/exec"
"path"
@@ -76,7 +76,12 @@ func (this *CmdProcess) Start(doneChan chan<- error) {
}
func (this *CmdProcess) Kill() error {
- return this.cmd.Process.Kill()
+ err := this.cmd.Process.Kill()
+ if err != nil {
+ return err
+ }
+ _ , err2 := this.cmd.Process.Wait()
+ return err2
}
// A serve task. This wraps a running process. It was designed to run 'erisdb' processes.
@@ -183,12 +188,12 @@ func (this *ServerManager) add(data *RequestData) (*ResponseData, error) {
}
st := newServeTask(port, workDir, maxDur, proc)
- this.running = append(this.running, st)
+ this.running = append(this.running, st)
// TODO add validation data. The node should ideally return some post-deploy state data
// and send it back with the server URL, so that the validity of the chain can be
// established client-side before starting the tests.
- return &ResponseData{fmt.Sprintf("%d",port)}, nil
+ return &ResponseData{fmt.Sprintf("%d", port)}, nil
}
// Add a new erisdb process to the list.
diff --git a/erisdb/event_cache_test.go b/erisdb/event_cache_test.go
index 5dc824588b76e33bd88c9e40e5e27a301dc3d52e..c1532adb07f3498f531c7c605381437d4e47711d 100644
--- a/erisdb/event_cache_test.go
+++ b/erisdb/event_cache_test.go
@@ -3,7 +3,7 @@ package erisdb
import (
"encoding/hex"
"fmt"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
"runtime"
"testing"
"time"
diff --git a/erisdb/json_service.go b/erisdb/json_service.go
index f8b750003fa3604c3db7ee0392c02b9acfb47a34..887d270709e7269d68166bc9c1e690f0923e8640 100644
--- a/erisdb/json_service.go
+++ b/erisdb/json_service.go
@@ -3,10 +3,10 @@ package erisdb
import (
"encoding/json"
"fmt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
rpc "github.com/eris-ltd/eris-db/rpc"
"github.com/eris-ltd/eris-db/server"
- "github.com/gin-gonic/gin"
"net/http"
)
diff --git a/erisdb/methods.go b/erisdb/methods.go
index 29cdf3ac4acbdba28e8c6bf6a68a6be315be7dbd..95871fb7af676050e98cdd8e64e6f267e0645de1 100644
--- a/erisdb/methods.go
+++ b/erisdb/methods.go
@@ -4,9 +4,9 @@ import (
"crypto/rand"
"encoding/hex"
"fmt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
rpc "github.com/eris-ltd/eris-db/rpc"
- "github.com/tendermint/tendermint/types"
"strings"
)
diff --git a/erisdb/middleware_test.go b/erisdb/middleware_test.go
index 75a091868b85915569a3e10ea14e80b2555d9898..6a40a277d2b4ace7397da1180540628dca325f98 100644
--- a/erisdb/middleware_test.go
+++ b/erisdb/middleware_test.go
@@ -1,8 +1,8 @@
package erisdb
import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
- "github.com/stretchr/testify/assert"
"testing"
)
diff --git a/erisdb/params.go b/erisdb/params.go
index 25ac97b615a244fc5dd2cb5e991db24f2434f03d..dc0c532af12b6286e11ce471b1a0f68851186f1c 100644
--- a/erisdb/params.go
+++ b/erisdb/params.go
@@ -1,9 +1,9 @@
package erisdb
import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
"github.com/eris-ltd/eris-db/erisdb/pipe"
- "github.com/tendermint/tendermint/account"
- "github.com/tendermint/tendermint/types"
)
type (
diff --git a/erisdb/pipe/accounts.go b/erisdb/pipe/accounts.go
index 17e80e89432d3315290912c5b7406cc432bdff08..081cd242d4f60cda0904856614e50e3be00665e5 100644
--- a/erisdb/pipe/accounts.go
+++ b/erisdb/pipe/accounts.go
@@ -4,10 +4,10 @@ import (
"bytes"
"encoding/hex"
"fmt"
- "github.com/tendermint/tendermint/account"
- cmn "github.com/tendermint/tendermint/common"
- cs "github.com/tendermint/tendermint/consensus"
- mempl "github.com/tendermint/tendermint/mempool"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ cmn "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ cs "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus"
+ mempl "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool"
"sync"
)
diff --git a/erisdb/pipe/blockchain.go b/erisdb/pipe/blockchain.go
index aaebbf887afb95abdf26fab857b67d34b26778d4..b0704d7cf571a2fd192649420e7de16a2bbcd02b 100644
--- a/erisdb/pipe/blockchain.go
+++ b/erisdb/pipe/blockchain.go
@@ -2,10 +2,10 @@ package pipe
import (
"fmt"
- bc "github.com/tendermint/tendermint/blockchain"
- dbm "github.com/tendermint/tendermint/db"
- "github.com/tendermint/tendermint/state"
- "github.com/tendermint/tendermint/types"
+ bc "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain"
+ dbm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/db"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
"math"
"strconv"
"strings"
diff --git a/erisdb/pipe/config.go b/erisdb/pipe/config.go
index 3a2f232116c0dc7c828bd8aeed9b4f493fd2448c..a7e51520ff5f6865287a991ba815d026b10e4f78 100644
--- a/erisdb/pipe/config.go
+++ b/erisdb/pipe/config.go
@@ -1,8 +1,8 @@
package pipe
import (
- "github.com/tendermint/log15"
- cfg "github.com/tendermint/tendermint/config"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
+ cfg "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config"
)
var log = log15.New("module", "eris/erisdb_pipe")
diff --git a/erisdb/pipe/consensus.go b/erisdb/pipe/consensus.go
index 324e17b19931430893f9ca66cb8bf1a0b1c23fe9..344dc877427d3e9eac4023699e36f3a6862dc463 100644
--- a/erisdb/pipe/consensus.go
+++ b/erisdb/pipe/consensus.go
@@ -1,10 +1,10 @@
package pipe
import (
- "github.com/tendermint/tendermint/binary"
- cm "github.com/tendermint/tendermint/consensus"
- "github.com/tendermint/tendermint/p2p"
- "github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ cm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
)
// The consensus struct.
diff --git a/erisdb/pipe/events.go b/erisdb/pipe/events.go
index 7f145897634a7dd54e8c97d537a325e5db8e91d7..9171ea5146fe9f397c5b1e73f77e3171b8371a94 100644
--- a/erisdb/pipe/events.go
+++ b/erisdb/pipe/events.go
@@ -1,7 +1,7 @@
package pipe
import (
- evts "github.com/tendermint/tendermint/events"
+ evts "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/events"
)
// TODO improve
diff --git a/erisdb/pipe/filters.go b/erisdb/pipe/filters.go
index ba05335541202d087c7b2740bf13c800dfda1c7b..dcf40aea23cb9d5845ce01a8dde5f0d03b3e6f48 100644
--- a/erisdb/pipe/filters.go
+++ b/erisdb/pipe/filters.go
@@ -177,14 +177,14 @@ func GetRangeFilter(op, fName string) (func(a, b int64) bool, error) {
}
}
-func GetStringFilter(op, fName string) (func(s0, s1 string) bool, error){
+func GetStringFilter(op, fName string) (func(s0, s1 string) bool, error) {
if op == "==" {
return func(s0, s1 string) bool {
- return strings.EqualFold(s0,s1)
+ return strings.EqualFold(s0, s1)
}, nil
} else if op == "!=" {
return func(s0, s1 string) bool {
- return !strings.EqualFold(s0,s1)
+ return !strings.EqualFold(s0, s1)
}, nil
} else {
return nil, fmt.Errorf("Op: " + op + " is not supported for '" + fName + "' filtering.")
diff --git a/erisdb/pipe/net.go b/erisdb/pipe/net.go
index fe7b6e6f3c0445483b7aaad8f35c193980ef5c01..914b49d1f4022b8f4577502947470220615f0002 100644
--- a/erisdb/pipe/net.go
+++ b/erisdb/pipe/net.go
@@ -1,7 +1,7 @@
package pipe
import (
- "github.com/tendermint/tendermint/p2p"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p"
)
// The net struct.
diff --git a/erisdb/pipe/pipe.go b/erisdb/pipe/pipe.go
index d5569211b287a39af0238eb9ca9232c027ebf47f..c2a203a1556b624310e25d004e7133e2705c8f7f 100644
--- a/erisdb/pipe/pipe.go
+++ b/erisdb/pipe/pipe.go
@@ -2,9 +2,9 @@
package pipe
import (
- "github.com/tendermint/tendermint/account"
- "github.com/tendermint/tendermint/node"
- "github.com/tendermint/tendermint/types"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/node"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
)
type (
@@ -63,7 +63,6 @@ type (
CallCode(code, data []byte) (*Call, error)
BroadcastTx(tx types.Tx) (*Receipt, error)
Transact(privKey, address, data []byte, gasLimit, fee uint64) (*Receipt, error)
- TransactAsync(privKey, address, data []byte, gasLimit, fee uint64) (*TransactionResult, error)
UnconfirmedTxs() (*UnconfirmedTxs, error)
SignTx(tx types.Tx, privAccounts []*account.PrivAccount) (types.Tx, error)
}
diff --git a/erisdb/pipe/transactor.go b/erisdb/pipe/transactor.go
index 5fe910cef5a8ae1288281513f373bb7468510158..c97d328c4dc985bb2b39851bb3291c5f6a4f0d33 100644
--- a/erisdb/pipe/transactor.go
+++ b/erisdb/pipe/transactor.go
@@ -3,14 +3,13 @@ package pipe
import (
"encoding/hex"
"fmt"
- "github.com/tendermint/tendermint/account"
- cmn "github.com/tendermint/tendermint/common"
- cs "github.com/tendermint/tendermint/consensus"
- mempl "github.com/tendermint/tendermint/mempool"
- "github.com/tendermint/tendermint/state"
- "github.com/tendermint/tendermint/types"
- "github.com/tendermint/tendermint/vm"
- "sync"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ cmn "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ cs "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus"
+ mempl "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/vm"
)
const (
@@ -22,8 +21,6 @@ const (
type transactor struct {
consensusState *cs.ConsensusState
mempoolReactor *mempl.MempoolReactor
- pending []TxFuture
- pendingLock *sync.Mutex
eventEmitter EventEmitter
}
@@ -31,18 +28,8 @@ func newTransactor(consensusState *cs.ConsensusState, mempoolReactor *mempl.Memp
txs := &transactor{
consensusState,
mempoolReactor,
- []TxFuture{},
- &sync.Mutex{},
eventEmitter,
}
- /*
- eventEmitter.Subscribe(SUB_ID, EVENT_ID, func(v interface{}) {
- block := v.(*types.Block)
- for _, fut := range txs.pending {
- fut.NewBlock(block)
- }
- })
- */
return txs
}
@@ -126,10 +113,6 @@ func (this *transactor) UnconfirmedTxs() (*UnconfirmedTxs, error) {
return &UnconfirmedTxs{transactions}, nil
}
-func (this *transactor) TransactAsync(privKey, address, data []byte, gasLimit, fee uint64) (*TransactionResult, error) {
- return nil, nil
-}
-
func (this *transactor) Transact(privKey, address, data []byte, gasLimit, fee uint64) (*Receipt, error) {
fmt.Printf("ADDRESS: %v\n", address)
var addr []byte
@@ -165,8 +148,8 @@ func (this *transactor) Transact(privKey, address, data []byte, gasLimit, fee ui
tx := &types.CallTx{
Input: txInput,
Address: addr,
- GasLimit: 1000,
- Fee: 1000,
+ GasLimit: gasLimit,
+ Fee: fee,
Data: data,
}
// Got ourselves a tx.
@@ -235,85 +218,3 @@ func toVMAccount(acc *account.Account) *vm.Account {
Other: acc.PubKey,
}
}
-
-// This is the different status codes for transactions.
-// 0 - the tx tracker object is being set up.
-// 1 - the tx has been created and passed into the tx pool.
-// 2 - the tx was succesfully committed into a block.
-// Errors
-// -1 - the tx failed.
-const (
- TX_NEW_CODE int8 = 0
- TX_POOLED_CODE int8 = 1
- TX_COMITTED_CODE int8 = 2
- TX_FAILED_CODE int8 = -1
-)
-
-// Number of bytes in a transaction hash
-const TX_HASH_BYTES = 32
-
-// Length of the tx hash hex-string (prepended by 0x)
-const TX_HASH_LENGTH = 2 * TX_HASH_BYTES
-
-type TxFuture interface {
- // Tx Hash
- Hash() string
- // Target account.
- Target() string
- // Get the Receipt for this transaction.
- Results() *TransactionResult
- // This will block and wait for the tx to be done.
- Get() *TransactionResult
- // This will block for 'timeout' miliseconds and wait for
- // the tx to be done. 0 means no timeout, and is equivalent
- // to calling 'Get()'.
- GetWithTimeout(timeout uint64) *TransactionResult
- // Checks the status. The status codes can be find near the
- // top of this file.
- StatusCode() int8
- // This is true when the transaction is done (whether it was successful or not).
- Done() bool
-}
-
-// Implements the 'TxFuture' interface.
-type TxFutureImpl struct {
- receipt *Receipt
- result *TransactionResult
- target string
- status int8
- transactor Transactor
- errStr string
- getLock *sync.Mutex
-}
-
-func (this *TxFutureImpl) Results() *TransactionResult {
- return this.result
-}
-
-func (this *TxFutureImpl) StatusCode() int8 {
- return this.status
-}
-
-func (this *TxFutureImpl) Done() bool {
- return this.status == TX_COMITTED_CODE || this.status == TX_FAILED_CODE
-}
-
-func (this *TxFutureImpl) Wait() *TransactionResult {
- return this.WaitWithTimeout(0)
-}
-
-// We wait for blocks, and when a block arrives we check if tx is committed.
-// This will return after it has been confirmed that tx was committed, or if
-// it failed, and for a maximum of 'blocks' blocks. If 'blocks' is set to 0,
-// it will be set to DEFAULT_BLOCKS_WAIT.
-// This is a temporary solution until we have solidity events.
-func (this *TxFutureImpl) WaitWithTimeout(blocks int) *TransactionResult {
- return nil
-}
-
-func (this *TxFutureImpl) setStatus(status int8, errorStr string) {
- this.status = status
- if status == TX_FAILED_CODE {
- this.errStr = errorStr
- }
-}
diff --git a/erisdb/pipe/types.go b/erisdb/pipe/types.go
index 2901ec7107a702bb766d582b5c8413f5b31b67bb..bf75a020ab7ed865cabdb92db4d6e644d0d0c8f2 100644
--- a/erisdb/pipe/types.go
+++ b/erisdb/pipe/types.go
@@ -1,11 +1,11 @@
package pipe
import (
- "github.com/tendermint/tendermint/account"
- csus "github.com/tendermint/tendermint/consensus"
- ctypes "github.com/tendermint/tendermint/consensus/types"
- sm "github.com/tendermint/tendermint/state"
- "github.com/tendermint/tendermint/types"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ csus "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus"
+ ctypes "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/types"
+ sm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
)
type (
diff --git a/erisdb/restServer.go b/erisdb/restServer.go
index 9e81aed889a27fe1793060a3a0f1953244c96047..4544afa70ce5df2930d0b9b58764a197e2d0b46b 100644
--- a/erisdb/restServer.go
+++ b/erisdb/restServer.go
@@ -3,12 +3,12 @@ package erisdb
import (
"encoding/hex"
"fmt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
rpc "github.com/eris-ltd/eris-db/rpc"
"github.com/eris-ltd/eris-db/server"
"github.com/eris-ltd/eris-db/util"
- "github.com/gin-gonic/gin"
- "github.com/tendermint/tendermint/types"
"strconv"
"strings"
)
@@ -430,6 +430,7 @@ func addressParam(c *gin.Context) {
}
bts, _ := hex.DecodeString(addr)
c.Set("addrBts", bts)
+ c.Next()
}
func keyParam(c *gin.Context) {
@@ -439,6 +440,7 @@ func keyParam(c *gin.Context) {
c.AbortWithError(400, err)
}
c.Set("keyBts", bts)
+ c.Next()
}
func heightParam(c *gin.Context) {
@@ -450,6 +452,7 @@ func heightParam(c *gin.Context) {
c.AbortWithError(400, fmt.Errorf("Negative number used as height."))
}
c.Set("height", uint(h))
+ c.Next()
}
func subIdParam(c *gin.Context) {
@@ -458,12 +461,14 @@ func subIdParam(c *gin.Context) {
c.AbortWithError(400, fmt.Errorf("Malformed event id"))
}
c.Set("id", subId)
+ c.Next()
}
// TODO
func peerAddressParam(c *gin.Context) {
subId := c.Param("address")
c.Set("address", subId)
+ c.Next()
}
func parseQuery(c *gin.Context) {
diff --git a/erisdb/serve.go b/erisdb/serve.go
index 9d1345477b4bf70a65d21b4d83b4dd9d7e3bb385..b40fcfcb35ae4a774e89292e03c6cab01f935343 100644
--- a/erisdb/serve.go
+++ b/erisdb/serve.go
@@ -3,14 +3,14 @@
package erisdb
import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
+ . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ cfg "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config"
+ tmcfg "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/node"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
"github.com/eris-ltd/eris-db/server"
- "github.com/tendermint/log15"
- . "github.com/tendermint/tendermint/common"
- cfg "github.com/tendermint/tendermint/config"
- tmcfg "github.com/tendermint/tendermint/config/tendermint"
- "github.com/tendermint/tendermint/node"
- "github.com/tendermint/tendermint/p2p"
"path"
)
@@ -53,9 +53,9 @@ func ServeErisDB(workDir string) (*server.ServeProcess, error) {
// Get tendermint configuration
tmConfig = tmcfg.GetConfig(workDir)
- tmConfig.Set("version", TENDERMINT_VERSION)
+ tmConfig.Set("version", TENDERMINT_VERSION)
cfg.ApplyConfig(tmConfig) // Notify modules of new config
-
+
// Set the node up.
nodeRd := make(chan struct{})
nd := node.NewNode()
diff --git a/erisdb/wsService.go b/erisdb/wsService.go
index 215dc4d6ee7428f2b09eb986fb8dfea7c25c7c50..258cccea795696acba82149b0b616528286a62f6 100644
--- a/erisdb/wsService.go
+++ b/erisdb/wsService.go
@@ -1,11 +1,11 @@
package erisdb
import (
+ "encoding/json"
"fmt"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
rpc "github.com/eris-ltd/eris-db/rpc"
"github.com/eris-ltd/eris-db/server"
- "encoding/json"
)
// Used for ErisDb. Implements WebSocketService.
@@ -37,7 +37,7 @@ func (this *ErisDbWsService) Process(msg []byte, session *server.WSSession) {
// Error when unmarshaling.
if errU != nil {
- this.writeError("Failed to parse request: " + errU.Error() + " . Raw: " + string(msg), "", rpc.PARSE_ERROR, session)
+ this.writeError("Failed to parse request: "+errU.Error()+" . Raw: "+string(msg), "", rpc.PARSE_ERROR, session)
return
}
diff --git a/files/files.go b/files/files.go
index eaa2b3bab1d3f40af149d60e6182ed140739af65..aa9e59c83a11c980383e50198125fde577dd59cf 100644
--- a/files/files.go
+++ b/files/files.go
@@ -71,7 +71,12 @@ func IsRegular(fileName string) bool {
func WriteAndBackup(fileName string, data []byte) error {
fs, err := os.Stat(fileName)
+ fmt.Println("Write and backup")
if err != nil {
+ if os.IsNotExist(err) {
+ WriteFileRW(fileName, data)
+ return nil
+ }
return err
}
if !fs.Mode().IsRegular() {
diff --git a/files/files_test.go b/files/files_test.go
index 2d9cdc23ed1646f3acb242904015df3ba1418945..bdfa44265a19b727a8ef9dad251632bcaec26f18 100644
--- a/files/files_test.go
+++ b/files/files_test.go
@@ -2,7 +2,7 @@ package files
import (
"bytes"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
"os"
"path"
"testing"
diff --git a/files/log.go b/files/log.go
index a18f6b6a6ec7420d469269b33832a2e5cc277a43..9067bf137b741db2a06094b0de429054bfcc493e 100644
--- a/files/log.go
+++ b/files/log.go
@@ -1,7 +1,7 @@
package files
import (
- "github.com/tendermint/log15"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
)
var log = log15.New("module", "eris/server/files")
diff --git a/rpc/rpc_test.go b/rpc/rpc_test.go
index eb2cfd8abccb5ea9f59bbcd6fc665a695d4105bc..a5debf5f78621a45beda0440ebcd95fbfe9bc8e6 100644
--- a/rpc/rpc_test.go
+++ b/rpc/rpc_test.go
@@ -1,7 +1,7 @@
package rpc
import (
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
"testing"
)
@@ -32,4 +32,4 @@ func TestNewJsonRpcErrorResponse(t *testing.T) {
}
respGen := NewRPCErrorResponse(id, code, message)
assert.Equal(t, respGen, resp)
-}
\ No newline at end of file
+}
diff --git a/server/config.go b/server/config.go
index 9d979f06b4747ba0ff09ed389c4c608d3ea4dc79..ae5f2f5c64c8312a390cf247c27924356f296239 100644
--- a/server/config.go
+++ b/server/config.go
@@ -1,8 +1,8 @@
package server
import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/naoina/toml"
"github.com/eris-ltd/eris-db/files"
- "github.com/naoina/toml"
)
// Standard configuration file for the server.
@@ -43,8 +43,10 @@ type (
}
WebSocket struct {
- WebSocketEndpoint string `toml:"websocket_endpoint"`
+ WebSocketEndpoint string `toml:"websocket_endpoint"`
MaxWebSocketSessions uint `toml:"max_websocket_sessions"`
+ ReadBufferSize uint `toml:"read_buffer_size"`
+ WriteBufferSize uint `toml:"write_buffer_size"`
}
Logging struct {
@@ -69,8 +71,10 @@ func DefaultServerConfig() *ServerConfig {
CORS: CORS{},
HTTP: HTTP{JsonRpcEndpoint: "/rpc"},
WebSocket: WebSocket{
- WebSocketEndpoint: "/socketrpc",
+ WebSocketEndpoint: "/socketrpc",
MaxWebSocketSessions: 50,
+ ReadBufferSize: 2048,
+ WriteBufferSize: 2048,
},
Logging: Logging{
ConsoleLogLevel: "info",
@@ -95,11 +99,10 @@ func ReadServerConfig(filePath string) (*ServerConfig, error) {
}
// Write a server configuration file.
-// TODO use the backup file write.
func WriteServerConfig(filePath string, cfg *ServerConfig) error {
bts, err := toml.Marshal(*cfg)
if err != nil {
return err
}
- return files.WriteFileRW(filePath, bts)
+ return files.WriteAndBackup(filePath, bts)
}
diff --git a/server/log.go b/server/log.go
index aacad33d92109b6353e54b91b438b3f2f7e746f3..09e6fbdad3708856ff9bfa14bc8e2236a99ba1eb 100644
--- a/server/log.go
+++ b/server/log.go
@@ -1,7 +1,7 @@
package server
import (
- "github.com/tendermint/log15"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
)
var log = log15.New("module", "eris/server")
diff --git a/server/logging.go b/server/logging.go
index a5a70031af162f749641075bd1dd01e32087946e..8b1ba444e437a70995ea69461d4d3c31e0500228 100644
--- a/server/logging.go
+++ b/server/logging.go
@@ -2,7 +2,7 @@ package server
import (
"fmt"
- "github.com/tendermint/log15"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
"os"
)
diff --git a/server/server.go b/server/server.go
index d2532cd3b066c0f051819dde3b670d0bb27a926a..6a5809c8d0d65ef4e7e1ba4f990b9f35610e0d25 100644
--- a/server/server.go
+++ b/server/server.go
@@ -3,9 +3,9 @@ package server
import (
"crypto/tls"
"fmt"
- "github.com/gin-gonic/gin"
- cors "github.com/tommy351/gin-cors"
- "gopkg.in/tylerb/graceful.v1"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
+ cors "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tommy351/gin-cors"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1"
"net"
"net/http"
"time"
@@ -15,7 +15,6 @@ var (
killTime = 100 * time.Millisecond
)
-// TODO should this be here.
type HttpService interface {
Process(*http.Request, http.ResponseWriter)
}
@@ -51,15 +50,11 @@ func (this *ServeProcess) Start() error {
router := gin.New()
config := this.config
-
+
InitLogger(config)
- // if config.CORS.Enable {
ch := NewCORSMiddleware(config.CORS)
- router.Use(gin.Recovery(), logHandler, ch)
- //} else {
- // router.Use(gin.Recovery(), logHandler)
- //}
+ router.Use(gin.Recovery(), logHandler, contentTypeMW, ch)
address := config.Bind.Address
port := config.Bind.Port
@@ -69,7 +64,6 @@ func (this *ServeProcess) Start() error {
}
listenAddress := address + ":" + fmt.Sprintf("%d", port)
-
srv := &graceful.Server{
Server: &http.Server{
Handler: router,
@@ -123,7 +117,7 @@ func (this *ServeProcess) Start() error {
}
}()
// Listen to the process stop event, it will call 'Stop'
- // on the graceful Server. This happens when someone
+ // on the graceful Server. This happens when someone
// calls 'Stop' on the process.
go func() {
<-this.stopChan
@@ -206,7 +200,6 @@ func NewServeProcess(config *ServerConfig, servers ...Server) *ServeProcess {
// Used to enable log15 logging instead of the default Gin logging.
// This is done mainly because we at Eris uses log15 in other components.
-// TODO make this optional perhaps.
func logHandler(c *gin.Context) {
path := c.Request.URL.Path
@@ -219,7 +212,7 @@ func logHandler(c *gin.Context) {
statusCode := c.Writer.Status()
comment := c.Errors.String()
- log.Info("[GIN] HTTP: "+clientIP, "Code", statusCode, "Method", method, "path", path, "error", comment)
+ log.Info("[GIN] HTTP: " + clientIP, "Code", statusCode, "Method", method, "path", path, "error", comment)
}
@@ -235,3 +228,11 @@ func NewCORSMiddleware(options CORS) gin.HandlerFunc {
return cors.Middleware(o)
}
+// Just a catch-all for POST requests right now. Only allow default charset (utf8).
+func contentTypeMW(c *gin.Context) {
+ if c.Request.Method == "POST" && c.ContentType() != "application/json" {
+ c.AbortWithError(415, fmt.Errorf("Media type not supported: "+c.ContentType()))
+ } else {
+ c.Next()
+ }
+}
diff --git a/server/server_test.go b/server/server_test.go
index 6a1a2c784f2375c874cd25ea88c2e5d8bf86a64c..55bfb66676a76ad2c610f67874cbb62b0196efcf 100644
--- a/server/server_test.go
+++ b/server/server_test.go
@@ -2,12 +2,12 @@ package server
import (
//"fmt"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
"testing"
)
// Unit tests for server components goes here. Full-on client-server tests
-// can be found in the test folder. TODO change that?
+// can be found in the test folder.
func TestIdGet(t *testing.T) {
idPool := NewIdPool(100)
diff --git a/server/websocket.go b/server/websocket.go
index 2481fb570ae940516ba4613da7b1fd0392d8e745..e83729d81254c6a99211385f7c4ffeb4db70089e 100644
--- a/server/websocket.go
+++ b/server/websocket.go
@@ -2,8 +2,8 @@ package server
import (
"fmt"
- "github.com/gin-gonic/gin"
- "github.com/gorilla/websocket"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gorilla/websocket"
"net/http"
"sync"
"time"
@@ -60,18 +60,16 @@ func NewWebSocketServer(maxSessions uint, service WebSocketService) *WebSocketSe
}
// Start the server. Adds the handler to the router and sets everything up.
-// TODO fix CORS.
func (this *WebSocketServer) Start(config *ServerConfig, router *gin.Engine) {
this.config = config
this.upgrader = websocket.Upgrader{
- ReadBufferSize: 1024,
+ ReadBufferSize: int(config.WebSocket.ReadBufferSize),
// TODO Will this be enough for massive "get blockchain" requests?
- WriteBufferSize: 1024,
+ WriteBufferSize: int(config.WebSocket.WriteBufferSize),
}
- this.upgrader.CheckOrigin = func(r *http.Request) bool {return true}
-
+ this.upgrader.CheckOrigin = func(r *http.Request) bool { return true }
router.GET(config.WebSocket.WebSocketEndpoint, this.handleFunc)
this.running = true
}
@@ -82,9 +80,6 @@ func (this *WebSocketServer) Running() bool {
}
// Shut the server down.
-// TODO This should only ensure that all read/write procceses and
-// timers has been terminated. Closing the sockets should be done
-// by the http.Server
func (this *WebSocketServer) ShutDown() {
this.sessionManager.Shutdown()
this.running = false
@@ -114,7 +109,6 @@ func (this *WebSocketServer) handleFunc(c *gin.Context) {
if cErr != nil {
cErrStr := "Failed to establish websocket connection: " + cErr.Error()
http.Error(w, cErrStr, 503)
- // TODO Look into what these logging params all mean..
log.Info(cErrStr)
return
}
@@ -330,7 +324,7 @@ func NewSessionManager(maxSessions uint, wss WebSocketService) *SessionManager {
}
}
-// TODO should ensure all session objects are released.
+// TODO
func (this *SessionManager) Shutdown() {
this.activeSessions = nil
}
@@ -408,7 +402,6 @@ func (this *SessionManager) createSession(wsConn *websocket.Conn) (*WSSession, e
sessionManager: this,
id: newId,
wsConn: wsConn,
- // TODO Tracking removed as of now.
writeChan: make(chan []byte, writeChanBufferSize),
writeCloseChan: make(chan struct{}),
service: this.service,
diff --git a/test/filters/filter_test.go b/test/filters/filter_test.go
index 13caed45a8514bfa5f4be6834b67e473566f1811..adfbc98b2918a47670718af17f831ff86b9c199e 100644
--- a/test/filters/filter_test.go
+++ b/test/filters/filter_test.go
@@ -2,17 +2,17 @@ package filters
import (
"fmt"
- "github.com/stretchr/testify/suite"
- "testing"
- "sync"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/suite"
. "github.com/eris-ltd/eris-db/erisdb/pipe"
+ "sync"
+ "testing"
)
const OBJECTS = 100
type FilterableObject struct {
Integer int
- String string
+ String string
}
// Filter for integer value.
@@ -76,37 +76,37 @@ func (this *StringFilter) Match(v interface{}) bool {
// Test suite
type FilterSuite struct {
suite.Suite
- objects []FilterableObject
+ objects []FilterableObject
filterFactory *FilterFactory
}
func (this *FilterSuite) SetupSuite() {
objects := make([]FilterableObject, OBJECTS, OBJECTS)
-
+
for i := 0; i < 100; i++ {
- objects[i] = FilterableObject{i, fmt.Sprintf("string%d",i)}
+ objects[i] = FilterableObject{i, fmt.Sprintf("string%d", i)}
}
-
+
ff := NewFilterFactory()
-
+
ff.RegisterFilterPool("integer", &sync.Pool{
New: func() interface{} {
return &IntegerFilter{}
},
})
-
+
ff.RegisterFilterPool("string", &sync.Pool{
New: func() interface{} {
return &StringFilter{}
},
})
-
+
this.objects = objects
this.filterFactory = ff
}
func (this *FilterSuite) TearDownSuite() {
-
+
}
// ********************************************* Tests *********************************************
@@ -191,7 +191,6 @@ func (this *FilterSuite) Test_FilterIntegersGTEQ() {
this.Equal(arr, this.objects[77:])
}
-
func (this *FilterSuite) Test_FilterIntegersNEQ() {
fd := &FilterData{"integer", "!=", "50"}
filter, err := this.filterFactory.NewFilter([]*FilterData{fd})
@@ -221,13 +220,12 @@ func (this *FilterSuite) Test_FilterStringEquals() {
this.Equal(arr, this.objects[7:8])
}
-
func (this *FilterSuite) Test_FilterStringNEQ() {
fd := &FilterData{"string", "!=", "string50"}
filter, err := this.filterFactory.NewFilter([]*FilterData{fd})
this.NoError(err)
arr := []FilterableObject{}
-
+
for _, o := range this.objects {
if filter.Match(o) {
arr = append(arr, o)
@@ -243,4 +241,4 @@ func (this *FilterSuite) Test_FilterStringNEQ() {
func TestFilterSuite(t *testing.T) {
suite.Run(t, &FilterSuite{})
-}
\ No newline at end of file
+}
diff --git a/test/mock/mock_web_api_test.go b/test/mock/mock_web_api_test.go
index 456d628342587cd4640aa6f9adfa44764e81590d..c0421b7d845ef83fe4ac7a7509ce6a4219bb1a6b 100644
--- a/test/mock/mock_web_api_test.go
+++ b/test/mock/mock_web_api_test.go
@@ -5,19 +5,19 @@ import (
"bytes"
"fmt"
// edb "github.com/eris-ltd/erisdb/erisdb"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/suite"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
edb "github.com/eris-ltd/eris-db/erisdb"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
"github.com/eris-ltd/eris-db/rpc"
"github.com/eris-ltd/eris-db/server"
td "github.com/eris-ltd/eris-db/test/testdata/testdata"
- "github.com/gin-gonic/gin"
- "github.com/stretchr/testify/suite"
- "github.com/tendermint/tendermint/account"
- "github.com/tendermint/log15"
"net/http"
- "testing"
"os"
"runtime"
+ "testing"
)
func init() {
diff --git a/test/mock/pipe.go b/test/mock/pipe.go
index 05c687ef0479d4564e4c94ca59874a5e70047856..caa5bbeafb27bcaa2c065c4a5dc90ef2e9a929a6 100644
--- a/test/mock/pipe.go
+++ b/test/mock/pipe.go
@@ -1,10 +1,10 @@
package mock
import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
td "github.com/eris-ltd/eris-db/test/testdata/testdata"
- "github.com/tendermint/tendermint/account"
- "github.com/tendermint/tendermint/types"
)
// Base struct.
@@ -211,10 +211,6 @@ func (this *transactor) UnconfirmedTxs() (*ep.UnconfirmedTxs, error) {
return this.testOutput.UnconfirmedTxs, nil
}
-func (this *transactor) TransactAsync(privKey, address, data []byte, gasLimit, fee uint64) (*ep.TransactionResult, error) {
- return nil, nil
-}
-
func (this *transactor) Transact(privKey, address, data []byte, gasLimit, fee uint64) (*ep.Receipt, error) {
if address == nil || len(address) == 0 {
return this.testOutput.TxCreateReceipt, nil
diff --git a/test/server/http_burst_test.go b/test/server/http_burst_test.go
index 2ac5dbcc09a8201c2bde87e2f2114587205408ff..cc415a0e7aefdedbaff975774ca8ab0f88b312e2 100644
--- a/test/server/http_burst_test.go
+++ b/test/server/http_burst_test.go
@@ -2,7 +2,7 @@ package server
import (
// "fmt"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
"net/http"
"testing"
"time"
diff --git a/test/server/scumbag.go b/test/server/scumbag.go
index fb01e75d315164a5499a8705296e1729cf521048..dbf50eff00cb111f2eb1e60fea15286c7e361e01 100644
--- a/test/server/scumbag.go
+++ b/test/server/scumbag.go
@@ -2,10 +2,10 @@ package server
import (
"encoding/json"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
"github.com/eris-ltd/eris-db/rpc"
"github.com/eris-ltd/eris-db/server"
- "github.com/gin-gonic/gin"
- "github.com/tendermint/log15"
"os"
"runtime"
)
diff --git a/test/server/ws_burst_test.go b/test/server/ws_burst_test.go
index e3922d98dd682072db4dd0c93f8beb7a1b77adab..b894aeea9c5f2e07a721ac551a2b898e5e51bc2a 100644
--- a/test/server/ws_burst_test.go
+++ b/test/server/ws_burst_test.go
@@ -1,9 +1,9 @@
package server
import (
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
"github.com/eris-ltd/eris-db/client"
"github.com/eris-ltd/eris-db/server"
- "github.com/stretchr/testify/assert"
"testing"
"time"
)
@@ -36,9 +36,8 @@ func (this *SessionCounter) Report() (int, int, int) {
return this.opened, this.closed, this.opened - this.closed
}
-// Coarse flood testing just to ensure that websocket server
-// does not crash, and that it cleans up after itself.
-// TODO clean this up.
+// Testing to ensure that websocket server does not crash, and that it
+// cleans up after itself.
func TestWsFlooding(t *testing.T) {
// New websocket server.
@@ -104,6 +103,6 @@ func wsClient(doneChan chan bool, errChan chan error) {
}
client.Close()
- time.Sleep(time.Millisecond * 500)
+ time.Sleep(time.Millisecond * 100)
doneChan <- true
}
diff --git a/test/testdata/filters/testdata_filters.go b/test/testdata/filters/testdata_filters.go
index a6ab388e76f10316d21c6f484ffc8bb25903c3c6..2c0aac8205267b5643fe7c99a07c83ad784546ae 100644
--- a/test/testdata/filters/testdata_filters.go
+++ b/test/testdata/filters/testdata_filters.go
@@ -3,7 +3,7 @@ package filters
import (
edb "github.com/eris-ltd/eris-db/erisdb"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
- "github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
)
var testDataJson = `{
@@ -229,7 +229,6 @@ func LoadTestData() *TestData {
codec := edb.NewTCodec()
testData := &TestData{}
err := codec.DecodeBytes(testData, []byte(testDataJson))
- // TODO for now.
if err != nil {
panic(err)
}
diff --git a/test/testdata/testdata/testdata.go b/test/testdata/testdata/testdata.go
index 9b818cfa7cce59fc1d709f1575645cbb7ea76b1e..943c2b1fe7a65df8c651bd8ca754463d43df9697 100644
--- a/test/testdata/testdata/testdata.go
+++ b/test/testdata/testdata/testdata.go
@@ -3,9 +3,9 @@ package testdata
import (
edb "github.com/eris-ltd/eris-db/erisdb"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
- "github.com/tendermint/tendermint/account"
- "github.com/tendermint/tendermint/state"
- "github.com/tendermint/tendermint/types"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
)
var testDataJson = `{
@@ -336,7 +336,6 @@ func LoadTestData() *TestData {
codec := edb.NewTCodec()
testData := &TestData{}
err := codec.DecodeBytes(testData, []byte(testDataJson))
- // TODO for now.
if err != nil {
panic(err)
}
diff --git a/test/web_api/query_test.go b/test/web_api/query_test.go
index e6714d1751e7139731832158410fc3d258f6fed1..5368b5246eb7f664e6904004a868c20cf920d2c1 100644
--- a/test/web_api/query_test.go
+++ b/test/web_api/query_test.go
@@ -4,13 +4,14 @@ package web_api
import (
"bytes"
"fmt"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/suite"
edb "github.com/eris-ltd/eris-db/erisdb"
ess "github.com/eris-ltd/eris-db/erisdb/erisdbss"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
"github.com/eris-ltd/eris-db/rpc"
"github.com/eris-ltd/eris-db/server"
fd "github.com/eris-ltd/eris-db/test/testdata/filters"
- "github.com/stretchr/testify/suite"
+ "io/ioutil"
"net/http"
"os"
"path"
@@ -45,6 +46,12 @@ func (this *QuerySuite) SetupSuite() {
requestData := &ess.RequestData{testData.ChainData.PrivValidator, testData.ChainData.Genesis, SERVER_DURATION}
rBts, _ := this.codec.EncodeBytes(requestData)
resp, _ := http.Post(QS_URL, "application/json", bytes.NewBuffer(rBts))
+ if resp.StatusCode != 200 {
+ bts, _ := ioutil.ReadAll(resp.Body)
+ fmt.Println("ERROR GETTING SS ADDRESS: " + string(bts))
+ fmt.Printf("%v\n", resp)
+ panic(fmt.Errorf(string(bts)))
+ }
rd := &ess.ResponseData{}
err2 := this.codec.Decode(rd, resp.Body)
if err2 != nil {
@@ -64,8 +71,7 @@ func (this *QuerySuite) TearDownSuite() {
// ********************************************* Tests *********************************************
-
-// TODO make these functions into one.
+// TODO less duplication.
func (this *QuerySuite) Test_Accounts0() {
fd := this.testData.Input.Filters0
resp := this.get("/accounts?" + generateQuery(fd))
diff --git a/test/web_api/shared.go b/test/web_api/shared.go
index 46962a317725043a2726f8237933ce689883bc6f..4f08a3c45f73170b113a1cef609d13220fb7a2a0 100644
--- a/test/web_api/shared.go
+++ b/test/web_api/shared.go
@@ -1,8 +1,8 @@
package web_api
import (
- "github.com/gin-gonic/gin"
- "github.com/tendermint/log15"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
"os"
"runtime"
)
@@ -12,7 +12,7 @@ const SERVER_DURATION = 10
func init() {
runtime.GOMAXPROCS(runtime.NumCPU())
log15.Root().SetHandler(log15.LvlFilterHandler(
- log15.LvlWarn,
+ log15.LvlInfo,
log15.StreamHandler(os.Stdout, log15.TerminalFormat()),
))
gin.SetMode(gin.ReleaseMode)
diff --git a/test/web_api/web_api_test.go b/test/web_api/web_api_test.go
index bc765df0ca5908cdaa2d0cf8a2207ee43023e888..2ce4e3ad9a8a806673045a097d39dda99210ed68 100644
--- a/test/web_api/web_api_test.go
+++ b/test/web_api/web_api_test.go
@@ -5,15 +5,16 @@ import (
"bytes"
"fmt"
// edb "github.com/eris-ltd/erisdb/erisdb"
+ "io/ioutil"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/suite"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
edb "github.com/eris-ltd/eris-db/erisdb"
ess "github.com/eris-ltd/eris-db/erisdb/erisdbss"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
"github.com/eris-ltd/eris-db/rpc"
"github.com/eris-ltd/eris-db/server"
td "github.com/eris-ltd/eris-db/test/testdata/testdata"
- "github.com/gin-gonic/gin"
- "github.com/stretchr/testify/suite"
- "github.com/tendermint/tendermint/account"
"net/http"
"os"
"path"
@@ -252,6 +253,7 @@ func (this *WebApiSuite) Test_E4_Blocks() {
func (this *WebApiSuite) get(endpoint string) *http.Response {
resp, errG := http.Get(this.sUrl + endpoint)
this.NoError(errG)
+ this.Equal(200, resp.StatusCode)
return resp
}
@@ -259,6 +261,10 @@ func (this *WebApiSuite) postJson(endpoint string, v interface{}) *http.Response
bts, errE := this.codec.EncodeBytes(v)
this.NoError(errE)
resp, errP := http.Post(this.sUrl+endpoint, "application/json", bytes.NewBuffer(bts))
+ if resp.StatusCode != 200 {
+ bts, _ := ioutil.ReadAll(resp.Body)
+ fmt.Println("ERROR: " + string(bts))
+ }
this.NoError(errP)
this.Equal(200, resp.StatusCode)
return resp
diff --git a/util/util.go b/util/util.go
index b3f7b1b3a3de89ee55cf40f9c3910b1d0e3a0d51..c0acaefc64d4b75b74c66a4a3802e9edc0d0385f 100644
--- a/util/util.go
+++ b/util/util.go
@@ -32,4 +32,4 @@ func IsPubKey(str string) bool {
// Is the candidate a private key string (64 bytes, hex). This is not a good name.
func IsPrivKey(str string) bool {
return privRe.MatchString(str)
-}
\ No newline at end of file
+}
diff --git a/util/util_test.go b/util/util_test.go
index 5353d6714c7106761155f761a7279bf6e9ee3553..69046d219592a4d071331a09855db0c998003e56 100644
--- a/util/util_test.go
+++ b/util/util_test.go
@@ -1,7 +1,7 @@
package util
import (
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
"testing"
)
@@ -12,7 +12,7 @@ func TestIsHexSuccess(t *testing.T) {
// This should fail because there is a non matching character.
func TestIsHexFailChar(t *testing.T) {
- assert.False(t,IsHex("562Q"))
+ assert.False(t, IsHex("562Q"))
}
// This should succeed
@@ -22,12 +22,12 @@ func TestIsHashSuccess(t *testing.T) {
// This should fail because there is a non matching character.
func TestIsHashFailChar(t *testing.T) {
- assert.False(t,IsHash("RM4F4DC4A54620F1E0AA1213631C4DC2957B7415E3F8C066C30009BC57C4E5FC"))
+ assert.False(t, IsHash("RM4F4DC4A54620F1E0AA1213631C4DC2957B7415E3F8C066C30009BC57C4E5FC"))
}
// This should fail because the length is not right.
func TestIsHashFailLength(t *testing.T) {
- assert.False(t,IsHash("DA4F4DC4A54620F1E0AA1213631C4DC2957B7415E3F8C066C30009BC57C4E5F"))
+ assert.False(t, IsHash("DA4F4DC4A54620F1E0AA1213631C4DC2957B7415E3F8C066C30009BC57C4E5F"))
}
// This should succeed
@@ -37,12 +37,12 @@ func TestIsAddressSuccess(t *testing.T) {
// This should fail because there is a non matching character.
func TestIsAddressFailChar(t *testing.T) {
- assert.False(t,IsAddress("37236DF251AB70022B1DA351F08A20FB52443E3Q"))
+ assert.False(t, IsAddress("37236DF251AB70022B1DA351F08A20FB52443E3Q"))
}
// This should fail because the length is not right.
func TestIsAddressFailLength(t *testing.T) {
- assert.False(t,IsAddress("37236DF251AB70022B1DA351F08A20FB52443E"))
+ assert.False(t, IsAddress("37236DF251AB70022B1DA351F08A20FB52443E"))
}
// This should succeed
@@ -52,12 +52,12 @@ func TestIsPubKeySuccess(t *testing.T) {
// This should fail because there is a non matching character.
func TestIsPubKeyFailChar(t *testing.T) {
- assert.False(t,IsPubKey("CB3688B7I6TD488A2A4834E1AEE9398BEF94844D8BDBBCA980C11E3654A45906"))
+ assert.False(t, IsPubKey("CB3688B7I6TD488A2A4834E1AEE9398BEF94844D8BDBBCA980C11E3654A45906"))
}
// This should fail because the length is not right.
func TestIsPubKeyFailLength(t *testing.T) {
- assert.False(t,IsPubKey("CB3688B7561D488A2A4834E1AEE9398BEF94844D8BDBBCA980C11"))
+ assert.False(t, IsPubKey("CB3688B7561D488A2A4834E1AEE9398BEF94844D8BDBBCA980C11"))
}
// This should succeed
@@ -67,10 +67,10 @@ func TestIsPrivKeySuccess(t *testing.T) {
// This should fail because there is a non matching character.
func TestIsPrivKeyFailChar(t *testing.T) {
- assert.False(t,IsPrivKey("6B72D45EB65F619F11CE580C8CAED9E0BADC774E9C9C334687A65DCBAD2C4151CB3688B7561D488A2A4834ESAEE9398BEF94844D8BDBBCA980C11E3654A45906"))
+ assert.False(t, IsPrivKey("6B72D45EB65F619F11CE580C8CAED9E0BADC774E9C9C334687A65DCBAD2C4151CB3688B7561D488A2A4834ESAEE9398BEF94844D8BDBBCA980C11E3654A45906"))
}
// This should fail because the length is not right.
func TestIsPrivKeyFailLength(t *testing.T) {
- assert.False(t,IsPrivKey("6B72D45EB65F619F11CE580C8CAED9E0BADC774ED2C4151CB3688B7561D488A2A48EF94844D8BDBBCA980C11E3654A45906"))
-}
\ No newline at end of file
+ assert.False(t, IsPrivKey("6B72D45EB65F619F11CE580C8CAED9E0BADC774ED2C4151CB3688B7561D488A2A48EF94844D8BDBBCA980C11E3654A45906"))
+}