• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    迪恩网络公众号
登陆 注册
描述文字

Golang primitives.HexToHash函数代码示例

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

本文整理汇总了Golang中github.com/FactomProject/factomd/common/primitives.HexToHash函数的典型用法代码示例。如果您正苦于以下问题：Golang HexToHash函数的具体用法？Golang HexToHash怎么用？Golang HexToHash使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。



在下文中一共展示了HexToHash函数的20个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于我们的系统推荐出更棒的Golang代码示例。

示例1: setupFirstAuthority

func setupFirstAuthority(s *state.State) {
	var id state.Identity
	if networkIdentity := s.GetNetworkBootStrapIdentity(); networkIdentity != nil {
		id.IdentityChainID = networkIdentity
	} else {
		id.IdentityChainID = primitives.NewZeroHash()
	}
	id.ManagementChainID, _ = primitives.HexToHash("88888800000000000000000000000000")
	if pub := s.GetNetworkBootStrapKey(); pub != nil {
		id.SigningKey = pub
	} else {
		id.SigningKey = primitives.NewZeroHash()
	}
	id.MatryoshkaHash = primitives.NewZeroHash()
	id.ManagementCreated = 0
	id.ManagementRegistered = 0
	id.IdentityCreated = 0
	id.IdentityRegistered = 0
	id.Key1 = primitives.NewZeroHash()
	id.Key2 = primitives.NewZeroHash()
	id.Key3 = primitives.NewZeroHash()
	id.Key4 = primitives.NewZeroHash()
	id.Status = 1
	s.Identities = append(s.Identities, &id)

	var auth state.Authority
	auth.Status = 1
	auth.SigningKey = primitives.PubKeyFromString(id.SigningKey.String())
	auth.MatryoshkaHash = primitives.NewZeroHash()
	auth.AuthorityChainID = id.IdentityChainID
	auth.ManagementChainID, _ = primitives.HexToHash("88888800000000000000000000000000")
	s.Authorities = append(s.Authorities, &auth)
}
开发者ID:FactomProject，项目名称:factomd，代码行数:33，代码来源:NetStart.go


示例2: TestOutECAddress

func TestOutECAddress(t *testing.T) {
	h, err := primitives.HexToHash("ec9f1cefa00406b80d46135a53504f1f4182d4c0f3fed6cca9281bc020eff973")
	if err != nil {
		t.Error(err)
	}
	add := h.(interfaces.IAddress)
	outECAdd := NewOutECAddress(add, 12345678)
	str := outECAdd.String()

	t.Logf("outECAdd str - %v", str)

	if strings.Contains(str, "ecoutput") == false {
		t.Error("'ecoutput' not found")
	}
	if strings.Contains(str, "0.12345678") == false {
		t.Error("'0.12345678' not found")
	}
	if strings.Contains(str, "EC3ZMxDt8xUBKBmrmzLwSpnMHkdptLS8gTSf8NQhVf7vpAWqNE2p") == false {
		t.Error("'EC3ZMxDt8xUBKBmrmzLwSpnMHkdptLS8gTSf8NQhVf7vpAWqNE2p' not found")
	}
	if strings.Contains(str, "0000000000bc614e") == false {
		t.Error("'0000000000bc614e' not found")
	}
	if strings.Contains(str, "ec9f1cefa00406b80d46135a53504f1f4182d4c0f3fed6cca9281bc020eff973") == false {
		t.Error("'ec9f1cefa00406b80d46135a53504f1f4182d4c0f3fed6cca9281bc020eff973' not found")
	}
}
开发者ID:FactomProject，项目名称:factomd，代码行数:27，代码来源:outecaddress_test.go


示例3: getECblock

