feat: standard non-evm inbound memo

changelog.md

@@ -18,6 +18,7 @@
 * [2919](https://github.com/zeta-chain/node/pull/2919) - add inbound sender to revert context
 * [2957](https://github.com/zeta-chain/node/pull/2957) - enable Bitcoin inscription support on testnet
 * [2896](https://github.com/zeta-chain/node/pull/2896) - add TON inbound observation
+* [2987](https://github.com/zeta-chain/node/pull/2987) - add non-EVM standard inbound memo package
 
 ### Refactor
 

go.mod

@@ -336,6 +336,7 @@ require (
 require (
  github.com/bnb-chain/tss-lib v1.5.0
  github.com/showa-93/go-mask v0.6.2
+ github.com/test-go/testify v1.1.4
  github.com/tonkeeper/tongo v1.9.3
 )
 

pkg/math/bits.go

@@ -0,0 +1,52 @@
+package math
+
+import (
+ "math/bits"
+)
+
+// SetBit sets the bit at the given position (0-7) in the byte to 1
+func SetBit(b *byte, position uint8) {
+ if position > 7 {
+ return
+ }
+ *b |= 1 << position
+}
+
+// IsBitSet returns true if the bit at the given position (0-7) is set in the byte, false otherwise
+func IsBitSet(b byte, position uint8) bool {
+ if position > 7 {
+ return false
+ }
+ bitMask := byte(1 << position)
+ return b&bitMask != 0
+}
+
+// GetBits extracts the value of bits for a given mask
+//
+// Example: given b = 0b11011001 and mask = 0b11100000, the function returns 0b110
+func GetBits(b byte, mask byte) byte {
+ extracted := b & mask
+
+ // get the number of trailing zero bits
+ trailingZeros := bits.TrailingZeros8(mask)
+
+ // remove trailing zeros
+ return extracted >> trailingZeros
+}
+
+// SetBits sets the value to the bits specified in the mask
+//
+// Example: given b = 0b00100001 and mask = 0b11100000, and value = 0b110, the function returns 0b11000001
+func SetBits(b byte, mask byte, value byte) byte {
+ // get the number of trailing zero bits in the mask
+ trailingZeros := bits.TrailingZeros8(mask)
+
+ // shift the value left by the number of trailing zeros
+ valueShifted := value << trailingZeros
+
+ // clear the bits in 'b' that correspond to the mask
+ bCleared := b &^ mask
+
+ // Set the bits by ORing the cleared 'b' with the shifted value
+ return bCleared | valueShifted
+}

pkg/math/bits_test.go

@@ -0,0 +1,171 @@
+package math_test
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+ "github.com/zeta-chain/node/pkg/math"
+)
+
+func TestSetBit(t *testing.T) {
+ tests := []struct {
+ name string
+ initial byte
+ position uint8
+ expected byte
+ }{
+ {
+ name: "set bit at position 0",
+ initial: 0b00001000,
+ position: 0,
+ expected: 0b00001001,
+ },
+ {
+ name: "set bit at position 7",
+ initial: 0b00001000,
+ position: 7,
+ expected: 0b10001000,
+ },
+ {
+ name: "out of range bit position (no effect)",
+ initial: 0b00000000,
+ position: 8, // Out of range
+ expected: 0b00000000,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ b := tt.initial
+ math.SetBit(&b, tt.position)
+ require.Equal(t, tt.expected, b)
+ })
+ }
+}
+
+func TestIsBitSet(t *testing.T) {
+ tests := []struct {
+ name string
+ b byte
+ position uint8
+ expected bool
+ }{
+ {
+ name: "bit 0 set",
+ b: 0b00000001,
+ position: 0,
+ expected: true,
+ },
+ {
+ name: "bit 7 set",
+ b: 0b10000000,
+ position: 7,
+ expected: true,
+ },
+ {
+ name: "bit 2 not set",
+ b: 0b00000001,
+ position: 2,
+ expected: false,
+ },
+ {
+ name: "bit out of range",
+ b: 0b00000001,
+ position: 8, // Position out of range
+ expected: false,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ result := math.IsBitSet(tt.b, tt.position)
+ require.Equal(t, tt.expected, result)
+ })
+ }
+}
+
+func TestGetBits(t *testing.T) {
+ tests := []struct {
+ name string
+ b byte
+ mask byte
+ expected byte
+ }{
+ {
+ name: "extract upper 3 bits",
+ b: 0b11011001,
+ mask: 0b11100000,
+ expected: 0b110,
+ },
+ {
+ name: "extract middle 3 bits",
+ b: 0b11011001,
+ mask: 0b00011100,
+ expected: 0b110,
+ },
+ {
+ name: "extract lower 3 bits",
+ b: 0b11011001,
+ mask: 0b00000111,
+ expected: 0b001,
+ },
+ {
+ name: "extract no bits",
+ b: 0b11011001,
+ mask: 0b00000000,
+ expected: 0b000,
+ },
+ {
+ name: "extract all bits",
+ b: 0b11111111,
+ mask: 0b11111111,
+ expected: 0b11111111,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ result := math.GetBits(tt.b, tt.mask)
+ require.Equal(t, tt.expected, result)
+ })
+ }
+}
+
+func TestSetBits(t *testing.T) {
+ tests := []struct {
+ name string
+ b byte
+ mask byte
+ value byte
+ expected byte
+ }{
+ {
+ name: "set upper 3 bits",
+ b: 0b00100001,
+ mask: 0b11100000,
+ value: 0b110,
+ expected: 0b11000001,
+ },
+ {
+ name: "set middle 3 bits",
+ b: 0b00100001,
+ mask: 0b00011100,
+ value: 0b101,
+ expected: 0b00110101,
+ },
+ {
+ name: "set lower 3 bits",
+ b: 0b11111100,
+ mask: 0b00000111,
+ value: 0b101,
+ expected: 0b11111101,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ result := math.SetBits(tt.b, tt.mask, tt.value)
+ require.Equal(t, tt.expected, result)
+ })
+ }
+}

