FVM integration

.circleci/config.yml

@@ -7,7 +7,7 @@ orbs:
 executors:
   golang:
     docker:
-      - image: circleci/golang:1.13
+      - image: circleci/golang:1.16.4
     resource_class: 2xlarge
   rust:
     docker:
@@ -32,7 +32,7 @@ jobs:
       - go/mod-download
       - go/install-golangci-lint:
           gobin: $HOME/.local/bin
-          version: 1.32.0
+          version: 1.44.2
       - run:
           command: make go-lint
 
@@ -109,6 +109,7 @@ jobs:
             - cargo-v0-{{ checksum "rust/rust-toolchain" }}-{{ checksum "rust/Cargo.toml" }}-{{ checksum "rust/Cargo.lock" }}-{{ arch }}
       - run: cd rust && rustup install $(cat rust-toolchain)
       - run: cd rust && rustup default $(cat rust-toolchain)
+      - run: cd rust && rustup target add wasm32-unknown-unknown
       - run: cd rust && rustup component add rustfmt
       - run: cd rust && rustup component add clippy
       - run: cd rust && cargo fetch
@@ -145,6 +146,7 @@ jobs:
             - cargo-v0-{{ checksum "rust/rust-toolchain" }}-{{ checksum "rust/Cargo.toml" }}-{{ checksum "rust/Cargo.lock" }}-{{ arch }}
       - run: cd rust && rustup install $(cat rust-toolchain)
       - run: cd rust && rustup default $(cat rust-toolchain)
+      - run: cd rust && rustup target add wasm32-unknown-unknown
       - run: cd rust && rustup component add rustfmt
       - run: cd rust && rustup component add clippy
       - run: cd rust && cargo fetch
@@ -209,7 +211,7 @@ commands:
             - run:
                 name: Install Go
                 command: |
-                  curl https://dl.google.com/go/go1.13.7.darwin-amd64.pkg -o /tmp/go.pkg && \
+                  curl https://dl.google.com/go/go1.16.4.darwin-amd64.pkg -o /tmp/go.pkg && \
                   sudo installer -pkg /tmp/go.pkg -target /
                   go version
             - run:

bls.go

@@ -1,8 +1,10 @@
-//+build cgo
+//go:build cgo
+// +build cgo
 
 package ffi
 
-// #cgo LDFLAGS: ${SRCDIR}/libfilcrypto.a
+// #cgo linux LDFLAGS: ${SRCDIR}/libfilcrypto.a -Wl,-unresolved-symbols=ignore-all
+// #cgo darwin LDFLAGS: ${SRCDIR}/libfilcrypto.a -Wl,-undefined,dynamic_lookup
 // #cgo pkg-config: ${SRCDIR}/filcrypto.pc
 // #include "./filcrypto.h"
 import "C"

cgo/blockstore.go

