Import from github.com/allinbits/gno@aib/feat/ibc

Setup the required forked gno with:
gnolang/gno#4868
tbruyelle/gno#1

Author: tbruyelle

Makefile

@@ -0,0 +1,16 @@
+
+ifdef GNOROOT
+	# If GNOROOT is already user defined, we need to override it with the
+	# GNOROOT of the fork.
+	# This is not required otherwise because the GNOROOT that originated the
+	# binary is stored in a build flag.
+	# (see -X github.com/gnolang/gno/gnovm/pkg/gnoenv._GNOROOT)
+	GNOROOT = $(shell go list -f '{{.Module.Dir}}' github.com/gnolang/gno)
+endif
+
+gnodev:
+	go tool gnodev -resolver root=. \
+		-resolver root=$(shell go tool gno env GNOROOT)/examples
+
+test: 
+	go tool gno test -v ./gno.land/...

gno.land/p/aib/encoding/encoding.gno

@@ -0,0 +1,21 @@
+package encoding
+
+import "encoding/binary"
+
+// Uint64ToBigEndian - marshals uint64 to a bigendian byte slice so it can be
+// sorted
+func Uint64ToBigEndian(i uint64) []byte {
+	b := make([]byte, 8)
+	binary.BigEndian.PutUint64(b, i)
+	return b
+}
+
+// BigEndianToUint64 returns an uint64 from big endian encoded bytes. If
+// encoding is empty, zero is returned.
+func BigEndianToUint64(bz []byte) uint64 {
+	if len(bz) == 0 {
+		return 0
+	}
+
+	return binary.BigEndian.Uint64(bz)
+}

gno.land/p/aib/encoding/gnomod.toml

@@ -0,0 +1,2 @@
+module = "gno.land/p/aib/encoding"
+gno = "0.9"

gno.land/p/aib/encoding/proto/gnomod.toml

@@ -0,0 +1,2 @@
+module = "gno.land/p/aib/encoding/proto"
+gno = "0.9"

gno.land/p/aib/encoding/proto/proto.gno

@@ -0,0 +1,103 @@
+package proto
+
+import (
+	"encoding/binary"
+	"time"
+
+	"gno.land/p/nt/ufmt"
+)
+
+type WireType int
+
+const (
+	VARINT  WireType = 0 //	int32, int64, uint32, uint64, sint32, sint64, bool, enum
+	FIXED64 WireType = 1 // fixed64, sfixed64, double
+	LEN     WireType = 2 // string, bytes, embedded messages, packed repeated fields
+	FIXED32 WireType = 5 //	fixed32, sfixed32, float
+)
+
+// AppendVarint appends a varint field.
+func AppendVarint(buf []byte, fieldNum int, v uint64) []byte {
+	if v == 0 {
+		return buf
+	}
+	buf = AppendTag(buf, fieldNum, VARINT)
+	return binary.AppendUvarint(buf, v)
+}
+
+// AppendFixed64 appends a fixed 64-bit field.
+func AppendFixed64(buf []byte, fieldNum int, v uint64) []byte {
+	if v == 0 {
+		return buf
+	}
+	buf = AppendTag(buf, fieldNum, FIXED64)
+	var b [8]byte
+	binary.LittleEndian.PutUint64(b[:], v)
+	return append(buf, b[:]...)
+}
+
+// AppendLengthDelimited appends a length-delimited field.
+func AppendLengthDelimited(buf []byte, fieldNum int, bz []byte) []byte {
+	if len(bz) == 0 {
+		return buf
+	}
+	buf = AppendTag(buf, fieldNum, LEN)
+	buf = binary.AppendUvarint(buf, uint64(len(bz)))
+	return append(buf, bz...)
+}
+
+// AppendTime appends a google.protobuf.Timestamp field.
+func AppendTime(buf []byte, fieldNum int, t time.Time) []byte {
+	var (
+		_buf    []byte
+		seconds = t.Unix()
+		nanos   = int32(t.Nanosecond())
+	)
+	// Field 1: seconds (int64 - varint)
+	_buf = AppendVarint(_buf, 1, uint64(seconds))
+	// Field 2: nanos (int32 - varint)
+	_buf = AppendVarint(_buf, 2, uint64(nanos))
+
+	return AppendLengthDelimited(buf, fieldNum, _buf)
+}
+
+// AppendTag appends a protobuf tag (field number and wire type)
+func AppendTag(buf []byte, fieldNum int, wireType WireType) []byte {
+	tag := (fieldNum << 3) | int(wireType)
+	return binary.AppendUvarint(buf, uint64(tag))
+}
+
+// DecodeVarint reads a varint from the byte slice and returns the value and new position
+func DecodeVarint(buf []byte, pos int) (uint64, int, error) {
+	var result uint64
+	var shift uint
+	for {
+		if pos >= len(buf) {
+			return 0, pos, ufmt.Errorf("buffer underflow while reading varint")
+		}
+		b := buf[pos]
+		pos++
+		result |= uint64(b&0x7F) << shift
+		if b&0x80 == 0 {
+			break
+		}
+		shift += 7
+	}
+	return result, pos, nil
+}
+
+// DecodeString reads a string (length-prefixed) from the byte slice
+func DecodeString(buf []byte, pos int) (string, int, error) {
+	length, newPos, err := DecodeVarint(buf, pos)
+	if err != nil {
+		return "", newPos, err
+	}
+	pos = newPos
+
+	if pos+int(length) > len(buf) {
+		return "", pos, ufmt.Errorf("buffer underflow while reading string")
+	}
+
+	str := string(buf[pos : pos+int(length)])
+	return str, pos + int(length), nil
+}