func getECblock(hash string) *ECBlockHolder {
	mr, err := primitives.HexToHash(hash)
	if err != nil {
		return nil
	}

	dbase := StatePointer.GetAndLockDB()
	ecblk, err := dbase.FetchECBlock(mr)
	StatePointer.UnlockDB()

	if ecblk == nil || err != nil {
		return nil
	}
	if ecblk.GetHeader() == nil {
		return nil
	}

	holder := new(ECBlockHolder)
	holder.ECBlock = ecblk
	length := 0
	zero := primitives.NewZeroHash()
	for _, e := range ecblk.GetEntryHashes() {
		if e != nil && !e.IsSameAs(zero) {
			length++
		}
	}
	holder.Length = length

	return holder
}
开发者ID:FactomProject，项目名称:factomd，代码行数:30，代码来源:searchResultHandler.go


示例4: TestTransAddressMarshalUnmarshal

func TestTransAddressMarshalUnmarshal(t *testing.T) {
	ta := new(TransAddress)
	ta.SetAmount(12345678)
	h, err := primitives.HexToHash("ec9f1cefa00406b80d46135a53504f1f4182d4c0f3fed6cca9281bc020eff973")
	if err != nil {
		t.Error(err)
	}
	add := h.(interfaces.IAddress)
	ta.SetAddress(add)

	hex, err := ta.MarshalBinary()
	if err != nil {
		t.Error(err)
	}
	ta2 := new(TransAddress)
	err = ta2.UnmarshalBinary(hex)
	if err != nil {
		t.Error(err)
	}
	json1, err := ta.JSONString()
	if err != nil {
		t.Error(err)
	}
	json2, err := ta2.JSONString()
	if err != nil {
		t.Error(err)
	}
	if json1 != json2 {
		t.Error("JSONs are not identical")
	}
}
开发者ID:jjdevbiz，项目名称:factomd，代码行数:31，代码来源:transaddress_test.go


示例5: getFactTransaction

func getFactTransaction(hash string) interfaces.ITransaction {
	mr, err := primitives.HexToHash(hash)
	if err != nil {
		return nil
	}

	dbase := StatePointer.GetAndLockDB()
	trans, err := dbase.FetchFactoidTransaction(mr)
	StatePointer.UnlockDB()

	if trans == nil || err != nil {
		return nil
	}
	if trans.GetInputs() == nil {
		return nil
	}
	status := getFactoidAck(hash)
	if status == nil {
		return struct {
			interfaces.ITransaction
			wsapi.FactoidTxStatus
		}{trans, *status}
	}
	return struct {
		interfaces.ITransaction
		wsapi.FactoidTxStatus
	}{trans, *status}
}
开发者ID:FactomProject，项目名称:factomd，代码行数:28，代码来源:searchResultHandler.go


示例6: getFblock

func getFblock(hash string) *FBlockHolder {
	mr, err := primitives.HexToHash(hash)
	if err != nil {
		return nil
	}

	dbase := StatePointer.GetAndLockDB()
	fblk, err := dbase.FetchFBlock(mr)
	StatePointer.UnlockDB()

	if fblk == nil || err != nil {
		return nil
	}
	bytes, err := fblk.MarshalBinary()
	if err != nil {
		return nil
	}
	holder := new(FBlockHolder)
	err = holder.UnmarshalBinary(bytes)
	if err != nil {
		return nil
	}

	holder.Length = len(holder.Transactions)
	return holder
}
开发者ID:FactomProject，项目名称:factomd，代码行数:26，代码来源:searchResultHandler.go


示例7: TestInAddress