@@ -0,0 +1,130 @@
+package cgo
+
+import (
+	"unsafe"
+
+	blocks "github.com/ipfs/go-block-format"
+	"github.com/ipfs/go-cid"
+	blockstore "github.com/ipfs/go-ipfs-blockstore"
+)
+
+/*
+#include <stdint.h>
+typedef const uint8_t* buf_t;
+*/
+import "C"
+
+func toCid(k C.buf_t, kLen C.int32_t) cid.Cid {
+	type cidRepr struct {
+		str string
+	}
+	return *(*cid.Cid)(unsafe.Pointer(&cidRepr{
+		str: C.GoStringN((*C.char)(unsafe.Pointer(k)), kLen),
+	}))
+}
+
+//export cgo_blockstore_get
+func cgo_blockstore_get(handle C.uint64_t, k C.buf_t, kLen C.int32_t, block **C.uint8_t, size *C.int32_t) C.int32_t {
+	c := toCid(k, kLen)
+	externs, ctx := Lookup(uint64(handle))
+	if externs == nil {
+		return ErrInvalidHandle
+	}
+
+	err := externs.View(ctx, c, func(data []byte) error {
+		*block = (C.buf_t)(C.CBytes(data))
+		*size = C.int32_t(len(data))
+		return nil
+	})
+
+	switch err {
+	case nil:
+		return 0
+	case blockstore.ErrNotFound:
+		return ErrNotFound
+	default:
+		return ErrIO
+	}
+}
+
+//export cgo_blockstore_put
+func cgo_blockstore_put(handle C.uint64_t, k C.buf_t, kLen C.int32_t, block C.buf_t, blockLen C.int32_t) C.int32_t {
+	c := toCid(k, kLen)
+	externs, ctx := Lookup(uint64(handle))
+	if externs == nil {
+		return ErrInvalidHandle
+	}
+	b, _ := blocks.NewBlockWithCid(C.GoBytes(unsafe.Pointer(block), blockLen), c)
+	if externs.Put(ctx, b) != nil {
+		return ErrIO
+	}
+	return 0
+}
+
+//export cgo_blockstore_put_many
+func cgo_blockstore_put_many(handle C.uint64_t, lengths *C.int32_t, lengthsLen C.int32_t, blockBuf C.buf_t) C.int32_t {
+	externs, ctx := Lookup(uint64(handle))
+	if externs == nil {
+		return ErrInvalidHandle
+	}
+	// Get a reference to the lengths vector without copying.
+	const MAX_LEN = 1 << 30
+	if lengthsLen > MAX_LEN {
+		return ErrInvalidArgument
+	}
+
+	lengthsGo := (*[MAX_LEN]C.int32_t)(unsafe.Pointer(lengths))[:lengthsLen:lengthsLen]
+	blocksGo := make([]blocks.Block, 0, lengthsLen)
+	for _, length := range lengthsGo {
+		if length > MAX_LEN {
+			return ErrInvalidArgument
+		}
+		// get the next buffer. We could use C.GoBytes, but that copies.
+		buf := (*[MAX_LEN]byte)(unsafe.Pointer(blockBuf))[:length:length]
+
+		// read the CID. This function will copy the CID internally.
+		cidLen, k, err := cid.CidFromBytes(buf)
+		if err != nil {
+			return ErrInvalidArgument
+		}
+		buf = buf[cidLen:]
+
+		// Read the block and copy it. Unfortunately, our blockstore makes no guarantees
+		// about not holding onto blocks.
+		block := make([]byte, len(buf))
+		copy(block, buf)
+		b, _ := blocks.NewBlockWithCid(block, k)
+
+		// Add it to the batch.
+		blocksGo = append(blocksGo, b)
+
+		// Advance the block buffer.
+		blockBuf = (C.buf_t)(unsafe.Pointer(uintptr(unsafe.Pointer(blockBuf)) + uintptr(length)))
+	}
+	if externs.PutMany(ctx, blocksGo) != nil {
+		return ErrIO
+	}
+	return 0
+}
+
+//export cgo_blockstore_has
+func cgo_blockstore_has(handle C.uint64_t, k C.buf_t, kLen C.int32_t) C.int32_t {
+	c := toCid(k, kLen)
+	externs, ctx := Lookup(uint64(handle))
+	if externs == nil {
+		return ErrInvalidHandle
+	}
+	has, err := externs.Has(ctx, c)
+	switch err {
+	case nil:
+	case blockstore.ErrNotFound:
+		// Some old blockstores still return this.
+		return 0
+	default:
+		return ErrIO
+	}
+	if has {
+		return 1
+	}
+	return 0
+}

cgo/errors.go

@@ -0,0 +1,8 @@
+package cgo
+
+const (
+	ErrInvalidHandle = -1 - iota
+	ErrNotFound
+	ErrIO
+	ErrInvalidArgument
+)

cgo/extern.go

