func (l *LogTreeNode) ComputeHash() sha.Hash {
var buffer [68]byte
binary.LittleEndian.PutUint32(buffer[0:4], uint32(l.Num))
copy(buffer[4:36], ads.Hash(l.Left).Bytes())
copy(buffer[36:68], ads.Hash(l.Right).Bytes())
return sha.Sum(buffer[:])
}
func (n *BitrieNode) ComputeHash() sha.Hash {
var buffer [96]byte
n.Bits.Canonicalize(buffer[0:32])
copy(buffer[32:64], ads.Hash(n.Left).Bytes())
copy(buffer[64:96], ads.Hash(n.Right).Bytes())
return sha.Sum(buffer[:])
}
func (c *PagingC) Store(info *ads.Info) int64 {
if info.Token != 0 {
return info.Token
}
buffer := ads.GetFromPool()
defer ads.ReturnToPool(buffer)
ads.Hash(info.Value)
buffer.Reset()
e := ads.Encoder{
Writer: buffer,
Transparent: map[ads.ADS]bool{info.Value: true},
}
e.Encode(&info.Value)
for _, root := range ads.CollectChildren(info.Value) {
info := ads.GetInfo(root)
c.Store(info)
var buffer [8]byte
binary.LittleEndian.PutUint64(buffer[:], uint64(info.Token))
if n, err := e.Write(buffer[:]); n != 8 || err != nil {
log.Panic(err)
}
}
info.Token = c.DB.Write(buffer.Bytes())
return info.Token
}
func ProcessTransactionImpl(transaction *Transaction, balances bitrie.Bitrie, c comp.C) bitrie.Bitrie {
c.Use(transaction, balances)
for _, input := range transaction.MsgTx.TxIn {
if (input.PreviousOutpoint.Hash == btcwire.ShaHash{}) {
continue
}
balances = ProcessOutpoint(input.PreviousOutpoint, balances, c)
}
loc := bitrie.MakeBits(ads.Hash(transaction))
x, found := balances.Get(loc, c)
var oi *OutpointInfo
if found {
oi = x.(*OutpointInfo)
} else {
oi = &OutpointInfo{}
}
c.Use(oi)
oi = oi.Add(len(transaction.MsgTx.TxOut))
return balances.Set(loc, oi, c)
}
func (l *BitrieLeaf) ComputeHash() sha.Hash {
var buffer [64]byte
l.Bits.Canonicalize(buffer[0:32])
if l.Value == nil {
spew.Dump(l)
}
copy(buffer[32:64], ads.Hash(l.Value).Bytes())
return sha.Sum(buffer[:])
}
func doRound(elems []Hashable, volatileLeft, volatileRight bool, c comp.C) round {
N := len(elems)
kind := make([]int, N)
left := 0
right := N - 1
hashes := make([]sha.Hash, N)
for i := 0; i < N; i++ {
hashes[i] = ads.Hash(elems[i])
}
for idx := uint(0); ; idx++ {
if idx > 0 && idx%sha.Bits == 0 {
for i := 0; i < N; i++ {
hashes[i] = sha.Sum(hashes[i].Bytes())
}
}
done := true
if volatileLeft {
if left < N && kind[left] == unknown && hashes[left].Bit(idx%sha.Bits) == 0 {
kind[left] = leftFringe
left++
}
if left < N && kind[left] == unknown {
done = false
}
}
if volatileRight {
if right >= 0 && kind[right] == unknown && hashes[right].Bit(idx%sha.Bits) == 1 {
kind[right] = rightFringe
right--
}
if right >= 0 && kind[right] == unknown {
done = false
}
}
for j := 0; j < N-1; j++ {
if kind[j] == unknown && kind[j+1] == unknown {
if hashes[j].Bit(idx%sha.Bits) == 1 && hashes[j+1].Bit(idx%sha.Bits) == 0 {
kind[j] = mergeLeft
kind[j+1] = mergeRight
} else {
done = false
}
}
}
if done {
break
}
}
var r round
for i := 0; i < N; i++ {
switch kind[i] {
case unknown:
r.center = append(r.center, elems[i])
case mergeLeft:
r.center = append(r.center, elems[i].CombineWith(elems[i+1], c))
i++
case leftFringe:
r.leftFringe = append(r.leftFringe, elems[i])
case rightFringe:
r.rightFringe = append(r.rightFringe, elems[i])
}
}
return r
}
func verifiedMain() {
ads.RegisterType(0, &LogTreap{})
ads.RegisterType(1, &LogEntry{})
ads.RegisterType(2, &Tmp{})
ads.RegisterType(4, int64(0))
ads.RegisterType(5, &LogTreeNode{})
ads.RegisterType(6, &seqhash.Hash{})
ads.RegisterFunc(0, fib)
c := NewProofC()
fmt.Printf("fib(5) = %d\n", Fib(5, c))
/*
log := c.stack[0]
seqHash := log.Slice(0, 10000)
c = NewProofC()
next, err := Resolve(seqHash.Finish(c).(LogTree), c)
spew.Dump(next, err)
buffer := new(bytes.Buffer)
encoder := ads.Encoder{
Writer: buffer,
Transparent: c.used,
}
encoder.Encode(&seqHash)
fmt.Printf("proof length: %v\n", buffer.Len())
var newSeqHash *seqhash.Hash
decoder := ads.Decoder{
Reader: buffer,
}
decoder.Decode(&newSeqHash)
next, err = Resolve(newSeqHash.Finish(comp.NilC).(LogTree), comp.NilC)
spew.Dump(next, err)
// spew.Dump(newSeqHash)
fmt.Printf("%s\n%s\n", ads.Hash(seqHash), ads.Hash(newSeqHash))
*/
for i := int32(1); i <= c.Stack[0].Count(comp.NilC); i++ {
seqHash := c.Stack[0].Slice(0, i, comp.NilC)
fmt.Printf("commitment %v\n", ads.Hash(seqHash))
fmt.Printf("printing prefix of length %d\n", i)
logTree := seqHash.Finish(comp.NilC).(LogTree)
for j, entry := range logTree.Flatten() {
switch entry.Type {
case FunctionEntry:
fmt.Printf("%d: enter fib(%d)\n", j, entry.ArgsOrResults[0])
case FunctionExit:
idx := int32(j) - entry.Length
entryEntry := logTree.Index(idx, comp.NilC)
fmt.Printf("%d: exit fib(%d)@%d -> %d\n", j, entryEntry.ArgsOrResults[0], idx, entry.ArgsOrResults[0])
}
}
//spew.Dump("last:", logTree.Flatten()[i-1])
next, err := Resolve(logTree, comp.NilC)
if err != nil {
panic(err)
} else {
if next != nil {
expected := seqhash.Merge(seqHash, seqhash.New(next), comp.NilC)
fmt.Printf("predicted %v\n", ads.Hash(expected))
}
//spew.Dump("next:", next)
}
}
/*
var t *Treap
for i := 0; i < 10000; i++ {
c := NewProofC()
t = t.Insert(KeyType(i), ValueType(i*3), c)
}
c := NewProofC()
fmt.Printf("found %v\n", *t.Find(20, c))
t.CachingCount(c)
tmp := &Tmp{Log: c.log}
fmt.Printf("%v\n", Hash(tmp))
buffer := new(bytes.Buffer)
encoder := Encoder{
Writer: buffer,
transparent: map[Value]bool{tmp: true},
}
encoder.Encode(&tmp)
var newTmp *Tmp
decoder := Decoder{
Reader: buffer,
}
decoder.Decode(&newTmp)
spew.Dump(newTmp)
*/
/*
buffer := new(bytes.Buffer)
encoder := Encoder{
Writer: buffer,
transparent: c.used,
}
encoder.Encode(&t)
fmt.Printf("proof size: %d\n", buffer.Len())
var newT *Treap
decoder := Decoder{
Reader: buffer,
}
decoder.Decode(&newT)
// spew.Dump(t)
// spew.Dump(newT)
c = NewC()
fmt.Printf("found %v\n", *newT.Find(20, c))
fmt.Printf("%+v\n", Hash(t))
fmt.Printf("%+v\n", Hash(newT))
*/
/*
le := new(LogEntry)
le.Func = (*Treap).cachingCount
le.ArgsOrResults = []interface{}{t}
buffer := new(bytes.Buffer)
encoder := Encoder{
Writer: buffer,
transparent: map[Value]bool{le: true},
}
encoder.Encode(&le)
fmt.Printf("proof size: %d\n", buffer.Len())
var newLE *LogEntry
decoder := Decoder{
Reader: buffer,
}
decoder.Decode(&newLE)
fmt.Printf("hash of le: %v\n", Hash(le))
fmt.Printf("hash of new le: %v\n", Hash(newLE))
*/
}