@solana-mobile/mobile-wallet-adapter-protocol 2.1.5 → 2.1.6

package/lib/types/index.d.ts

@@ -11,6 +11,7 @@ declare const SolanaMobileWalletAdapterErrorCode: {
     readonly ERROR_SESSION_TIMEOUT: "ERROR_SESSION_TIMEOUT";
     readonly ERROR_WALLET_NOT_FOUND: "ERROR_WALLET_NOT_FOUND";
     readonly ERROR_INVALID_PROTOCOL_VERSION: "ERROR_INVALID_PROTOCOL_VERSION";
+    readonly ERROR_BROWSER_NOT_SUPPORTED: "ERROR_BROWSER_NOT_SUPPORTED";
 };
 type SolanaMobileWalletAdapterErrorCodeEnum = (typeof SolanaMobileWalletAdapterErrorCode)[keyof typeof SolanaMobileWalletAdapterErrorCode];
 type ErrorDataTypeMap = {
@@ -28,6 +29,7 @@ type ErrorDataTypeMap = {
     [SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_TIMEOUT]: undefined;
     [SolanaMobileWalletAdapterErrorCode.ERROR_WALLET_NOT_FOUND]: undefined;
     [SolanaMobileWalletAdapterErrorCode.ERROR_INVALID_PROTOCOL_VERSION]: undefined;
+    [SolanaMobileWalletAdapterErrorCode.ERROR_BROWSER_NOT_SUPPORTED]: undefined;
 };
 declare class SolanaMobileWalletAdapterError<TErrorCode extends SolanaMobileWalletAdapterErrorCodeEnum> extends Error {
     data: ErrorDataTypeMap[TErrorCode] | undefined;
@@ -248,10 +250,14 @@ type SignInResult = Readonly<{
     signature: Base64EncodedAddress;
     signature_type?: string;
 }>;
-declare function transact<TReturn>(callback: (wallet: MobileWallet) => TReturn, config?: WalletAssociationConfig): Promise<TReturn>;
-declare function transactRemote<TReturn>(callback: (wallet: RemoteMobileWallet) => TReturn, config: RemoteWalletAssociationConfig): Promise<{
+type Scenario = Readonly<{
+    wallet: Promise<MobileWallet>;
+    close: () => void;
+}>;
+type RemoteScenario = Scenario & Readonly<{
     associationUrl: URL;
-    result: Promise<TReturn>;
 }>;
-export { SolanaMobileWalletAdapterErrorCode, SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterProtocolErrorCode, SolanaMobileWalletAdapterProtocolError, transact, transactRemote, Account, AppIdentity, AssociationKeypair, ProtocolVersion, SessionProperties, AuthorizationResult, AuthToken, Base64EncodedAddress, Base64EncodedTransaction, Cluster, Chain, Finality, WalletAssociationConfig, RemoteWalletAssociationConfig, AuthorizeAPI, CloneAuthorizationAPI, DeauthorizeAPI, GetCapabilitiesAPI, ReauthorizeAPI, SignMessagesAPI, SignTransactionsAPI, SignAndSendTransactionsAPI, MobileWallet, TerminateSessionAPI, RemoteMobileWallet, SolanaSignTransactions, SolanaCloneAuthorization, SolanaSignInWithSolana, SignInPayload, SignInPayloadWithRequiredFields, SignInResult };
+declare function transact<TReturn>(callback: (wallet: MobileWallet) => TReturn, config?: WalletAssociationConfig): Promise<TReturn>;
+declare function startRemoteScenario(config: RemoteWalletAssociationConfig): Promise<RemoteScenario>;
+export { SolanaMobileWalletAdapterErrorCode, SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterProtocolErrorCode, SolanaMobileWalletAdapterProtocolError, transact, startRemoteScenario, Account, AppIdentity, AssociationKeypair, ProtocolVersion, SessionProperties, AuthorizationResult, AuthToken, Base64EncodedAddress, Base64EncodedTransaction, Cluster, Chain, Finality, WalletAssociationConfig, RemoteWalletAssociationConfig, AuthorizeAPI, CloneAuthorizationAPI, DeauthorizeAPI, GetCapabilitiesAPI, ReauthorizeAPI, SignMessagesAPI, SignTransactionsAPI, SignAndSendTransactionsAPI, MobileWallet, TerminateSessionAPI, RemoteMobileWallet, SolanaSignTransactions, SolanaCloneAuthorization, SolanaSignInWithSolana, SignInPayload, SignInPayloadWithRequiredFields, SignInResult, Scenario, RemoteScenario };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts","../../src/errors.ts","../../src/createHelloReq.ts","../../src/types.ts","../../src/base64Utils.ts","../../src/createSIWSMessage.ts","../../src/createMobileWalletProxy.ts","../../src/createSequenceNumberVector.ts","../../src/parseHelloRsp.ts","../../src/encryptedMessage.ts","../../src/generateAssociationKeypair.ts","../../src/generateECDHKeypair.ts","../../src/jsonRpcMessage.ts","../../src/parseSessionProps.ts","../../src/associationPort.ts","../../src/arrayBufferToBase64String.ts","../../src/getStringWithURLUnsafeBase64CharactersReplaced.ts","../../src/reflectorId.ts","../../src/getAssociateAndroidIntentURL.ts","../../src/startSession.ts","../../src/transact.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts","../../src/errors.ts","../../src/base64Utils.ts","../../src/createHelloReq.ts","../../src/types.ts","../../src/createSIWSMessage.ts","../../src/createMobileWalletProxy.ts","../../src/createSequenceNumberVector.ts","../../src/parseHelloRsp.ts","../../src/encryptedMessage.ts","../../src/generateAssociationKeypair.ts","../../src/generateECDHKeypair.ts","../../src/arrayBufferToBase64String.ts","../../src/associationPort.ts","../../src/getStringWithURLUnsafeBase64CharactersReplaced.ts","../../src/getAssociateAndroidIntentURL.ts","../../src/jsonRpcMessage.ts","../../src/parseSessionProps.ts","../../src/startSession.ts","../../src/transact.ts"],"names":[],"mappings":""}

package/lib/types/index.native.d.ts

@@ -11,6 +11,7 @@ declare const SolanaMobileWalletAdapterErrorCode: {
     readonly ERROR_SESSION_TIMEOUT: "ERROR_SESSION_TIMEOUT";
     readonly ERROR_WALLET_NOT_FOUND: "ERROR_WALLET_NOT_FOUND";
     readonly ERROR_INVALID_PROTOCOL_VERSION: "ERROR_INVALID_PROTOCOL_VERSION";
+    readonly ERROR_BROWSER_NOT_SUPPORTED: "ERROR_BROWSER_NOT_SUPPORTED";
 };
 type SolanaMobileWalletAdapterErrorCodeEnum = (typeof SolanaMobileWalletAdapterErrorCode)[keyof typeof SolanaMobileWalletAdapterErrorCode];
 type ErrorDataTypeMap = {
@@ -28,6 +29,7 @@ type ErrorDataTypeMap = {
     [SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_TIMEOUT]: undefined;
     [SolanaMobileWalletAdapterErrorCode.ERROR_WALLET_NOT_FOUND]: undefined;
     [SolanaMobileWalletAdapterErrorCode.ERROR_INVALID_PROTOCOL_VERSION]: undefined;
+    [SolanaMobileWalletAdapterErrorCode.ERROR_BROWSER_NOT_SUPPORTED]: undefined;
 };
 declare class SolanaMobileWalletAdapterError<TErrorCode extends SolanaMobileWalletAdapterErrorCodeEnum> extends Error {
     data: ErrorDataTypeMap[TErrorCode] | undefined;
@@ -248,10 +250,14 @@ type SignInResult = Readonly<{
     signature: Base64EncodedAddress;
     signature_type?: string;
 }>;
-declare function transact<TReturn>(callback: (wallet: MobileWallet) => TReturn, config?: WalletAssociationConfig): Promise<TReturn>;
-declare function transactRemote<TReturn>(callback: (wallet: RemoteMobileWallet) => TReturn, config: RemoteWalletAssociationConfig): Promise<{
+type Scenario = Readonly<{
+    wallet: Promise<MobileWallet>;
+    close: () => void;
+}>;
+type RemoteScenario = Scenario & Readonly<{
     associationUrl: URL;
-    result: Promise<TReturn>;
 }>;
-export { SolanaMobileWalletAdapterErrorCode, SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterProtocolErrorCode, SolanaMobileWalletAdapterProtocolError, transact, transactRemote, Account, AppIdentity, AssociationKeypair, ProtocolVersion, SessionProperties, AuthorizationResult, AuthToken, Base64EncodedAddress, Base64EncodedTransaction, Cluster, Chain, Finality, WalletAssociationConfig, RemoteWalletAssociationConfig, AuthorizeAPI, CloneAuthorizationAPI, DeauthorizeAPI, GetCapabilitiesAPI, ReauthorizeAPI, SignMessagesAPI, SignTransactionsAPI, SignAndSendTransactionsAPI, MobileWallet, TerminateSessionAPI, RemoteMobileWallet, SolanaSignTransactions, SolanaCloneAuthorization, SolanaSignInWithSolana, SignInPayload, SignInPayloadWithRequiredFields, SignInResult };
+declare function transact<TReturn>(callback: (wallet: MobileWallet) => TReturn, config?: WalletAssociationConfig): Promise<TReturn>;
+declare function startRemoteScenario(config: RemoteWalletAssociationConfig): Promise<RemoteScenario>;
+export { SolanaMobileWalletAdapterErrorCode, SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterProtocolErrorCode, SolanaMobileWalletAdapterProtocolError, transact, startRemoteScenario, Account, AppIdentity, AssociationKeypair, ProtocolVersion, SessionProperties, AuthorizationResult, AuthToken, Base64EncodedAddress, Base64EncodedTransaction, Cluster, Chain, Finality, WalletAssociationConfig, RemoteWalletAssociationConfig, AuthorizeAPI, CloneAuthorizationAPI, DeauthorizeAPI, GetCapabilitiesAPI, ReauthorizeAPI, SignMessagesAPI, SignTransactionsAPI, SignAndSendTransactionsAPI, MobileWallet, TerminateSessionAPI, RemoteMobileWallet, SolanaSignTransactions, SolanaCloneAuthorization, SolanaSignInWithSolana, SignInPayload, SignInPayloadWithRequiredFields, SignInResult, Scenario, RemoteScenario };
 //# sourceMappingURL=index.native.d.ts.map

package/lib/types/index.native.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.native.d.ts","sourceRoot":"","sources":["../../src/index.ts","../../src/errors.ts","../../src/createHelloReq.ts","../../src/types.ts","../../src/base64Utils.ts","../../src/createSIWSMessage.ts","../../src/createMobileWalletProxy.ts","../../src/createSequenceNumberVector.ts","../../src/parseHelloRsp.ts","../../src/encryptedMessage.ts","../../src/generateAssociationKeypair.ts","../../src/generateECDHKeypair.ts","../../src/jsonRpcMessage.ts","../../src/parseSessionProps.ts","../../src/associationPort.ts","../../src/arrayBufferToBase64String.ts","../../src/getStringWithURLUnsafeBase64CharactersReplaced.ts","../../src/reflectorId.ts","../../src/getAssociateAndroidIntentURL.ts","../../src/startSession.ts","../../src/transact.ts","../../src/codegenSpec/NativeSolanaMobileWalletAdapter.ts","../../src/__forks__/react-native/transact.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.native.d.ts","sourceRoot":"","sources":["../../src/index.ts","../../src/errors.ts","../../src/base64Utils.ts","../../src/createHelloReq.ts","../../src/types.ts","../../src/createSIWSMessage.ts","../../src/createMobileWalletProxy.ts","../../src/createSequenceNumberVector.ts","../../src/parseHelloRsp.ts","../../src/encryptedMessage.ts","../../src/generateAssociationKeypair.ts","../../src/generateECDHKeypair.ts","../../src/arrayBufferToBase64String.ts","../../src/associationPort.ts","../../src/getStringWithURLUnsafeBase64CharactersReplaced.ts","../../src/getAssociateAndroidIntentURL.ts","../../src/jsonRpcMessage.ts","../../src/parseSessionProps.ts","../../src/startSession.ts","../../src/transact.ts","../../src/codegenSpec/NativeSolanaMobileWalletAdapter.ts","../../src/__forks__/react-native/transact.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@solana-mobile/mobile-wallet-adapter-protocol",
     "description": "An implementation of the Solana Mobile Mobile Wallet Adapter protocol. Use this to open a session with a mobile wallet app, and to issue API calls to it.",
-    "version": "2.1.5",
+    "version": "2.1.6",
     "author": "Steven Luscher <steven.luscher@solanamobile.com>",
     "repository": {
         "type": "git",
@@ -28,6 +28,7 @@
     },
     "files": [
         "android",
+        "src/codegenSpec",
         "!android/build",
         "lib",
         "LICENSE"

package/src/__forks__/react-native/base64Utils.ts

@@ -0,0 +1 @@
+export { encode, fromUint8Array, toUint8Array } from 'js-base64';

package/src/__forks__/react-native/transact.ts

@@ -0,0 +1,91 @@
+import { Platform } from 'react-native';
+
+import NativeSolanaMobileWalletAdapter from '../../codegenSpec/NativeSolanaMobileWalletAdapter.js';
+import createMobileWalletProxy from '../../createMobileWalletProxy.js';
+import { SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterProtocolError } from '../../errors.js';
+import { MobileWallet, SessionProperties, WalletAssociationConfig } from '../../types.js';
+
+type ReactNativeError = Error & { code?: string; userInfo?: Record<string, unknown> };
+
+const LINKING_ERROR =
+    `The package 'solana-mobile-wallet-adapter-protocol' doesn't seem to be linked. Make sure: \n\n` +
+    '- You rebuilt the app after installing the package\n' +
+    '- If you are using Lerna workspaces\n' +
+    '  - You have added `@solana-mobile/mobile-wallet-adapter-protocol` as an explicit dependency, and\n' +
+    '  - You have added `@solana-mobile/mobile-wallet-adapter-protocol` to the `nohoist` section of your package.json\n' +
+    '- You are not using Expo managed workflow\n';
+
+const SolanaMobileWalletAdapter =
+    Platform.OS === 'android' && NativeSolanaMobileWalletAdapter
+        ? NativeSolanaMobileWalletAdapter
+        : (new Proxy(
+              {},
+              {
+                  get() {
+                      throw new Error(
+                          Platform.OS !== 'android'
+                              ? 'The package `solana-mobile-wallet-adapter-protocol` is only compatible with React Native Android'
+                              : LINKING_ERROR,
+                      );
+                  },
+              },
+          ) as typeof NativeSolanaMobileWalletAdapter);
+
+function getErrorMessage(e: ReactNativeError): string {
+    switch (e.code) {
+        case 'ERROR_WALLET_NOT_FOUND':
+            return 'Found no installed wallet that supports the mobile wallet protocol.';
+        default:
+            return e.message;
+    }
+}
+
+function handleError(e: any): never {
+    if (e instanceof Error) {
+        const reactNativeError: ReactNativeError = e;
+        switch (reactNativeError.code) {
+            case undefined:
+                throw e;
+            case 'JSON_RPC_ERROR': {
+                const details = reactNativeError.userInfo as Readonly<{ jsonRpcErrorCode: number }>;
+                throw new SolanaMobileWalletAdapterProtocolError(
+                    0 /* jsonRpcMessageId */,
+                    details.jsonRpcErrorCode,
+                    e.message,
+                );
+            }
+            default:
+                throw new SolanaMobileWalletAdapterError<any>(
+                    reactNativeError.code,
+                    getErrorMessage(reactNativeError),
+                    reactNativeError.userInfo,
+                );
+        }
+    }
+    throw e;
+}
+
+export async function transact<TReturn>(
+    callback: (wallet: MobileWallet) => TReturn,
+    config?: WalletAssociationConfig,
+): Promise<TReturn> {
+    let didSuccessfullyConnect = false;
+    try {
+        const sessionProperties: SessionProperties = await SolanaMobileWalletAdapter.startSession(config);
+        didSuccessfullyConnect = true;
+        const wallet = createMobileWalletProxy(sessionProperties.protocol_version, async (method, params) => {
+            try {
+                return SolanaMobileWalletAdapter.invoke(method, params);
+            } catch (e) {
+                return handleError(e);
+            }
+        });
+        return await callback(wallet);
+    } catch (e) {
+        return handleError(e);
+    } finally {
+        if (didSuccessfullyConnect) {
+            await SolanaMobileWalletAdapter.endSession();
+        }
+    }
+}

package/src/arrayBufferToBase64String.ts

@@ -0,0 +1,10 @@
+// https://stackoverflow.com/a/9458996/802047
+export default function arrayBufferToBase64String(buffer: ArrayBuffer) {
+    let binary = '';
+    const bytes = new Uint8Array(buffer);
+    const len = bytes.byteLength;
+    for (let ii = 0; ii < len; ii++) {
+        binary += String.fromCharCode(bytes[ii]);
+    }
+    return window.btoa(binary);
+}

package/src/associationPort.ts

@@ -0,0 +1,19 @@
+import { SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterErrorCode } from './errors.js';
+
+declare const tag: unique symbol;
+export type AssociationPort = number & { readonly [tag]: 'AssociationPort' };
+
+export function getRandomAssociationPort(): AssociationPort {
+    return assertAssociationPort(49152 + Math.floor(Math.random() * (65535 - 49152 + 1)));
+}
+
+export function assertAssociationPort(port: number): AssociationPort {
+    if (port < 49152 || port > 65535) {
+        throw new SolanaMobileWalletAdapterError(
+            SolanaMobileWalletAdapterErrorCode.ERROR_ASSOCIATION_PORT_OUT_OF_RANGE,
+            `Association port number must be between 49152 and 65535. ${port} given.`,
+            { port },
+        );
+    }
+    return port as AssociationPort;
+}

package/src/base64Utils.ts

@@ -0,0 +1,22 @@
+export function encode(input: string): string {
+    return window.btoa(input);
+}
+
+export function fromUint8Array(byteArray: Uint8Array, urlsafe?: boolean): string {
+    const base64 = window.btoa(String.fromCharCode.call(null, ...byteArray));
+    if (urlsafe) {
+        return base64
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=+$/, '');
+    } else return base64;
+}
+
+export function toUint8Array(base64EncodedByteArray: string): Uint8Array {
+    return new Uint8Array(
+        window
+            .atob(base64EncodedByteArray)
+            .split('')
+            .map((c) => c.charCodeAt(0)),
+    );
+}

package/src/codegenSpec/NativeSolanaMobileWalletAdapter.ts

@@ -0,0 +1,13 @@
+import { TurboModule, TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+    startSession(config?: { baseUri?: string }): Promise<{
+        protocol_version: 'legacy' | 'v1';
+    }>;
+
+    invoke(method: string, params: Object | undefined): Promise<Object>;
+
+    endSession(): Promise<boolean>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('SolanaMobileWalletAdapter') as Spec;

package/src/createHelloReq.ts

@@ -0,0 +1,12 @@
+export default async function createHelloReq(ecdhPublicKey: CryptoKey, associationKeypairPrivateKey: CryptoKey) {
+    const publicKeyBuffer = await crypto.subtle.exportKey('raw', ecdhPublicKey);
+    const signatureBuffer = await crypto.subtle.sign(
+        { hash: 'SHA-256', name: 'ECDSA' },
+        associationKeypairPrivateKey,
+        publicKeyBuffer,
+    );
+    const response = new Uint8Array(publicKeyBuffer.byteLength + signatureBuffer.byteLength);
+    response.set(new Uint8Array(publicKeyBuffer), 0);
+    response.set(new Uint8Array(signatureBuffer), publicKeyBuffer.byteLength);
+    return response;
+}

package/src/createMobileWalletProxy.ts

@@ -0,0 +1,182 @@
+import { createSIWSMessageBase64 } from "./createSIWSMessage";
+import { 
+    AuthorizationResult, 
+    MobileWallet, 
+    ProtocolVersion, 
+    SignInPayload, 
+    SignInResult, 
+    SolanaCloneAuthorization, 
+    SolanaSignTransactions 
+} from "./types";
+import type { IdentifierArray } from "@wallet-standard/core";
+
+/**
+ * Creates a {@link MobileWallet} proxy that handles backwards compatibility and API to RPC conversion.
+ * 
+ * @param protocolVersion the protocol version in use for this session/request
+ * @param protocolRequestHandler callback function that handles sending the RPC request to the wallet endpoint.
+ * @returns a {@link MobileWallet} proxy
+ */
+export default function createMobileWalletProxy<
+    TMethodName extends keyof MobileWallet, 
+    TReturn extends Awaited<ReturnType<MobileWallet[TMethodName]>>
+>(
+    protocolVersion: ProtocolVersion,
+    protocolRequestHandler: (method: string, params: Parameters<MobileWallet[TMethodName]>[0]) => Promise<any>
+): MobileWallet {
+    return new Proxy<MobileWallet>({} as MobileWallet, {
+        get<TMethodName extends keyof MobileWallet>(target: MobileWallet, p: TMethodName) {
+            // Wrapping a Proxy in a promise results in the Proxy being asked for a 'then' property so must 
+            // return null if 'then' is called on this proxy to let the 'resolve()' call know this is not a promise.
+            // see: https://stackoverflow.com/a/53890904
+            //@ts-ignore
+            if (p === 'then') { 
+                return null;
+            }
+            if (target[p] == null) {
+                target[p] = async function (inputParams: Parameters<MobileWallet[TMethodName]>[0]) {
+                    const { method, params } = handleMobileWalletRequest(p, inputParams, protocolVersion);
+                    const result = await protocolRequestHandler(method, params) as Awaited<ReturnType<MobileWallet[TMethodName]>>;
+                    // if the request tried to sign in but the wallet did not return a sign in result, fallback on message signing
+                    if (method === 'authorize' && (params as any).sign_in_payload && !(result as any).sign_in_result) {
+                        (result as any)['sign_in_result'] = await signInFallback(
+                            (params as Parameters<MobileWallet['authorize']>[0]).sign_in_payload as SignInPayload, 
+                            result as Awaited<ReturnType<MobileWallet['authorize']>>, 
+                            protocolRequestHandler
+                        );
+                    }
+                    return handleMobileWalletResponse(p, result, protocolVersion) as TReturn;
+                } as MobileWallet[TMethodName];
+            }
+            return target[p];
+        },
+        defineProperty() {
+            return false;
+        },
+        deleteProperty() {
+            return false;
+        },
+    });
+};
+
+/**
+ * Handles all {@link MobileWallet} API requests and determines the correct MWA RPC method and params to call.
+ * This handles backwards compatibility, based on the provided @protocolVersion. 
+ * 
+ * @param methodName the name of {@link MobileWallet} method that was called
+ * @param methodParams the parameters that were passed to the method
+ * @param protocolVersion the protocol version in use for this session/request
+ * @returns the RPC request method and params that should be sent to the wallet endpoint 
+ */
+function handleMobileWalletRequest<TMethodName extends keyof MobileWallet>(
+    methodName: TMethodName, 
+    methodParams: Parameters<MobileWallet[TMethodName]>[0],
+    protocolVersion: ProtocolVersion
+) {
+    let params = methodParams;
+    let method: string = methodName
+        .toString()
+        .replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)
+        .toLowerCase();
+    switch (methodName) {
+        case 'authorize': {
+            let { chain } = params as Parameters<MobileWallet['authorize']>[0];
+            if (protocolVersion === 'legacy') {
+                switch (chain) {
+                    case 'solana:testnet': { chain = 'testnet'; break; }
+                    case 'solana:devnet': { chain = 'devnet'; break; }
+                    case 'solana:mainnet': { chain = 'mainnet-beta'; break; }
+                    default: { chain = (params as any).cluster; }
+                }
+                (params as any).cluster = chain;
+            } else {
+                switch (chain) {
+                    case 'testnet':
+                    case 'devnet': { chain = `solana:${chain}`; break; }
+                    case 'mainnet-beta': { chain = 'solana:mainnet'; break; }
+                }
+                (params as Parameters<MobileWallet['authorize']>[0]).chain = chain;
+            }
+        }
+        case 'reauthorize': {
+            const { auth_token, identity } = params as Parameters<MobileWallet['authorize' | 'reauthorize']>[0];
+            if (auth_token) {
+                switch (protocolVersion) {
+                    case 'legacy': {
+                        method = 'reauthorize';
+                        params = { auth_token: auth_token, identity: identity };
+                        break;
+                    }
+                    default: {
+                        method = 'authorize';
+                        break;
+                    }
+                }
+            }
+            break;
+        }
+    }
+    return { method, params }
+};
+
+/**
+ * Handles all {@link MobileWallet} API responses and modifies the response for backwards compatibility, if needed 
+ * 
+ * @param method the {@link MobileWallet} method that was called
+ * @param response the original response that was returned by the method call
+ * @param protocolVersion the protocol version in use for this session/request
+ * @returns the possibly modified response 
+ */
+function handleMobileWalletResponse<TMethodName extends keyof MobileWallet>(
+    method: TMethodName, 
+    response: Awaited<ReturnType<MobileWallet[TMethodName]>>,
+    protocolVersion: ProtocolVersion
+): Awaited<ReturnType<MobileWallet[TMethodName]>> {
+    switch (method) {
+        case 'getCapabilities': {
+            const capabilities = response as Awaited<ReturnType<MobileWallet['getCapabilities']>>
+            switch (protocolVersion) {
+                case 'legacy': {
+                    const features: `${string}:${string}`[] = [ SolanaSignTransactions ];
+                    if (capabilities.supports_clone_authorization === true) {
+                        features.push(SolanaCloneAuthorization);
+                    }
+                    return {
+                        ...capabilities,
+                        features: features as IdentifierArray,
+                    } as Awaited<ReturnType<MobileWallet[TMethodName]>>;
+                }
+                case 'v1': {
+                    return {
+                        ...capabilities,
+                        supports_sign_and_send_transactions: true,
+                        supports_clone_authorization: capabilities.features.includes(SolanaCloneAuthorization)
+                    } as Awaited<ReturnType<MobileWallet[TMethodName]>>;
+                }
+            }
+        }
+    }
+    return response;
+};
+
+async function signInFallback(
+    signInPayload: SignInPayload,
+    authorizationResult: Awaited<ReturnType<MobileWallet['authorize']>>,
+    protocolRequestHandler: (method: string, params: Parameters<MobileWallet['signMessages']>[0]) => Promise<unknown>
+) {
+    const domain = signInPayload.domain ?? window.location.host;
+    const address = (authorizationResult as AuthorizationResult).accounts[0].address;
+    const siwsMessage = createSIWSMessageBase64({ ...signInPayload, domain, address })
+    const signMessageResult = await (protocolRequestHandler('sign_messages', 
+        { 
+            addresses: [ address ], 
+            payloads: [ siwsMessage ]
+        }
+    ) as ReturnType<MobileWallet['signMessages']>);
+    const signInResult: SignInResult = {
+        address: address,
+        signed_message: siwsMessage,
+        signature: signMessageResult.signed_payloads[0].slice(siwsMessage.length)
+    };
+    return signInResult;
+}

package/src/createSIWSMessage.ts

@@ -0,0 +1,14 @@
+import {
+    SolanaSignInInputWithRequiredFields, 
+    createSignInMessageText,
+} from '@solana/wallet-standard-util';
+import { SignInPayload } from './types';
+import { encode } from './base64Utils';
+
+export function createSIWSMessage(payload: SolanaSignInInputWithRequiredFields & SignInPayload): string {
+    return createSignInMessageText(payload);
+}
+
+export function createSIWSMessageBase64(payload: SolanaSignInInputWithRequiredFields & SignInPayload): string {
+    return encode(createSIWSMessage(payload));
+}

package/src/createSequenceNumberVector.ts

@@ -0,0 +1,11 @@
+export const SEQUENCE_NUMBER_BYTES = 4;
+
+export default function createSequenceNumberVector(sequenceNumber: number): Uint8Array {
+    if (sequenceNumber >= 4294967296) {
+        throw new Error('Outbound sequence number overflow. The maximum sequence number is 32-bytes.');
+    }
+    const byteArray = new ArrayBuffer(SEQUENCE_NUMBER_BYTES);
+    const view = new DataView(byteArray);
+    view.setUint32(0, sequenceNumber, /* littleEndian */ false);
+    return new Uint8Array(byteArray);
+}

package/src/encryptedMessage.ts

@@ -0,0 +1,60 @@
+import createSequenceNumberVector, { SEQUENCE_NUMBER_BYTES } from './createSequenceNumberVector.js';
+import { SharedSecret } from './parseHelloRsp.js';
+
+const INITIALIZATION_VECTOR_BYTES = 12;
+export const ENCODED_PUBLIC_KEY_LENGTH_BYTES = 65;
+
+export async function encryptMessage(
+    plaintext: string,
+    sequenceNumber: number,
+    sharedSecret: SharedSecret,
+) {
+    const sequenceNumberVector = createSequenceNumberVector(sequenceNumber);
+    const initializationVector = new Uint8Array(INITIALIZATION_VECTOR_BYTES);
+    crypto.getRandomValues(initializationVector);
+    const ciphertext = await crypto.subtle.encrypt(
+        getAlgorithmParams(sequenceNumberVector, initializationVector),
+        sharedSecret,
+        new TextEncoder().encode(plaintext),
+    );
+    const response = new Uint8Array(
+        sequenceNumberVector.byteLength + initializationVector.byteLength + ciphertext.byteLength,
+    );
+    response.set(new Uint8Array(sequenceNumberVector), 0);
+    response.set(new Uint8Array(initializationVector), sequenceNumberVector.byteLength);
+    response.set(new Uint8Array(ciphertext), sequenceNumberVector.byteLength + initializationVector.byteLength);
+    return response;
+}
+
+export async function decryptMessage(message: ArrayBuffer, sharedSecret: SharedSecret) {
+    const sequenceNumberVector = message.slice(0, SEQUENCE_NUMBER_BYTES);
+    const initializationVector = message.slice(
+        SEQUENCE_NUMBER_BYTES,
+        SEQUENCE_NUMBER_BYTES + INITIALIZATION_VECTOR_BYTES,
+    );
+    const ciphertext = message.slice(SEQUENCE_NUMBER_BYTES + INITIALIZATION_VECTOR_BYTES);
+    const plaintextBuffer = await crypto.subtle.decrypt(
+        getAlgorithmParams(sequenceNumberVector, initializationVector),
+        sharedSecret,
+        ciphertext,
+    );
+    const plaintext = getUtf8Decoder().decode(plaintextBuffer);
+    return plaintext
+}
+
+function getAlgorithmParams(sequenceNumber: ArrayBuffer, initializationVector: ArrayBuffer) {
+    return {
+        additionalData: sequenceNumber,
+        iv: initializationVector,
+        name: 'AES-GCM',
+        tagLength: 128, // 16 byte tag => 128 bits
+    };
+}
+
+let _utf8Decoder: TextDecoder | undefined;
+function getUtf8Decoder() {
+    if (_utf8Decoder === undefined) {
+        _utf8Decoder = new TextDecoder('utf-8');
+    }
+    return _utf8Decoder;
+}