@solana/offchain-messages 0.0.0 → 5.1.0-canary-20251203224929

package/dist/types/codecs/preamble-v1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preamble-v1.d.ts","sourceRoot":"","sources":["../../../src/codecs/preamble-v1.ts"],"names":[],"mappings":"AACA,OAAO,EAMH,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACtB,MAAM,qBAAqB,CAAC;AAU7B,OAAO,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAO3D,wBAAgB,mCAAmC,IAAI,mBAAmB,CAAC,yBAAyB,CAAC,CA2BpG;AAED,wBAAgB,mCAAmC,IAAI,mBAAmB,CAAC,yBAAyB,CAAC,CA0BpG;AAED,wBAAgB,iCAAiC,IAAI,iBAAiB,CAAC,yBAAyB,CAAC,CAEhG"}

package/dist/types/codecs/signatures.d.ts

@@ -0,0 +1,4 @@
+import { VariableSizeEncoder } from '@solana/codecs-core';
+import { OffchainMessageEnvelope } from '../envelope';
+export declare function getSignaturesEncoder(): VariableSizeEncoder<OffchainMessageEnvelope['signatures']>;
+//# sourceMappingURL=signatures.d.ts.map

package/dist/types/codecs/signatures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signatures.d.ts","sourceRoot":"","sources":["../../../src/codecs/signatures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAM5F,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAgBtD,wBAAgB,oBAAoB,IAAI,mBAAmB,CAAC,uBAAuB,CAAC,YAAY,CAAC,CAAC,CAKjG"}

package/dist/types/codecs/signing-domain.d.ts

@@ -0,0 +1,5 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+export declare function getOffchainMessageSigningDomainDecoder(): FixedSizeDecoder<void, 16>;
+export declare function getOffchainMessageSigningDomainEncoder(): FixedSizeEncoder<void, 16>;
+export declare function getOffchainMessageSigningDomainCodec(): FixedSizeCodec<void, void, 16>;
+//# sourceMappingURL=signing-domain.d.ts.map

package/dist/types/codecs/signing-domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signing-domain.d.ts","sourceRoot":"","sources":["../../../src/codecs/signing-domain.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAEnB,MAAM,qBAAqB,CAAC;AAQ7B,wBAAgB,sCAAsC,IAAI,gBAAgB,CAAC,IAAI,EAAE,EAAE,CAAC,CAEnF;AAED,wBAAgB,sCAAsC,IAAI,gBAAgB,CAAC,IAAI,EAAE,EAAE,CAAC,CAEnF;AAED,wBAAgB,oCAAoC,IAAI,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,CAErF"}

package/dist/types/content.d.ts

