예제 #1
0
func (b *IncreaseBalance) UnmarshalBinaryData(data []byte) (newData []byte, err error) {
	buf := bytes.NewBuffer(data)
	hash := make([]byte, 32)

	_, err = buf.Read(hash)
	if err != nil {
		return
	}
	b.ECPubKey = new(primitives.ByteSlice32)
	copy(b.ECPubKey[:], hash)

	_, err = buf.Read(hash)
	if err != nil {
		return
	}
	if b.TXID == nil {
		b.TXID = primitives.NewZeroHash()
	}
	b.TXID.SetBytes(hash)

	tmp := make([]byte, 0)
	b.Index, tmp = primitives.DecodeVarInt(buf.Bytes())

	b.NumEC, tmp = primitives.DecodeVarInt(tmp)

	newData = tmp
	return
}
예제 #2
0
func (b *IncreaseBalance) UnmarshalBinaryData(data []byte) (newData []byte, err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("Error unmarshalling IncreaseBalance: %v", r)
		}
	}()

	buf := primitives.NewBuffer(data)
	hash := make([]byte, 32)

	_, err = buf.Read(hash)
	if err != nil {
		return
	}
	b.ECPubKey = new(primitives.ByteSlice32)
	copy(b.ECPubKey[:], hash)

	_, err = buf.Read(hash)
	if err != nil {
		return
	}
	if b.TXID == nil {
		b.TXID = primitives.NewZeroHash()
	}
	b.TXID.SetBytes(hash)

	tmp := make([]byte, 0)
	b.Index, tmp = primitives.DecodeVarInt(buf.DeepCopyBytes())

	b.NumEC, tmp = primitives.DecodeVarInt(tmp)

	newData = tmp
	return
}
예제 #3
0
func (b *ABlockHeader) UnmarshalBinaryData(data []byte) (newData []byte, err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("Error unmarshalling Admin Block Header: %v", r)
		}
	}()
	newData = data
	newData, err = b.GetAdminChainID().UnmarshalBinaryData(newData)
	if err != nil {
		return
	}

	b.PrevBackRefHash = new(primitives.Hash)
	newData, err = b.PrevBackRefHash.UnmarshalBinaryData(newData)
	if err != nil {
		return
	}

	b.DBHeight, newData = binary.BigEndian.Uint32(newData[0:4]), newData[4:]

	b.HeaderExpansionSize, newData = primitives.DecodeVarInt(newData)
	b.HeaderExpansionArea, newData = newData[:b.HeaderExpansionSize], newData[b.HeaderExpansionSize:]

	b.MessageCount, newData = binary.BigEndian.Uint32(newData[0:4]), newData[4:]
	b.BodySize, newData = binary.BigEndian.Uint32(newData[0:4]), newData[4:]

	return
}
예제 #4
0
func (e *ECBlockHeader) UnmarshalBinaryData(data []byte) (newData []byte, err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("Error unmarshalling: %v", r)
		}
	}()

	buf := primitives.NewBuffer(data)
	hash := make([]byte, 32)

	if _, err = buf.Read(hash); err != nil {
		return
	} else {
		if fmt.Sprintf("%x", hash) != "000000000000000000000000000000000000000000000000000000000000000c" {
			err = fmt.Errorf("Invalid ChainID - %x", hash)
			return
		}
	}

	if _, err = buf.Read(hash); err != nil {
		return
	} else {
		e.BodyHash.SetBytes(hash)
	}

	if _, err = buf.Read(hash); err != nil {
		return
	} else {
		e.PrevHeaderHash.SetBytes(hash)
	}

	if _, err = buf.Read(hash); err != nil {
		return
	} else {
		e.PrevFullHash.SetBytes(hash)
	}

	if err = binary.Read(buf, binary.BigEndian, &e.DBHeight); err != nil {
		return
	}

	// read the Header Expansion Area
	hesize, tmp := primitives.DecodeVarInt(buf.DeepCopyBytes())
	buf = primitives.NewBuffer(tmp)
	e.HeaderExpansionArea = make([]byte, hesize)
	if _, err = buf.Read(e.HeaderExpansionArea); err != nil {
		return
	}

	if err = binary.Read(buf, binary.BigEndian, &e.ObjectCount); err != nil {
		return
	}

	if err = binary.Read(buf, binary.BigEndian, &e.BodySize); err != nil {
		return
	}

	newData = buf.DeepCopyBytes()
	return
}
예제 #5
0
func (e *ECBlock) unmarshalHeaderBinaryData(data []byte) (newData []byte, err error) {
	buf := primitives.NewBuffer(data)
	hash := make([]byte, 32)

	if _, err = buf.Read(hash); err != nil {
		return
	} else {
		e.Header.GetECChainID().SetBytes(hash)
	}

	if _, err = buf.Read(hash); err != nil {
		return
	} else {
		e.Header.GetBodyHash().SetBytes(hash)
	}

	if _, err = buf.Read(hash); err != nil {
		return
	} else {
		e.Header.GetPrevHeaderHash().SetBytes(hash)
	}

	if _, err = buf.Read(hash); err != nil {
		return
	} else {
		e.Header.GetPrevFullHash().SetBytes(hash)
	}

	h := e.Header.GetDBHeight()
	if err = binary.Read(buf, binary.BigEndian, &h); err != nil {
		return
	}

	// read the Header Expansion Area
	hesize, tmp := primitives.DecodeVarInt(buf.DeepCopyBytes())
	buf = primitives.NewBuffer(tmp)
	e.Header.SetHeaderExpansionArea(make([]byte, hesize))
	if _, err = buf.Read(e.Header.GetHeaderExpansionArea()); err != nil {
		return
	}

	oc := e.Header.GetObjectCount()
	if err = binary.Read(buf, binary.BigEndian, &oc); err != nil {
		return
	}

	sz := e.Header.GetBodySize()
	if err = binary.Read(buf, binary.BigEndian, &sz); err != nil {
		return
	}

	newData = buf.DeepCopyBytes()
	return
}
예제 #6
0
func (t *TransAddress) UnmarshalBinaryData(data []byte) (newData []byte, err error) {

	if len(data) < 36 {
		return nil, fmt.Errorf("Data source too short to UnmarshalBinary() an address: %d", len(data))
	}

	t.Amount, data = primitives.DecodeVarInt(data)
	t.Address = new(Address)

	data, err = t.Address.UnmarshalBinaryData(data)

	return data, err
}
예제 #7
0
func (e *ECBlockHeader) UnmarshalBinaryData(data []byte) (newData []byte, err error) {
	buf := bytes.NewBuffer(data)
	hash := make([]byte, 32)

	if _, err = buf.Read(hash); err != nil {
		return
	} else {
		e.ECChainID.SetBytes(hash)
	}

	if _, err = buf.Read(hash); err != nil {
		return
	} else {
		e.BodyHash.SetBytes(hash)
	}

	if _, err = buf.Read(hash); err != nil {
		return
	} else {
		e.PrevHeaderHash.SetBytes(hash)
	}

	if _, err = buf.Read(hash); err != nil {
		return
	} else {
		e.PrevLedgerKeyMR.SetBytes(hash)
	}

	if err = binary.Read(buf, binary.BigEndian, &e.DBHeight); err != nil {
		return
	}

	// read the Header Expansion Area
	hesize, tmp := primitives.DecodeVarInt(buf.Bytes())
	buf = bytes.NewBuffer(tmp)
	e.HeaderExpansionArea = make([]byte, hesize)
	if _, err = buf.Read(e.HeaderExpansionArea); err != nil {
		return
	}

	if err = binary.Read(buf, binary.BigEndian, &e.ObjectCount); err != nil {
		return
	}

	if err = binary.Read(buf, binary.BigEndian, &e.BodySize); err != nil {
		return
	}

	newData = buf.Bytes()
	return
}
예제 #8
0
// UnmarshalBinary assumes that the Binary is all good.  We do error
// out if there isn't enough data, or the transaction is too large.
func (t *Transaction) UnmarshalBinaryData(data []byte) (newData []byte, err error) {

	// To catch memory errors, I capture the panic and turn it into
	// a reported error.
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("Error unmarshalling transaction: %v", r)
		}
	}()

	v, data := primitives.DecodeVarInt(data)
	if v != t.GetVersion() {
		return nil, fmt.Errorf("Wrong Transaction Version encountered. Expected %v and found %v", t.GetVersion(), v)
	}
	hd, data := binary.BigEndian.Uint32(data[:]), data[4:]
	ld, data := binary.BigEndian.Uint16(data[:]), data[2:]
	t.MilliTimestamp = (uint64(hd) << 16) + uint64(ld)

	numInputs := int(data[0])
	data = data[1:]
	numOutputs := int(data[0])
	data = data[1:]
	numOutECs := int(data[0])
	data = data[1:]

	t.Inputs = make([]interfaces.IInAddress, numInputs, numInputs)
	t.Outputs = make([]interfaces.IOutAddress, numOutputs, numOutputs)
	t.OutECs = make([]interfaces.IOutECAddress, numOutECs, numOutECs)

	for i, _ := range t.Inputs {
		t.Inputs[i] = new(InAddress)
		data, err = t.Inputs[i].UnmarshalBinaryData(data)
		if err != nil || t.Inputs[i] == nil {
			return nil, err
		}
	}
	for i, _ := range t.Outputs {
		t.Outputs[i] = new(OutAddress)
		data, err = t.Outputs[i].UnmarshalBinaryData(data)
		if err != nil {
			return nil, err
		}
	}
	for i, _ := range t.OutECs {
		t.OutECs[i] = new(OutECAddress)
		data, err = t.OutECs[i].UnmarshalBinaryData(data)
		if err != nil {
			return nil, err
		}
	}

	t.RCDs = make([]interfaces.IRCD, len(t.Inputs))
	t.SigBlocks = make([]interfaces.ISignatureBlock, len(t.Inputs))

	for i := 0; i < len(t.Inputs); i++ {
		t.RCDs[i] = CreateRCD(data)
		data, err = t.RCDs[i].UnmarshalBinaryData(data)
		if err != nil {
			return nil, err
		}

		t.SigBlocks[i] = new(SignatureBlock)
		data, err = t.SigBlocks[i].UnmarshalBinaryData(data)
		if err != nil {
			return nil, err
		}
	}

	return data, nil
}
예제 #9
0
// UnmarshalBinary assumes that the Binary is all good.  We do error
// out if there isn't enough data, or the transaction is too large.
func (b *FBlock) UnmarshalBinaryData(data []byte) (newdata []byte, err error) {
	// To catch memory errors, we capture the panic and turn it into
	// a reported error.
	defer func() {
		return
		if r := recover(); r != nil {
			err = fmt.Errorf("Error unmarshalling transaction: %v", r)
		}
	}()

	if bytes.Compare(data[:constants.ADDRESS_LENGTH], constants.FACTOID_CHAINID[:]) != 0 {
		panic(fmt.Sprintf("error in: %x %x", data[:35], constants.FACTOID_CHAINID[:]))
		return nil, fmt.Errorf("Block does not begin with the Factoid ChainID")
	}
	newdata = data[32:]

	b.BodyMR = new(primitives.Hash)
	newdata, err = b.BodyMR.UnmarshalBinaryData(newdata)
	if err != nil {
		return nil, err
	}

	b.PrevKeyMR = new(primitives.Hash)
	newdata, err = b.PrevKeyMR.UnmarshalBinaryData(newdata)
	if err != nil {
		return nil, err
	}

	b.PrevLedgerKeyMR = new(primitives.Hash)
	newdata, err = b.PrevLedgerKeyMR.UnmarshalBinaryData(newdata)
	if err != nil {
		return nil, err
	}

	b.ExchRate, newdata = binary.BigEndian.Uint64(newdata[0:8]), newdata[8:]
	b.DBHeight, newdata = binary.BigEndian.Uint32(newdata[0:4]), newdata[4:]

	skip, newdata := primitives.DecodeVarInt(newdata) // Skip the Expansion Header, if any, since
	newdata = newdata[skip:]                          // we don't know what to do with it.

	cnt, newdata := binary.BigEndian.Uint32(newdata[0:4]), newdata[4:]

	newdata = newdata[4:] // Just skip the size... We don't really need it.

	b.Transactions = make([]interfaces.ITransaction, cnt, cnt)
	for i, _ := range b.endOfPeriod {
		b.endOfPeriod[i] = 0
	}
	var periodMark = 0

	for i := uint32(0); i < cnt; i++ {
		for newdata[0] == constants.MARKER {
			b.endOfPeriod[periodMark] = int(i)
			newdata = newdata[1:]
			periodMark++
		}

		trans := new(Transaction)
		newdata, err = trans.UnmarshalBinaryData(newdata)
		if err != nil {
			return nil, fmt.Errorf("Failed to unmarshal a transaction in block.\n" + err.Error())
		}
		b.Transactions[i] = trans
	}
	for periodMark < len(b.endOfPeriod) {
		newdata = newdata[1:]
		b.endOfPeriod[periodMark] = int(cnt)
		periodMark++
	}

	return newdata, nil
}