func TestInAddress(t *testing.T) {
	h, err := primitives.HexToHash("ec9f1cefa00406b80d46135a53504f1f4182d4c0f3fed6cca9281bc020eff973")
	if err != nil {
		t.Error(err)
	}
	add := h.(interfaces.IAddress)
	inAdd := NewInAddress(add, 12345678)
	str := inAdd.String()

	t.Logf("InAdd str - %v", str)

	if strings.Contains(str, "input") == false {
		t.Error("'input' not found")
	}
	if strings.Contains(str, "0.12345678") == false {
		t.Error("'0.12345678' not found")
	}
	if strings.Contains(str, "FA3mHjgsVvQJjVbvJpy67deDKzEsqc8FsLU122i8Tj76rmakpqRL") == false {
		t.Error("'FA3mHjgsVvQJjVbvJpy67deDKzEsqc8FsLU122i8Tj76rmakpqRL' not found")
	}
	if strings.Contains(str, "0000000000bc614e") == false {
		t.Error("'0000000000bc614e' not found")
	}
	if strings.Contains(str, "ec9f1cefa00406b80d46135a53504f1f4182d4c0f3fed6cca9281bc020eff973") == false {
		t.Error("'ec9f1cefa00406b80d46135a53504f1f4182d4c0f3fed6cca9281bc020eff973' not found")
	}
}
开发者ID:FactomProject，项目名称:factomd，代码行数:27，代码来源:inaddress_test.go


示例8: getEblock

func getEblock(hash string) *EblockHolder {
	mr, err := primitives.HexToHash(hash)
	if err != nil {
		return nil
	}
	holder := new(EblockHolder)

	dbase := StatePointer.GetAndLockDB()
	eblk, err := dbase.FetchEBlock(mr)
	StatePointer.UnlockDB()

	if eblk == nil || err != nil {
		return nil
	}
	bytes, err := eblk.JSONByte()
	if err != nil {
		return nil
	}
	err = json.Unmarshal(bytes, holder)
	if err != nil {
		return nil
	}

	if keymr, err := eblk.KeyMR(); err != nil {
		holder.KeyMR = "Error"
	} else {
		holder.KeyMR = keymr.String()
	}
	holder.BodyMR = eblk.BodyKeyMR().String()
	holder.FullHash = eblk.GetHash().String()

	entries := eblk.GetEntryHashes()
	count := 0
	for _, entry := range entries {
		if len(entry.String()) < 32 {
			continue
		} else if entry.String()[:10] == "0000000000" {
			ent := new(EntryHolder)
			ent.Hash = "Minute Marker"
			num := entry.String()[63:]
			if num == "a" {
				num = "10"
			}
			ent.ChainID = num

			holder.Entries = append(holder.Entries, *ent)
			continue
		}
		ent := getEntry(entry.String())
		count++
		if ent != nil {
			ent.Hash = entry.String()
			holder.Entries = append(holder.Entries, *ent)
		}
	}
	holder.Header.EntryCount = count

	return holder
}
开发者ID:FactomProject，项目名称:factomd，代码行数:59，代码来源:searchResultHandler.go


示例9: TestHandleEntryBlock