@@ -0,0 +1,234 @@
+import { Brand } from '@solana/nominal-types';
+/**
+ * A restriction on what characters the message text can contain and how long it can be.
+ *
+ * The aim of this restriction is to make a message more likely to be signable by a hardware wallet
+ * that imposes limits on message size. In the case of wanting a message to be clear-signable,
+ * restricting the character set to ASCII may ensure that certain models of hardware wallet without
+ * extended character sets can display it onscreen.
+ *
+ * @remarks This only applies to v0 messages.
+ */
+export declare enum OffchainMessageContentFormat {
+    RESTRICTED_ASCII_1232_BYTES_MAX = 0,
+    UTF8_1232_BYTES_MAX = 1,
+    UTF8_65535_BYTES_MAX = 2
+}
+/**
+ * Describes message text that is no more than 1232 bytes long and made up of characters with ASCII
+ * character codes in the range [0x20, 0x7e].
+ *
+ * @remarks This type aims to restrict text to that which can be clear-signed by hardware wallets
+ * that can only display ASCII characters onscreen.
+ */
+export type OffchainMessageContentRestrictedAsciiOf1232BytesMax<TContent extends string = string> = Readonly<{
+    format: OffchainMessageContentFormat.RESTRICTED_ASCII_1232_BYTES_MAX;
+    text: Brand<TContent, 'offchainMessageContentRestrictedAsciiOf1232BytesMax'>;
+}>;
+/**
+ * Describes message text that is no more than 1232 bytes long and mdae up of any UTF-8 characters.
+ */
+export type OffchainMessageContentUtf8Of1232BytesMax<TContent extends string = string> = Readonly<{
+    format: OffchainMessageContentFormat.UTF8_1232_BYTES_MAX;
+    text: Brand<TContent, 'offchainMessageContentUtf8Of1232BytesMax'>;
+}>;
+/**
+ * Describes message text that is no more than 65535 bytes long and mdae up of any UTF-8 characters.
+ */
+export type OffchainMessageContentUtf8Of65535BytesMax<TContent extends string = string> = Readonly<{
+    format: OffchainMessageContentFormat.UTF8_65535_BYTES_MAX;
+    text: Brand<TContent, 'offchainMessageContentUtf8Of65535BytesMax'>;
+}>;
+export type OffchainMessageContent = OffchainMessageContentRestrictedAsciiOf1232BytesMax | OffchainMessageContentUtf8Of1232BytesMax | OffchainMessageContentUtf8Of65535BytesMax;
+/**
+ * In the event that you receive content of a v0 offchain message from an untrusted source, use this
+ * function to assert that it conforms to the
+ * {@link OffchainMessageContentRestrictedAsciiOf1232BytesMax} type.
+ *
+ * @see {@link OffchainMessageContentRestrictedAsciiOf1232BytesMax} for more detail.
+ */
+export declare function assertIsOffchainMessageContentRestrictedAsciiOf1232BytesMax(putativeContent: {
+    format: OffchainMessageContentFormat;
+    text: string;
+}): asserts putativeContent is OffchainMessageContentRestrictedAsciiOf1232BytesMax;
+/**
+ * A type guard that returns `true` when supplied content of a v0 offchain message that conforms to
+ * the {@link OffchainMessageContentRestrictedAsciiOf1232BytesMax} type, and refines its type for use in your
+ * program.
+ *
+ * @see {@link OffchainMessageContentRestrictedAsciiOf1232BytesMax} for more detail.
+ */
+export declare function isOffchainMessageContentRestrictedAsciiOf1232BytesMax(putativeContent: {
+    format: OffchainMessageContentFormat;
+    text: string;
+}): putativeContent is OffchainMessageContentRestrictedAsciiOf1232BytesMax;
+/**
+ * Combines _asserting_ that the content of a v0 offchain message is restricted ASCII with
+ * _coercing_ it to the {@link OffchainMessageContentRestrictedAsciiOf1232BytesMax} type. It's most
+ * useful with untrusted input.
+ *
+ * @example
+ * ```ts
+ * import { offchainMessageContentRestrictedAsciiOf1232BytesMax, OffchainMessageV0 } from '@solana/offchain-messages';
+ *
+ * function handleSubmit() {
+ *     // We know only that what the user typed conforms to the `string` type.
+ *     const text: string = textInput.value;
+ *     try {
+ *         const offchainMessage: OffchainMessageV0 = {
+ *             content: offchainMessageContentRestrictedAsciiOf1232BytesMax(text),
+ *             // ...
+ *         };
+ *     } catch (e) {
+ *         // `text` turned out not to conform to
+ *         // `OffchainMessageContentRestrictedAsciiOf1232BytesMax`
+ *     }
+ * }
+ * ```
+ *
+ * > [!TIP]
+ * > When starting from known-good ASCII content as a string, it's more efficient to typecast it
+ * > rather than to use the {@link offchainMessageContentRestrictedAsciiOf1232BytesMax} helper,
+ * > because the helper unconditionally performs validation on its input.
+ * >
+ * > ```ts
+ * > import { OffchainMessageContentFormat, OffchainMessageV0 } from '@solana/offchain-messages';
+ * >
+ * > const offchainMessage: OffchainMessageV0 = {
+ * >     /* ... *\/
+ * >     content: Object.freeze({
+ * >         format: OffchainMessageContentFormat.RESTRICTED_ASCII_1232_BYTES_MAX,
+ * >         text: 'Hello world',
+ * >     } as OffchainMessageContentRestrictedAsciiOf1232BytesMax<'Hello world'>),
+ * > };
+ * > ```
+ */
+export declare function offchainMessageContentRestrictedAsciiOf1232BytesMax<TText extends string>(text: TText): OffchainMessageContentRestrictedAsciiOf1232BytesMax<TText>;
+/**
+ * In the event that you receive content of a v0 offchain message from an untrusted source, use this
+ * function to assert that it conforms to the {@link OffchainMessageContentUtf8Of1232BytesMax} type.
+ *
+ * @see {@link OffchainMessageContentUtf8Of1232BytesMax} for more detail.
+ */
+export declare function assertIsOffchainMessageContentUtf8Of1232BytesMax(putativeContent: {
+    format: OffchainMessageContentFormat;
+    text: string;
+}): asserts putativeContent is OffchainMessageContentUtf8Of1232BytesMax;
+/**
+ * A type guard that returns `true` when supplied content of a v0 offchain message that conforms to
+ * the {@link OffchainMessageContentUtf8Of1232BytesMax} type, and refines its type for use in your
+ * program.
+ *
+ * @see {@link OffchainMessageContentUtf8Of1232BytesMax} for more detail.
+ */
+export declare function isOffchainMessageContentUtf8Of1232BytesMax(putativeContent: {
+    format: OffchainMessageContentFormat;
+    text: string;
+}): putativeContent is OffchainMessageContentUtf8Of1232BytesMax;
+/**
+ * Combines _asserting_ that the content of a v0 offchain message is UTF-8 of up to 1232 characters
+ * with _coercing_ it to the {@link OffchainMessageContentUtf8Of1232BytesMax} type. It's most useful
+ * with untrusted input.
+ *
+ * @example
+ * ```ts
+ * import { OffchainMessageContentUtf8Of1232BytesMax, OffchainMessageV0 } from '@solana/offchain-messages';
+ *
+ * function handleSubmit() {
+ *     // We know only that what the user typed conforms to the `string` type.
+ *     const text: string = textInput.value;
+ *     try {
+ *         const offchainMessage: OffchainMessageV0 = {
+ *             content: OffchainMessageContentUtf8Of1232BytesMax(text),
+ *             // ...
+ *         };
+ *     } catch (e) {
+ *         // `text` turned out not to conform to
+ *         // `OffchainMessageContentUtf8Of1232BytesMax`
+ *     }
+ * }
+ * ```
+ *
+ * > [!TIP]
+ * > When starting from known-good UTF-8 content as a string up to 1232 bytes, it's more efficient
+ * > to typecast it rather than to use the {@link offchainMessageContentUtf8Of1232BytesMax} helper,
+ * > because the helper unconditionally performs validation on its input.
+ * >
+ * > ```ts
+ * > import { OffchainMessageContentFormat, OffchainMessageV0 } from '@solana/offchain-messages';
+ * >
+ * > const offchainMessage: OffchainMessageV0 = {
+ * >     /* ... *\/
+ * >     content: Object.freeze({
+ * >         format: OffchainMessageContentFormat.UTF8_1232_BYTES_MAX,
+ * >         text: '✌🏿cool',
+ * >     } as OffchainMessageContentUtf8Of1232BytesMax<'✌🏿cool'>),
+ * > };
+ * > ```
+ */
+export declare function offchainMessageContentUtf8Of1232BytesMax<TText extends string>(text: TText): OffchainMessageContentUtf8Of1232BytesMax<TText>;
+/**
+ * In the event that you receive content of a v0 offchain message from an untrusted source, use this
+ * function to assert that it conforms to the {@link OffchainMessageContentUtf8Of65535BytesMax}
+ * type.
+ *
+ * @see {@link OffchainMessageContentUtf8Of65535BytesMax} for more detail.
+ */
+export declare function assertIsOffchainMessageContentUtf8Of65535BytesMax(putativeContent: {
+    format: OffchainMessageContentFormat;
+    text: string;
+}): asserts putativeContent is OffchainMessageContentUtf8Of65535BytesMax;
+/**
+ * A type guard that returns `true` when supplied content of a v0 offchain message that conforms to
+ * the {@link OffchainMessageContentUtf8Of65535BytesMax} type, and refines its type for use in your
+ * program.
+ *
+ * @see {@link OffchainMessageContentUtf8Of65535BytesMax} for more detail.
+ */
+export declare function isOffchainMessageContentUtf8Of65535BytesMax(putativeContent: {
+    format: OffchainMessageContentFormat;
+    text: string;
+}): putativeContent is OffchainMessageContentUtf8Of65535BytesMax;
+/**
+ * Combines _asserting_ that the content of a v0 offchain message is UTF-8 of up to 65535 characters
+ * with _coercing_ it to the {@link OffchainMessageContentUtf8Of65535BytesMax} type. It's most useful
+ * with untrusted input.
+ *
+ * @example
+ * ```ts
+ * import { OffchainMessageContentUtf8Of65535BytesMax, OffchainMessageV0 } from '@solana/offchain-messages';
+ *
+ * function handleSubmit() {
+ *     // We know only that what the user typed conforms to the `string` type.
+ *     const text: string = textInput.value;
+ *     try {
+ *         const offchainMessage: OffchainMessageV0 = {
+ *             content: OffchainMessageContentUtf8Of65535BytesMax(text),
+ *             // ...
+ *         };
+ *     } catch (e) {
+ *         // `text` turned out not to conform to
+ *         // `OffchainMessageContentUtf8Of65535BytesMax`
+ *     }
+ * }
+ * ```
+ *
+ * > [!TIP]
+ * > When starting from known-good UTF-8 content as a string up to 65535 bytes, it's more efficient
+ * > to typecast it rather than to use the {@link OffchainMessageContentUtf8Of65535BytesMax} helper,
+ * > because the helper unconditionally performs validation on its input.
+ * >
+ * > ```ts
+ * > import { OffchainMessageContentFormat, OffchainMessageV0 } from '@solana/offchain-messages';
+ * >
+ * > const offchainMessage: OffchainMessageV0 = {
+ * >     /* ... *\/
+ * >     content: Object.freeze({
+ * >         format: OffchainMessageContentFormat.UTF8_65535_BYTES_MAX,
+ * >         text: '✌🏿cool',
+ * >     } as OffchainMessageContentUtf8Of65535BytesMax<'✌🏿cool'>),
+ * > };
+ * > ```
+ */
+export declare function offchainMessageContentUtf8Of65535BytesMax<TText extends string>(text: TText): OffchainMessageContentUtf8Of65535BytesMax<TText>;
+//# sourceMappingURL=content.d.ts.map

