@agoric/cosmos 0.34.2-dev-5dc325b.0 → 0.35.0-getting-started-dev-26244e8.0

package/x/vstorage/capdata/capdata.go

@@ -1,298 +0,0 @@
-package capdata
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-// JsonMarshal returns JSON text representing its input,
-// without special replacement of "<", ">", "&", U+2028, or U+2029.
-func JsonMarshal(val any) ([]byte, error) {
-	buf := &bytes.Buffer{}
-	encoder := json.NewEncoder(buf)
-	encoder.SetEscapeHTML(false)
-	if err := encoder.Encode(val); err != nil {
-		return nil, err
-	}
-	// Return without a trailing line feed.
-	lineTerminatedJson := buf.Bytes()
-	return bytes.TrimSuffix(lineTerminatedJson, []byte("\n")), nil
-}
-
-// cf. https://github.com/endojs/endo/tree/master/packages/marshal
-
-type Capdata struct {
-	Body  string        `json:"body"`
-	Slots []interface{} `json:"slots"`
-}
-
-var validBigint = regexp.MustCompile(`^-?(?:0|[1-9][0-9]*)$`)
-
-type CapdataBigint struct {
-	Normalized string
-}
-
-type CapdataRemotable struct {
-	Id             interface{}
-	Iface          *string
-	Representation interface{}
-}
-
-func NewCapdataBigint(str string) *CapdataBigint {
-	if !validBigint.MatchString(str) {
-		return nil
-	}
-	bigint := CapdataBigint{str}
-	return &bigint
-}
-
-func (r *CapdataRemotable) MarshalJSON() ([]byte, error) {
-	return JsonMarshal(r.Representation)
-}
-
-type CapdataValueTransformations struct {
-	Bigint    func(*CapdataBigint) interface{}
-	Remotable func(*CapdataRemotable) interface{}
-}
-
-// upsertCapdataRemotable either adds a new CapdataRemotable to `remotables` at the specified
-// slot index or updates the iface of the value that is already there, ensuring lack of iface name
-// inconsistency (iteration order is not guaranteed to correspond with JSON text like it does in
-// JavaScript, so we must accept encountering the "first" reference to a slot late
-// and must therefore also defer transformations).
-func upsertCapdataRemotable(remotables map[uint64]*CapdataRemotable, slotIndex uint64, id interface{}, iface *string) (*CapdataRemotable, error) {
-	r := remotables[slotIndex]
-	if r == nil {
-		r = new(CapdataRemotable)
-		r.Id = id
-		r.Iface = iface
-		remotables[slotIndex] = r
-	} else if iface != nil {
-		if r.Iface != nil && *iface != *r.Iface {
-			return nil, fmt.Errorf("slot iface mismatch: %q", *iface)
-		}
-		r.Iface = iface
-	}
-	return r, nil
-}
-
-// decodeCapdataLegacyValue decodes the non-smallcaps encoding of
-// https://github.com/endojs/endo/blob/master/packages/marshal/src/encodeToCapData.js
-func decodeCapdataLegacyValue(
-	encoded interface{},
-	slots []interface{},
-	remotables map[uint64]*CapdataRemotable,
-	transformations CapdataValueTransformations,
-) (interface{}, error) {
-	if arr, ok := encoded.([]interface{}); ok {
-		for i, v := range arr {
-			decoded, err := decodeCapdataLegacyValue(v, slots, remotables, transformations)
-			if err != nil {
-				return nil, err
-			}
-			arr[i] = decoded
-		}
-		return arr, nil
-	} else if obj, ok := encoded.(map[string]interface{}); ok {
-		if qclassVal, ok := obj["@qclass"]; ok {
-			qclass, ok := qclassVal.(string)
-			if !ok {
-				return nil, fmt.Errorf("invalid @qclass: %q", qclassVal)
-			}
-			switch qclass {
-			case "bigint":
-				var bigint *CapdataBigint
-				digitsVal := obj["digits"]
-				if digitsStr, ok := digitsVal.(string); ok {
-					bigint = NewCapdataBigint(digitsStr)
-				}
-				if bigint == nil {
-					return nil, fmt.Errorf("invalid bigint: %q", digitsVal)
-				}
-				if transformations.Bigint == nil {
-					return nil, fmt.Errorf("untransformed bigint")
-				}
-				return transformations.Bigint(bigint), nil
-			case "slot":
-				var iface *string
-				slotIndexVal, ifaceVal := obj["index"], obj["iface"]
-				slotIndexNum, ok := slotIndexVal.(float64)
-				slotIndex := uint64(slotIndexNum)
-				if !ok || float64(slotIndex) != slotIndexNum || slotIndex >= uint64(len(slots)) {
-					return nil, fmt.Errorf("invalid slot index: %q", slotIndexVal)
-				}
-				if ifaceStr, ok := ifaceVal.(string); ok {
-					iface = &ifaceStr
-				} else if ifaceVal != nil {
-					return nil, fmt.Errorf("invalid slot iface: %q", ifaceVal)
-				}
-				return upsertCapdataRemotable(remotables, slotIndex, slots[slotIndex], iface)
-			case "hilbert":
-				fallthrough
-			case "undefined":
-				fallthrough
-			case "NaN":
-				fallthrough
-			case "Infinity":
-				fallthrough
-			case "symbol":
-				fallthrough
-			case "tagged":
-				fallthrough
-			case "error":
-				fallthrough
-			case "-Infinity":
-				return nil, fmt.Errorf("not implemented: @qclass %q", qclass)
-			default:
-				return nil, fmt.Errorf("unrecognized @qclass: %q", qclass)
-			}
-		}
-		for k, v := range obj {
-			decoded, err := decodeCapdataLegacyValue(v, slots, remotables, transformations)
-			if err != nil {
-				return nil, err
-			}
-			obj[k] = decoded
-		}
-		return obj, nil
-	} else {
-		return encoded, nil
-	}
-}
-
-// decodeCapdataSmallcapsValue decodes the "smallcaps" encoding from
-// https://github.com/endojs/endo/blob/master/packages/marshal/src/encodeToSmallcaps.js
-func decodeCapdataSmallcapsValue(
-	encoded interface{},
-	slots []interface{},
-	remotables map[uint64]*CapdataRemotable,
-	transformations CapdataValueTransformations,
-) (interface{}, error) {
-	if arr, ok := encoded.([]interface{}); ok {
-		for i, v := range arr {
-			decoded, err := decodeCapdataSmallcapsValue(v, slots, remotables, transformations)
-			if err != nil {
-				return nil, err
-			}
-			arr[i] = decoded
-		}
-		return arr, nil
-	} else if encodedObj, ok := encoded.(map[string]interface{}); ok {
-		if _, ok := encodedObj["#tag"]; ok {
-			return nil, fmt.Errorf("not implemented: #tag")
-		}
-		if _, ok := encodedObj["#error"]; ok {
-			return nil, fmt.Errorf("not implemented: #error")
-		}
-		// We need a distinct output map to avoid reprocessing already-decoded keys.
-		decodedObj := make(map[string]interface{}, len(encodedObj))
-		for encodedK, v := range encodedObj {
-			if strings.HasPrefix(encodedK, "#") {
-				return nil, fmt.Errorf("unrecognized record type: %q", encodedK)
-			}
-			decodedK, err := decodeCapdataSmallcapsValue(encodedK, slots, remotables, CapdataValueTransformations{})
-			k, ok := decodedK.(string)
-			if err != nil || !ok {
-				return nil, fmt.Errorf("invalid copyRecord key: %q", encodedK)
-			}
-			decoded, err := decodeCapdataSmallcapsValue(v, slots, remotables, transformations)
-			if err != nil {
-				return nil, err
-			}
-			decodedObj[k] = decoded
-		}
-		return decodedObj, nil
-	} else if str, ok := encoded.(string); ok {
-		if len(str) == 0 {
-			return str, nil
-		}
-		switch str[0] {
-		case '!':
-			return str[1:], nil
-		case '+':
-			// Normalize to no leading "+".
-			str = str[1:]
-			fallthrough
-		case '-':
-			bigint := NewCapdataBigint(str)
-			if bigint == nil {
-				return nil, fmt.Errorf("invalid bigint: %q", encoded.(string))
-			}
-			if transformations.Bigint == nil {
-				return nil, fmt.Errorf("untransformed bigint")
-			}
-			return transformations.Bigint(bigint), nil
-		case '$':
-			var slotIndexStr string
-			var iface *string
-			if dotIndex := strings.IndexByte(str, '.'); dotIndex >= 0 {
-				slotIndexStr = str[1:dotIndex]
-				ifaceStr := str[dotIndex+1:]
-				iface = &ifaceStr
-			} else {
-				slotIndexStr = str[1:]
-			}
-			slotIndex, err := strconv.ParseUint(slotIndexStr, 10, 0)
-			if err != nil || slotIndex >= uint64(len(slots)) {
-				return nil, fmt.Errorf("invalid slot index: %q", str)
-			}
-			r, err := upsertCapdataRemotable(remotables, slotIndex, slots[slotIndex], iface)
-			if err != nil {
-				return nil, fmt.Errorf("slot iface mismatch: %q", str)
-			}
-			return r, nil
-		case '#':
-			fallthrough
-		case '%':
-			fallthrough
-		case '&':
-			return nil, fmt.Errorf("not implemented: %q", str)
-		default:
-			if str[0] >= '!' && str[0] <= '-' {
-				return nil, fmt.Errorf("invalid smallcaps encoding prefix: %q", str[:1])
-			}
-		}
-		return str, nil
-	} else {
-		return encoded, nil
-	}
-}
-
-// DecodeSerializedCapdata accepts JSON text representing encoded CapData and
-// decodes it, applying specified transformations for values that otherwise
-// hinder interchange.
-func DecodeSerializedCapdata(
-	serializedCapdata string,
-	transformations CapdataValueTransformations,
-) (interface{}, error) {
-	var capdata Capdata
-	if err := json.Unmarshal([]byte(serializedCapdata), &capdata); err != nil {
-		return nil, err
-	}
-	if capdata.Body == "" || capdata.Slots == nil {
-		return nil, fmt.Errorf("invalid CapData")
-	}
-	serializedBody, decodeValue := capdata.Body, decodeCapdataLegacyValue
-	if strings.HasPrefix(serializedBody, "#") {
-		serializedBody, decodeValue = serializedBody[1:], decodeCapdataSmallcapsValue
-	}
-	var encoded interface{}
-	if err := json.Unmarshal([]byte(serializedBody), &encoded); err != nil {
-		return nil, err
-	}
-	remotables := map[uint64]*CapdataRemotable{}
-	decoded, err := decodeValue(encoded, capdata.Slots, remotables, transformations)
-	if err == nil && len(remotables) > 0 {
-		if transformations.Remotable == nil {
-			return nil, fmt.Errorf("untransformed remotable")
-		}
-		for _, r := range remotables {
-			r.Representation = transformations.Remotable(r)
-		}
-	}
-	return decoded, err
-}