func TestHandleEntryBlock(t *testing.T) {
	context := testHelper.CreateWebContext()
	chain, err := primitives.HexToHash("df3ade9eec4b08d5379cc64270c30ea7315d8a8a1a69efe2b98a60ecdd69e604")
	if err != nil {
		t.Error(err)
	}

	dbo := context.Server.Env["state"].(interfaces.IState).GetAndLockDB()
	defer context.Server.Env["state"].(interfaces.IState).UnlockDB()

	blocks, err := dbo.FetchAllEBlocksByChain(chain)
	if err != nil {
		t.Error(err)
	}
	fetched := 0
	for _, b := range blocks {
		hash := b.(*entryBlock.EBlock).DatabasePrimaryIndex().String()
		hash2 := b.(*entryBlock.EBlock).DatabaseSecondaryIndex().String()

		testHelper.ClearContextResponseWriter(context)
		HandleEntryBlock(context, hash)

		eBlock := new(EBlock)

		testHelper.UnmarshalRespDirectly(context, eBlock)

		if eBlock.Header.ChainID != "df3ade9eec4b08d5379cc64270c30ea7315d8a8a1a69efe2b98a60ecdd69e604" {
			t.Errorf("Wrong ChainID - %v", eBlock.Header.ChainID)
			t.Errorf("eBlock - %v", eBlock)
			t.Errorf("%v", testHelper.GetBody(context))
		}

		if eBlock.Header.DBHeight != int64(b.(*entryBlock.EBlock).GetHeader().GetDBHeight()) {
			t.Errorf("DBHeight is wrong - %v vs %v", eBlock.Header.DBHeight, b.(*entryBlock.EBlock).GetHeader().GetDBHeight())
		}

		testHelper.ClearContextResponseWriter(context)
		HandleEntryBlock(context, hash2)

		eBlock = new(EBlock)

		testHelper.UnmarshalRespDirectly(context, eBlock)

		if eBlock.Header.ChainID != "df3ade9eec4b08d5379cc64270c30ea7315d8a8a1a69efe2b98a60ecdd69e604" {
			t.Errorf("Wrong ChainID - %v", eBlock.Header.ChainID)
			t.Errorf("%v", testHelper.GetBody(context))
		}

		if eBlock.Header.DBHeight != int64(b.(*entryBlock.EBlock).GetHeader().GetDBHeight()) {
			t.Errorf("DBHeight is wrong - %v vs %v", eBlock.Header.DBHeight, b.(*entryBlock.EBlock).GetHeader().GetDBHeight())
		}

		fetched++
	}
	if fetched != testHelper.BlockCount {
		t.Errorf("Fetched %v blocks, expected %v", fetched, testHelper.BlockCount)
	}
}
开发者ID:FactomProject，项目名称:factomd，代码行数:58，代码来源:wsapi_test.go


示例10: getAllChainEntries

func getAllChainEntries(chainIDString string) []SearchedStruct {
	arr := make([]SearchedStruct, 0)
	chainID, err := primitives.HexToHash(chainIDString)
	if err != nil {
		return nil
	}
	s := new(SearchedStruct)
	s.Type = "chainhead"
	s.Input = chainID.String()

	dbase := StatePointer.GetAndLockDB()
	mr, err := dbase.FetchHeadIndexByChainID(chainID)
	StatePointer.UnlockDB()

	if err != nil || mr == nil {
		return nil
	}
	s.Content = mr.String()
	arr = append(arr[:], *s)
	if err != nil {
		return nil
	}

	entries := make([]interfaces.IEBEntry, 0)

	dbase = StatePointer.GetAndLockDB()
	eblks, err := dbase.FetchAllEBlocksByChain(chainID)
	if err != nil {
		StatePointer.UnlockDB()
		return nil
	}

	for _, eblk := range eblks {
		hashes := eblk.GetEntryHashes()
		for _, hash := range hashes {
			entry, err := dbase.FetchEntry(hash)
			if err != nil || entry == nil {
				continue
			}
			entries = append(entries, entry)
		}
	}
	//entries, err := dbase.FetchAllEntriesByChainID(chainID)
	StatePointer.UnlockDB()
	if err != nil {
		return nil
	}

	for _, entry := range entries {
		s := new(SearchedStruct)
		s.Type = "entry"
		e := getEntry(entry.GetHash().String())
		s.Content = e
		s.Input = entry.GetHash().String()
		arr = append(arr[:], *s)
	}
	return arr
}
开发者ID:FactomProject，项目名称:factomd，代码行数:58，代码来源:searchResultHandler.go


示例11: getEntry