package/dist/types/content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../src/content.ts"],"names":[],"mappings":"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"}

package/dist/types/envelope-common.d.ts

@@ -0,0 +1,9 @@
+import { VariableSizeEncoder } from '@solana/codecs-core';
+import { OffchainMessage, OffchainMessageBytes } from './message';
+export declare function compileOffchainMessageEnvelopeUsingEncoder<T extends OffchainMessage>(offchainMessage: T, encoder: VariableSizeEncoder<T>): Readonly<{
+    content: OffchainMessageBytes;
+    signatures: Readonly<{
+        [x: import("@solana/nominal-types").NominalType<"brand", "Address"> & import("@solana/nominal-types").NominalType<"stringEncoding", "base58"> & string]: import("@solana/keys").SignatureBytes | null;
+    }>;
+}>;
+//# sourceMappingURL=envelope-common.d.ts.map

package/dist/types/envelope-common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope-common.d.ts","sourceRoot":"","sources":["../../src/envelope-common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAG1D,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAElE,wBAAgB,0CAA0C,CAAC,CAAC,SAAS,eAAe,EAChF,eAAe,EAAE,CAAC,EAClB,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC;;;;;GAWlC"}

package/dist/types/envelope-v0.d.ts

@@ -0,0 +1,11 @@
+import { OffchainMessageEnvelope } from './envelope';
+import { OffchainMessageV0 } from './message-v0';
+/**
+ * Returns an {@link OffchainMessageEnvelope} object for a given {@link OffchainMessageV0}.
+ *
+ * This includes the compiled bytes of the offchain message, and a map of signatures. This map will
+ * have a key for each address that is required to sign the message. The message envelope will not
+ * yet have signatures for any of these signatories.
+ */
+export declare function compileOffchainMessageV0Envelope(offchainMessage: OffchainMessageV0): OffchainMessageEnvelope;
+//# sourceMappingURL=envelope-v0.d.ts.map