pkg/memo/arg.go

@@ -0,0 +1,52 @@
+package memo
+
+// ArgType is the enum for types supported by the codec
+type ArgType string
+
+// Define all the types supported by the codec
+const (
+ ArgTypeBytes ArgType = "bytes"
+ ArgTypeString ArgType = "string"
+ ArgTypeAddress ArgType = "address"
+)
+
+// CodecArg represents a codec argument
+type CodecArg struct {
+ Name string
+ Type ArgType
+ Arg interface{}
+}
+
+// NewArg create a new codec argument
+func NewArg(name string, argType ArgType, arg interface{}) CodecArg {
+ return CodecArg{
+ Name: name,
+ Type: argType,
+ Arg: arg,
+ }
+}
+
+// ArgReceiver wraps the receiver address in a CodecArg
+func ArgReceiver(arg interface{}) CodecArg {
+ return NewArg("receiver", ArgTypeAddress, arg)
+}
+
+// ArgPayload wraps the payload in a CodecArg
+func ArgPayload(arg interface{}) CodecArg {
+ return NewArg("payload", ArgTypeBytes, arg)
+}
+
+// ArgRevertAddress wraps the revert address in a CodecArg
+func ArgRevertAddress(arg interface{}) CodecArg {
+ return NewArg("revertAddress", ArgTypeString, arg)
+}
+
+// ArgAbortAddress wraps the abort address in a CodecArg
+func ArgAbortAddress(arg interface{}) CodecArg {
+ return NewArg("abortAddress", ArgTypeAddress, arg)
+}
+
+// ArgRevertMessage wraps the revert message in a CodecArg
+func ArgRevertMessage(arg interface{}) CodecArg {
+ return NewArg("revertMessage", ArgTypeBytes, arg)
+}

pkg/memo/arg_test.go

@@ -0,0 +1,70 @@
+package memo_test
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+ "github.com/zeta-chain/node/pkg/memo"
+ "github.com/zeta-chain/node/testutil/sample"
+)
+
+func Test_NewArg(t *testing.T) {
+ argAddress := sample.EthAddress()
+ argString := sample.String()
+ argBytes := sample.Bytes()
+
+ tests := []struct {
+ name string
+ argType string
+ arg interface{}
+ }{
+ {
+ name: "receiver",
+ argType: "address",
+ arg: &argAddress,
+ },
+ {
+ name: "payload",
+ argType: "bytes",
+ arg: &argBytes,
+ },
+ {
+ name: "revertAddress",
+ argType: "string",
+ arg: &argString,
+ },
+ {
+ name: "abortAddress",
+ argType: "address",
+ arg: &argAddress,
+ },
+ {
+ name: "revertMessage",
+ argType: "bytes",
+ arg: &argBytes,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ arg := memo.NewArg(tt.name, memo.ArgType(tt.argType), tt.arg)
+
+ require.Equal(t, tt.name, arg.Name)
+ require.Equal(t, memo.ArgType(tt.argType), arg.Type)
+ require.Equal(t, tt.arg, arg.Arg)
+
+ switch tt.name {
+ case "receiver":
+ require.Equal(t, arg, memo.ArgReceiver(&argAddress))
+ case "payload":
+ require.Equal(t, arg, memo.ArgPayload(&argBytes))
+ case "revertAddress":
+ require.Equal(t, arg, memo.ArgRevertAddress(&argString))
+ case "abortAddress":
+ require.Equal(t, arg, memo.ArgAbortAddress(&argAddress))
+ case "revertMessage":
+ require.Equal(t, arg, memo.ArgRevertMessage(&argBytes))
+ }
+ })
+ }
+}