func getEntry(hash string) *EntryHolder {
	entryHash, err := primitives.HexToHash(hash)
	if err != nil {
		return nil
	}
	dbase := StatePointer.GetAndLockDB()
	entry, err := dbase.FetchEntry(entryHash)
	StatePointer.UnlockDB()

	if err != nil {
		return nil
	}
	if entry == nil {
		return nil
	}

	holder := new(EntryHolder)
	holder.Hash = hash
	holder.ChainID = entry.GetChainID().String()
	max := byte(0x80)
	for _, data := range entry.ExternalIDs() {
		hexString := false
		for _, bytes := range data {
			if bytes > max {
				hexString = true
				break
			}
		}
		if hexString {
			str := hex.EncodeToString(data)
			holder.ExtIDs = append(holder.ExtIDs[:], "<span id='encoding'><a>Hex  : </a></span><span id='data'>"+htemp.HTMLEscaper(str)+"</span>")
		} else {
			str := string(data)
			holder.ExtIDs = append(holder.ExtIDs[:], "<span id='encoding'><a>Ascii: </a></span><span id='data'>"+htemp.HTMLEscaper(str)+"</span>")
		}
	}
	holder.Version = 0
	holder.Height = fmt.Sprintf("%d", entry.GetDatabaseHeight())
	holder.ContentLength = len(entry.GetContent())
	data := sha256.Sum256(entry.GetContent())
	content := string(entry.GetContent())
	holder.Content = htemp.HTMLEscaper(content)
	if bytes, err := entry.MarshalBinary(); err != nil {
		holder.ECCost = "Error"
	} else {
		if eccost, err := util.EntryCost(bytes); err != nil {
			holder.ECCost = "Error"
		} else {
			holder.ECCost = fmt.Sprintf("%d", eccost)
		}
	}

	//holder.Content = string(entry.GetContent())
	holder.ContentHash = primitives.NewHash(data[:]).String()
	return holder
}
开发者ID:FactomProject，项目名称:factomd，代码行数:56，代码来源:searchResultHandler.go


示例12: TestDBSEMisc

func TestDBSEMisc(t *testing.T) {
	dbe := new(DBEntry)
	hash, err := primitives.HexToHash("000000000000000000000000000000000000000000000000000000000000000a")
	if err != nil {
		t.Error(err)
	}
	dbe.ChainID = hash
	hash, err = primitives.HexToHash("000000000000000000000000000000000000000000000000000000000000000b")
	if err != nil {
		t.Error(err)
	}
	dbe.KeyMR = hash

	hash = dbe.GetChainID()
	if hash.String() != "000000000000000000000000000000000000000000000000000000000000000a" {
		t.Fail()
	}
	hash = dbe.GetKeyMR()
	if hash.String() != "000000000000000000000000000000000000000000000000000000000000000b" {
		t.Fail()
	}
	/*
		dbe2, err := NewDBEntry(dbe)
		if err != nil {
			t.Error(err)
		}
		if dbe2 == nil {
			t.Fail()
		}

		hash = dbe2.GetChainID()
		if hash.String() != "000000000000000000000000000000000000000000000000000000000000000a" {
			t.Fail()
		}
		hash, err = dbe2.GetKeyMR()
		if err != nil {
			t.Error(err)
		}
		if hash.String() != "000000000000000000000000000000000000000000000000000000000000000b" {
			t.Fail()
		}
	*/
}
开发者ID:jjdevbiz，项目名称:factomd，代码行数:43，代码来源:directoryBlockEntry_test.go


示例13: HandleDirectoryBlock

func HandleDirectoryBlock(ctx *web.Context, hashkey string) {
	state := ctx.Server.Env["state"].(interfaces.IState)

	d := new(DBlock)

	h, err := primitives.HexToHash(hashkey)
	if err != nil {
		wsLog.Error(err)
		ctx.WriteHeader(httpBad)
		ctx.Write([]byte(err.Error()))
		return
	}

	dbase := state.GetDB()

	block, err := dbase.FetchDBlockByKeyMR(h)
	if err != nil {
		wsLog.Error(err)
		ctx.WriteHeader(httpBad)
		ctx.Write([]byte(err.Error()))
		return
	}
	if block == nil {
		block, err = dbase.FetchDBlockByHash(h)
		if err != nil {
			wsLog.Error(err)
			ctx.WriteHeader(httpBad)
			ctx.Write([]byte(err.Error()))
			return
		}
		if block == nil {
			//TODO: Handle block not found
			return
		}
	}

	d.Header.PrevBlockKeyMR = block.GetHeader().GetPrevKeyMR().String()
	d.Header.SequenceNumber = block.GetHeader().GetDBHeight()
	d.Header.Timestamp = block.GetHeader().GetTimestamp() * 60
	for _, v := range block.GetDBEntries() {
		l := new(EBlockAddr)
		l.ChainID = v.GetChainID().String()
		l.KeyMR = v.GetKeyMR().String()
		d.EntryBlockList = append(d.EntryBlockList, *l)
	}

	if p, err := json.Marshal(d); err != nil {
		wsLog.Error(err)
		ctx.WriteHeader(httpBad)
		ctx.Write([]byte(err.Error()))
		return
	} else {
		ctx.Write(p)
	}
}
开发者ID:jjdevbiz，项目名称:factomd，代码行数:55，代码来源:wsapi.go


