_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q27100 | DBProvider | train | func (n *Node) DBProvider(ctx *node.DBContext) (dbm.DB, error) {
db := DBProvider(ctx.ID, dbm.DBBackendType(ctx.Config.DBBackend), ctx.Config.DBDir())
n.closers = append(n.closers, db)
return db, nil
} | go | {
"resource": ""
} |
q27101 | NewLogger | train | func NewLogger(level string) *Logger {
log := kitlog.NewJSONLogger(kitlog.NewSyncWriter(os.Stdout))
switch level {
case "error":
log = kitlevel.NewFilter(log, kitlevel.AllowError()) // only error logs
case "warn":
log = kitlevel.NewFilter(log, kitlevel.AllowWarn()) // warn + error logs
case "info":
log = kit... | go | {
"resource": ""
} |
q27102 | Error | train | func (l *Logger) Error(args ...interface{}) {
kitlevel.Error(l.Log).Log(args...)
} | go | {
"resource": ""
} |
q27103 | Warn | train | func (l *Logger) Warn(args ...interface{}) {
kitlevel.Warn(l.Log).Log(args...)
} | go | {
"resource": ""
} |
q27104 | Info | train | func (l *Logger) Info(args ...interface{}) {
kitlevel.Info(l.Log).Log(args...)
} | go | {
"resource": ""
} |
q27105 | Debug | train | func (l *Logger) Debug(args ...interface{}) {
kitlevel.Debug(l.Log).Log(args...)
} | go | {
"resource": ""
} |
q27106 | RealisePublicKeyAndAddress | train | func (ta TemplateAccount) RealisePublicKeyAndAddress(keyClient keys.KeyClient) (pubKey crypto.PublicKey, address crypto.Address, err error) {
if ta.PublicKey == nil {
if ta.Address == nil {
// If neither PublicKey or Address set then generate a new one
address, err = keyClient.Generate(ta.Name, crypto.CurveTyp... | go | {
"resource": ""
} |
q27107 | ExecuteTx | train | func ExecuteTx(logHeader string, executor execution.Executor, txDecoder txs.Decoder, txBytes []byte) types.ResponseCheckTx {
logf := func(format string, args ...interface{}) string {
return fmt.Sprintf("%s: "+format, append([]interface{}{logHeader}, args...)...)
}
txEnv, err := txDecoder.DecodeTx(txBytes)
if err... | go | {
"resource": ""
} |
q27108 | WithTags | train | func WithTags(logger *logging.Logger, tags []common.KVPair) *logging.Logger {
keyvals := make([]interface{}, len(tags)*2)
for i, kvp := range tags {
keyvals[i] = string(kvp.Key)
keyvals[i+1] = string(kvp.Value)
}
return logger.With(keyvals...)
} | go | {
"resource": ""
} |
q27109 | jsonParamsToArgsWS | train | func jsonParamsToArgsWS(rpcFunc *RPCFunc, params json.RawMessage, wsCtx types.WSRPCContext) ([]reflect.Value, error) {
values, err := jsonParamsToArgs(rpcFunc, params, 1)
if err != nil {
return nil, err
}
return append([]reflect.Value{reflect.ValueOf(wsCtx)}, values...), nil
} | go | {
"resource": ""
} |
q27110 | NewWebsocketManager | train | func NewWebsocketManager(funcMap map[string]*RPCFunc, logger *logging.Logger,
wsConnOptions ...func(*wsConnection)) *WebsocketManager {
return &WebsocketManager{
funcMap: funcMap,
Upgrader: websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool {
// TODO ???
return true
},
},
logger: ... | go | {
"resource": ""
} |
q27111 | checkHRS | train | func (lsi *LastSignedInfo) checkHRS(height int64, round int, step int8) (bool, error) {
if lsi.Height > height {
return false, errors.New("Height regression")
}
if lsi.Height == height {
if lsi.Round > round {
return false, errors.New("Round regression")
}
if lsi.Round == round {
if lsi.Step > step {... | go | {
"resource": ""
} |
q27112 | String | train | func (lsi *LastSignedInfo) String() string {
return fmt.Sprintf("PrivValidator{LH:%v, LR:%v, LS:%v}", lsi.Height, lsi.Round, lsi.Step)
} | go | {
"resource": ""
} |
q27113 | InstanceName | train | func (contract *solidityContract) InstanceName() string {
// Hopefully the contract name is UpperCamelCase. If it's not, oh well, this
// is meant to be illustrative rather than cast iron compilable
instanceName := strings.ToLower(contract.Name[:1]) + contract.Name[1:]
if instanceName == contract.Name {
return "c... | go | {
"resource": ""
} |
q27114 | Solidity | train | func (contract *solidityContract) Solidity() (string, error) {
buf := new(bytes.Buffer)
err := contractTemplate.Execute(buf, contract)
if err != nil {
return "", err
}
return buf.String(), nil
} | go | {
"resource": ""
} |
q27115 | clean | train | func clean(parameter string) string {
replacer := strings.NewReplacer("\n", " ", "\t", "")
return replacer.Replace(parameter)
} | go | {
"resource": ""
} |
q27116 | WaitReadLogLine | train | func (cl *ChannelLogger) WaitReadLogLine() []interface{} {
logLine, ok := <-cl.ch.Out()
return readLogLine(logLine, ok)
} | go | {
"resource": ""
} |
q27117 | ReadLogLine | train | func (cl *ChannelLogger) ReadLogLine() []interface{} {
select {
case logLine, ok := <-cl.ch.Out():
return readLogLine(logLine, ok)
default:
return nil
}
} | go | {
"resource": ""
} |
q27118 | DrainForever | train | func (cl *ChannelLogger) DrainForever(logger log.Logger, errCh channels.Channel) {
// logLine could be nil if channel was closed while waiting for next line
for logLine := cl.WaitReadLogLine(); logLine != nil; logLine = cl.WaitReadLogLine() {
err := logger.Log(logLine...)
if err != nil && errCh != nil {
errCh.... | go | {
"resource": ""
} |
q27119 | Flush | train | func (cl *ChannelLogger) Flush(logger log.Logger) error {
// Grab the buffer at the here rather than within loop condition so that we
// do not drain the buffer forever
cl.Lock()
defer cl.Unlock()
bufferLength := cl.BufferLength()
var errs []error
for i := 0; i < bufferLength; i++ {
logLine := cl.WaitReadLogLi... | go | {
"resource": ""
} |
q27120 | FlushLogLines | train | func (cl *ChannelLogger) FlushLogLines() [][]interface{} {
logLines := make([][]interface{}, 0, cl.ch.Len())
cl.Flush(log.LoggerFunc(func(keyvals ...interface{}) error {
logLines = append(logLines, keyvals)
return nil
}))
return logLines
} | go | {
"resource": ""
} |
q27121 | Reset | train | func (cl *ChannelLogger) Reset() {
cl.RWMutex.Lock()
defer cl.RWMutex.Unlock()
cl.ch.Close()
cl.ch = channels.NewRingChannel(cl.ch.Cap())
} | go | {
"resource": ""
} |
q27122 | NonBlockingLogger | train | func NonBlockingLogger(outputLogger log.Logger) (*ChannelLogger, channels.Channel) {
cl := NewChannelLogger(DefaultLoggingRingBufferCap)
errCh := channels.NewRingChannel(cl.BufferCap())
go cl.DrainForever(outputLogger, errCh)
return cl, errCh
} | go | {
"resource": ""
} |
q27123 | NewState | train | func NewState(db dbm.DB) *State {
forest, err := storage.NewMutableForest(storage.NewPrefixDB(db, forestPrefix), defaultCacheCapacity)
if err != nil {
// This should only happen if we have negative cache capacity, which for us is a positive compile-time constant
panic(fmt.Errorf("could not create new state becaus... | go | {
"resource": ""
} |
q27124 | MakeGenesisState | train | func MakeGenesisState(db dbm.DB, genesisDoc *genesis.GenesisDoc) (*State, error) {
s := NewState(db)
const errHeader = "MakeGenesisState():"
// Make accounts state tree
for _, genAcc := range genesisDoc.Accounts {
perm := genAcc.Permissions
acc := &acm.Account{
Address: genAcc.Address,
Balance: g... | go | {
"resource": ""
} |
q27125 | Update | train | func (s *State) Update(updater func(up Updatable) error) ([]byte, int64, error) {
s.Lock()
defer s.Unlock()
err := updater(&s.writeState)
if err != nil {
return nil, 0, err
}
return s.commit()
} | go | {
"resource": ""
} |
q27126 | Copy | train | func (s *State) Copy(db dbm.DB) (*State, error) {
stateCopy := NewState(db)
err := s.writeState.forest.IterateRWTree(nil, nil, true,
func(prefix []byte, tree *storage.RWTree) error {
treeCopy, err := stateCopy.writeState.forest.Writer(prefix)
if err != nil {
return err
}
return tree.IterateWriteTree... | go | {
"resource": ""
} |
q27127 | NewSQLDB | train | func NewSQLDB(connection types.SQLConnection) (*SQLDB, error) {
db := &SQLDB{
Schema: connection.DBSchema,
Log: connection.Log,
}
var url string
switch connection.DBAdapter {
case types.PostgresDB:
db.DBAdapter = adapters.NewPostgresAdapter(safe(connection.DBSchema), connection.Log)
url = connection.D... | go | {
"resource": ""
} |
q27128 | Close | train | func (db *SQLDB) Close() {
if err := db.DB.Close(); err != nil {
db.Log.Error("msg", "Error closing database", "err", err)
}
} | go | {
"resource": ""
} |
q27129 | GetLastBlockHeight | train | func (db *SQLDB) GetLastBlockHeight() (uint64, error) {
query := db.DBAdapter.LastBlockIDQuery()
id := ""
db.Log.Info("msg", "MAX ID", "query", query)
if err := db.DB.QueryRow(query).Scan(&id); err != nil {
db.Log.Info("msg", "Error selecting last block id", "err", err)
return 0, err
}
height, err := strcon... | go | {
"resource": ""
} |
q27130 | SynchronizeDB | train | func (db *SQLDB) SynchronizeDB(eventTables types.EventTables) error {
db.Log.Info("msg", "Synchronizing DB")
for _, table := range eventTables {
found, err := db.findTable(table.Name)
if err != nil {
return err
}
if found {
err = db.alterTable(table)
} else {
err = db.createTable(table, false)
... | go | {
"resource": ""
} |
q27131 | GetBlock | train | func (db *SQLDB) GetBlock(height uint64) (types.EventData, error) {
var data types.EventData
data.BlockHeight = height
data.Tables = make(map[string]types.EventDataTable)
// get all table structures involved in the block
tables, err := db.getBlockTables(height)
if err != nil {
return data, err
}
query := ""... | go | {
"resource": ""
} |
q27132 | RestoreDB | train | func (db *SQLDB) RestoreDB(time time.Time, prefix string) error {
const yymmddhhmmss = "2006-01-02 15:04:05"
var pointers []interface{}
if prefix == "" {
return fmt.Errorf("error prefix mus not be empty")
}
// Get Restore DB query
query := db.DBAdapter.RestoreDBQuery()
strTime := time.Format(yymmddhhmmss)
... | go | {
"resource": ""
} |
q27133 | Reader | train | func (imf *ImmutableForest) Reader(prefix []byte) (KVCallbackIterableReader, error) {
return imf.tree(prefix)
} | go | {
"resource": ""
} |
q27134 | tree | train | func (imf *ImmutableForest) tree(prefix []byte) (*RWTree, error) {
// Try cache
if value, ok := imf.treeCache.Get(string(prefix)); ok {
return value.(*RWTree), nil
}
// Not in caches but non-negative version - we should be able to load into memory
return imf.loadOrCreateTree(prefix)
} | go | {
"resource": ""
} |
q27135 | newTree | train | func (imf *ImmutableForest) newTree(prefix []byte) *RWTree {
p := string(prefix)
tree := NewRWTree(NewPrefixDB(imf.treeDB, p), imf.cacheSize)
imf.treeCache.Add(p, tree)
return tree
} | go | {
"resource": ""
} |
q27136 | stripBraces | train | func stripBraces(str string) string {
bs := []byte(str)
const lb = byte('{')
const rb = byte('}')
start := 0
for i := 0; i < len(bs); i++ {
switch bs[i] {
case lb:
start = i + 1
case rb:
return `\$` + str[start:i]
}
}
return str[start:]
} | go | {
"resource": ""
} |
q27137 | IsOmitted | train | func IsOmitted(value interface{}) bool {
value, isNil := validation.Indirect(value)
if isNil || validation.IsEmpty(value) {
return true
}
// Accept and empty slice or map
length, err := validation.LengthOfValue(value)
if err == nil && length == 0 {
return true
}
return false
} | go | {
"resource": ""
} |
q27138 | EnsureDir | train | func EnsureDir(dir string, mode os.FileMode) error {
if fileOptions, err := os.Stat(dir); os.IsNotExist(err) {
if errMake := os.MkdirAll(dir, mode); errMake != nil {
return fmt.Errorf("Could not create directory %s. %v", dir, err)
}
} else if err != nil {
return fmt.Errorf("Error asserting directory %s: %v",... | go | {
"resource": ""
} |
q27139 | IsDir | train | func IsDir(directory string) bool {
fileInfo, err := os.Stat(directory)
if err != nil {
return false
}
return fileInfo.IsDir()
} | go | {
"resource": ""
} |
q27140 | MonaxKeysJSON | train | func (key *Key) MonaxKeysJSON() string {
jsonKey := plainKeyJSON{
Address: key.Address.String(),
Type: "ed25519",
PrivateKey: PrivateKeyplainKeyJSON{Plain: key.PrivateKey},
}
bs, err := json.Marshal(jsonKey)
if err != nil {
return errors.Wrap(err, "could not create monax key json").Error()
}
retu... | go | {
"resource": ""
} |
q27141 | NewSNativeContract | train | func NewSNativeContract(comment, name string,
functions ...*SNativeFunctionDescription) *SNativeContractDescription {
functionsByID := make(map[abi.FunctionID]*SNativeFunctionDescription, len(functions))
for _, f := range functions {
f.Abi = *abi.SpecFromStructReflect(f.Name, f.Arguments, f.Returns)
fid := f.A... | go | {
"resource": ""
} |
q27142 | Dispatch | train | func (contract *SNativeContractDescription) Dispatch(st Interface, caller crypto.Address,
args []byte, gas *uint64, logger *logging.Logger) (output []byte, err error) {
logger = logger.With(structure.ScopeKey, "Dispatch", "contract_name", contract.Name)
if len(args) < abi.FunctionIDSize {
return nil, errors.Erro... | go | {
"resource": ""
} |
q27143 | Address | train | func (contract *SNativeContractDescription) Address() (address crypto.Address) {
hash := sha3.Sha3([]byte(contract.Name))
copy(address[:], hash[len(hash)-crypto.AddressLength:])
return
} | go | {
"resource": ""
} |
q27144 | FunctionByID | train | func (contract *SNativeContractDescription) FunctionByID(id abi.FunctionID) (*SNativeFunctionDescription, errors.CodedError) {
f, ok := contract.functionsByID[id]
if !ok {
return nil,
errors.ErrorCodef(errors.ErrorCodeNativeFunction, "unknown SNative function with ID %x", id)
}
return f, nil
} | go | {
"resource": ""
} |
q27145 | FunctionByName | train | func (contract *SNativeContractDescription) FunctionByName(name string) (*SNativeFunctionDescription, error) {
for _, f := range contract.functions {
if f.Name == name {
return f, nil
}
}
return nil, fmt.Errorf("unknown SNative function with name %s", name)
} | go | {
"resource": ""
} |
q27146 | Functions | train | func (contract *SNativeContractDescription) Functions() []*SNativeFunctionDescription {
functions := make([]*SNativeFunctionDescription, len(contract.functions))
copy(functions, contract.functions)
return functions
} | go | {
"resource": ""
} |
q27147 | Signature | train | func (function *SNativeFunctionDescription) Signature() string {
argTypeNames := make([]string, len(function.Abi.Inputs))
for i, arg := range function.Abi.Inputs {
argTypeNames[i] = arg.EVM.GetSignature()
}
return fmt.Sprintf("%s(%s)", function.Name,
strings.Join(argTypeNames, ","))
} | go | {
"resource": ""
} |
q27148 | AddTags | train | func (ct *CombinedTags) AddTags(concat bool, tagsList ...Tagged) {
for _, t := range tagsList {
for _, k := range t.Keys() {
if len(ct.ks[k]) == 0 {
ct.keys = append(ct.keys, k)
// Store reference to key-holder amongst Taggeds
ct.ks[k] = append(ct.ks[k], t)
} else if concat {
// Store additiona... | go | {
"resource": ""
} |
q27149 | SetSkip | train | func (cs *configSource) SetSkip(skip bool) ConfigProvider {
return &configSource{
skip: skip,
from: cs.from,
apply: cs.apply,
}
} | go | {
"resource": ""
} |
q27150 | XDGBaseDir | train | func XDGBaseDir(configFileName string) *configSource {
skip := false
// Look for config in standard XDG specified locations
configFile, err := xdgbasedir.GetConfigFileLocation(configFileName)
if err == nil {
_, err := os.Stat(configFile)
// Skip if config file does not exist at default location
skip = os.IsN... | go | {
"resource": ""
} |
q27151 | Environment | train | func Environment(key string) *configSource {
configString := os.Getenv(key)
return &configSource{
skip: configString == "",
from: fmt.Sprintf("'%s' environment variable", key),
apply: func(baseConfig interface{}) error {
return FromString(configString, baseConfig)
},
}
} | go | {
"resource": ""
} |
q27152 | DeepCopy | train | func DeepCopy(conf interface{}) (interface{}, error) {
// Create a zero value
confCopy := reflect.New(reflect.TypeOf(conf).Elem()).Interface()
// Perform a merge into that value to effect the copy
err := mergo.Merge(confCopy, conf)
if err != nil {
return nil, err
}
return confCopy, nil
} | go | {
"resource": ""
} |
q27153 | NewProjectionFromBytes | train | func NewProjectionFromBytes(bs []byte) (*Projection, error) {
eventSpec := types.EventSpec{}
err := ValidateJSONEventSpec(bs)
if err != nil {
return nil, err
}
err = json.Unmarshal(bs, &eventSpec)
if err != nil {
return nil, errors.Wrap(err, "Error unmarshalling eventSpec")
}
return NewProjectionFromEven... | go | {
"resource": ""
} |
q27154 | NewProjectionFromFolder | train | func NewProjectionFromFolder(specFileOrDirs ...string) (*Projection, error) {
eventSpec := types.EventSpec{}
const errHeader = "NewProjectionFromFolder():"
for _, dir := range specFileOrDirs {
err := filepath.Walk(dir, func(path string, _ os.FileInfo, err error) error {
if err != nil {
return fmt.Errorf("... | go | {
"resource": ""
} |
q27155 | NewProjectionFromEventSpec | train | func NewProjectionFromEventSpec(eventSpec types.EventSpec) (*Projection, error) {
// builds abi information from specification
tables := make(types.EventTables)
// obtain global field mappings to add to table definitions
globalFieldMappings := getGlobalFieldMappings()
for _, eventClass := range eventSpec {
// ... | go | {
"resource": ""
} |
q27156 | GetColumn | train | func (p *Projection) GetColumn(tableName, columnName string) (*types.SQLTableColumn, error) {
if table, ok := p.Tables[tableName]; ok {
column := table.GetColumn(columnName)
if column == nil {
return nil, fmt.Errorf("GetColumn: table '%s' has no column '%s'",
tableName, columnName)
}
return column, nil
... | go | {
"resource": ""
} |
q27157 | readFile | train | func readFile(file string) ([]byte, error) {
theFile, err := os.Open(file)
if err != nil {
return nil, err
}
defer theFile.Close()
byteValue, err := ioutil.ReadAll(theFile)
if err != nil {
return nil, err
}
return byteValue, nil
} | go | {
"resource": ""
} |
q27158 | getSQLType | train | func getSQLType(evmSignature string, bytesToString bool) (types.SQLColumnType, int, error) {
evmSignature = strings.ToLower(evmSignature)
re := regexp.MustCompile("[0-9]+")
typeSize, _ := strconv.Atoi(re.FindString(evmSignature))
switch {
// solidity address => sql varchar
case evmSignature == types.EventFieldTy... | go | {
"resource": ""
} |
q27159 | getGlobalFieldMappings | train | func getGlobalFieldMappings() []*types.EventFieldMapping {
return []*types.EventFieldMapping{
{
ColumnName: types.SQLColumnLabelHeight,
Field: types.BlockHeightLabel,
Type: types.EventFieldTypeString,
},
{
ColumnName: types.SQLColumnLabelTxHash,
Field: types.TxTxHashLabel,
Type:... | go | {
"resource": ""
} |
q27160 | Copy | train | func (acc *Account) Copy() *Account {
if acc == nil {
return nil
}
accCopy := *acc
accCopy.Permissions.Roles = make([]string, len(acc.Permissions.Roles))
copy(accCopy.Permissions.Roles, acc.Permissions.Roles)
return &accCopy
} | go | {
"resource": ""
} |
q27161 | GenesisDoc | train | func (gs *GenesisSpec) GenesisDoc(keyClient keys.KeyClient, generateNodeKeys bool) (*genesis.GenesisDoc, error) {
genesisDoc := new(genesis.GenesisDoc)
if gs.GenesisTime == nil {
genesisDoc.GenesisTime = time.Now()
} else {
genesisDoc.GenesisTime = *gs.GenesisTime
}
if gs.ChainName == "" {
genesisDoc.ChainN... | go | {
"resource": ""
} |
q27162 | SetPower | train | func (vs *Set) SetPower(id crypto.PublicKey, power *big.Int) error {
vs.ChangePower(id, power)
return nil
} | go | {
"resource": ""
} |
q27163 | ChangePower | train | func (vs *Set) ChangePower(id crypto.PublicKey, power *big.Int) *big.Int {
address := id.GetAddress()
// Calculate flow into this validator (positive means in, negative means out)
flow := vs.Flow(id, power)
vs.totalPower.Add(vs.totalPower, flow)
if vs.trim && power.Sign() == 0 {
delete(vs.publicKeys, address)
... | go | {
"resource": ""
} |
q27164 | Flow | train | func (vs *Set) Flow(id crypto.PublicKey, power *big.Int) *big.Int {
return new(big.Int).Sub(power, vs.GetPower(id.GetAddress()))
} | go | {
"resource": ""
} |
q27165 | MaybePower | train | func (vs *Set) MaybePower(id crypto.Address) *big.Int {
if vs.powers[id] == nil {
return nil
}
return new(big.Int).Set(vs.powers[id])
} | go | {
"resource": ""
} |
q27166 | Power | train | func (vs *Set) Power(id crypto.Address) (*big.Int, error) {
return vs.GetPower(id), nil
} | go | {
"resource": ""
} |
q27167 | Equal | train | func (vs *Set) Equal(vsOther *Set) error {
if vs.Size() != vsOther.Size() {
return fmt.Errorf("set size %d != other set size %d", vs.Size(), vsOther.Size())
}
// Stop iteration IFF we find a non-matching validator
return vs.IterateValidators(func(id crypto.Addressable, power *big.Int) error {
otherPower := vsOt... | go | {
"resource": ""
} |
q27168 | IterateValidators | train | func (vs *Set) IterateValidators(iter func(id crypto.Addressable, power *big.Int) error) error {
if vs == nil {
return nil
}
addresses := make(crypto.Addresses, 0, len(vs.powers))
for address := range vs.powers {
addresses = append(addresses, address)
}
sort.Sort(addresses)
for _, address := range addresses ... | go | {
"resource": ""
} |
q27169 | Bounds | train | func (br *BlockRange) Bounds(latestBlockHeight uint64) (startHeight, endHeight uint64, streaming bool) {
// End bound is exclusive in state.GetEvents so we increment the height
return br.GetStart().Bound(latestBlockHeight), br.GetEnd().Bound(latestBlockHeight) + 1,
br.GetEnd().GetType() == Bound_STREAM
} | go | {
"resource": ""
} |
q27170 | NewRPCRequest | train | func NewRPCRequest(id string, method string, params json.RawMessage) *RPCRequest {
return &RPCRequest{
JSONRPC: "2.0",
Id: id,
Method: method,
Params: params,
}
} | go | {
"resource": ""
} |
q27171 | NewRPCResponse | train | func NewRPCResponse(id string, res interface{}) RPCResponse {
return RPCResponse(&RPCResultResponse{
Result: res,
Id: id,
JSONRPC: "2.0",
})
} | go | {
"resource": ""
} |
q27172 | NewRPCErrorResponse | train | func NewRPCErrorResponse(id string, code int, message string) RPCResponse {
return RPCResponse(&RPCErrorResponse{
Error: &RPCError{code, message},
Id: id,
JSONRPC: "2.0",
})
} | go | {
"resource": ""
} |
q27173 | NewMultiIterator | train | func NewMultiIterator(reverse bool, iterators ...KVIterator) *MultiIterator {
// reuse backing array
lessComp := -1
if reverse {
lessComp = 1
}
mi := &MultiIterator{
iterators: iterators,
iteratorOrder: make(map[KVIterator]int),
lessComp: lessComp,
}
mi.init()
return mi
} | go | {
"resource": ""
} |
q27174 | InitKeyClient | train | func InitKeyClient(keysUrl string) (*LocalKeyClient, error) {
aliveCh := make(chan struct{})
localKeyClient, err := keys.NewRemoteKeyClient(keysUrl, logging.NewNoopLogger())
if err != nil {
return nil, err
}
err = localKeyClient.HealthCheck()
go func() {
for err != nil {
err = localKeyClient.HealthCheck(... | go | {
"resource": ""
} |
q27175 | NormaliseDomain | train | func NormaliseDomain(low, high []byte) ([]byte, []byte) {
if len(low) == 0 {
low = []byte{}
}
return low, high
} | go | {
"resource": ""
} |
q27176 | CompareKeys | train | func CompareKeys(k1, k2 []byte) int {
ko1 := KeyOrder(k1)
ko2 := KeyOrder(k2)
if ko1 < ko2 {
return -1
}
if ko1 > ko2 {
return 1
}
return bytes.Compare(k1, k2)
} | go | {
"resource": ""
} |
q27177 | delegateCall | train | func (vm *VM) delegateCall(callState Interface, eventSink EventSink, caller, callee crypto.Address,
code, input []byte, value uint64, gas *uint64,
callType exec.CallType) (output []byte, err errors.CodedError) {
// fire the post call event (including exception if applicable) and make sure we return the accumulated ... | go | {
"resource": ""
} |
q27178 | useGasNegative | train | func useGasNegative(gasLeft *uint64, gasToUse uint64, err errors.Sink) {
if *gasLeft >= gasToUse {
*gasLeft -= gasToUse
} else {
err.PushError(errors.ErrorCodeInsufficientGas)
}
} | go | {
"resource": ""
} |
q27179 | dumpTokens | train | func dumpTokens(nonce []byte, caller, callee crypto.Address, code []byte) {
var tokensString string
tokens, err := acm.Bytecode(code).Tokens()
if err != nil {
tokensString = fmt.Sprintf("error generating tokens from bytecode: %v", err)
} else {
tokensString = strings.Join(tokens, "\n")
}
txHashString := "nil-... | go | {
"resource": ""
} |
q27180 | MakePrivateAccounts | train | func MakePrivateAccounts(n int) []*acm.PrivateAccount {
accounts := make([]*acm.PrivateAccount, n)
for i := 0; i < n; i++ {
accounts[i] = acm.GeneratePrivateAccountFromSecret("mysecret" + strconv.Itoa(i))
}
return accounts
} | go | {
"resource": ""
} |
q27181 | NewPostgresAdapter | train | func NewPostgresAdapter(schema string, log *logger.Logger) *PostgresAdapter {
return &PostgresAdapter{
Log: log,
Schema: schema,
}
} | go | {
"resource": ""
} |
q27182 | Open | train | func (adapter *PostgresAdapter) Open(dbURL string) (*sql.DB, error) {
db, err := sql.Open("postgres", dbURL)
if err != nil {
adapter.Log.Info("msg", "Error creating database connection", "err", err)
return nil, err
}
// if there is a supplied Schema
if adapter.Schema != "" {
if err = db.Ping(); err != nil {... | go | {
"resource": ""
} |
q27183 | CreateTableQuery | train | func (adapter *PostgresAdapter) CreateTableQuery(tableName string, columns []*types.SQLTableColumn) (string, string) {
// build query
columnsDef := ""
primaryKey := ""
dictionaryValues := ""
for i, column := range columns {
secureColumn := adapter.SecureName(column.Name)
sqlType, _ := adapter.TypeMapping(colu... | go | {
"resource": ""
} |
q27184 | TableDefinitionQuery | train | func (adapter *PostgresAdapter) TableDefinitionQuery() string {
query := `
SELECT
%s,%s,%s,%s
FROM
%s.%s
WHERE
%s = $1
ORDER BY
%s;`
return Cleanf(query,
types.SQLColumnLabelColumnName, types.SQLColumnLabelColumnType, // select
types.SQLColumnLabelColumnLength, types.SQLColumnLabelPrimaryKey,... | go | {
"resource": ""
} |
q27185 | InsertLogQuery | train | func (adapter *PostgresAdapter) InsertLogQuery() string {
query := `
INSERT INTO %s.%s (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)
VALUES (CURRENT_TIMESTAMP, $1, $2, $3, $4, $5, $6 ,$7, $8, $9);`
return Cleanf(query,
adapter.Schema, types.SQLLogTableName, // insert
//fields
types.SQLColumnLabelTimeStamp, types.SQLColu... | go | {
"resource": ""
} |
q27186 | NewProcess | train | func NewProcess(committer execution.BatchCommitter, blockchain *bcm.Blockchain, txDecoder txs.Decoder,
commitInterval time.Duration, panicFunc func(error)) *Process {
p := &Process{
committer: committer,
blockchain: blockchain,
done: make(chan struct{}),
txDecoder: txDecoder,
panic: panicFunc,... | go | {
"resource": ""
} |
q27187 | Sign | train | func (tx *Tx) Sign(signingAccounts ...acm.AddressableSigner) (*Envelope, error) {
env := tx.Enclose()
err := env.Sign(signingAccounts...)
if err != nil {
return nil, err
}
tx.Rehash()
return env, nil
} | go | {
"resource": ""
} |
q27188 | MustSignBytes | train | func (tx *Tx) MustSignBytes() []byte {
bs, err := tx.SignBytes()
if err != nil {
panic(err)
}
return bs
} | go | {
"resource": ""
} |
q27189 | GenerateReceipt | train | func (tx *Tx) GenerateReceipt() *Receipt {
receipt := &Receipt{
TxType: tx.Type(),
TxHash: tx.Hash(),
}
if callTx, ok := tx.Payload.(*payload.CallTx); ok {
receipt.CreatesContract = callTx.Address == nil
if receipt.CreatesContract {
receipt.ContractAddress = crypto.NewContractAddress(callTx.Input.Address,... | go | {
"resource": ""
} |
q27190 | FilterLogger | train | func FilterLogger(outputLogger log.Logger, predicate func(keyvals []interface{}) bool) log.Logger {
return log.LoggerFunc(func(keyvals ...interface{}) error {
// Always forward signals
if structure.Signal(keyvals) != "" || !predicate(keyvals) {
return outputLogger.Log(keyvals...)
}
return nil
})
} | go | {
"resource": ""
} |
q27191 | dial | train | func (c *Client) dial(logger *logging.Logger) error {
if c.transactClient == nil {
conn, err := grpc.Dial(c.ChainAddress, grpc.WithInsecure())
if err != nil {
return err
}
c.transactClient = rpctransact.NewTransactClient(conn)
c.queryClient = rpcquery.NewQueryClient(conn)
c.executionEventsClient = rpcev... | go | {
"resource": ""
} |
q27192 | CreateKey | train | func (c *Client) CreateKey(keyName, curveTypeString string, logger *logging.Logger) (crypto.PublicKey, error) {
err := c.dial(logger)
if err != nil {
return crypto.PublicKey{}, err
}
if c.keyClient == nil {
return crypto.PublicKey{}, fmt.Errorf("could not create key pair since no keys service is attached, " +
... | go | {
"resource": ""
} |
q27193 | Broadcast | train | func (c *Client) Broadcast(tx payload.Payload, logger *logging.Logger) (*exec.TxExecution, error) {
err := c.dial(logger)
if err != nil {
return nil, err
}
ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
defer cancel()
return c.transactClient.BroadcastTxSync(ctx, &rpctransact.TxEnvelopeParam... | go | {
"resource": ""
} |
q27194 | BroadcastEnvelope | train | func (c *Client) BroadcastEnvelope(txEnv *txs.Envelope, logger *logging.Logger) (*exec.TxExecution, error) {
err := c.dial(logger)
if err != nil {
return nil, err
}
ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
defer cancel()
return c.transactClient.BroadcastTxSync(ctx, &rpctransact.TxEnv... | go | {
"resource": ""
} |
q27195 | NoConsensusLauncher | train | func NoConsensusLauncher(kern *Kernel) process.Launcher {
return process.Launcher{
Name: NoConsensusProcessName,
Enabled: kern.Node == nil,
Launch: func() (process.Process, error) {
accountState := kern.State
nameRegState := kern.State
kern.Service = rpc.NewService(accountState, nameRegState, kern.Bl... | go | {
"resource": ""
} |
q27196 | SigningAccounts | train | func SigningAccounts(concretePrivateAccounts []*PrivateAccount) []AddressableSigner {
signingAccounts := make([]AddressableSigner, len(concretePrivateAccounts))
for i, cpa := range concretePrivateAccounts {
signingAccounts[i] = cpa
}
return signingAccounts
} | go | {
"resource": ""
} |
q27197 | GeneratePrivateAccount | train | func GeneratePrivateAccount() (*PrivateAccount, error) {
privateKey, err := crypto.GeneratePrivateKey(nil, crypto.CurveTypeEd25519)
if err != nil {
return nil, err
}
publicKey := privateKey.GetPublicKey()
return ConcretePrivateAccount{
Address: publicKey.GetAddress(),
PublicKey: publicKey,
PrivateKey: ... | go | {
"resource": ""
} |
q27198 | GeneratePrivateAccountFromSecret | train | func GeneratePrivateAccountFromSecret(secret string) *PrivateAccount {
privateKey := crypto.PrivateKeyFromSecret(secret, crypto.CurveTypeEd25519)
publicKey := privateKey.GetPublicKey()
return ConcretePrivateAccount{
Address: publicKey.GetAddress(),
PublicKey: publicKey,
PrivateKey: privateKey,
}.PrivateAc... | go | {
"resource": ""
} |
q27199 | Snatives | train | func Snatives(output Output) func(cmd *cli.Cmd) {
return func(cmd *cli.Cmd) {
contractsOpt := cmd.StringsOpt("c contracts", nil, "Contracts to generate")
cmd.Action = func() {
contracts := evm.SNativeContracts()
// Index of next contract
i := 1
for _, contract := range contracts {
if len(*contracts... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.