@agoric/cosmos 0.35.0-u18.4 → 0.35.0-u18a.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/cosmos",
-  "version": "0.35.0-u18.4",
+  "version": "0.35.0-u18a.0",
   "description": "Connect JS to the Cosmos blockchain SDK",
   "parsers": {
     "js": "mjs"
@@ -39,5 +39,5 @@
   "typeCoverage": {
     "atLeast": 0
   },
-  "gitHead": "ff46c4aacd7b01ce8ea1fa14b77c187efa9a3b7f"
+  "gitHead": "4e4d2b4dedc5a268178712fc6beb89496518480a"
 }

package/proto/agoric/swingset/swingset.proto

@@ -82,6 +82,18 @@ message Params {
     repeated QueueSize queue_max = 5 [
       (gogoproto.nullable) = false
     ];
+
+    // Vat cleanup budget values.
+    // These values are used by SwingSet to control the pace of removing data
+    // associated with a terminated vat as described at
+    // https://github.com/Agoric/agoric-sdk/blob/master/packages/SwingSet/docs/run-policy.md#terminated-vat-cleanup
+    //
+    // There is no required order to this list of entries, but all the chain
+    // nodes must all serialize and deserialize the existing order without
+    // permuting it.
+    repeated UintMapEntry vat_cleanup_budget = 6 [
+      (gogoproto.nullable) = false
+    ];
 }
 
 // The current state of the module.
@@ -119,6 +131,7 @@ message PowerFlagFee {
 }
 
 // Map element of a string key to a size.
