@agoric/kmarshal 0.1.1-other-dev-fbe72e7.0.fbe72e7 → 0.1.1-other-dev-d15096d.0.d15096d

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/kmarshal",
-  "version": "0.1.1-other-dev-fbe72e7.0.fbe72e7",
+  "version": "0.1.1-other-dev-d15096d.0.d15096d",
   "description": "Token-only marshaller for kernel and tests",
   "type": "module",
   "main": "./src/kmarshal.js",
@@ -26,6 +26,8 @@
     "@endo/marshal": "^1.8.0"
   },
   "devDependencies": {
+    "@endo/init": "^1.1.12",
+    "@endo/ses-ava": "^1.3.2",
     "ava": "^5.3.0"
   },
   "publishConfig": {
@@ -35,13 +37,10 @@
     "files": [
       "test/**/*.test.*"
     ],
-    "require": [
-      "@endo/init/debug.js"
-    ],
     "timeout": "2m"
   },
   "engines": {
     "node": "^20.9 || ^22.11"
   },
-  "gitHead": "fbe72e72107f9997f788674e668c660d92ec4492"
+  "gitHead": "d15096dc4ff8b96e9b6cd11954c20d3a9efbb393"
 }

package/src/kmarshal.js

@@ -4,6 +4,7 @@ import { makeMarshal } from '@endo/marshal';
 
 /**
  * @import {ConvertSlotToVal} from '@endo/marshal';
+ * @import {CapData} from '@endo/marshal';
  */
 
 // Simple wrapper for serializing and unserializing marshalled values inside the
@@ -96,12 +97,14 @@ const kmarshal = makeMarshal(krefOf, kslot, {
 export const kser = value => kmarshal.serialize(harden(value));
 
 /**
- * @param {import('@endo/marshal').CapData<string>} serializedValue
+ * @param {CapData<string>} serializedValue
  * @returns {any}
  */
 export const kunser = serializedValue => kmarshal.unserialize(serializedValue);
 
 export function makeError(message) {
   assert.typeof(message, 'string');
+  // Marshal has a relaxation for an error at the root of the data
+  // so these will always serialize even if not passable
   return kser(Error(message));
 }

package/test/basic.test.js

@@ -1,3 +1,4 @@
+import '@endo/init/debug.js';
 import test from 'ava';
 
 import { kser, kunser, krefOf, kslot } from '../src/kmarshal.js';

package/test/error-test-cases.js

@@ -0,0 +1,62 @@
+import { passStyleOf, toPassableError } from '@endo/marshal';
+
+import { kser, makeError } from '../src/kmarshal.js';
+
+/**
+ * @import {ExecutionContext} from 'ava';
+ */
+
+/** @type {Record<string, (t: ExecutionContext) => void>} */
+export const cases = {
+  'kernel serialization of errors': t => {
+    // The kernel synthesizes e.g. `Error('vat terminated')`, so we
+    // need kmarshal to serialize those errors in a deterministic
+    // way. This test checks that we don't get surprising things like
+    // `errorId` or stack traces.
+    const e1 = kser(Error('fake error'));
+    const ref = {
+      body: '#{"#error":"fake error","name":"Error"}',
+      slots: [],
+    };
+    t.deepEqual(e1, ref);
+
+    const e2 = makeError('fake error');
+    t.deepEqual(e2, ref);
+  },
+  'kernel serialization of passable errors in deliveries': t => {
+    // The kernel synthesizes e.g. `Error('vat-upgrade failure')`, and includes
+    // it in arguments to deliveries, so we need kmarshal to serialize those
+    // nested errors reliably. This test checks that we don't get surprising
+    // behaviors like non-passable errors even when the kernel explicitly
+    // coerce those to passable.
+    const e1 = toPassableError(Error('fake nested error'));
+    const methargs = ['someMethod', [e1]];
+    const ref = {
+      body: '#["someMethod",[{"#error":"fake nested error","name":"Error"}]]',
+      slots: [],
+    };
+    t.deepEqual(kser(methargs), ref);
+  },
+  'kernel serialization of raw errors in deliveries': t => {
+    // The kernel synthesizes e.g. `Error('vat-upgrade failure')`, and includes
+    // it in arguments to deliveries, so we need kmarshal to serialize those
+    // nested errors reliably. While the kernel coerces errors it synthesizes to
+    // passable errors, here we check the behavior if it didn't.
+    const e1 = Error('fake nested error');
+    const methargs = ['someMethod', [e1]];
+
+    try {
+      t.is(passStyleOf(harden({ error: Error('sentinel') })), 'copyRecord');
+      // If the above doesn't throw, raw errors are passable, or passStyle repairs them
+      const ref = {
+        body: '#["someMethod",[{"#error":"fake nested error","name":"Error"}]]',
+        slots: [],
+      };
+      t.deepEqual(kser(methargs), ref);
+    } catch {
+      // If we threw, raw errors are not passable. We expect kser to throw as well
+
+      t.throws(() => kser(methargs));
+    }
+  },
+};

package/test/error-unsafe-fast.test.js

@@ -0,0 +1,14 @@
+// We are explicitly testing unsafe-fast behavior in this test
+// Unlike in error.test.js
+import '@endo/init/unsafe-fast.js';
+
+import { wrapTest } from '@endo/ses-ava';
+import rawTest from 'ava';
+
+import { cases } from './error-test-cases.js';
+
+const test = wrapTest(rawTest);
+
+for (const [title, impl] of Object.entries(cases)) {
+  test(title, impl);
+}

package/test/error.test.js

@@ -0,0 +1,14 @@
+// We are testing normal lockdown behavior in this test
+// Unlike in error-unsafe-fast.test.js
+import '@endo/init/debug.js';
+
+import { wrapTest } from '@endo/ses-ava';
+import rawTest from 'ava';
+
+import { cases } from './error-test-cases.js';
+
+const test = wrapTest(rawTest);
+
+for (const [title, impl] of Object.entries(cases)) {
+  test(title, impl);
+}