Protobuf3 with Interface support - Designed for blockchains (deterministic, upgradeable, fast, and compact)

Overview

Amino Spec (and impl for Go)

This software implements Go bindings for the Amino encoding protocol.

Amino is an object encoding specification. It is a subset of Proto3 with an extension for interface support. See the Proto3 spec for more information on Proto3, which Amino is largely compatible with (but not with Proto2).

The goal of the Amino encoding protocol is to bring parity into logic objects and persistence objects.

DISCLAIMER: We're still building out the ecosystem, which is currently most developed in Go. But Amino is not just for Go — if you'd like to contribute by creating supporting libraries in various languages from scratch, or by adapting existing Protobuf3 libraries, please open an issue on GitHub!

Why Amino?

Amino Goals

  • Bring parity into logic objects and persistent objects by supporting interfaces.
  • Have a unique/deterministic encoding of value.
  • Binary bytes must be decodeable with a schema.
  • Schema must be upgradeable.
  • Sufficient structure must be parseable without a schema.
  • The encoder and decoder logic must be reasonably simple.
  • The serialization must be reasonably compact.
  • A sufficiently compatible JSON format must be maintained (but not general conversion to/from JSON)

Amino vs JSON

JavaScript Object Notation (JSON) is human readable, well structured and great for interoperability with Javascript, but it is inefficient. Protobuf3, BER, RLP all exist because we need a more compact and efficient binary encoding standard. Amino provides efficient binary encoding for complex objects (e.g. embedded objects) that integrate naturally with your favorite modern programming language. Additionally, Amino has a fully compatible JSON encoding.

Amino vs Protobuf3

Amino wants to be Protobuf4. The bulk of this spec will explain how Amino differs from Protobuf3. Here, we will illustrate two key selling points for Amino.

  • Protobuf3 doesn't support interfaces. It supports oneof, which works as a kind of union type, but it doesn't translate well to "interfaces" and "implementations" in modern langauges such as C++ classes, Java interfaces/classes, Go interfaces/implementations, and Rust traits.

If Protobuf supported interfaces, users of externally defined schema files would be able to support caller-defined concrete types of an interface. Instead, the oneof feature of Protobuf3 requires the concrete types to be pre-declared in the definition of the oneof field.

Protobuf would be better if it supported interfaces/implementations as in most modern object-oriented languages. Since it is not, the generated code is often not the logical objects that you really want to use in your application, so you end up duplicating the structure in the Protobuf schema file and writing translators to and from your logic objects. Amino can eliminate this extra duplication and help streamline development from inception to maturity.

Amino in the Wild

Amino Spec

Interface

Amino is an encoding library that can handle Interfaces. This is achieved by prefixing bytes before each "concrete type".

A concrete type is a non-Interface type which implements a registered Interface. Not all types need to be registered as concrete types — only when they will be stored in Interface type fields (or in a List with Interface elements) do they need to be registered. Registration of Interfaces and the implementing concrete types should happen upon initialization of the program to detect any problems (such as conflicting prefix bytes -- more on that later).

Registering types

To encode and decode an Interface, it has to be registered with codec.RegisterInterface and its respective concrete type implementers should be registered with codec.RegisterConcrete

amino.RegisterInterface((*MyInterface1)(nil), nil)
amino.RegisterInterface((*MyInterface2)(nil), nil)
amino.RegisterConcrete(MyStruct1{}, "com.tendermint/MyStruct1", nil)
amino.RegisterConcrete(MyStruct2{}, "com.tendermint/MyStruct2", nil)
amino.RegisterConcrete(&MyStruct3{}, "anythingcangoinhereifitsunique", nil)

Notice that an Interface is represented by a nil pointer of that Interface.

NOTE: Go-Amino tries to transparently deal with pointers (and pointer-pointers) when it can. When it comes to decoding a concrete type into an Interface value, Go gives the user the option to register the concrete type as a pointer or non-pointer. If and only if the value is registered as a pointer is the decoded value will be a pointer as well.