示例14: getDblock

func getDblock(hash string) *DblockHolder {
	mr, err := primitives.HexToHash(hash)
	if err != nil {
		return nil
	}
	holder := new(DblockHolder)

	dbase := StatePointer.GetAndLockDB()
	dblk, err := dbase.FetchDBlock(mr)
	StatePointer.UnlockDB()

	if dblk == nil || err != nil {
		return nil
	}
	bytes, err := dblk.JSONByte()
	if err != nil {
		return nil
	}
	err = json.Unmarshal(bytes, holder)
	if err != nil {
		return nil
	}

	blocks := dblk.GetDBEntries()
	for _, block := range blocks {
		if len(block.GetKeyMR().String()) < 32 {
			continue
		} else if block.GetChainID().String()[:10] == "0000000000" {
			// Admin/FC/EC block
			switch block.GetChainID().String() {
			case "000000000000000000000000000000000000000000000000000000000000000a":
				holder.AdminBlock.ChainID = block.GetChainID().String()
				holder.AdminBlock.KeyMr = block.GetKeyMR().String()
			case "000000000000000000000000000000000000000000000000000000000000000c":
				holder.EntryCreditBlock.ChainID = block.GetChainID().String()
				holder.EntryCreditBlock.KeyMr = block.GetKeyMR().String()
			case "000000000000000000000000000000000000000000000000000000000000000f":
				holder.FactoidBlock.ChainID = block.GetChainID().String()
				holder.FactoidBlock.KeyMr = block.GetKeyMR().String()
			}
			continue
		}
		blk := getEblock(block.GetKeyMR().String())
		if blk != nil {
			holder.EBlocks = append(holder.EBlocks, *blk)
		}
	}

	holder.FullHash = dblk.GetHash().String()
	holder.KeyMR = dblk.GetKeyMR().String()

	ts := dblk.GetTimestamp()
	holder.Header.FormatedTimeStamp = ts.String()
	return holder
}
开发者ID:FactomProject，项目名称:factomd，代码行数:55，代码来源:searchResultHandler.go


示例15: HandleGetRaw