package/dist/types/envelope-v0.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope-v0.d.ts","sourceRoot":"","sources":["../../src/envelope-v0.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAErD,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEjD;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAAC,eAAe,EAAE,iBAAiB,GAAG,uBAAuB,CAE5G"}

package/dist/types/envelope-v1.d.ts

@@ -0,0 +1,11 @@
+import { OffchainMessageEnvelope } from './envelope';
+import { OffchainMessageV1 } from './message-v1';
+/**
+ * Returns an {@link OffchainMessageEnvelope} object for a given {@link OffchainMessageV1}.
+ *
+ * This includes the compiled bytes of the offchain message, and a map of signatures. This map will
+ * have a key for each address that is required to sign the message. The message envelope will not
+ * yet have signatures for any of these signatories.
+ */
+export declare function compileOffchainMessageV1Envelope(offchainMessage: OffchainMessageV1): OffchainMessageEnvelope;
+//# sourceMappingURL=envelope-v1.d.ts.map

package/dist/types/envelope-v1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope-v1.d.ts","sourceRoot":"","sources":["../../src/envelope-v1.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAErD,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEjD;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAAC,eAAe,EAAE,iBAAiB,GAAG,uBAAuB,CAE5G"}

package/dist/types/envelope.d.ts

@@ -0,0 +1,29 @@
+import { Address } from '@solana/addresses';
+import { SignatureBytes } from '@solana/keys';
+import { OffchainMessage, OffchainMessageBytes } from './message';
+type OrderedMap<K extends string, V> = Record<K, V>;
+type OffchainMessageSignaturesMap = OrderedMap<Address, SignatureBytes | null>;
+export interface OffchainMessageEnvelope {
+    /** The bytes of the combined offchain message preamble and content */
+    readonly content: OffchainMessageBytes;
+    /**
+     * A map between the addresses of an offchain message's signers, and the 64-byte Ed25519
+     * signature of the combined message preamble and message content by the private key associated
+     * with each.
+     */
+    readonly signatures: OffchainMessageSignaturesMap;
+}
+/**
+ * Returns an {@link OffchainMessageEnvelope} object for a given {@link OffchainMessage}.
+ *
+ * This includes the compiled bytes of the offchain message, and a map of signatures. This map will
+ * have a key for each address that is required to sign the message. The message envelope will not
+ * yet have signatures for any of these signatories.
+ *
+ * @remarks
+ * If the offchain message version is known ahead of time, use one of the compile functions
+ * specific to that version so as not to bundle more code than you need.
+ */
+export declare function compileOffchainMessageEnvelope(offchainMessage: OffchainMessage): OffchainMessageEnvelope;
+export {};
+//# sourceMappingURL=envelope.d.ts.map