gno.land/p/aib/ibc/app/app.gno

@@ -0,0 +1,48 @@
+package app
+
+import (
+	"chain/banker"
+
+	"gno.land/p/aib/ibc/types"
+)
+
+// IBCApp defines an interface that implements all the callbacks that apps must
+// define as specified in IBC Protocol V2.
+type IBCApp interface {
+	// OnSendPacket is executed when a packet is being sent from sending chain.
+	// This callback is provided with the source and destination IDs, the signer,
+	// the packet sequence and the packet data for this specific application.
+	OnSendPacket(
+		banker banker.Banker,
+		sourceClient string,
+		destinationClient string,
+		sequence uint64,
+		payload types.Payload,
+	) error
+
+	// OnRecvPacket is executed when a packet is received from receiving chain.
+	OnRecvPacket(
+		sourceClient string,
+		destinationClient string,
+		sequence uint64,
+		payload types.Payload,
+	) types.RecvPacketResult
+
+	// OnTimeoutPacket is executed when a packet has timed out on the receiving
+	// chain.
+	OnTimeoutPacket(
+		sourceClient string,
+		destinationClient string,
+		sequence uint64,
+		payload types.Payload,
+	) error
+
+	// OnAcknowledgementPacket is executed when a packet gets acknowledged.
+	OnAcknowledgementPacket(
+		sourceClient string,
+		destinationClient string,
+		sequence uint64,
+		acknowledgement []byte,
+		payload types.Payload,
+	) error
+}

gno.land/p/aib/ibc/app/gnomod.toml

@@ -0,0 +1,2 @@
+module = "gno.land/p/aib/ibc/app"
+gno = "0.9"

gno.land/p/aib/ibc/host/gnomod.toml

@@ -0,0 +1,2 @@
+module = "gno.land/p/aib/ibc/host"
+gno = "0.9"

gno.land/p/aib/ibc/host/packet_key.gno