func HandleGetRaw(ctx *web.Context, hashkey string) {
	state := ctx.Server.Env["state"].(interfaces.IState)

	//TODO: var block interfaces.BinaryMarshallable
	d := new(RawData)

	h, err := primitives.HexToHash(hashkey)
	if err != nil {
		wsLog.Error(err)
		ctx.WriteHeader(httpBad)
		ctx.Write([]byte(err.Error()))
		return
	}

	dbase := state.GetDB()

	var b []byte

	// try to find the block data in db and return the first one found
	if block, _ := dbase.FetchFBlockByKeyMR(h); block != nil {
		b, _ = block.MarshalBinary()
	} else if block, _ := dbase.FetchDBlockByKeyMR(h); block != nil {
		b, _ = block.MarshalBinary()
	} else if block, _ := dbase.FetchABlockByKeyMR(h); block != nil {
		b, _ = block.MarshalBinary()
	} else if block, _ := dbase.FetchEBlockByKeyMR(h); block != nil {
		b, _ = block.MarshalBinary()
	} else if block, _ := dbase.FetchECBlockByKeyMR(h); block != nil {
		b, _ = block.MarshalBinary()
	} else if block, _ := dbase.FetchEntryByHash(h); block != nil {
		b, _ = block.MarshalBinary()
	} else if block, _ := dbase.FetchFBlockByHash(h); block != nil {
		b, _ = block.MarshalBinary()
	} else if block, _ := dbase.FetchDBlockByHash(h); block != nil {
		b, _ = block.MarshalBinary()
	} else if block, _ := dbase.FetchABlockByHash(h); block != nil {
		b, _ = block.MarshalBinary()
	} else if block, _ := dbase.FetchEBlockByHash(h); block != nil {
		b, _ = block.MarshalBinary()
	} else if block, _ := dbase.FetchECBlockByHash(h); block != nil {
		b, _ = block.MarshalBinary()
	}

	d.Data = hex.EncodeToString(b)

	if p, err := json.Marshal(d); err != nil {
		wsLog.Error(err)
		ctx.WriteHeader(httpBad)
		ctx.Write([]byte(err.Error()))
		return
	} else {
		ctx.Write(p)
	}
}
开发者ID:jjdevbiz，项目名称:factomd，代码行数:54，代码来源:wsapi.go


示例16: TestAddressMisc

func TestAddressMisc(t *testing.T) {
	h, err := primitives.HexToHash("ec9f1cefa00406b80d46135a53504f1f4182d4c0f3fed6cca9281bc020eff973")
	if err != nil {
		t.Error(err)
	}
	add := CreateAddress(h)
	str := add.String()
	if strings.Contains(str, "ec9f1cefa00406b80d46135a53504f1f4182d4c0f3fed6cca9281bc020eff973") == false {
		t.Errorf("String doesn't contain an expected address:\n%v", str)
	}
}
开发者ID:jjdevbiz，项目名称:factomd，代码行数:11，代码来源:address_test.go


示例17: TestDBSEMarshalUnmarshal

func TestDBSEMarshalUnmarshal(t *testing.T) {
	dbe := new(DBEntry)

	hash, err := primitives.HexToHash("000000000000000000000000000000000000000000000000000000000000000a")
	if err != nil {
		t.Error(err)
	}
	dbe.ChainID = hash
	hash, err = primitives.HexToHash("000000000000000000000000000000000000000000000000000000000000000b")
	if err != nil {
		t.Error(err)
	}
	dbe.KeyMR = hash

	hex, err := dbe.MarshalBinary()
	if err != nil {
		t.Error(err)
	}

	dbe2 := new(DBEntry)
	err = dbe2.UnmarshalBinary(hex)
	if err != nil {
		t.Error(err)
	}

	hex2, err := dbe2.MarshalBinary()
	if err != nil {
		t.Error(err)
	}

	if len(hex) != len(hex2) {
		t.Fail()
	}

	for i := range hex {
		if hex[i] != hex2[i] {
			t.Fail()
		}
	}
}
开发者ID:jjdevbiz，项目名称:factomd，代码行数:40，代码来源:directoryBlockEntry_test.go


示例18: HandleV2RawData