package/dist/types/envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../../src/envelope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE5C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAI9C,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAElE,KAAK,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,IAAI,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACpD,KAAK,4BAA4B,GAAG,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAAC,CAAC;AAE/E,MAAM,WAAW,uBAAuB;IACpC,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,oBAAoB,CAAC;IACvC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,4BAA4B,CAAC;CACrD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAAC,eAAe,EAAE,eAAe,GAAG,uBAAuB,CAYxG"}

package/dist/types/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * This package contains utilities for encoding and decoding messages according to the offchain
+ * message [specification](https://github.com/solana-foundation/SRFCs/discussions/3).
+ * It can be used standalone, but it is also exported as part of Kit [`@solana/kit`](https://github.com/anza-xyz/kit/tree/main/packages/kit).
+ *
+ * @packageDocumentation
+ */
+export * from './application-domain';
+export * from './codecs/application-domain';
+export * from './codecs/envelope';
+export * from './codecs/message';
+export * from './codecs/message-v0';
+export * from './codecs/message-v1';
+export * from './content';
+export * from './envelope';
+export * from './envelope-v0';
+export * from './envelope-v1';
+export * from './message';
+export * from './message-v0';
+export * from './message-v1';
+export * from './signatures';
+export * from './version';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC"}

package/dist/types/message-v0.d.ts

@@ -0,0 +1,75 @@
+import { OffchainMessageContentFormat, OffchainMessageContentRestrictedAsciiOf1232BytesMax, OffchainMessageContentUtf8Of1232BytesMax, OffchainMessageContentUtf8Of65535BytesMax } from './content';
+import { OffchainMessagePreambleV0 } from './preamble-v0';
+import { OffchainMessageWithRequiredSignatories } from './signatures';
+export type BaseOffchainMessageV0 = Omit<OffchainMessagePreambleV0, 'messageFormat' | 'messageLength' | 'requiredSignatories'>;
+/**
+ * An offchain message whose content conforms to
+ * {@link OffchainMessageContentRestrictedAsciiOf1232BytesMax}
+ */
+export interface OffchainMessageWithRestrictedAsciiOf1232BytesMaxContent {
+    readonly content: OffchainMessageContentRestrictedAsciiOf1232BytesMax;
+}
+/**
+ * An offchain message whose content conforms to
+ * {@link offchainMessageContentUtf8Of1232BytesMax}
+ */
+export interface OffchainMessageWithUtf8Of1232BytesMaxContent {
+    readonly content: OffchainMessageContentUtf8Of1232BytesMax;
+}
+/**
+ * An offchain message whose content conforms to
+ * {@link OffchainMessageContentUtf8Of65535BytesMax}
+ */
+export interface OffchainMessageWithUtf8Of65535BytesMaxContent {
+    readonly content: OffchainMessageContentUtf8Of65535BytesMax;
+}
+/**
+ * A union of the formats a v0 message's contents can take.
+ *
+ * @remarks From v1 and onward, an offchain message has only one format: UTF-8 text of arbitrary
+ * length.
+ */
+export type OffchainMessageWithContent = OffchainMessageWithRestrictedAsciiOf1232BytesMaxContent | OffchainMessageWithUtf8Of1232BytesMaxContent | OffchainMessageWithUtf8Of65535BytesMaxContent;
+export type OffchainMessageV0 = BaseOffchainMessageV0 & OffchainMessageWithContent & OffchainMessageWithRequiredSignatories;
+/**
+ * In the event that you receive a v0 offchain message from an untrusted source, use this function
+ * to assert that it is one whose content conforms to the
+ * {@link OffchainMessageContentRestrictedAsciiOf1232BytesMax} type.
+ *
+ * @see {@link OffchainMessageContentRestrictedAsciiOf1232BytesMax} for more detail.
+ */
+export declare function assertIsOffchainMessageRestrictedAsciiOf1232BytesMax<TMessage extends OffchainMessageV0>(putativeMessage: Omit<TMessage, 'content'> & Readonly<{
+    content: {
+        format: OffchainMessageContentFormat;
+        text: string;
+    };
+}>): asserts putativeMessage is OffchainMessageWithRestrictedAsciiOf1232BytesMaxContent & Omit<TMessage, 'content'>;
+/**
+ * In the event that you receive a v0 offchain message from an untrusted source, use this function
+ * to assert that it is one whose content conforms to the
+ * {@link offchainMessageContentUtf8Of1232BytesMax} type.
+ *
+ * @see {@link offchainMessageContentUtf8Of1232BytesMax} for more detail.
+ */
+export declare function assertIsOffchainMessageUtf8Of1232BytesMax<TMessage extends OffchainMessageV0>(putativeMessage: Omit<TMessage, 'content'> & Readonly<{
+    content: {
+        format: OffchainMessageContentFormat;
+        text: string;
+    };
+    version: number;
+}>): asserts putativeMessage is OffchainMessageWithUtf8Of1232BytesMaxContent & Omit<TMessage, 'content'>;
+/**
+ * In the event that you receive a v0 offchain message from an untrusted source, use this function
+ * to assert that it is one whose content conforms to the
+ * {@link OffchainMessageContentUtf8Of65535BytesMax} type.
+ *
+ * @see {@link OffchainMessageContentUtf8Of65535BytesMax} for more detail.
+ */
+export declare function assertIsOffchainMessageUtf8Of65535BytesMax<TMessage extends OffchainMessageV0>(putativeMessage: Omit<TMessage, 'content'> & Readonly<{
+    content: {
+        format: OffchainMessageContentFormat;
+        text: string;
+    };
+    version: number;
+}>): asserts putativeMessage is OffchainMessageWithUtf8Of65535BytesMaxContent & Omit<TMessage, 'content'>;
+//# sourceMappingURL=message-v0.d.ts.map

package/dist/types/message-v0.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-v0.d.ts","sourceRoot":"","sources":["../../src/message-v0.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,4BAA4B,EAC5B,mDAAmD,EACnD,wCAAwC,EACxC,yCAAyC,EAC5C,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,sCAAsC,EAAE,MAAM,cAAc,CAAC;AAEtE,MAAM,MAAM,qBAAqB,GAAG,IAAI,CACpC,yBAAyB,EACzB,eAAe,GAAG,eAAe,GAAG,qBAAqB,CAC5D,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,uDAAuD;IACpE,QAAQ,CAAC,OAAO,EAAE,mDAAmD,CAAC;CACzE;AAED;;;GAGG;AACH,MAAM,WAAW,4CAA4C;IACzD,QAAQ,CAAC,OAAO,EAAE,wCAAwC,CAAC;CAC9D;AAED;;;GAGG;AACH,MAAM,WAAW,6CAA6C;IAC1D,QAAQ,CAAC,OAAO,EAAE,yCAAyC,CAAC;CAC/D;AAED;;;;;GAKG;AACH,MAAM,MAAM,0BAA0B,GAChC,uDAAuD,GACvD,4CAA4C,GAC5C,6CAA6C,CAAC;AAEpD,MAAM,MAAM,iBAAiB,GAAG,qBAAqB,GACjD,0BAA0B,GAC1B,sCAAsC,CAAC;AAE3C;;;;;;GAMG;AACH,wBAAgB,oDAAoD,CAAC,QAAQ,SAAS,iBAAiB,EACnG,eAAe,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,GACtC,QAAQ,CAAC;IACL,OAAO,EAAE;QACL,MAAM,EAAE,4BAA4B,CAAC;QACrC,IAAI,EAAE,MAAM,CAAC;KAChB,CAAC;CACL,CAAC,GACP,OAAO,CAAC,eAAe,IAAI,uDAAuD,GAAG,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,CAEhH;AAED;;;;;;GAMG;AACH,wBAAgB,yCAAyC,CAAC,QAAQ,SAAS,iBAAiB,EACxF,eAAe,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,GACtC,QAAQ,CAAC;IACL,OAAO,EAAE;QACL,MAAM,EAAE,4BAA4B,CAAC;QACrC,IAAI,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,OAAO,EAAE,MAAM,CAAC;CACnB,CAAC,GACP,OAAO,CAAC,eAAe,IAAI,4CAA4C,GAAG,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,CAErG;AAED;;;;;;GAMG;AACH,wBAAgB,0CAA0C,CAAC,QAAQ,SAAS,iBAAiB,EACzF,eAAe,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,GACtC,QAAQ,CAAC;IACL,OAAO,EAAE;QACL,MAAM,EAAE,4BAA4B,CAAC;QACrC,IAAI,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,OAAO,EAAE,MAAM,CAAC;CACnB,CAAC,GACP,OAAO,CAAC,eAAe,IAAI,6CAA6C,GAAG,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,CAEtG"}

package/dist/types/message-v1.d.ts

@@ -0,0 +1,7 @@
+import { OffchainMessagePreambleV1 } from './preamble-v1';
+import { OffchainMessageWithRequiredSignatories } from './signatures';
+export type BaseOffchainMessageV1 = Omit<OffchainMessagePreambleV1, 'requiredSignatories'>;
+export type OffchainMessageV1 = BaseOffchainMessageV1 & OffchainMessageWithRequiredSignatories & Readonly<{
+    content: string;
+}>;
+//# sourceMappingURL=message-v1.d.ts.map

package/dist/types/message-v1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-v1.d.ts","sourceRoot":"","sources":["../../src/message-v1.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,sCAAsC,EAAE,MAAM,cAAc,CAAC;AAEtE,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,yBAAyB,EAAE,qBAAqB,CAAC,CAAC;AAE3F,MAAM,MAAM,iBAAiB,GAAG,qBAAqB,GACjD,sCAAsC,GACtC,QAAQ,CAAC;IACL,OAAO,EAAE,MAAM,CAAC;CACnB,CAAC,CAAC"}

package/dist/types/message.d.ts

@@ -0,0 +1,7 @@
+import { ReadonlyUint8Array } from '@solana/codecs-core';
+import { Brand } from '@solana/nominal-types';
+import { OffchainMessageV0 } from './message-v0';
+import { OffchainMessageV1 } from './message-v1';
+export type OffchainMessage = OffchainMessageV0 | OffchainMessageV1;
+export type OffchainMessageBytes = Brand<ReadonlyUint8Array, 'OffchainMessageBytes'>;
+//# sourceMappingURL=message.d.ts.map

package/dist/types/message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../src/message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAE9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEjD,MAAM,MAAM,eAAe,GAAG,iBAAiB,GAAG,iBAAiB,CAAC;AACpE,MAAM,MAAM,oBAAoB,GAAG,KAAK,CAAC,kBAAkB,EAAE,sBAAsB,CAAC,CAAC"}

package/dist/types/preamble-v0.d.ts

@@ -0,0 +1,10 @@
+import { OffchainMessageApplicationDomain } from './application-domain';
+import { OffchainMessageContentFormat } from './content';
+import { OffchainMessageWithRequiredSignatories } from './signatures';
+export interface OffchainMessagePreambleV0 extends OffchainMessageWithRequiredSignatories {
+    applicationDomain: OffchainMessageApplicationDomain;
+    messageFormat: OffchainMessageContentFormat;
+    messageLength: number;
+    version: 0;
+}
+//# sourceMappingURL=preamble-v0.d.ts.map

package/dist/types/preamble-v0.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preamble-v0.d.ts","sourceRoot":"","sources":["../../src/preamble-v0.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAE,4BAA4B,EAAE,MAAM,WAAW,CAAC;AACzD,OAAO,EAAE,sCAAsC,EAAE,MAAM,cAAc,CAAC;AAEtE,MAAM,WAAW,yBAA0B,SAAQ,sCAAsC;IACrF,iBAAiB,EAAE,gCAAgC,CAAC;IACpD,aAAa,EAAE,4BAA4B,CAAC;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,CAAC,CAAC;CACd"}

package/dist/types/preamble-v1.d.ts

@@ -0,0 +1,5 @@
+import { OffchainMessageWithRequiredSignatories } from './signatures';
+export interface OffchainMessagePreambleV1 extends OffchainMessageWithRequiredSignatories {
+    version: 1;
+}
+//# sourceMappingURL=preamble-v1.d.ts.map

package/dist/types/preamble-v1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preamble-v1.d.ts","sourceRoot":"","sources":["../../src/preamble-v1.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sCAAsC,EAAE,MAAM,cAAc,CAAC;AAEtE,MAAM,WAAW,yBAA0B,SAAQ,sCAAsC;IACrF,OAAO,EAAE,CAAC,CAAC;CACd"}

package/dist/types/signatures.d.ts

@@ -0,0 +1,138 @@
+import { Address } from '@solana/addresses';
+import { NominalType } from '@solana/nominal-types';
+import { OffchainMessageEnvelope } from './envelope';
+/**
+ * Represents an offchain message envelope that is signed by all of its required signers.
+ */
+export type FullySignedOffchainMessageEnvelope = NominalType<'offchainMessageEnvelopeSignedness', 'fullySigned'>;
+/**
+ * Represents an address that is required to sign an offchain message for it to be valid.
+ */
+export type OffchainMessageSignatory<TAddress extends string = string> = Readonly<{
+    address: Address<TAddress>;
+}>;
+/**
+ * An offchain message having a list of accounts that must sign it in order for it to be valid.
+ */
+export interface OffchainMessageWithRequiredSignatories<TSignatory extends OffchainMessageSignatory = OffchainMessageSignatory> {
+    requiredSignatories: readonly TSignatory[];
+}
+/**
+ * Given an array of `CryptoKey` objects which are private keys pertaining to addresses that are
+ * required to sign an offchain message, this method will return a new signed offchain message
+ * envelope of type {@link OffchainMessageEnvelope}.
+ *
+ * Though the resulting message might be signed by all required signers, this function will not
+ * assert that it is. A partially signed message is not complete, but can be serialized and
+ * deserialized.
+ *
+ * @example
+ * ```ts
+ * import { generateKeyPair } from '@solana/keys';
+ * import { partiallySignOffchainMessageEnvelope } from '@solana/offchain-messages';
+ *
+ * const partiallySignedOffchainMessage = await partiallySignOffchainMessageEnvelope(
+ *     [myPrivateKey],
+ *     offchainMessageEnvelope,
+ * );
+ * ```
+ *
+ * @see {@link signOffchainMessageEnvelope} if you want to assert that the message is signed by all
+ * its required signers after signing.
+ */
+export declare function partiallySignOffchainMessageEnvelope<TOffchainMessageEnvelope extends OffchainMessageEnvelope>(keyPairs: CryptoKeyPair[], offchainMessageEnvelope: TOffchainMessageEnvelope): Promise<TOffchainMessageEnvelope>;
+/**
+ * Given an array of `CryptoKey` objects which are private keys pertaining to addresses that are
+ * required to sign an offchain message envelope, this method will return a new signed envelope of
+ * type {@link FullySignedOffchainMessageEnvelope}.
+ *
+ * This function will throw unless the resulting message is fully signed.
+ *
+ * @example
+ * ```ts
+ * import { generateKeyPair } from '@solana/keys';
+ * import { signOffchainMessageEnvelope } from '@solana/offchain-messages';
+ *
+ * const signedOffchainMessage = await signOffchainMessageEnvelope(
+ *     [myPrivateKey],
+ *     offchainMessageEnvelope,
+ * );
+ * ```
+ *
+ * @see {@link partiallySignOffchainMessageEnvelope} if you want to sign the message without
+ * asserting that the resulting message envelope is fully signed.
+ */
+export declare function signOffchainMessageEnvelope<TOffchainMessageEnvelope extends OffchainMessageEnvelope>(keyPairs: CryptoKeyPair[], offchainMessageEnvelope: TOffchainMessageEnvelope): Promise<FullySignedOffchainMessageEnvelope & TOffchainMessageEnvelope>;
+/**
+ * A type guard that returns `true` if the input {@link OffchainMessageEnvelope} is fully signed,
+ * and refines its type for use in your program, adding the
+ * {@link FullySignedOffchainMessageEnvelope} type.
+ *
+ * @example
+ * ```ts
+ * import { isFullySignedOffchainMessageEnvelope } from '@solana/offchain-messages';
+ *
+ * const offchainMessageEnvelope = getOffchainMessageDecoder().decode(offchainMessageBytes);
+ * if (isFullySignedOffchainMessageEnvelope(offchainMessageEnvelope)) {
+ *   // At this point we know that the offchain message is fully signed.
+ * }
+ * ```
+ */
+export declare function isFullySignedOffchainMessageEnvelope<TEnvelope extends OffchainMessageEnvelope>(offchainMessage: TEnvelope): offchainMessage is FullySignedOffchainMessageEnvelope & TEnvelope;
+/**
+ * From time to time you might acquire a {@link OffchainMessageEnvelope}, that you expect to be
+ * fully signed, from an untrusted network API or user input. Use this function to assert that such
+ * an offchain message is fully signed.
+ *
+ * @example
+ * ```ts
+ * import { assertIsFullySignedOffchainMessage } from '@solana/offchain-messages';
+ *
+ * const offchainMessageEnvelope = getOffchainMessageDecoder().decode(offchainMessageBytes);
+ * try {
+ *     // If this type assertion function doesn't throw, then Typescript will upcast
+ *     // `offchainMessageEnvelope` to `FullySignedOffchainMessageEnvelope`.
+ *     assertIsFullySignedOffchainMessageEnvelope(offchainMessage);
+ *     // At this point we know that the offchain message is signed by all required signers.
+ * } catch(e) {
+ *     if (isSolanaError(e, SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURES_MISSING)) {
+ *         setError(`Missing signatures for ${e.context.addresses.join(', ')}`);
+ *     } else {
+ *         throw e;
+ *     }
+ * }
+ * ```
+ */
+export declare function assertIsFullySignedOffchainMessageEnvelope<TEnvelope extends OffchainMessageEnvelope>(offchainMessage: TEnvelope): asserts offchainMessage is FullySignedOffchainMessageEnvelope & TEnvelope;
+/**
+ * Asserts that there are signatures present for all of an offchain message's required signatories,
+ * and that those signatures are valid given the message.
+ *
+ * @example
+ * ```ts
+ * import { isSolanaError, SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURE_VERIFICATION_FAILURE } from '@solana/errors';
+ * import { verifyOffchainMessageEnvelope } from '@solana/offchain-messages';
+ *
+ * try {
+ *     await verifyOffchainMessageEnvelope(offchainMessageEnvelope);
+ *     // At this point the message is valid and signed by all of the required signatories.
+ * } catch (e) {
+ *     if (isSolanaError(e, SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURE_VERIFICATION_FAILURE)) {
+ *         if (e.context.signatoriesWithMissingSignatures.length) {
+ *             console.error(
+ *                 'Missing signatures for the following addresses',
+ *                 e.context.signatoriesWithMissingSignatures,
+ *             );
+ *         }
+ *         if (e.context.signatoriesWithInvalidSignatures.length) {
+ *             console.error(
+ *                 'Signatures for the following addresses are invalid',
+ *                 e.context.signatoriesWithInvalidSignatures,
+ *             );
+ *         }
+ *     }
+ *     throw e;
+ * }
+ */
+export declare function verifyOffchainMessageEnvelope(offchainMessageEnvelope: OffchainMessageEnvelope): Promise<void>;
+//# sourceMappingURL=signatures.d.ts.map