@@ -0,0 +1,57 @@
+package host
+
+import "gno.land/p/aib/encoding"
+
+const (
+	PacketCommitmentBasePrefix      = byte(1)
+	PacketReceiptBasePrefix         = byte(2)
+	PacketAcknowledgementBasePrefix = byte(3)
+)
+
+// PacketCommitmentPrefixKey returns the store key prefix under which packet
+// commitments for a particular client are stored.
+// clientID must be a generated identifier, not provided externally so key
+// collisions are not possible.
+func PacketCommitmentPrefixKey(clientID string) []byte {
+	return append([]byte(clientID), PacketCommitmentBasePrefix)
+}
+
+// PacketCommitmentKey returns the store key of under which a packet commitment
+// is stored.
+// clientID must be a generated identifier, not provided externally so key
+// collisions are not possible.
+func PacketCommitmentKey(clientID string, sequence uint64) []byte {
+	return append(PacketCommitmentPrefixKey(clientID), encoding.Uint64ToBigEndian(sequence)...)
+}
+
+// PacketReceiptPrefixKey returns the store key prefix under which packet
+// receipts for a particular channel are stored.
+// clientID must be a generated identifier, not provided externally so key
+// collisions are not possible.
+func PacketReceiptPrefixKey(clientID string) []byte {
+	return append([]byte(clientID), PacketReceiptBasePrefix)
+}
+
+// PacketReceiptKey returns the store key of under which a packet receipt is
+// stored.
+// clientID must be a generated identifier, not provided externally so key
+// collisions are not possible.
+func PacketReceiptKey(clientID string, sequence uint64) []byte {
+	return append(PacketReceiptPrefixKey(clientID), encoding.Uint64ToBigEndian(sequence)...)
+}
+
+// PacketAcknowledgementPrefixKey returns the store key prefix under which
+// packet acknowledgements for a particular channel are stored.  clientID must
+// be a generated identifier, not provided externally so key collisions are not
+// possible.
+func PacketAcknowledgementPrefixKey(clientID string) []byte {
+	return append([]byte(clientID), PacketAcknowledgementBasePrefix)
+}
+
+// PacketAcknowledgementKey returns the store key of under which a packet
+// acknowledgement is stored.
+// clientID must be a generated identifier, not provided externally so key
+// collisions are not possible.
+func PacketAcknowledgementKey(clientID string, sequence uint64) []byte {
+	return append(PacketAcknowledgementPrefixKey(clientID), encoding.Uint64ToBigEndian(sequence)...)
+}

gno.land/p/aib/ibc/host/packet_key_test.gno

@@ -0,0 +1,33 @@
+package host_test
+
+import (
+	"encoding/hex"
+	"testing"
+
+	"gno.land/p/aib/ibc/host"
+	"gno.land/p/nt/urequire"
+)
+
+// TestPacketCommitmentKey is primarily used to document the expected key output
+// so that other implementations (such as the IBC Solidity) can replicate the
+// same key output. But it is also useful to catch any changes in the keys.
+func TestPacketCommitmentKey(t *testing.T) {
+	actual := hex.EncodeToString(host.PacketCommitmentKey("channel-0", 1))
+	urequire.Equal(t, "6368616e6e656c2d30010000000000000001", actual)
+}
+
+// TestPacketReceiptKey is primarily used to document the expected key output
+// so that other implementations (such as the IBC Solidity) can replicate the
+// same key output. But it is also useful to catch any changes in the keys.
+func TestPacketReceiptKey(t *testing.T) {
+	actual := hex.EncodeToString(host.PacketReceiptKey("channel-0", 1))
+	urequire.Equal(t, "6368616e6e656c2d30020000000000000001", actual)
+}
+
+// TestPacketAcknowledgementKey is primarily used to document the expected key output
+// so that other implementations (such as the IBC Solidity) can replicate the
+// same key output. But it is also useful to catch any changes in the keys.
+func TestPacketAcknowledgementKey(t *testing.T) {
+	actual := hex.EncodeToString(host.PacketAcknowledgementKey("channel-0", 1))
+	urequire.Equal(t, "6368616e6e656c2d30030000000000000001", actual)
+}