@@ -0,0 +1,97 @@
+package cgo
+
+/*
+#include <stdint.h>
+typedef const uint8_t* buf_t;
+*/
+import "C"
+import (
+	"unsafe"
+
+	"github.com/filecoin-project/go-address"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+)
+
+//export cgo_extern_get_chain_randomness
+func cgo_extern_get_chain_randomness(
+	handle C.uint64_t, pers C.int64_t, round C.int64_t,
+	entropy C.buf_t, entropyLen C.int32_t,
+	output C.buf_t,
+) C.int32_t {
+	out := (*[32]byte)(unsafe.Pointer(output))
+	externs, ctx := Lookup(uint64(handle))
+	if externs == nil {
+		return ErrInvalidHandle
+	}
+
+	rand, err := externs.GetChainRandomness(ctx, crypto.DomainSeparationTag(pers), abi.ChainEpoch(round), C.GoBytes(unsafe.Pointer(entropy), entropyLen))
+
+	switch err {
+	case nil:
+		copy(out[:], rand)
+		return 0
+	default:
+		return ErrIO
+	}
+}
+
+//export cgo_extern_get_beacon_randomness
+func cgo_extern_get_beacon_randomness(
+	handle C.uint64_t, pers C.int64_t, round C.int64_t,
+	entropy C.buf_t, entropyLen C.int32_t,
+	output C.buf_t,
+) C.int32_t {
+	out := (*[32]byte)(unsafe.Pointer(output))
+	externs, ctx := Lookup(uint64(handle))
+	if externs == nil {
+		return ErrInvalidHandle
+	}
+
+	rand, err := externs.GetBeaconRandomness(ctx, crypto.DomainSeparationTag(pers), abi.ChainEpoch(round), C.GoBytes(unsafe.Pointer(entropy), entropyLen))
+
+	switch err {
+	case nil:
+		copy(out[:], rand)
+		return 0
+	default:
+		return ErrIO
+	}
+}
+
+//export cgo_extern_verify_consensus_fault
+func cgo_extern_verify_consensus_fault(
+	handle C.uint64_t,
+	h1 C.buf_t, h1Len C.int32_t,
+	h2 C.buf_t, h2Len C.int32_t,
+	extra C.buf_t, extraLen C.int32_t,
+	minerId *C.uint64_t,
+	epoch *C.int64_t,
+	fault *C.int64_t,
+	gasUsed *C.int64_t,
+) C.int32_t {
+	externs, ctx := Lookup(uint64(handle))
+	if externs == nil {
+		return ErrInvalidHandle
+	}
+
+	h1Go := C.GoBytes(unsafe.Pointer(h1), h1Len)
+	h2Go := C.GoBytes(unsafe.Pointer(h2), h2Len)
+	extraGo := C.GoBytes(unsafe.Pointer(extra), extraLen)
+
+	res, gas := externs.VerifyConsensusFault(ctx, h1Go, h2Go, extraGo)
+	*gasUsed = C.int64_t(gas)
+	*fault = C.int64_t(res.Type)
+
+	if res.Type != ConsensusFaultNone {
+		id, err := address.IDFromAddress(res.Target)
+		if err != nil {
+			return ErrIO
+		}
+		*epoch = C.int64_t(res.Epoch)
+		*minerId = C.uint64_t(id)
+	}
+
+	return 0
+}

cgo/interface.go

@@ -0,0 +1,37 @@
+package cgo
+
+import (
+	"context"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+	blockstore "github.com/ipfs/go-ipfs-blockstore"
+)
+
+type ConsensusFault struct {
+	// Address of the miner at fault (always an ID address).
+	Target address.Address
+	// Epoch of the fault, which is the higher epoch of the two blocks causing it.
+	Epoch abi.ChainEpoch
+	// Type of fault.
+	Type ConsensusFaultType
+}
+
+type ConsensusFaultType int64
+
+const (
+	ConsensusFaultNone             ConsensusFaultType = 0
+	ConsensusFaultDoubleForkMining ConsensusFaultType = 1
+	ConsensusFaultParentGrinding   ConsensusFaultType = 2
+	ConsensusFaultTimeOffsetMining ConsensusFaultType = 3
+)
+
+type Externs interface {
+	GetChainRandomness(ctx context.Context, personalization crypto.DomainSeparationTag, epoch abi.ChainEpoch, entropy []byte) ([]byte, error)
+	GetBeaconRandomness(ctx context.Context, personalization crypto.DomainSeparationTag, epoch abi.ChainEpoch, entropy []byte) ([]byte, error)
+	VerifyConsensusFault(ctx context.Context, h1, h2, extra []byte) (*ConsensusFault, int64)
+
+	blockstore.Blockstore
+	blockstore.Viewer
+}

cgo/registry.go

@@ -0,0 +1,49 @@
+package cgo
+
+import (
+	"context"
+	"sync"
+)
+
+var (
+	mu       sync.RWMutex
+	registry map[uint64]registeredExterns
+	nextId   uint64
+)
+
+type registeredExterns struct {
+	context.Context
+	Externs
+}
+
+// Register a new item and get a handle.
+func Register(ctx context.Context, externs Externs) uint64 {
+	mu.Lock()
+	defer mu.Unlock()
+	if registry == nil {
+		registry = make(map[uint64]registeredExterns)
+	}
+	id := nextId
+	nextId++
+	registry[id] = registeredExterns{ctx, externs}
+	return id
+}
+
+// Unregister a blockstore.
+//
+// WARNING: This method must be called at most _once_ with a handle previously returned by Register.
+func Unregister(handle uint64) {
+	mu.Lock()
+	defer mu.Unlock()
+
+	delete(registry, handle)
+}
+
+// Lookup a blockstore by handle.
+func Lookup(handle uint64) (Externs, context.Context) {
+	mu.RLock()
+	externs := registry[handle]
+	mu.RUnlock()
+
+	return externs.Externs, externs.Context
+}