Prefix bytes to identify the concrete type

All registered concrete types are encoded with leading 4 bytes (called "prefix bytes"), even when it's not held in an Interface field/element. In this way, Amino ensures that concrete types (almost) always have the same canonical representation. The first byte of the prefix bytes must not be a zero byte, so there are 2^(8x4)-2^(8x3) = 4,278,190,080 possible values.

When there are 1024 concrete types registered that implement the same Interface, the probability of there being a conflict is ~ 0.01%.

This is assuming that all registered concrete types have unique natural names (e.g. prefixed by a unique entity name such as "com.tendermint/", and not "mined/grinded" to produce a particular sequence of "prefix bytes"). Do not mine/grind to produce a particular sequence of prefix bytes, and avoid using dependencies that do so.

The Birthday Paradox: 1024 random registered types, Wire prefix bytes
https://instacalc.com/51554

possible = 4278190080                               = 4,278,190,080 
registered = 1024                                   = 1,024 
pairs = ((registered)*(registered-1)) / 2           = 523,776 
no_collisions = ((possible-1) / possible)^pairs     = 0.99987757816 
any_collisions = 1 - no_collisions                  = 0.00012242184 
percent_any_collisions = any_collisions * 100       = 0.01224218414 

Since 4 bytes are not sufficient to ensure no conflicts, sometimes it is necessary to prepend more than the 4 prefix bytes for disambiguation. Like the prefix bytes, the disambiguation bytes are also computed from the registered name of the concrete type. There are 3 disambiguation bytes, and in binary form they always precede the prefix bytes. The first byte of the disambiguation bytes must not be a zero byte, so there are 2^(8x3)-2^(8x2) possible values.

// Sample Amino encoded binary bytes with 4 prefix bytes.
> [0xBB 0x9C 0x83 0xDD] [...]

// Sample Amino encoded binary bytes with 3 disambiguation bytes and 4
// prefix bytes.
> 0x00 <0xA8 0xFC 0x54> [0xBB 0x9C 0x83 0xDD] [...]

The prefix bytes never start with a zero byte, so the disambiguation bytes are escaped with 0x00.

The 4 prefix bytes always immediately precede the binary encoding of the concrete type.

Computing the prefix and disambiguation bytes

To compute the disambiguation bytes, we take hash := sha256(concreteTypeName), and drop the leading 0x00 bytes.

> hash := sha256("com.tendermint.consensus/MyConcreteName")
> hex.EncodeBytes(hash) // 0x{00 00 A8 FC 54 00 00 00 BB 9C 83 DD ...} (example)

In the example above, hash has two leading 0x00 bytes, so we drop them.

> rest = dropLeadingZeroBytes(hash) // 0x{A8 FC 54 00 00 00 BB 9C 83 DD ...}
> disamb = rest[0:3]
> rest = dropLeadingZeroBytes(rest[3:])
> prefix = rest[0:4]

The first 3 bytes are called the "disambiguation bytes" (in angle brackets). The next 4 bytes are called the "prefix bytes" (in square brackets).

> <0xA8 0xFC 0x54> [0xBB 0x9C 9x83 9xDD] // <Disamb Bytes> and [Prefix Bytes]

Unsupported types

Floating points

Floating point number types are discouraged as they are generally non-deterministic. If you need to use them, use the field tag amino:"unsafe".

Enums

Enum types are not supported in all languages, and they're simple enough to model as integers anyways.

Maps

Maps are not currently supported. There is an unstable experimental support for maps for the Amino:JSON codec, but it shouldn't be relied on. Ideally, each Amino library should decode maps as a List of key-value structs (in the case of langauges without generics, the library should maybe provide a custom Map implementation). TODO specify the standard for key-value items.