func HandleV2RawData(state interfaces.IState, params interface{}) (interface{}, *primitives.JSONError) {
	hashkey := new(HashRequest)
	err := MapToObject(params, hashkey)
	if err != nil {
		panic(reflect.TypeOf(params))
		return nil, NewInvalidParamsError()
	}

	h, err := primitives.HexToHash(hashkey.Hash)
	if err != nil {
		return nil, NewInvalidHashError()
	}

	var block interfaces.BinaryMarshallable
	var b []byte

	if block, _ = state.FetchECTransactionByHash(h); block != nil {
		b, _ = block.MarshalBinary()
	} else if block, _ = state.FetchFactoidTransactionByHash(h); block != nil {
		b, _ = block.MarshalBinary()
	} else if block, _ = state.FetchEntryByHash(h); block != nil {
		b, _ = block.MarshalBinary()
	}

	if b == nil {
		dbase := state.GetAndLockDB()
		defer state.UnlockDB()

		// try to find the block data in db and return the first one found
		if block, _ = dbase.FetchFBlock(h); block != nil {
			b, _ = block.MarshalBinary()
		} else if block, _ = dbase.FetchDBlock(h); block != nil {
			b, _ = block.MarshalBinary()
		} else if block, _ = dbase.FetchABlock(h); block != nil {
			b, _ = block.MarshalBinary()
		} else if block, _ = dbase.FetchEBlock(h); block != nil {
			b, _ = block.MarshalBinary()
		} else if block, _ = dbase.FetchECBlock(h); block != nil {
			b, _ = block.MarshalBinary()
		} else if block, _ = dbase.FetchFBlock(h); block != nil {
			b, _ = block.MarshalBinary()
		} else if block, _ = dbase.FetchEntry(h); block != nil {
			b, _ = block.MarshalBinary()
		} else {
			return nil, NewEntryNotFoundError()
		}
	}

	d := new(RawDataResponse)
	d.Data = hex.EncodeToString(b)
	return d, nil
}
开发者ID:FactomProject，项目名称:factomd，代码行数:52，代码来源:wsapiV2.go


示例19: getEcTransaction

func getEcTransaction(hash string) interfaces.IECBlockEntry {
	mr, err := primitives.HexToHash(hash)
	if err != nil {
		return nil
	}

	dbase := StatePointer.GetAndLockDB()
	trans, err := dbase.FetchECTransaction(mr)
	StatePointer.UnlockDB()

	if trans == nil || err != nil {
		return nil
	}
	if trans.GetEntryHash() == nil {
		return nil
	}
	return trans
}
开发者ID:FactomProject，项目名称:factomd，代码行数:18，代码来源:searchResultHandler.go


示例20: HandleEntry

func HandleEntry(ctx *web.Context, hashkey string) {
	state := ctx.Server.Env["state"].(interfaces.IState)

	e := new(EntryStruct)

	h, err := primitives.HexToHash(hashkey)
	if err != nil {
		wsLog.Error(err)
		ctx.WriteHeader(httpBad)
		ctx.Write([]byte(err.Error()))
		return
	}

	dbase := state.GetDB()

	entry, err := dbase.FetchEntryByHash(h)
	if err != nil {
		wsLog.Error(err)
		ctx.WriteHeader(httpBad)
		ctx.Write([]byte(err.Error()))
		return
	}
	if entry == nil {
		//TODO: Handle block not found
		return
	}

	e.ChainID = entry.GetChainIDHash().String()
	e.Content = hex.EncodeToString(entry.GetContent())
	for _, v := range entry.ExternalIDs() {
		e.ExtIDs = append(e.ExtIDs, hex.EncodeToString(v))
	}

	if p, err := json.Marshal(e); err != nil {
		wsLog.Error(err)
		ctx.WriteHeader(httpBad)
		ctx.Write([]byte(err.Error()))
		return
	} else {
		ctx.Write(p)
	}

}
开发者ID:jjdevbiz，项目名称:factomd，代码行数:43，代码来源:wsapi.go



注：本文中的github.com/FactomProject/factomd/common/primitives.HexToHash函数示例整理自Github/MSDocs等源码及文档管理平台，相关代码片段筛选自各路编程大神贡献的开源项目，源码版权归原作者所有，传播和使用请参考对应项目的License；未经允许，请勿转载。

鲜花
握手
雷人
路过
鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
More+
上一篇：
Golang primitives.NewHash函数代码示例发布时间：2022-05-23
下一篇：
Golang primitives.EncodeJSONToBuffer函数代码示例发布时间：2022-05-23
热门推荐
More+
热门话题
More+
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服（服务时间 9:00～18:00）

在线QQ客服
地址：深圳市南山区西丽大学城创智工业园
电邮：jeky_zhao#qq.com
移动电话：139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap