//TODO pass amt in from url. (make estimate of length) func UpdateNameReg(fileName, hash, amt string) (string, error) { nodeAddr := os.Getenv("MINTX_NODE_ADDR") signAddr := os.Getenv("MINTX_SIGN_ADDR") chainID := os.Getenv("MINTX_CHAINID") pubkey := os.Getenv("MINTX_PUBKEY") addr := "" amtS := "1000000" nonceS := "" feeS := "0" name := fileName data := hash //build and sign a nameTx, send it away for broadcasting nTx, err := core.Name(nodeAddr, pubkey, addr, amtS, nonceS, feeS, name, data) if err != nil { fmt.Printf("corename error: %v\n", err) } //sign but don't broadcast _, err = core.SignAndBroadcast(chainID, "", signAddr, nTx, true, false, false) if err != nil { fmt.Printf("sign error: %v\n", err) } n := new(int64) w := new(bytes.Buffer) wire.WriteBinary(nTx, w, n, &err) err = postTxData(nodeAddr, hash, w.Bytes()) if err != nil { fmt.Printf("post error: %v\n", err) } return "", nil }
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) wire.WriteBinary(sig, buf, n, err) if *err != nil { t.Fatalf("Failed to write Signature: %v", err) } if len(buf.Bytes()) != ed25519.SignatureSize+1 { // 1 byte TypeByte, 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 := wire.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") } }
// General Convenience func SimpleHashFromBinary(item interface{}) []byte { hasher, n, err := ripemd160.New(), new(int64), new(error) wire.WriteBinary(item, hasher, n, err) if *err != nil { PanicCrisis(err) } return hasher.Sum(nil) }
// TODO: Slicing the array gives us length prefixing but loses the type byte. // Revisit if we add more pubkey types. // For now, we artificially append the type byte in front to give us backwards // compatibility for when the pubkey wasn't fixed length array func (pubKey PubKeyEd25519) Address() []byte { w, n, err := new(bytes.Buffer), new(int64), new(error) wire.WriteBinary(pubKey[:], w, n, err) if *err != nil { PanicCrisis(*err) } // append type byte encodedPubkey := append([]byte{1}, w.Bytes()...) hasher := ripemd160.New() hasher.Write(encodedPubkey) // does not error return hasher.Sum(nil) }
func (kv KVPair) Hash() []byte { hasher, n, err := ripemd160.New(), new(int64), new(error) wire.WriteString(kv.Key, hasher, n, err) if kvH, ok := kv.Value.(Hashable); ok { wire.WriteByteSlice(kvH.Hash(), hasher, n, err) } else { wire.WriteBinary(kv.Value, hasher, n, err) } if *err != nil { PanicSanity(*err) } return hasher.Sum(nil) }
func ValidatorInfoEncoder(o interface{}, w io.Writer, n *int64, err *error) { wire.WriteBinary(o.(*ValidatorInfo), w, n, err) }
func (vc validatorCodec) Encode(o interface{}, w io.Writer, n *int64, err *error) { wire.WriteBinary(o.(*Validator), w, n, err) }