Comments
  • Sorted JSON from MarshalJSON

    Sorted JSON from MarshalJSON

    Can we enforce that the json created is ordered in the same order which the fields are defined in the struct?

    edit by @Liamsi: this is already the case. The discussion below diverted to if amino should sort keys alphabetically.

    See: https://github.com/cosmos/cosmos-sdk/issues/983#issuecomment-393008655

    opened by rigelrozanski 18
  • Tpy3_StructTerm seems to be grouped at the end of the struct.

    Tpy3_StructTerm seems to be grouped at the end of the struct.

    Below is a test vector for SignVoteStruct generated by the snippet here: https://github.com/tendermint/kms/issues/14

    The SignVote struct contains 3 sub struct. 0x04 is the typ3 for struct termination.

    I would expect that we would see the 0x04 inside the the body of the serialized data instead of grouped at the end.

    Based on the structs I have reviewed I have never seen a Typ3_StructTerm inside the body of the data.

    This seems to me to be a bug

    0x58, 0x6c, 0x1d, 0x3a, 0x33, 0xb, 0xa, 0x14, 0xa3, 0xb2, 0xcc, 0xdd, 0x71, 0x86, 0xf1, 0x68, 0x5f, 0x21, 0xf2, 0x48, 0x2a, 0xf4, 0xfb, 0x34, 0x46, 0xa8, 0x4b, 0x35, 0x10, 0xaa, 0xf7, 0x6, 0x19, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x30, 0x39, 0x20, 0x4, 0x2b, 0x9, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x40, 0x69, 0xb1, 0x15, 0xd, 0xf2, 0x8e, 0x80, 0x4, 0x30, 0x1, 0x3b, 0xa, 0x4, 0x68, 0x61, 0x73, 0x68, 0x13, 0x8, 0x80, 0x89, 0x7a, 0x12, 0xa, 0x70, 0x61, 0x72, 0x74, 0x73, 0x5f, 0x68, 0x61, 0x73, 0x68,0x4, 0x4, 0x4, 0x4
    
    
    opened by zmanian 11
  • how to make backwards compatible changes ?

    how to make backwards compatible changes ?

    The naiive thing doesn't seem to work:

    package main
    
    import (
    	"fmt"
    	"github.com/tendermint/go-amino"
    )
    
    type V1 struct {
    	String string `json:"string"`
    }
    
    type V2 struct {
    	String string `json:"string"`
    	Int    int    `json:"int"`
    }
    
    func main() {
    	cdc := amino.NewCodec()
    
    	v2 := V2{String: "hi"}
    	bz, _ := cdc.MarshalBinaryBare(v2)
    	var v1 V1
    	err := cdc.UnmarshalBinaryBare(bz, &v1)
    	fmt.Println(err)
    	fmt.Println(v1)
    
    }
    

    Returns:

    Invalid typ3 byte
    {hi}
    

    So it does unmarshal whatever it can, but it also returns an error.

    If the order of String and Int are reversed in V2, it just fails outright.

    improvement 
    opened by ebuchman 11
  • Add hash commit for serialized JSON as part of amino encoding

    Add hash commit for serialized JSON as part of amino encoding

    Currently the amino format for encoding data is as follows:

    [3]byte{type} | []byte{protoEncodedData}
    

    We propose adding an optional encoding format (to be decided at codec creation) that will encode data as follows:

    [3]byte{type} | [32]byte{sha256(JSON)} |  []byte{protoEncodedData}
    

    Where sha256(JSON) is the sha256 hash of the minified JSON representation of the protoEncodedData.

    If this method was implemented and used in the store of Tendermint based chain, then full nodes could serve JSON representations to clients that include light client proofs which could be verified w/o the need to deserialize the amino encoded data.

    opened by jackzampolin 9
  • Proposal: make amino fully compatible with proto3, except for oneof

    Proposal: make amino fully compatible with proto3, except for oneof

    Aminos shining feature and motivator is the way it handles oneof.

    To simplify integrations and useability, we should consider making Amino perfectly compatible with the subset of protobuf3 that does not include oneof. Then any structs that do not themselves contain interfaces will be perfectly proto3. If they're registered, they'll just also be prefixed with the type bytes

    This would be great for things like the Header and IAVL node structure if we could just point to structs and say "proto3". Especially since these pieces are critical in IBC. It would also dramatically simplify implementation to just be able to append prefix bytes than have to change the way structs are encoded ...

    proposal 
    opened by ebuchman 9
  • Why Uint16s

    Why Uint16s

    We have functions for writing []uint16 but not anything else.

    Do we need that? Maybe we can remove.

    Also, the implementation appears buggy: https://github.com/tendermint/go-wire/blob/develop/nowriter/tmdecoding/tm_decoder_pure.go#L158

    • should use +2 and needs to slice off the first 4 bytes (the length) before reading the rest
    opened by ebuchman 8
  • Rethink go-wire API

    Rethink go-wire API

    As we are working to design the cosmos-sdk API, I am writing up sample apps, and realized how confusing it can be to explain go-wire to newcomers. Not just funny things like needing to embed an interface in a struct, but also the api itself. I want to propose that we redesign the public API, hide most of the methods (which can be private), and adapt the rest to match a cleaner interface. I am not proposing here any fundamental changes to the feature set, except cleaning up how things work.

    For example, look at the godoc: https://godoc.org/github.com/tendermint/go-wire

    Compared with another binary encoding library: https://godoc.org/encoding/gob#pkg-index Or even the extremely feature (and error) rich json encoding library: https://godoc.org/encoding/json#pkg-index

    Not just the giant intro in the beginning, but that gob has about 90% fewer public methods and a very similar functionality (including registering implementations of interfaces). I am not suggesting to use gob instead (it is much larger than go-wire), but to model our API against something standard.

    As a strawman, I would suggest something like this:

    // registration multiple implementations for an interface, similar to go-data, but global
    // multiple calls to Interface with the same base will return the same Registrar
    type Registrar
      func Interface(base interface{}) Registrar
      func (r Registrar) RegisterImplementation(data interface{}, b byte) Registrar
    
    // if we want to read/write to bytes - eg. ReadBinaryBytes and BinaryBytes
    func Marshal(v interface{}) ([]byte, error)
    func Unmarshal(data []byte, v interface{}) error
    
    // if we want to read/write to streams of data - eg. ReadBinary and WriteBinary
    type Decoder
      func NewDecoder(r io.Reader) *Decoder
      func (dec *Decoder) Decode(v interface{}) error
    type Encoder
      func NewEncoder(w io.Writer) *Encoder
      func (enc *Encoder) Encode(v interface{}) error
    
    proposal improvement 
    opened by ethanfrey 8
  • disallow multidimensional slices and arrays

    disallow multidimensional slices and arrays

    Stop allowing multidimensional slices and arrays, in order to increase proto3 compatibility. Addresses #272.

    This is my first PR, and a little bit of a shot in the dark, so please let me know if I need to restructure anything!

    opened by tessr 6
  • Wire vs CBOR

    Wire vs CBOR

    Sorry to be That Guy™, but why would someone use this instead of CBOR? And if there is a reason, "Wire vs CBOR" deserves a heading in the README.

    opened by gibson042 6
  • 'decoder.go / encoder.go' overflows int issue when cross compile c(for android)

    'decoder.go / encoder.go' overflows int issue when cross compile c(for android)

    I've cross-compile cosmos-sdk v0.26.1-rc1 with c(androideabi). However, an error has occurred.

    [Got message] ../../../../vendor/github.com/tendermint/go-amino/decoder.go:246:44: constant -62135596800 overflows int ../../../../vendor/github.com/tendermint/go-amino/decoder.go:246:44: constant 253402300800 overflows int ../../../../vendor/github.com/tendermint/go-amino/encoder.go:147:38: constant -62135596800 overflows int ../../../../vendor/github.com/tendermint/go-amino/encoder.go:147:38: constant 253402300800 overflows int

    [Please change both files.] 1. go-amino/decoder.go:246 return 0, n, InvalidTimeErr(fmt.Sprintf("seconds have to be > %d and < %d, got: %d", minSeconds, maxSeconds, res))

    to

    return 0, n, InvalidTimeErr(fmt.Sprintf("seconds have to be > %d and < %d, got: %d", int64(minSeconds), int64(maxSeconds), res))

    2. go-amino/encoder.go:147 return InvalidTimeErr(fmt.Sprintf("seconds have to be >= %d and < %d, got: %d", minSeconds, maxSeconds, s))

    to

    return InvalidTimeErr(fmt.Sprintf("seconds have to be >= %d and < %d, got: %d", int64(minSeconds), int64(maxSeconds), s))

    Thank you for your hard work.

    opened by Lunagram 5
  • Remove defers from getTypeInfo functions

    Remove defers from getTypeInfo functions

    These defers were taking up around .5% of the gaia state machines time, due to their usage within MarshalJSON and UnmarshalBinaryBare. (exact percentage is a bit unclear)

    There is no safety concern for removing these defers, as none of the methods within the functions should panic.

    opened by ValarDragon 5
  • Upgrade to GitHub-native Dependabot

    Upgrade to GitHub-native Dependabot

    Dependabot Preview will be shut down on August 3rd, 2021. In order to keep getting Dependabot updates, please merge this PR and migrate to GitHub-native Dependabot before then.

    Dependabot has been fully integrated into GitHub, so you no longer have to install and manage a separate app. This pull request migrates your configuration from Dependabot.com to a config file, using the new syntax. When merged, we'll swap out dependabot-preview (me) for a new dependabot app, and you'll be all set!

    With this change, you'll now use the Dependabot page in GitHub, rather than the Dependabot dashboard, to monitor your version updates, and you'll configure Dependabot through the new config file rather than a UI.

    If you've got any questions or feedback for us, please let us know by creating an issue in the dependabot/dependabot-core repository.

    Learn more about migrating to GitHub-native Dependabot

    Please note that regular @dependabot commands do not work on this pull request.

    dependencies 
    opened by dependabot-preview[bot] 1
  • Bump github.com/golang/protobuf from 1.3.5 to 1.5.2

    Bump github.com/golang/protobuf from 1.3.5 to 1.5.2

    Bumps github.com/golang/protobuf from 1.3.5 to 1.5.2.

    Release notes

    Sourced from github.com/golang/protobuf's releases.

    v1.5.2

    Notable changes:

    • (#1306) all: deprecate the module
    • (#1300) jsonpb: restore previous behavior for handling nulls and JSONPBUnmarshaler

    v1.5.1

    Notable changes:

    v1.5.0

    Overview

    This marks the ptypes package as deprecated and upgrades the dependency on google.golang.org/protobuf to a pre-release version of v1.26.0. A subsequent patch release will update the dependency to v1.26.0 proper.

    Notable changes

    • (#1217) ptypes: deprecate the package
    • (#1214) rely on protodesc.ToFileDescriptorProto

    v1.4.3

    Notable changes:

    • (#1221) jsonpb: Fix marshaling of Duration
    • (#1210) proto: convert integer to rune before converting to string

    v1.4.2

    Notable changes:

    v1.4.1

    Notable changes:

    v1.4.0

    ... (truncated)

    Commits

    Dependabot compatibility score

    Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


    Dependabot commands and options

    You can trigger Dependabot actions by commenting on this PR:

    • @dependabot rebase will rebase this PR
    • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
    • @dependabot merge will merge this PR after your CI passes on it
    • @dependabot squash and merge will squash and merge this PR after your CI passes on it
    • @dependabot cancel merge will cancel a previously requested merge and block automerging
    • @dependabot reopen will reopen this PR if it is closed
    • @dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
    • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
    • @dependabot use these labels will set the current labels as the default for future PRs for this repo and language
    • @dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language
    • @dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language
    • @dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language
    • @dependabot badge me will comment on this PR with code to add a "Dependabot enabled" badge to your readme

    Additionally, you can set the following in your Dependabot dashboard:

    • Update frequency (including time of day and day of week)
    • Pull request limits (per update run and/or open at any time)
    • Out-of-range updates (receive only lockfile updates, if desired)
    • Security updates (receive only security updates, if desired)
    dependencies 
    opened by dependabot-preview[bot] 1
  • Bump github.com/stretchr/testify from 1.6.0 to 1.7.0

    Bump github.com/stretchr/testify from 1.6.0 to 1.7.0

    Bumps github.com/stretchr/testify from 1.6.0 to 1.7.0.

    Release notes

    Sourced from github.com/stretchr/testify's releases.

    Minor improvements and bug fixes

    Minor feature improvements and bug fixes

    Fixes breaking change with HTTPBodyContains

    A breaking change was accidentally released in v1.6.0 which breaks the API for the HTTPBodyContains and HTTPBodyNotContains, this release reverts that change.

    Commits
    • acba37e Only use repeatability if no repeatability left
    • eb8c41e Add more tests to mock package
    • a5830c5 Extract method to evaluate closest match
    • 1962448 Use Repeatability as tie-breaker for closest match
    • 92707c0 Fixed the link to not point to assert only
    • 05dd0b2 Updated the readme to point to pkg.dev
    • c26b7f3 Update assertions.go
    • 8fb4b24 [Fix] The most recent changes to golang/protobuf breaks the spew Circular dat...
    • dc8af72 add generated code for positive/negative assertion
    • 1544508 add assert positive/negative
    • Additional commits viewable in compare view

    Dependabot compatibility score

    Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


    Dependabot commands and options

    You can trigger Dependabot actions by commenting on this PR:

    • @dependabot rebase will rebase this PR
    • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
    • @dependabot merge will merge this PR after your CI passes on it
    • @dependabot squash and merge will squash and merge this PR after your CI passes on it
    • @dependabot cancel merge will cancel a previously requested merge and block automerging
    • @dependabot reopen will reopen this PR if it is closed
    • @dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
    • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
    • @dependabot use these labels will set the current labels as the default for future PRs for this repo and language
    • @dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language
    • @dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language
    • @dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language
    • @dependabot badge me will comment on this PR with code to add a "Dependabot enabled" badge to your readme

    Additionally, you can set the following in your Dependabot dashboard:

    • Update frequency (including time of day and day of week)
    • Pull request limits (per update run and/or open at any time)
    • Out-of-range updates (receive only lockfile updates, if desired)
    • Security updates (receive only security updates, if desired)
    dependencies 
    opened by dependabot-preview[bot] 1
  • Amino 2.0

    Amino 2.0

    This is not backwards compatible.

    • Native Any support
    • No need for local codecs, just use the global one.
    • Package registration.
    • (genproto) .proto schema generation
    • (genproto) go <---> proto3-generated-go translations
    • Fuzz testing with above translations
    • Convenience for generating types.proto and pb/* protoc and pbbindings.go
    • TODO maybe faster encoding/decoding with protoc.
    opened by jaekwon 1
Releases(v0.16.0)
Owner
Tendermint
Bringing simplicity, security, and speed to the world's blockchains.
Tendermint
Powerful and versatile MIME sniffing package using pre-compiled glob patterns, magic number signatures, XML document namespaces, and tree magic for mounted volumes, generated from the XDG shared-mime-info database.

mimemagic Powerful and versatile MIME sniffing package using pre-compiled glob patterns, magic number signatures, xml document namespaces, and tree ma

Ronen Ulanovsky 77 Sep 17, 2022
A Go language binding for encodeing and decoding data in the bencode format that is used by the BitTorrent peer-to-peer file sharing protocol.

bencode-go A Go language binding for encoding and decoding data in the bencode format that is used by the BitTorrent peer-to-peer file sharing protoco

Jack Palevich 186 Sep 27, 2022
Compact, sortable and fast unique IDs with embedded metadata.

A spec for unique IDs in distributed systems based on the Snowflake design, i.e. a coordination-based ID variant. It aims to be friendly to both machi

null 71 Aug 27, 2022
Record and replay your HTTP interactions for fast, deterministic and accurate tests

go-vcr go-vcr simplifies testing by recording your HTTP interactions and replaying them in future runs in order to provide fast, deterministic and acc

Marin Atanasov Nikolov 944 Sep 25, 2022
A compact, cross-platform scanner that scans ports and recognizes fingerprints.

portscan A compact, cross-platform scanner that scans ports and recognizes fingerprints. Usage: Usage of ./portscan: -H headers request headers

Leon 4 Apr 4, 2022
Library for multi-armed bandit selection strategies, including efficient deterministic implementations of Thompson sampling and epsilon-greedy.

Mab Multi-Armed Bandits Go Library Description Installation Usage Creating a bandit and selecting arms Numerical integration with numint Documentation

Stitch Fix Technology 30 Jul 2, 2022
SwissWallet is a deterministic cryptocurrency wallet generator heavily based on MindWallet and MemWallet

SwissWallet SwissWallet is a deterministic cryptocurrency wallet generator heavily based on MindWallet and MemWallet but using argon2 and scrypt by de

vortex.live 7 Jul 28, 2022
A simple and (currently) deterministic decision management service written in go

dang This is a simple and (currently) deterministic decision management service written in Go. Inspired by (but not yet conforming to) the DMN spec. L

ida 0 Dec 10, 2021
Coroutine based Deterministic 2PC Distributed Transaction

Enviorment set up off the mod go env -w GO111MODULE=off change to GPATH to project directory go env -w GOPATH=$HOME/coroprove Usage This project serve

Jack Wang 0 Oct 30, 2021
A blockchains platform with high throughput, and blazing fast transactions

Node implementation for the Avalanche network - a blockchains platform with high throughput, and blazing fast transactions. Installation Avalanche is

null 1 Oct 31, 2021
A blockchains platform with high throughput, and blazing fast transactions

Node implementation for the Avalanche network - a blockchains platform with high

null 0 Dec 18, 2021
Dijetsnetgo: a blockchains platform with high throughput, and blazing fast transactions

Node implementation for the Avalanche network - a blockchains platform with high

Dijets 0 Jan 18, 2022
A terminal designed for anyone to use and designed for any platform

A terminal designed for anyone to use and designed for any platform. Which includes the basic features of any terminal and includes friendly commands to perform tools such as ping, traceroute, generate key pairs, encrypt/decrypt, router security actions, etc. All of the source code is done in Go.

Karun Kanda 1 Jan 25, 2022
An open-source, distributed, cloud-native CD (Continuous Delivery) product designed for developersAn open-source, distributed, cloud-native CD (Continuous Delivery) product designed for developers

Developer-oriented Continuous Delivery Product ⁣ English | 简体中文 Table of Contents Zadig Table of Contents What is Zadig Quick start How to use? How to

null 0 Oct 19, 2021
⚡ Rux is an simple and fast web framework. support middleware, compatible http.Handler interface. 简单且快速的 Go web 框架,支持中间件,兼容 http.Handler 接口

Rux Simple and fast web framework for build golang HTTP applications. NOTICE: v1.3.x is not fully compatible with v1.2.x version Fast route match, sup

Gookit 81 Jul 20, 2022
KintoHub is an open source build and deployment platform designed with a developer-friendly interface for Kubernetes.

What is Kintohub? KintoHub is an open source build and deployment platform designed with a developer-friendly interface for Kubernetes. Build your cod

KintoHub 30 Jun 7, 2022
Couper is a lightweight API gateway designed to support developers in building and operating API-driven Web projects

Couper Couper is a lightweight API gateway designed to support developers in building and operating API-driven Web projects. Getting started The quick

Avenga 70 Sep 13, 2022
a Golang sdk for working with DeFi protocols, and ethereum compatible blockchains

A golang sdk for working with DeFi protocols and general utilities for working with ethereum-compatible blockchains. packages bclient bindings cli con

bonedaddy 70 Sep 13, 2022