+// TODO: Replace with UintMapEntry?
 message QueueSize {
   option (gogoproto.equal) = true;
 
@@ -129,6 +142,18 @@ message QueueSize {
   int32 size = 2;
 }
 
+// Map element of a string key to an unsigned integer.
+// The value uses cosmos-sdk Uint rather than a native Go type to ensure that
+// zeroes survive "omitempty" JSON serialization.
+message UintMapEntry {
+  option (gogoproto.equal) = true;
+  string key = 1;
+  string value = 2 [
+    (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Uint",
+    (gogoproto.nullable) = false
+  ];
+}
+
 // Egress is the format for a swingset egress.
 message Egress {
     option (gogoproto.equal) = false;

package/proto/agoric/vbank/vbank.proto

@@ -33,6 +33,13 @@ message Params {
     int64 reward_smoothing_blocks = 3 [
       (gogoproto.moretags) = "yaml:\"reward_smoothing_blocks\""
     ];
+
+    // allowed_monitoring_accounts is an array of account addresses that can be
+    // monitored for sends and receives.  An element of `"*"` will permit any
+    // address.
+    repeated string allowed_monitoring_accounts = 4 [
+      (gogoproto.moretags) = "yaml:\"allowed_monitoring_accounts\""
+    ];
 }
 
 // The current state of the module.

package/types/address_hooks.go

@@ -0,0 +1,242 @@
+package types
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/types/bech32"
+
+	transfertypes "github.com/cosmos/ibc-go/v6/modules/apps/transfer/types"
+	clienttypes "github.com/cosmos/ibc-go/v6/modules/core/02-client/types"
+	channeltypes "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
+	ibcexported "github.com/cosmos/ibc-go/v6/modules/core/exported"
+)
+
+type AddressRole string
+type PacketOrigin string
+
+const (
+	RoleSender   AddressRole = "Sender"
+	RoleReceiver AddressRole = "Receiver"
+
+	PacketSrc PacketOrigin = "src"
+	PacketDst PacketOrigin = "dst"
+
+	AddressHookVersion     = 0
+	BaseAddressLengthBytes = 2
+)
+
+// AddressHookBytePrefix is a magic prefix that identifies a hooked address.
+// Chosen to make bech32 address hooks that look like "agoric10rch..."
+var AddressHookBytePrefix = []byte{0x78, 0xf1, 0x70 /* | AddressHookVersion */}
+
+func init() {
+	if AddressHookVersion&0x0f != AddressHookVersion {
+		panic(fmt.Sprintf("AddressHookVersion must be less than 0x10, got 0x%x", AddressHookVersion))
+	}
+}
+
+// ExtractBaseAddress extracts the base address from an Address Hook.  It
+// returns addr verbatim if it is not an Address Hook.
+func ExtractBaseAddress(addr string) (string, error) {
+	baseAddr, _, err := SplitHookedAddress(addr)
+	if err != nil {
+		return "", err
+	}
+	return baseAddr, nil
+}
+
+// SplitHookedAddress splits a hooked address into its base address and hook data.
+// For the JS implementation, look at @agoric/cosmic-proto/src/address-hooks.js.
+func SplitHookedAddress(addr string) (string, []byte, error) {
+	prefix, payload, err := bech32.DecodeAndConvert(addr)
+	if err != nil {
+		return "", []byte{}, err
+	}
+
+	lastPrefixHighNibble := AddressHookBytePrefix[len(AddressHookBytePrefix)-1]
+	bz := bytes.TrimPrefix(payload, AddressHookBytePrefix[:len(AddressHookBytePrefix)-1])
+	if len(bz) == len(payload) || len(bz) == 0 || bz[0]&0xf0 != lastPrefixHighNibble {
+		// Return an unhooked address.
+		return addr, []byte{}, nil
+	}
+
+	version := bz[0] & 0x0f
+	bz = bz[1:]
+	if version != AddressHookVersion {
+		return "", []byte{}, fmt.Errorf("unsupported address hook version %d", version)
+	}
+
+	if len(bz) < BaseAddressLengthBytes {
+		return "", []byte{}, fmt.Errorf("hooked address must have at least %d bytes", BaseAddressLengthBytes)
+	}
+
+	b := 0
+	for i := BaseAddressLengthBytes - 1; i >= 0; i -= 1 {
+		byteVal := bz[len(bz)-1-i]
+		b <<= 8
+		b |= int(byteVal)
+	}
+
+	payloadEnd := len(bz) - BaseAddressLengthBytes
+	if b > payloadEnd {
+		return "", []byte{}, fmt.Errorf("base address length 0x%x is longer than payload end 0x%x", b, payloadEnd)
+	}
+
+	baseAddressBuf := bz[0:b]
+	baseAddress, err := bech32.ConvertAndEncode(prefix, baseAddressBuf)
+	if err != nil {
+		return "", []byte{}, err
+	}
+
+	return baseAddress, bz[b:payloadEnd], nil
+}
+
+// JoinHookedAddress joins a base bech32 address with hook data to create a
+// hooked bech32 address.
+// For the JS implementation, look at @agoric/cosmic-proto/src/address-hooks.js
+func JoinHookedAddress(baseAddr string, hookData []byte) (string, error) {
+	prefix, bz, err := bech32.DecodeAndConvert(baseAddr)
+	if err != nil {
+		return "", err
+	}
+
+	b := len(bz)
+	maxB := 1<<(8*BaseAddressLengthBytes-1) + 1
+	if b > maxB {
+		return "", fmt.Errorf("base address length 0x%x is longer than the maximum 0x%x", b, maxB)
+	}
+
+	payload := make([]byte, 0, len(AddressHookBytePrefix)+b+len(hookData)+BaseAddressLengthBytes)
+	payload = append(payload, AddressHookBytePrefix...)
+	payload[len(payload)-1] |= byte(AddressHookVersion)
+	payload = append(payload, bz...)
+	payload = append(payload, hookData...)
+	baLen := make([]byte, BaseAddressLengthBytes)
+	for i := BaseAddressLengthBytes - 1; i >= 0; i -= 1 {
+		baLen[i] = byte(b)
+		b >>= 8
+	}
+	payload = append(payload, baLen...)
+
+	return bech32.ConvertAndEncode(prefix, payload)
+}
+
+// extractBaseTransferData returns the base address from the transferData.Sender
+// (if RoleSender) or transferData.Receiver (if RoleReceiver). Errors in
+// determining the base address are ignored... we then assume the base address
+// is exactly the original address.  If newTransferData is not nil, it will be
+// populated with a new FungibleTokenPacketData consisting of the role replaced
+// with its base address.
+func extractBaseTransferData(transferData transfertypes.FungibleTokenPacketData, role AddressRole, newTransferData *transfertypes.FungibleTokenPacketData) (string, error) {
+	var target string
+	sender := transferData.Sender
+	receiver := transferData.Receiver
+
+	switch role {
+	case RoleSender:
+		baseSender, err := ExtractBaseAddress(sender)
+		if err == nil {
+			sender = baseSender
+		}
+		target = sender
+
+	case RoleReceiver:
+		baseReceiver, err := ExtractBaseAddress(receiver)
+		if err == nil {
+			receiver = baseReceiver
+		}
+		target = receiver
+
+	default:
+		err := fmt.Errorf("invalid address role: %s", role)
+		return target, err
+	}
+
+	if newTransferData == nil {
+		return target, nil
+	}
+
+	// Create the new transfer data.
+	*newTransferData = transfertypes.NewFungibleTokenPacketData(
+		transferData.Denom,
+		transferData.Amount,
+		sender, receiver,
+		transferData.Memo,
+	)
+
+	return target, nil
+}
+
+// ExtractBaseAddressFromPacket returns the base address from a transfer
+// packet's data, either Sender (if role is RoleSender) or Receiver (if role is
+// RoleReceiver).
+// Errors in determining the base address are ignored... we then assume the base
+// address is exactly the original address.
+// If newPacket is not nil, it is populated with a new transfer packet whose
+// corresponding Sender or Receiver is replaced with the extracted base address.
+func ExtractBaseAddressFromPacket(cdc codec.Codec, packet ibcexported.PacketI, role AddressRole, newPacket *channeltypes.Packet) (string, error) {
+	var newDataP *[]byte
+	if newPacket != nil {
+		// Capture the data for the new packet.
+		newDataP = new([]byte)
+	}
+	target, err := ExtractBaseAddressFromData(cdc, packet.GetData(), role, newDataP)
+	if err != nil {
+		return target, err
+	}
+
+	if newPacket == nil {
+		return target, nil
+	}
+
+	// Create a new packet with the new transfer packet data.
+	*newPacket = channeltypes.NewPacket(
+		*newDataP, packet.GetSequence(),
+		packet.GetSourcePort(), packet.GetSourceChannel(),
+		packet.GetDestPort(), packet.GetDestChannel(),
+		clienttypes.MustParseHeight(packet.GetTimeoutHeight().String()),
+		packet.GetTimeoutTimestamp(),
+	)
+
+	return target, nil
+}
+
+// ExtractBaseAddressFromData returns the base address from a transfer packet's data,
+// either Sender (if role is RoleSender) or Receiver (if role is RoleReceiver).
+// Errors in determining the base address are ignored... we then assume the base
+// address is exactly the original address.
+// If newDataP is not nil, it is populated with new transfer packet data whose
+// corresponding Sender or Receiver is replaced with the extracted base address.
+func ExtractBaseAddressFromData(cdc codec.Codec, data []byte, role AddressRole, newDataP *[]byte) (string, error) {
+	transferData := transfertypes.FungibleTokenPacketData{}
+
+	if err := cdc.UnmarshalJSON(data, &transferData); err != nil {
+		return "", err
+	}
+
+	var newTransferData *transfertypes.FungibleTokenPacketData
+	if newDataP != nil {
+		// Capture the transfer data for the new packet data.
+		newTransferData = &transfertypes.FungibleTokenPacketData{}
+	}
+	target, err := extractBaseTransferData(transferData, role, newTransferData)
+	if err != nil {
+		return target, err
+	}
+
+	if newDataP == nil {
+		return target, nil
+	}
+
+	// Reuse the original data if we didn't transform it.
+	if transferData == *newTransferData {
+		*newDataP = bytes.Clone(data)
+	} else {
+		// Re-serialize the packet data with the new base address.
+		*newDataP = newTransferData.GetBytes()
+	}
+
+	return target, nil
+}

package/types/address_hooks_test.go

@@ -0,0 +1,221 @@
+package types_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	codec "github.com/cosmos/cosmos-sdk/codec"
+	cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
+
+	transfertypes "github.com/cosmos/ibc-go/v6/modules/apps/transfer/types"
+	clienttypes "github.com/cosmos/ibc-go/v6/modules/core/02-client/types"
+	channeltypes "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/types"
+)
+
+func TestSplitHookedAddress(t *testing.T) {
+	cases := []struct {
+		name     string
+		hook     string
+		baseAddr string
+		hookData []byte
+		err      string
+	}{
+		{"empty", "", "", []byte{}, "decoding bech32 failed: invalid bech32 string length 0"},
+		{"no hook", "agoric1qqp0e5ys", "agoric1qqp0e5ys", []byte{}, ""},
+		{"Fast USDC", "agoric10rchp4vc53apxn32q42c3zryml8xq3xshyzuhjk6405wtxy7tl3d7e0f8az423padaek6me38qekget2vdhx66mtvy6kg7nrw5uhsaekd4uhwufswqex6dtsv44hxv3cd4jkuqpqvduyhf",
+			"agoric16kv2g7snfc4q24vg3pjdlnnqgngtjpwtetd2h689nz09lcklvh5s8u37ek",
+			[]byte("?EUD=osmo183dejcnmkka5dzcu9xw6mywq0p2m5peks28men"),
+			""},
+		{"version 0",
+			"agoric10rchqqqpqgpsgpgxquyqjzstpsxsurcszyfpxpqrqgqsq9qx0p9wp",
+			"agoric1qqqsyqcyq5rqwzqfpg9scrgwpugpzysn3tn9p0",
+			[]byte{4, 3, 2, 1},
+			""},
+		{"version 1 reject",
+			"agoric10rchzqqpqgpsgpgxquyqjzstpsxsurcszyfpxpqrqgqsq9q04n2fg",
+			"",
+			[]byte{},
+			"unsupported address hook version 1"},
+		{"version 15 reject",
+			"agoric10rch7qqpqgpsgpgxquyqjzstpsxsurcszyfpxpqrqgqsq9q25ez2d",
+			"",
+			[]byte{},
+			"unsupported address hook version 15"},
+	}
+
+	for _, tc := range cases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			baseAddr, hookData, err := types.SplitHookedAddress(tc.hook)
+			if len(tc.err) > 0 {
+				require.Error(t, err)
+				require.Equal(t, tc.err, err.Error())
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tc.baseAddr, baseAddr)
+				require.Equal(t, string(tc.hookData), string(hookData))
+			}
+		})
+	}
+}
+
+func TestExtractBaseAddress(t *testing.T) {
+	bases := []struct {
+		name string
+		addr string
+	}{
+		{"agoric address", "agoric1qqp0e5ys"},
+		{"cosmos address", "cosmos1qqxuevtt"},
+	}
+
+	suffixes := []struct {
+		hookStr     string
+		baseIsWrong bool
+		isErr       bool
+	}{
+		{"", false, false},
+		{"/", false, false},
+		{"/sub/account", false, false},
+		{"?query=something&k=v&k2=v2", false, false},
+		{"?query=something&k=v&k2=v2#fragment", false, false},
+		{"unexpected", false, false},
+		{"\x01", false, false},
+	}
+
+	for _, b := range bases {
+		b := b
+		for _, s := range suffixes {
+			s := s
+			t.Run(b.name+" "+s.hookStr, func(t *testing.T) {
+				addrHook, err := types.JoinHookedAddress(b.addr, []byte(s.hookStr))
+				require.NoError(t, err)
+				addr, err := types.ExtractBaseAddress(addrHook)
+				if s.isErr {
+					require.Error(t, err)
+				} else {
+					require.NoError(t, err)
+					if s.baseIsWrong {
+						require.NotEqual(t, b.addr, addr)
+					} else {
+						require.Equal(t, b.addr, addr)
+						addr, hookData, err := types.SplitHookedAddress(addrHook)
+						require.NoError(t, err)
+						require.Equal(t, b.addr, addr)
+						require.Equal(t, s.hookStr, string(hookData))
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestExtractBaseAddressFromPacket(t *testing.T) {
+	ir := cdctypes.NewInterfaceRegistry()
+	cdc := codec.NewProtoCodec(ir)
+	transfertypes.RegisterInterfaces(ir)
+	channeltypes.RegisterInterfaces(ir)
+	clienttypes.RegisterInterfaces(ir)
+
+	cosmosAddr := "cosmos1qqxuevtt"
+	cosmosHookStr := "?foo=bar&baz=bot#fragment"
+	cosmosHook, err := types.JoinHookedAddress(cosmosAddr, []byte(cosmosHookStr))
+	require.NoError(t, err)
+	addr, hookData, err := types.SplitHookedAddress(cosmosHook)
+	require.NoError(t, err)
+	require.Equal(t, cosmosAddr, addr)
+	require.Equal(t, cosmosHookStr, string(hookData))
+
+	agoricAddr := "agoric1qqp0e5ys"
+	agoricHookStr := "?bingo=again"
+	agoricHook, err := types.JoinHookedAddress(agoricAddr, []byte(agoricHookStr))
+	require.NoError(t, err)
+	addr, hookData, err = types.SplitHookedAddress(agoricHook)
+	require.NoError(t, err)
+	require.Equal(t, agoricAddr, addr)
+	require.Equal(t, agoricHookStr, string(hookData))
+
+	cases := []struct {
+		name  string
+		addrs map[types.AddressRole]struct{ addr, baseAddr string }
+	}{
+		{"sender has params",
+			map[types.AddressRole]struct{ addr, baseAddr string }{
+				types.RoleSender:   {cosmosHook, "cosmos1qqxuevtt"},
+				types.RoleReceiver: {"agoric1qqp0e5ys", "agoric1qqp0e5ys"},
+			},
+		},
+		{"receiver has params",
+			map[types.AddressRole]struct{ addr, baseAddr string }{
+				types.RoleSender:   {"cosmos1qqxuevtt", "cosmos1qqxuevtt"},
+				types.RoleReceiver: {agoricHook, "agoric1qqp0e5ys"},
+			},
+		},
+		{"both are base",
+			map[types.AddressRole]struct{ addr, baseAddr string }{
+				types.RoleSender:   {"cosmos1qqxuevtt", "cosmos1qqxuevtt"},
+				types.RoleReceiver: {"agoric1qqp0e5ys", "agoric1qqp0e5ys"},
+			},
+		},
+		{"both have params",
+			map[types.AddressRole]struct{ addr, baseAddr string }{
+				types.RoleSender:   {agoricHook, "agoric1qqp0e5ys"},
+				types.RoleReceiver: {cosmosHook, "cosmos1qqxuevtt"},
+			},
+		},
+	}
+
+	for _, tc := range cases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			ftPacketData := transfertypes.NewFungibleTokenPacketData("denom", "100", tc.addrs[types.RoleSender].addr, tc.addrs[types.RoleReceiver].addr, "my-favourite-memo")
+			packetBz := ftPacketData.GetBytes()
+			packet := channeltypes.NewPacket(packetBz, 1234, "my-port", "my-channel", "their-port", "their-channel", clienttypes.NewHeight(133, 445), 10999)
+
+			for role, addrs := range tc.addrs {
+				addrs := addrs
+				role := role
+
+				t.Run(string(role), func(t *testing.T) {
+					baseAddr, err := types.ExtractBaseAddress(addrs.addr)
+					require.NoError(t, err)
+					require.Equal(t, addrs.baseAddr, baseAddr)
+
+					packetBaseAddr0, err := types.ExtractBaseAddressFromData(cdc, packet.GetData(), role, nil)
+					require.NoError(t, err)
+					require.Equal(t, addrs.baseAddr, packetBaseAddr0)
+
+					packetBaseAddr1, err := types.ExtractBaseAddressFromPacket(cdc, packet, role, nil)
+					require.NoError(t, err)
+					require.Equal(t, addrs.baseAddr, packetBaseAddr1)
+
+					var newPacket channeltypes.Packet
+					packetBaseAddr2, err := types.ExtractBaseAddressFromPacket(cdc, packet, role, &newPacket)
+					require.NoError(t, err)
+					require.Equal(t, addrs.baseAddr, packetBaseAddr2)
+
+					var basePacketData transfertypes.FungibleTokenPacketData
+					err = cdc.UnmarshalJSON(newPacket.GetData(), &basePacketData)
+					require.NoError(t, err)
+
+					// Check that the only difference between the packet data is the baseAddr.
+					packetData := basePacketData
+					switch role {
+					case types.RoleSender:
+						require.Equal(t, addrs.baseAddr, basePacketData.Sender)
+						packetData.Sender = addrs.addr
+					case types.RoleReceiver:
+						require.Equal(t, addrs.baseAddr, basePacketData.Receiver)
+						packetData.Receiver = addrs.addr
+					default:
+						t.Fatal("unexpected role", role)
+					}
+
+					require.Equal(t, ftPacketData, packetData)
+				})
+			}
+		})
+	}
+}