package/x/vstorage/capdata/capdata_test.go

@@ -1,352 +0,0 @@
-package capdata
-
-import (
-	"encoding/json"
-	"fmt"
-	"reflect"
-	"strings"
-	"testing"
-)
-
-func ptr[T any](v T) *T {
-	return &v
-}
-
-func mustJsonMarshal(val any) string {
-	jsonText, err := JsonMarshal(val)
-	if err != nil {
-		panic(err)
-	}
-	return string(jsonText)
-}
-
-func mustJsonUnmarshal(jsonText string, ptr any) {
-	if err := json.Unmarshal([]byte(jsonText), ptr); err != nil {
-		panic(err)
-	}
-}
-
-func prefixBigint(bigint *CapdataBigint) interface{} {
-	return fmt.Sprintf("bigint:%s", bigint.Normalized)
-}
-
-func remotableToString(r *CapdataRemotable) interface{} {
-	iface := ""
-	if r.Iface != nil {
-		iface = *r.Iface
-	}
-	return fmt.Sprintf("remotable:%s{%s}", iface, r.Id)
-}
-
-func Test_JsonMarshal(t *testing.T) {
-	type testCase struct {
-		input       string
-		expected    string
-		errContains *string
-	}
-	testCases := []testCase{
-		{
-			input:    "<>&\u2028\u2029",
-			expected: `"<>&\u2028\u2029"`,
-		},
-	}
-	for _, desc := range testCases {
-		label := fmt.Sprintf("%q", desc.input)
-		result, err := JsonMarshal(desc.input)
-		if desc.errContains == nil {
-			if err != nil {
-				t.Errorf("%s: got unexpected error %v", label, err)
-			} else if string(result) != desc.expected {
-				t.Errorf("%s: wrong result: %#q", label, result)
-			}
-		} else if err == nil {
-			t.Errorf("%s: got no error, want error %q", label, *desc.errContains)
-		} else if !strings.Contains(err.Error(), *desc.errContains) {
-			t.Errorf("%s: got error %v, want error %q", label, err, *desc.errContains)
-		}
-	}
-}
-
-func Test_DecodeSerializedCapdata(t *testing.T) {
-	type testCase struct {
-		format          string
-		label           string
-		body            string
-		slots           []interface{}
-		expected        string
-		errContains     *string
-		transformations CapdataValueTransformations
-	}
-	testCases := []testCase{
-		// JSON
-		// cf. https://github.com/endojs/endo/blob/209b612e0a267239f33cd607e94ccd179d3ba248/packages/marshal/test/test-marshal-capdata.js#L11
-		{body: `[1, 2]`},
-		{body: `{ "foo": 1 }`},
-		{body: `{}`},
-		{body: `{ "a": 1, "b": 2 }`},
-		{body: `{ "a": 1, "b": { "c": 3 } }`},
-		{body: `true`},
-		{body: `1`},
-		{body: `"abc"`},
-		{body: `null`},
-
-		// transformation of non-JSON values
-		{format: "smallcaps", label: "bigint",
-			body:            `"+98765432101234567890"`,
-			expected:        `"bigint:98765432101234567890"`,
-			transformations: CapdataValueTransformations{Bigint: prefixBigint},
-		},
-		{format: "legacy", label: "bigint",
-			body:            `{ "@qclass": "bigint", "digits": "98765432101234567890" }`,
-			expected:        `"bigint:98765432101234567890"`,
-			transformations: CapdataValueTransformations{Bigint: prefixBigint},
-		},
-		{format: "smallcaps", label: "remotables",
-			body:            `["$0.Foo", "$0"]`,
-			slots:           []interface{}{"a"},
-			expected:        `["remotable:Foo{a}","remotable:Foo{a}"]`,
-			transformations: CapdataValueTransformations{Remotable: remotableToString},
-		},
-		{format: "legacy", label: "remotables",
-			body:            `[{"@qclass":"slot","index":0,"iface":"Foo"}, {"@qclass":"slot","index":0}]`,
-			slots:           []interface{}{"a"},
-			expected:        `["remotable:Foo{a}","remotable:Foo{a}"]`,
-			transformations: CapdataValueTransformations{Remotable: remotableToString},
-		},
-		{format: "smallcaps", label: "escaped string",
-			body:     `"!#escaped"`,
-			expected: `"#escaped"`,
-		},
-
-		// unimplemented
-		{format: "smallcaps",
-			body:        `"#undefined"`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "legacy", label: "undefined",
-			body:        `{"@qclass":"undefined"}`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "smallcaps",
-			body:        `"#NaN"`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "legacy", label: "NaN",
-			body:        `{"@qclass":"NaN"}`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "smallcaps",
-			body:        `"#Infinity"`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "legacy", label: "Infinity",
-			body:        `{"@qclass":"Infinity"}`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "smallcaps",
-			body:        `"#-Infinity"`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "legacy", label: "-Infinity",
-			body:        `{"@qclass":"-Infinity"}`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "smallcaps", label: "symbol",
-			body:        `"%foo"`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "legacy", label: "symbol",
-			body:        `{"@qclass":"symbol"}`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "smallcaps", label: "tagged",
-			body:        `{"#tag":"foo","payload":"bar"}`,
-			errContains: ptr("not implemented: #tag"),
-		},
-		{format: "legacy", label: "tagged",
-			body:        `{"@qclass":"tagged","tag":"foo","payload":"bar"}`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "smallcaps", label: "error",
-			body:        `{"#error":"","name":"Error"}`,
-			errContains: ptr("not implemented: #error"),
-		},
-		{format: "legacy", label: "error",
-			body:        `{"@qclass":"error","message":"foo","name":"bar"}`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "smallcaps", label: "promise",
-			body:        `"&0"`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("not implemented"),
-		},
-		{format: "legacy", label: "error",
-			body:        `{"@qclass":"hilbert","original":"foo"}`,
-			errContains: ptr("not implemented"),
-		},
-
-		// missing transformations
-		{format: "smallcaps", label: "untransformed bigint",
-			body:        `"+98765432101234567890"`,
-			errContains: ptr("untransformed bigint"),
-		},
-		{format: "legacy", label: "untransformed bigint",
-			body:        `{ "@qclass": "bigint", "digits": "98765432101234567890" }`,
-			errContains: ptr("untransformed bigint"),
-		},
-		{format: "smallcaps", label: "untransformed remotable",
-			body:        `["$0.Foo", "$0"]`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("untransformed remotable"),
-		},
-		{format: "legacy", label: "untransformed remotable",
-			body:        `[{"@qclass":"slot","index":0,"iface":"Foo"}, {"@qclass":"slot","index":0}]`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("untransformed remotable"),
-		},
-
-		// invalid data
-		{format: "smallcaps", label: "iface mismatch",
-			body:        `["$0.Foo", "$0."]`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("iface mismatch"),
-		},
-		{format: "legacy", label: "iface mismatch",
-			body:        `[{"@qclass":"slot","index":0,"iface":"Foo"}, {"@qclass":"slot","index":0,"iface":""}]`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("iface mismatch"),
-		},
-		{format: "smallcaps", label: "invalid slot index (out of bounds)",
-			body:        `"$0.Foo"`,
-			errContains: ptr("invalid slot index"),
-		},
-		{format: "legacy", label: "invalid slot index (out of bounds)",
-			body:        `{"@qclass":"slot","index":0}`,
-			errContains: ptr("invalid slot index"),
-		},
-		{format: "smallcaps", label: "invalid slot index (bad format)",
-			body:        `"$x.Foo"`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("invalid slot index"),
-		},
-		{format: "legacy", label: "invalid slot index (missing)",
-			body:        `{"@qclass":"slot"}`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("invalid slot index"),
-		},
-		{format: "legacy", label: "invalid slot index (null)",
-			body:        `{"@qclass":"slot","index":null}`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("invalid slot index"),
-		},
-		{format: "legacy", label: "invalid slot index (string)",
-			body:        `{"@qclass":"slot","index":"0"}`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("invalid slot index"),
-		},
-		{format: "legacy", label: "invalid slot index (non-integer)",
-			body:        `{"@qclass":"slot","index":0.1}`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("invalid slot index"),
-		},
-		{format: "legacy", label: "invalid slot index (negative)",
-			body:        `{"@qclass":"slot","index":-1}`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("invalid slot index"),
-		},
-		{format: "legacy", label: "invalid slot iface (number)",
-			body:        `{"@qclass":"slot","index":0,"iface":0}`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("invalid slot iface"),
-		},
-		{format: "smallcaps", label: "unrecognized record type",
-			body:        `{"#foo":0}`,
-			errContains: ptr("unrecognized record type"),
-		},
-		{format: "legacy", label: "invalid @qclass (null)",
-			body:        `{"@qclass":null}`,
-			errContains: ptr("invalid @qclass"),
-		},
-		{format: "legacy", label: "invalid @qclass (number)",
-			body:        `{"@qclass":1}`,
-			errContains: ptr("invalid @qclass"),
-		},
-		{format: "legacy", label: "invalid @qclass (number)",
-			body:        `{"@qclass":1}`,
-			errContains: ptr("invalid @qclass"),
-		},
-		{format: "legacy", label: "unrecognized @qclass",
-			body:        `{"@qclass":"foo"}`,
-			errContains: ptr("unrecognized @qclass"),
-		},
-		{format: "smallcaps", label: "invalid copyRecord key",
-			body:        `{"+0":0}`,
-			errContains: ptr("invalid copyRecord key"),
-		},
-		{format: "smallcaps", label: "invalid bigint (`--`)",
-			body:        `"--"`,
-			errContains: ptr("invalid bigint"),
-		},
-		{format: "smallcaps", label: "invalid bigint (`+0x`)",
-			body:        `"+0x"`,
-			errContains: ptr("invalid bigint"),
-		},
-		{format: "legacy", label: "invalid bigint (no digits)",
-			body:        `{"@qclass":"bigint"}`,
-			errContains: ptr("invalid bigint"),
-		},
-		{format: "legacy", label: "invalid bigint (null digits)",
-			body:        `{"@qclass":"bigint","digits":null}`,
-			errContains: ptr("invalid bigint"),
-		},
-		{format: "legacy", label: "invalid bigint (`7up`)",
-			body:        `{"@qclass":"bigint","digits":"7up"}`,
-			errContains: ptr("invalid bigint"),
-		},
-	}
-
-	for _, desc := range testCases {
-		slots := desc.slots
-		if slots == nil {
-			slots = []interface{}{}
-		}
-		var expected interface{}
-		if desc.expected != "" {
-			mustJsonUnmarshal(desc.expected, &expected)
-		} else {
-			mustJsonUnmarshal(desc.body, &expected)
-		}
-		for _, format := range []string{"smallcaps", "legacy"} {
-			if desc.format != "" && desc.format != format {
-				continue
-			}
-			label := fmt.Sprintf("%s %s", format, desc.label)
-			if desc.label == "" {
-				label = fmt.Sprintf("%s %s", format, desc.body)
-			}
-			capdata := Capdata{desc.body, slots}
-			if format == "smallcaps" {
-				capdata.Body = "#" + capdata.Body
-			}
-			intermediate, err := DecodeSerializedCapdata(mustJsonMarshal(capdata), desc.transformations)
-			// Replace each Remotable with its representation before comparing.
-			var got interface{}
-			mustJsonUnmarshal(mustJsonMarshal(intermediate), &got)
-			if desc.errContains == nil {
-				if err != nil {
-					t.Errorf("%s: got unexpected error %v", label, err)
-				} else if !reflect.DeepEqual(got, expected) {
-					result, err := JsonMarshal(got)
-					if err != nil {
-						panic(fmt.Errorf("%s: %v", label, err))
-					}
-					t.Errorf("%s: wrong result: %s", label, result)
-				}
-			} else if err == nil {
-				t.Errorf("%s: got no error, want error %q", label, *desc.errContains)
-			} else if !strings.Contains(err.Error(), *desc.errContains) {
-				t.Errorf("%s: got error %v, want error %q", label, err, *desc.errContains)
-			}
-		}
-	}
-}