Support for v1 of the offchain message specification

packages/offchain-messages/src/__tests__/envelope-codec-test.ts

@@ -260,7 +260,7 @@ describe('getOffchainMessageEnvelopeDecoder()', () => {
         );
     });
     it.each(
-        Array.from({ length: 255 - 0 /* highest supported version */ })
+        Array.from({ length: 255 - 1 /* highest supported version */ })
             .map((_, ii) => 255 - ii)
             .reverse(),
     )('throws if the preamble is of version `%s`', putativeVersion => {
@@ -451,7 +451,7 @@ describe('getOffchainMessageEnvelopeEncoder()', () => {
         );
     });
     it.each(
-        Array.from({ length: 255 - 0 /* highest supported version */ })
+        Array.from({ length: 255 - 1 /* highest supported version */ })
             .map((_, ii) => 255 - ii)
             .reverse(),
     )('throws if the envelope is of version `%s`', putativeVersion => {

packages/offchain-messages/src/__tests__/message-codec-test.ts

@@ -1,12 +1,15 @@
 import { ReadonlyUint8Array, VariableSizeDecoder, VariableSizeEncoder } from '@solana/codecs-core';
 import { SOLANA_ERROR__OFFCHAIN_MESSAGE__VERSION_NUMBER_NOT_SUPPORTED, SolanaError } from '@solana/errors';
 
 import { getOffchainMessageDecoder, getOffchainMessageEncoder } from '../codecs/message';
 import { getOffchainMessageV0Decoder, getOffchainMessageV0Encoder } from '../codecs/message-v0';
 import { OffchainMessage } from '../message';
 import { OffchainMessageV0 } from '../message-v0';
+import { getOffchainMessageV1Decoder, getOffchainMessageV1Encoder } from '../codecs/message-v1';
+import { OffchainMessageV1 } from '../message-v1';
 
 jest.mock('../codecs/message-v0');
+jest.mock('../codecs/message-v1');
 
 // The string `'\xffsolana offchain'`
 const OFFCHAIN_MESSAGE_SIGNING_DOMAIN_BYTES: ReadonlyUint8Array = new Uint8Array([
@@ -44,8 +47,34 @@
         expect(mockReader).toHaveBeenCalledWith(encodedMessage, 1);
         expect(result).toBe(expectedResult);
     });
+    it('delegates to the version 1 message decoder when the preamble is of version 1', () => {
+        const expectedResult = 123;
+        const mockDecoder = jest.fn().mockReturnValue(expectedResult);
+        const mockReader = jest.fn().mockReturnValue([
+            expectedResult,
+            OFFCHAIN_MESSAGE_SIGNING_DOMAIN_BYTES.byteLength +
+                // Version
+                1 +
+                // Padding
+                1,
+        ]);
+        jest.mocked(getOffchainMessageV1Decoder).mockReturnValue({ decode: mockDecoder, read: mockReader });
+        const encodedMessage =
+            // prettier-ignore
+            new Uint8Array([
+                    // Padding
+                    0xff,
+                    // Signing domain
+                    ...OFFCHAIN_MESSAGE_SIGNING_DOMAIN_BYTES,
+                    // Version
+                    0x01,
+                ]);
+        const result = decoder.decode(encodedMessage, 1);
+        expect(mockReader).toHaveBeenCalledWith(encodedMessage, 1);
+        expect(result).toBe(expectedResult);
+    });
     it.each(
-        Array.from({ length: 255 - 0 /* highest supported version */ })
+        Array.from({ length: 255 - 1 /* highest supported version */ })
             .map((_, ii) => 255 - ii)
             .reverse(),
     )('throws if the preamble is of version `%s`', putativeVersion => {
@@ -86,8 +115,22 @@
         expect(mockWriter).toHaveBeenCalledWith(mockMessage, expect.any(Uint8Array), 0 /* offset */);
         expect(result).toStrictEqual(new Uint8Array([1, 2, 3]));
     });
+    it('delegates to the version 1 message encoder when the message is of version 1', () => {
+        const mockMessage = { version: 1 };
+        const mockWriter = jest.fn().mockImplementation((_message, bytes, offset) => {
+            bytes.set([1, 2, 3], offset);
+        });
+        jest.mocked(getOffchainMessageV1Encoder).mockReturnValue({
+            encode: jest.fn(),
+            getSizeFromValue: jest.fn().mockReturnValue(3),
+            write: mockWriter,
+        });
+        const result = encoder.encode(mockMessage as OffchainMessageV1);
+        expect(mockWriter).toHaveBeenCalledWith(mockMessage, expect.any(Uint8Array), 0 /* offset */);
+        expect(result).toStrictEqual(new Uint8Array([1, 2, 3]));
+    });
     it.each(
-        Array.from({ length: 255 - 0 /* highest supported version */ })
+        Array.from({ length: 255 - 1 /* highest supported version */ })
             .map((_, ii) => 255 - ii)
             .reverse(),
     )('throws if the preamble is of version `%s`', putativeVersion => {

packages/offchain-messages/src/__tests__/message-v0-codec-test.ts

@@ -13,6 +13,7 @@ import {
     SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_MUST_BE_NON_EMPTY,
     SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_REQUIRED_SIGNERS_CANNOT_BE_ZERO,
     SOLANA_ERROR__OFFCHAIN_MESSAGE__RESTRICTED_ASCII_BODY_CHARACTER_OUT_OF_RANGE,
+    SOLANA_ERROR__OFFCHAIN_MESSAGE__UNEXPECTED_VERSION,
     SOLANA_ERROR__OFFCHAIN_MESSAGE__VERSION_NUMBER_NOT_SUPPORTED,
     SolanaError,
 } from '@solana/errors';
@@ -26,7 +27,6 @@ import {
     OffchainMessageContentUtf8Of65535BytesMax,
 } from '../content';
 import { OffchainMessageV0 } from '../message-v0';
-import { OffchainMessageVersion } from '../version';
 
 // The string `'\xffsolana offchain'`
 const OFFCHAIN_MESSAGE_SIGNING_DOMAIN_BYTES: ReadonlyUint8Array = new Uint8Array([
@@ -199,8 +199,9 @@ describe('getOffchainMessageV0Decoder()', () => {
                     0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x0A, 0x77, 0x6f, 0x72, 0x6c, 0x64,
             ]);
         expect(() => decoder.decode(encodedMessage)).toThrow(
-            new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__VERSION_NUMBER_NOT_SUPPORTED, {
-                unsupportedVersion: 1,
+            new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__UNEXPECTED_VERSION, {
+                actualVersion: 1,
+                expectedVersion: 0,
             }),
         );
     });
@@ -636,32 +637,33 @@ describe('getOffchainMessageEncoder()', () => {
         },
     );
     it('throws when encoding an ASCII encoded message with a non-zero version', () => {
-        const offchainMessage: OffchainMessageV0 = {
+        const offchainMessage = {
             applicationDomain: APPLICATION_DOMAIN,
             content: {
                 format: OffchainMessageContentFormat.RESTRICTED_ASCII_1232_BYTES_MAX,
                 text: 'Hello\nworld',
             } as OffchainMessageContentRestrictedAsciiOf1232BytesMax,
             requiredSignatories: [{ address: SIGNER_A }, { address: SIGNER_B }],
-            version: 1 as OffchainMessageVersion,
+            version: 1,
         };
-        expect(() => encoder.encode(offchainMessage)).toThrow(
-            new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__VERSION_NUMBER_NOT_SUPPORTED, {
-                unsupportedVersion: 1,
+        expect(() => encoder.encode(offchainMessage as unknown as OffchainMessageV0)).toThrow(
+            new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__UNEXPECTED_VERSION, {
+                actualVersion: 1,
+                expectedVersion: 0,
             }),
         );
     });
     it('throws when encoding an ASCII encoded message with an unsupported version', () => {
-        const offchainMessage: OffchainMessageV0 = {
+        const offchainMessage = {
             applicationDomain: APPLICATION_DOMAIN,
             content: {
                 format: OffchainMessageContentFormat.RESTRICTED_ASCII_1232_BYTES_MAX,
                 text: 'Hello\nworld',
             } as OffchainMessageContentRestrictedAsciiOf1232BytesMax,
             requiredSignatories: [{ address: SIGNER_A }, { address: SIGNER_B }],
-            version: 255 as OffchainMessageVersion,
+            version: 255,
         };
-        expect(() => encoder.encode(offchainMessage)).toThrow(
+        expect(() => encoder.encode(offchainMessage as unknown as OffchainMessageV0)).toThrow(
             new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__VERSION_NUMBER_NOT_SUPPORTED, {
                 unsupportedVersion: 255,
             }),