bcnet
Tipos de datos
static: un tipo de constante que se lee ANTES de parsear el bloque.
cons: un valor constante que se define una sola vez cuando se parsea un bloque
var: un valor que puede cambiar durante el parseo del bloque
prot: un tipo de var protegida que se crea o cambia solo en modo protegido o desde una protFunction
En Bcnet es obligatorio para un bloque:
#static: netName, nombre_red;
#static: blockId, num_id; el id 1 es considerado un bloque GENESIS
el #prot: mainHome; es optativo y sirve para cambiar de bloque GENESIS.
Espacios
cons, var y prot: son espacios (arrays) en la MAC donde se guardar cada tipo de dato de igual nombre.
hspaces: Hash, add (o pubkey) u otra tipo de etiquetas pueden ser definidas como espacios (arrays)
Dentro de ellas se pueden definir prots ( vars, cons publicas o solo privadas ?¿?)
ejemplo:
#setSpace: adcffg1234fdhc345vc3; //un nuevo espacio
[mesaje@var] = "hola mundo"; una var
[alias@cons] = soy_yo; una const
[coinamoun@prot] = 100; un prot
NO -> ////////[mywallet@priv] = 100; un prot
NO?? -> [myfunction@func] = funtion: myfunction;#var: lotengo, TRUE; endFunction:myfunction;
Estructuras
fn: un bloque de codigo que se llama desde #fn_name y termina en rtn. Al salir vuelve a la siguiente instruccion inmediata.
Los tipos var son privados a la fn.
div: define un sub bloque de codigo para poder ser extraido RAW para poder hacer un hasheo parcial de sus datos.. termina en endDiv (obsoleto?)
sec: define un sub bloque de codigo para poder ser extraido RAW para poder hacer un hasheo parcial de sus datos.. termina en endSec
se declara como:
#sec: secHash, publicKey;
#....sec code
#endSec: secSiganture;
main: define un sub bloque que sera llamado con cada parseo de cada bloque...alli estan contenidas las reglas de la red escrito en el lenguaje de.
Termina en endMain;
sub: define un sub bloque de codigo. Comparte el ambito del tipo var.
sub_name@event: Igual que los sub pero que solo es llamado en un evento durante la ejecucion, se debe definir dentro de main,
ideal para hacer primeras-ultimas comprobaciones.
Son optativos.
start@event al comienzo de ejecución
end@event al final ejecución
otros@event antes de end@event
Cuando se recibe una tx, el driver prueba la tx en una ejecución de bloque tentativo:
La tx se agrega un header de blockId + 1, se parsea y se hay exito se llama a newTx@event
newTx script -> buffer
//Estructura bloque genesis
[cabecera]
Id
hash
firma
[cuerpo]
statics
main
Inits
fn
Subs
sec
Subs@event
[de uso]
txs
etc...
//Estructura bloque regular[cabecera]
Id
hash
firma
[cuerpo]
statics
[de uso]sec
etc....
--------------------------------------------------------------------
Flujo de parseo de bloques
1) Se lee la cabecera, y cargan los datos que contienen en MAC, luego se la retira del bloque.
2) Se leen los statics y se cargan en MAC. Si estamos en un bloque genesis, --> la MAC entra en modo protegido <--
3) se carga el programa definido por main <--> endMain y se parsea...la MAC toma los valores
4) se parsea la seccion "de uso"...
5) fin con el resultado
Resumen de reglas de operacion
-> no
Las functioProt solo pueden ser definidas en un bloque genesis o extensor (genesis: define la red completamente de nuevo,
extensor: extiende las funcionalidades que ya tiene la red), definir fuera de ese ambito genera un error de proteccion.
las variables prot solo pueden ser alcanzadas por funciones protFunctions definidas en los bloques genesis y/o extensores
<-
--------------------------------------------------------------------
Lista comandos:
"mainHome":
//set el prot especial con el blockId donde se busca el main
//este prot es un caso epecial porque execbcnet lo busca en ultimo bloque de la cadena (antes de buscar el main)
//#mainHome: 1;// set como mainhome al block id 1
___________________________________
vars, cons y prots
___________________________________
"headerStatic"
//rellena un array de constantes cuando lee la cabecera del bloque, ANTES de la ejecucion
//solo se puede usar una etiqueta una vez;
//solo argumentos literales
//formato: [indice_nombre],[valor]
//#headerStatic:myconstant,154657;
"static"
//rellena un array de constantes antes de hacer nada: 1º pasada, ANTES de la ejecucion
//solo se puede usar una etiqueta una vez;
//solo argumentos literales
//formato: [indice_nombre],[valor]
//define:myconstant,154657;
"set" -----> revisar si es necesario
//rellena array de constantes o vars;
//formato: [indice_nombre],[valor]
//set: my@cons, num;
//set: my@cons, num@const;
//en modo protegido puede escribir en prot
//set: my@prot, num@const;
"setRef" -----> revisar si es necesario
//rellena array de constantes, vars prots , referenciado por el valor de otra
//formato: [var,prot,cons], [indice_nombre, literal], [space]
//set: my@cons, num@var, prot;
//set: my@cons, num@const, cons;
//en modo protegido puede escribir en prot
//set: my@prot, num@const;
//#setRef: tmp2@var, addressIn@var, prot;
//#setRef: tmp2@var, addressIn@var, prot;
"define"
//rellena un array de constantes en tiempo de ejecucion
//solo se puede usar una etiqueta una vez;
//formato: [indice_nombre],[valor]
//define:myconstant,154657;
//define:myconstant, my@var;
"var"
//rellena un array con una var, declarada literal ejem: mivar o referenciada a otra var cons o prot ejemplo: minombre@var
//formato: [indice_nombre (txt)],[valor]
//#var:myar, m154657;
//puede definir un indice_nombre con el valor de otra variable
//#var: una_var_definida@var, unvalordeunavardefinida@var;
//ejemplo:
//#define: myconst, nombre;
//#var: myconst@cons, 1234; -> nombre = 1234;
"unset"
//borra una var
//#unSet:myar;
//tambien
//#unSet: una_var_definida@var, unvalordeunavardefinida@var;
"prot"
//rellena un array con un prot, declarado literal ejem: miprot o referenciada a otra var cons o prot ejemplo: minombre@var
//#prot: myprotvar, m154657;
//#prot: una_var_definida@var, unvalordeunavardefinida@var;
//#define: myconst, nombre;
//#prot: myconst@cons, 1234; -> nombre = 1234;
"required"
//comprueba si una var, cons o prot esta definido
//detiene la ejecucion en caso de falso
//required:myconstant@space;
"check"
//comprueba si una var cons o prot (solo posible en modo protegido)
//existe en mac
//#check: result2@cons,algo@var;
"checkDatInSpace" -----> revisar si es necesario
//comprueba si un indice esta definido en un space
//check: bool@var, myconstant@space, space;
//#check: result@var, miadd@var, prot;
"setSpace"
//crea array para (constantes, vars y functions?¿) prot
//formato: [indice_nombre][valor]
"setProtSpa"
//rellena un array (hspace) de prots.
//#setProtSpa: premio@cons, coinName@cons, address@var;
//#setProtSpa: value, index, space;
___________________________________
Estructura
___________________________________
"Fn"
// crea una funcion, las variables estan aisladas, se puede pasar argumentos y devolver un resultado
// se llaman con #nombreMiFn:;
"sub"
//engloba codigo bajo la etiqueta para ser llamado con callSub
//puede haber funciones anidadas, pero si se vuelve a llamar a la funcion padre se redefinen y produce error
//#function: myfuncion;
"rtnSub"
//retorna de la funcion a la siguiente instruccion del programa
//#callfunction: myfuncion;
"callSub"
//Llama a un sub
//#callfunction: myfuncion;
"endIf"
//cierra el if
//endIf:;
"if"
//ejecuta un bloque de codigo si cumple una condicion logica
// puede estar anidado
//op: equal, not, may, min, minEqual, mayEqual
//#if:myvar@var,equal,mycons@const;
"getBlockDiv"
//trae una parte de un bloque (RAW) delimitado entre div .... endDiv
//#div: var...cons, var....cons....literal ;
"main"
//aqui reside el programa de la red, que se carga para parsear cada bloque nuevo
//solo se puede definir una vez, y presentar un solo main alternativo
"endMain"
//cierra el bloque especial main
"close"
// define el codigo que se ejecuta al terminar con el bloque
// solo puede estar dentro de main
//#close:;
"endClose"
// cierra el bloque especial close
"div"
//divide una seccion del bloque, util para hashear
//#div: mypart;
"endDiv"
//delimita el final de una parte del bloque
//#endDiv:;
___________________________________
Math y crypto
___________________________________
"addVar"
//suma un numero o una var cons o prot (si se puede) referenciado (@cons...) y una var (literal)
//addVar: myvar,154657;
//addVar: myvar, mydato@var;
"sigVerif"
//verifica la firma de un hash con la clave publica
//sigVerf: result@var, dataToSig@var, signature@var, pubkey;
"mkSha256" ?????
//hace el hash de una var, cons, prot (si esta disponible)
//mkSha256: variableResul,varibleIn;
"mkHash"
//hash con sha256, ripemd160, crc32b, md5, tiger160
//#mkHash: Result, data, alg;
"mathVar"
//opera numero y una var cons o prot (si se puede) referenciado (@cons...@var) y una var (literal)
//mathVar:myvar, add,154657;
//mathVar:myvar, add, dato@cons;
"add"
//suma var, const y nums
//add:result,varmyvar,constmyconst;
//add:resultado@con, mydat1@var, dat2@cons;
"math"
//suma var, const y nums
//math:result,var1,op,var2;
//op: add, sub, mul, div
//math:resultado@var, var1@prot , add, var2@cons;
___________________________________
Db y sistema
___________________________________
"getSystemTime"
//obtiene la hora actual (float) del sistema
//getSystemTime: myhora@cons;
"getBlockRaw"
//obtiene los datos del bloque crudo
//getBlockRaw: mybloque@var;
"getFromBc"
//[result] [block_id] [var@space]
//Trae un dato desde la db...
//el tercer par. es la variable y el espacio en el bloque
//#GetDatBc: tmp@var, txInBlockId, nodeAdd@var;
//#GetDatBc: tmp@var, txInBlockId, ->nodeAdd@[var];
"getProtFromSpaBc" ---> revisar
//atencion: si el espacio o el prot no esta definido devuelve 0
// el tercer argumento toma el valor que tiene la variable local, es necesario
// especificar el espacio donde encontrar el dato (space)
//#getFromBcSpace: result, name, space;
//#getFromBcSpace: tmp@var, index@var, add@var;