README
¶
borsh-go
borsh-go is an implementation of the [Borsh] binary serialization format for Go projects.
Borsh stands for Binary Object Representation Serializer for Hashing. It is meant to be used in security-critical projects as it prioritizes consistency, safety, speed, and comes with a strict specification.
Features
- Based on Go Reflection. Avoids the need for create protocol file and code generation. Simply
defining
structand go.
Usage
Example
package demo
import (
"log"
"reflect"
"testing"
"github.com/near/borsh-go"
)
type A struct {
X uint64
Y string
Z string `borsh_skip:"true"` // will skip this field when serializing/deserializing
}
func TestSimple(t *testing.T) {
x := A{
X: 3301,
Y: "liber primus",
}
data, err := borsh.Serialize(x)
log.Print(data)
if err != nil {
t.Error(err)
}
y := new(A)
err = borsh.Deserialize(y, data)
if err != nil {
t.Error(err)
}
if !reflect.DeepEqual(x, *y) {
t.Error(x, y)
}
}
For more examples of usage, refer to borsh_test.go.
Type Mappings
| Borsh | Go | Description |
|---|---|---|
bool |
bool |
|
u8 integer |
uint8 |
|
u16 integer |
uint16 |
|
u32 integer |
uint32 |
|
u64 integer |
uint64 |
|
u128 integer |
big.Int |
|
i8 integer |
int8 |
|
i16 integer |
int16 |
|
i32 integer |
int32 |
|
i64 integer |
int64 |
|
i128 integer |
Not supported yet | |
f32 float |
float32 |
|
f64 float |
float64 |
|
| fixed-size array | [size]type |
go array |
| dynamic-size array | []type |
go slice |
| string | string |
|
| option | *type |
go pointer |
| map | map |
|
| set | map[type]struct{} |
go map with value type set to struct{} |
| structs | struct |
|
| enum | borsh.Enum |
use type MyEnum borsh.Enum to define enum type |
Documentation
¶
Index ¶
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Deserialize ¶
Deserialize `data` according to the schema of `s`, and store the value into it. `s` must be a pointer type variable that points to the original schema of `data`.
Example ¶
package main
import (
"log"
"github.com/near/borsh-go"
)
type A struct {
B int32
}
func main() {
a := A{B: 123}
data, _ := borsh.Serialize(a)
b := &A{}
err := borsh.Deserialize(b, data)
if err != nil {
log.Fatal(err)
}
}
Output:
func Serialize ¶
Serialize `s` into bytes according to Borsh's specification(https://borsh.io/).
The type mapping can be found at https://github.com/near/borsh-go.
Example ¶
package main
import (
"log"
"github.com/near/borsh-go"
)
type A struct {
B int32
}
func main() {
a := A{B: 123}
data, err := borsh.Serialize(a)
if err != nil {
log.Fatal(err)
}
log.Print(data)
}
Output:
Types ¶
type Decoder ¶
type Decoder struct {
// contains filtered or unexported fields
}
func NewDecoder ¶
Example ¶
package main
import (
"bytes"
"log"
"github.com/near/borsh-go"
)
type A struct {
B int32
}
func main() {
a := A{B: 123}
data, _ := borsh.Serialize(a)
b := &A{}
d := borsh.NewDecoder(bytes.NewReader(data))
if err := d.Decode(b); err != nil {
log.Fatal(err)
}
}
Output:
type Encoder ¶
type Encoder struct {
// contains filtered or unexported fields
}
func NewEncoder ¶
Example ¶
package main
import (
"log"
"strings"
"github.com/near/borsh-go"
)
type A struct {
B int32
}
func main() {
a := A{B: 123}
b := strings.Builder{}
e := borsh.NewEncoder(&b)
if err := e.Encode(a); err != nil {
log.Fatal(err)
}
}
Output:
Source Files
Click to show internal directories.
Click to hide internal directories.