@solana-mobile/mobile-wallet-adapter-protocol 2.0.1 → 2.0.2

package/lib/esm/index.js

@@ -1,3 +1,5 @@
+import { createSignInMessageText } from '@solana/wallet-standard-util';
+
 // Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/
 const SolanaMobileWalletAdapterErrorCode = {
     ERROR_ASSOCIATION_PORT_OUT_OF_RANGE: 'ERROR_ASSOCIATION_PORT_OUT_OF_RANGE',
@@ -6,6 +8,7 @@ const SolanaMobileWalletAdapterErrorCode = {
     ERROR_SESSION_CLOSED: 'ERROR_SESSION_CLOSED',
     ERROR_SESSION_TIMEOUT: 'ERROR_SESSION_TIMEOUT',
     ERROR_WALLET_NOT_FOUND: 'ERROR_WALLET_NOT_FOUND',
+    ERROR_INVALID_PROTOCOL_VERSION: 'ERROR_INVALID_PROTOCOL_VERSION',
 };
 class SolanaMobileWalletAdapterError extends Error {
     constructor(...args) {
@@ -73,6 +76,175 @@ function createHelloReq(ecdhPublicKey, associationKeypairPrivateKey) {
     });
 }
 
+function encode(input) {
+    return window.btoa(input);
+}
+
+function createSIWSMessage(payload) {
+    return createSignInMessageText(payload);
+}
+function createSIWSMessageBase64(payload) {
+    return encode(createSIWSMessage(payload));
+}
+
+// optional features
+const SolanaSignTransactions = 'solana:signTransactions';
+const SolanaCloneAuthorization = 'solana:cloneAuthorization';
+const SolanaSignInWithSolana = 'solana:signInWithSolana';
+
+/**
+ * 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
+ */
+function createMobileWalletProxy(protocolVersion, protocolRequestHandler) {
+    return new Proxy({}, {
+        get(target, p) {
+            if (target[p] == null) {
+                target[p] = function (inputParams) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        const { method, params } = handleMobileWalletRequest(p, inputParams, protocolVersion);
+                        const result = yield protocolRequestHandler(method, params);
+                        // 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.sign_in_payload && !result.sign_in_result) {
+                            result['sign_in_result'] = yield signInFallback(params.sign_in_payload, result, protocolRequestHandler);
+                        }
+                        return handleMobileWalletResponse(p, result, protocolVersion);
+                    });
+                };
+            }
+            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(methodName, methodParams, protocolVersion) {
+    let params = methodParams;
+    let method = methodName
+        .toString()
+        .replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)
+        .toLowerCase();
+    switch (methodName) {
+        case 'authorize': {
+            let { chain } = params;
+            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.cluster;
+                    }
+                }
+                params.cluster = chain;
+            }
+            else {
+                switch (chain) {
+                    case 'testnet':
+                    case 'devnet': {
+                        chain = `solana:${chain}`;
+                        break;
+                    }
+                    case 'mainnet-beta': {
+                        chain = 'solana:mainnet';
+                        break;
+                    }
+                }
+                params.chain = chain;
+            }
+        }
+        case 'reauthorize': {
+            const { auth_token, identity } = params;
+            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(method, response, protocolVersion) {
+    switch (method) {
+        case 'getCapabilities': {
+            const capabilities = response;
+            switch (protocolVersion) {
+                case 'legacy': {
+                    const features = [SolanaSignTransactions];
+                    if (capabilities.supports_clone_authorization === true) {
+                        features.push(SolanaCloneAuthorization);
+                    }
+                    return Object.assign(Object.assign({}, capabilities), { features: features });
+                }
+                case 'v1': {
+                    return Object.assign(Object.assign({}, capabilities), { supports_sign_and_send_transactions: true, supports_clone_authorization: capabilities.features.includes(SolanaCloneAuthorization) });
+                }
+            }
+        }
+    }
+    return response;
+}
+function signInFallback(signInPayload, authorizationResult, protocolRequestHandler) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const domain = (_a = signInPayload.domain) !== null && _a !== void 0 ? _a : window.location.host;
+        const address = authorizationResult.accounts[0].address;
+        const siwsMessage = createSIWSMessageBase64(Object.assign(Object.assign({}, signInPayload), { domain, address }));
+        const signMessageResult = yield protocolRequestHandler('sign_messages', {
+            addresses: [address],
+            payloads: [siwsMessage]
+        });
+        const signInResult = {
+            address: address,
+            signed_message: siwsMessage,
+            signature: signMessageResult.signed_payloads[0].slice(siwsMessage.length)
+        };
+        return signInResult;
+    });
+}
+
 const SEQUENCE_NUMBER_BYTES = 4;
 function createSequenceNumberVector(sequenceNumber) {
     if (sequenceNumber >= 4294967296) {
@@ -84,29 +256,11 @@ function createSequenceNumberVector(sequenceNumber) {
     return new Uint8Array(byteArray);
 }
 
-function generateAssociationKeypair() {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield crypto.subtle.generateKey({
-            name: 'ECDSA',
-            namedCurve: 'P-256',
-        }, false /* extractable */, ['sign'] /* keyUsages */);
-    });
-}
-
-function generateECDHKeypair() {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield crypto.subtle.generateKey({
-            name: 'ECDH',
-            namedCurve: 'P-256',
-        }, false /* extractable */, ['deriveKey', 'deriveBits'] /* keyUsages */);
-    });
-}
-
 const INITIALIZATION_VECTOR_BYTES = 12;
-function encryptJsonRpcMessage(jsonRpcMessage, sharedSecret) {
+const ENCODED_PUBLIC_KEY_LENGTH_BYTES = 65;
+function encryptMessage(plaintext, sequenceNumber, sharedSecret) {
     return __awaiter(this, void 0, void 0, function* () {
-        const plaintext = JSON.stringify(jsonRpcMessage);
-        const sequenceNumberVector = createSequenceNumberVector(jsonRpcMessage.id);
+        const sequenceNumberVector = createSequenceNumberVector(sequenceNumber);
         const initializationVector = new Uint8Array(INITIALIZATION_VECTOR_BYTES);
         crypto.getRandomValues(initializationVector);
         const ciphertext = yield crypto.subtle.encrypt(getAlgorithmParams(sequenceNumberVector, initializationVector), sharedSecret, new TextEncoder().encode(plaintext));
@@ -117,18 +271,14 @@ function encryptJsonRpcMessage(jsonRpcMessage, sharedSecret) {
         return response;
     });
 }
-function decryptJsonRpcMessage(message, sharedSecret) {
+function decryptMessage(message, sharedSecret) {
     return __awaiter(this, void 0, void 0, function* () {
         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 = yield crypto.subtle.decrypt(getAlgorithmParams(sequenceNumberVector, initializationVector), sharedSecret, ciphertext);
         const plaintext = getUtf8Decoder().decode(plaintextBuffer);
-        const jsonRpcMessage = JSON.parse(plaintext);
-        if (Object.hasOwnProperty.call(jsonRpcMessage, 'error')) {
-            throw new SolanaMobileWalletAdapterProtocolError(jsonRpcMessage.id, jsonRpcMessage.error.code, jsonRpcMessage.error.message);
-        }
-        return jsonRpcMessage;
+        return plaintext;
     });
 }
 function getAlgorithmParams(sequenceNumber, initializationVector) {
@@ -147,12 +297,48 @@ function getUtf8Decoder() {
     return _utf8Decoder;
 }
 
+function generateAssociationKeypair() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield crypto.subtle.generateKey({
+            name: 'ECDSA',
+            namedCurve: 'P-256',
+        }, false /* extractable */, ['sign'] /* keyUsages */);
+    });
+}
+
+function generateECDHKeypair() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield crypto.subtle.generateKey({
+            name: 'ECDH',
+            namedCurve: 'P-256',
+        }, false /* extractable */, ['deriveKey', 'deriveBits'] /* keyUsages */);
+    });
+}
+
+function encryptJsonRpcMessage(jsonRpcMessage, sharedSecret) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const plaintext = JSON.stringify(jsonRpcMessage);
+        const sequenceNumber = jsonRpcMessage.id;
+        return encryptMessage(plaintext, sequenceNumber, sharedSecret);
+    });
+}
+function decryptJsonRpcMessage(message, sharedSecret) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const plaintext = yield decryptMessage(message, sharedSecret);
+        const jsonRpcMessage = JSON.parse(plaintext);
+        if (Object.hasOwnProperty.call(jsonRpcMessage, 'error')) {
+            throw new SolanaMobileWalletAdapterProtocolError(jsonRpcMessage.id, jsonRpcMessage.error.code, jsonRpcMessage.error.message);
+        }
+        return jsonRpcMessage;
+    });
+}
+
 function parseHelloRsp(payloadBuffer, // The X9.62-encoded wallet endpoint ephemeral ECDH public keypoint.
 associationPublicKey, ecdhPrivateKey) {
     return __awaiter(this, void 0, void 0, function* () {
         const [associationPublicKeyBuffer, walletPublicKey] = yield Promise.all([
             crypto.subtle.exportKey('raw', associationPublicKey),
-            crypto.subtle.importKey('raw', payloadBuffer, { name: 'ECDH', namedCurve: 'P-256' }, false /* extractable */, [] /* keyUsages */),
+            crypto.subtle.importKey('raw', payloadBuffer.slice(0, ENCODED_PUBLIC_KEY_LENGTH_BYTES), { name: 'ECDH', namedCurve: 'P-256' }, false /* extractable */, [] /* keyUsages */),
         ]);
         const sharedSecret = yield crypto.subtle.deriveBits({ name: 'ECDH', public: walletPublicKey }, ecdhPrivateKey, 256);
         const ecdhSecretKey = yield crypto.subtle.importKey('raw', sharedSecret, 'HKDF', false /* extractable */, ['deriveKey'] /* keyUsages */);
@@ -166,6 +352,31 @@ associationPublicKey, ecdhPrivateKey) {
     });
 }
 
+function parseSessionProps(message, sharedSecret) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const plaintext = yield decryptMessage(message, sharedSecret);
+        const jsonProperties = JSON.parse(plaintext);
+        let protocolVersion = 'legacy';
+        if (Object.hasOwnProperty.call(jsonProperties, 'v')) {
+            switch (jsonProperties.v) {
+                case 1:
+                case '1':
+                case 'v1':
+                    protocolVersion = 'v1';
+                    break;
+                case 'legacy':
+                    protocolVersion = 'legacy';
+                    break;
+                default:
+                    throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_INVALID_PROTOCOL_VERSION, `Unknown/unsupported protocol version: ${jsonProperties.v}`);
+            }
+        }
+        return ({
+            protocol_version: protocolVersion
+        });
+    });
+}
+
 function getRandomAssociationPort() {
     return assertAssociationPort(49152 + Math.floor(Math.random() * (65535 - 49152 + 1)));
 }
@@ -222,7 +433,7 @@ function getIntentURL(methodPathname, intentUrlBase) {
             [...getPathParts(baseUrl.pathname), ...getPathParts(methodPathname)].join('/');
     return new URL(pathname, baseUrl);
 }
-function getAssociateAndroidIntentURL(associationPublicKey, putativePort, associationURLBase) {
+function getAssociateAndroidIntentURL(associationPublicKey, putativePort, associationURLBase, protocolVersions = ['v1']) {
     return __awaiter(this, void 0, void 0, function* () {
         const associationPort = assertAssociationPort(putativePort);
         const exportedKey = yield crypto.subtle.exportKey('raw', associationPublicKey);
@@ -230,6 +441,9 @@ function getAssociateAndroidIntentURL(associationPublicKey, putativePort, associ
         const url = getIntentURL('v1/associate/local', associationURLBase);
         url.searchParams.set('association', getStringWithURLUnsafeCharactersReplaced(encodedKey));
         url.searchParams.set('port', `${associationPort}`);
+        protocolVersions.forEach((version) => {
+            url.searchParams.set('v', version);
+        });
         return url;
     });
 }
@@ -434,59 +648,51 @@ function transact(callback, config) {
                         break;
                     case 'hello_req_sent': {
                         const sharedSecret = yield parseHelloRsp(responseBuffer, state.associationPublicKey, state.ecdhPrivateKey);
-                        state = { __type: 'connected', sharedSecret };
-                        const wallet = new Proxy({}, {
-                            get(target, p) {
-                                if (target[p] == null) {
-                                    const method = p
-                                        .toString()
-                                        .replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)
-                                        .toLowerCase();
-                                    target[p] = function (params) {
-                                        return __awaiter(this, void 0, void 0, function* () {
-                                            const id = nextJsonRpcMessageId++;
-                                            socket.send(yield encryptJsonRpcMessage({
-                                                id,
-                                                jsonrpc: '2.0',
-                                                method,
-                                                params: params !== null && params !== void 0 ? params : {},
-                                            }, sharedSecret));
-                                            return new Promise((resolve, reject) => {
-                                                jsonRpcResponsePromises[id] = {
-                                                    resolve(result) {
-                                                        switch (p) {
-                                                            case 'authorize':
-                                                            case 'reauthorize': {
-                                                                const { wallet_uri_base } = result;
-                                                                if (wallet_uri_base != null) {
-                                                                    try {
-                                                                        assertSecureEndpointSpecificURI(wallet_uri_base);
-                                                                    }
-                                                                    catch (e) {
-                                                                        reject(e);
-                                                                        return;
-                                                                    }
-                                                                }
-                                                                break;
-                                                            }
-                                                        }
-                                                        resolve(result);
-                                                    },
-                                                    reject,
-                                                };
-                                            });
-                                        });
-                                    };
+                        const sessionPropertiesBuffer = responseBuffer.slice(ENCODED_PUBLIC_KEY_LENGTH_BYTES);
+                        const sessionProperties = sessionPropertiesBuffer.byteLength !== 0
+                            ? yield (() => __awaiter(this, void 0, void 0, function* () {
+                                const sequenceNumberVector = sessionPropertiesBuffer.slice(0, SEQUENCE_NUMBER_BYTES);
+                                const sequenceNumber = getSequenceNumberFromByteArray(sequenceNumberVector);
+                                if (sequenceNumber !== (lastKnownInboundSequenceNumber + 1)) {
+                                    throw new Error('Encrypted message has invalid sequence number');
                                 }
-                                return target[p];
-                            },
-                            defineProperty() {
-                                return false;
-                            },
-                            deleteProperty() {
-                                return false;
-                            },
-                        });
+                                lastKnownInboundSequenceNumber = sequenceNumber;
+                                return parseSessionProps(sessionPropertiesBuffer, sharedSecret);
+                            }))() : { protocol_version: 'legacy' };
+                        state = { __type: 'connected', sharedSecret, sessionProperties };
+                        const wallet = createMobileWalletProxy(sessionProperties.protocol_version, (method, params) => __awaiter(this, void 0, void 0, function* () {
+                            const id = nextJsonRpcMessageId++;
+                            socket.send(yield encryptJsonRpcMessage({
+                                id,
+                                jsonrpc: '2.0',
+                                method,
+                                params: params !== null && params !== void 0 ? params : {},
+                            }, sharedSecret));
+                            return new Promise((resolve, reject) => {
+                                jsonRpcResponsePromises[id] = {
+                                    resolve(result) {
+                                        switch (method) {
+                                            case 'authorize':
+                                            case 'reauthorize': {
+                                                const { wallet_uri_base } = result;
+                                                if (wallet_uri_base != null) {
+                                                    try {
+                                                        assertSecureEndpointSpecificURI(wallet_uri_base);
+                                                    }
+                                                    catch (e) {
+                                                        reject(e);
+                                                        return;
+                                                    }
+                                                }
+                                                break;
+                                            }
+                                        }
+                                        resolve(result);
+                                    },
+                                    reject,
+                                };
+                            });
+                        }));
                         try {
                             resolve(yield callback(wallet));
                         }
@@ -529,4 +735,4 @@ function transact(callback, config) {
     });
 }
 
-export { SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterErrorCode, SolanaMobileWalletAdapterProtocolError, SolanaMobileWalletAdapterProtocolErrorCode, transact };
+export { SolanaCloneAuthorization, SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterErrorCode, SolanaMobileWalletAdapterProtocolError, SolanaMobileWalletAdapterProtocolErrorCode, SolanaSignInWithSolana, SolanaSignTransactions, transact };

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

@@ -1,4 +1,6 @@
 import { TransactionVersion } from "@solana/web3.js";
+import { SolanaSignInInput } from "@solana/wallet-standard";
+import { IdentifierArray, IdentifierString, WalletAccount, WalletIcon } from "@wallet-standard/core";
 // Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/
 declare const SolanaMobileWalletAdapterErrorCode: {
     readonly ERROR_ASSOCIATION_PORT_OUT_OF_RANGE: "ERROR_ASSOCIATION_PORT_OUT_OF_RANGE";
@@ -7,6 +9,7 @@ declare const SolanaMobileWalletAdapterErrorCode: {
     readonly ERROR_SESSION_CLOSED: "ERROR_SESSION_CLOSED";
     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";
 };
 type SolanaMobileWalletAdapterErrorCodeEnum = (typeof SolanaMobileWalletAdapterErrorCode)[keyof typeof SolanaMobileWalletAdapterErrorCode];
 type ErrorDataTypeMap = {
@@ -20,6 +23,7 @@ type ErrorDataTypeMap = {
     };
     [SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_TIMEOUT]: undefined;
     [SolanaMobileWalletAdapterErrorCode.ERROR_WALLET_NOT_FOUND]: undefined;
+    [SolanaMobileWalletAdapterErrorCode.ERROR_INVALID_PROTOCOL_VERSION]: undefined;
 };
 declare class SolanaMobileWalletAdapterError<TErrorCode extends SolanaMobileWalletAdapterErrorCodeEnum> extends Error {
     data: ErrorDataTypeMap[TErrorCode] | undefined;
@@ -74,7 +78,10 @@ declare class SolanaMobileWalletAdapterProtocolError<TErrorCode extends SolanaMo
 type Account = Readonly<{
     address: Base64EncodedAddress;
     label?: string;
-}>;
+    icon?: WalletIcon;
+    chains?: IdentifierArray;
+    features?: IdentifierArray;
+}> | WalletAccount;
 /**
  * Properties that wallets may present to users when an app
  * asks for authorization to execute privileged methods (see
@@ -91,6 +98,10 @@ type AppIdentity = Readonly<{
  * The private key is used during session establishment.
  */
 type AssociationKeypair = CryptoKeyPair;
+type ProtocolVersion = "v1" | "legacy";
+type SessionProperties = Readonly<{
+    protocol_version: ProtocolVersion;
+}>;
 /**
  * The context returned from a wallet after having authorized a given
  * account for use with a given application. You can cache this and
@@ -100,6 +111,7 @@ type AuthorizationResult = Readonly<{
     accounts: Account[];
     auth_token: AuthToken;
     wallet_uri_base: string;
+    sign_in_result?: SignInResult;
 }>;
 type AuthToken = string;
 type Base64EncodedAddress = string;
@@ -108,16 +120,31 @@ type Base64EncodedMessage = string;
 type Base64EncodedSignedMessage = string;
 type Base64EncodedSignedTransaction = string;
 type Base64EncodedTransaction = string;
+/**
+ * @deprecated Replaced by the 'chain' parameter, which adds multi-chain capability as per MWA 2.0 spec.
+ */
 type Cluster = "devnet" | "testnet" | "mainnet-beta";
+type Chain = IdentifierString | Cluster;
 type Finality = "confirmed" | "finalized" | "processed";
 type WalletAssociationConfig = Readonly<{
     baseUri?: string;
 }>;
 interface AuthorizeAPI {
+    /**
+     * @deprecated Replaced by updated authorize() method, which adds MWA 2.0 spec support.
+     */
     authorize(params: {
         cluster: Cluster;
         identity: AppIdentity;
     }): Promise<AuthorizationResult>;
+    authorize(params: {
+        identity: AppIdentity;
+        chain?: Chain;
+        features?: IdentifierArray;
+        addresses?: string[];
+        auth_token?: AuthToken;
+        sign_in_payload?: SignInPayload;
+    }): Promise<AuthorizationResult>;
 }
 interface CloneAuthorizationAPI {
     cloneAuthorization(params: {
@@ -133,11 +160,18 @@ interface DeauthorizeAPI {
 }
 interface GetCapabilitiesAPI {
     getCapabilities(): Promise<Readonly<{
+        max_transactions_per_request: number;
+        max_messages_per_request: number;
+        supported_transaction_versions: ReadonlyArray<TransactionVersion>;
+        features: IdentifierArray;
+        /**
+         * @deprecated Replaced by features array.
+         */
         supports_clone_authorization: boolean;
+        /**
+         * @deprecated Replaced by features array.
+         */
         supports_sign_and_send_transactions: boolean;
-        max_transactions_per_request: boolean;
-        max_messages_per_request: boolean;
-        supported_transaction_versions: ReadonlyArray<TransactionVersion>;
     }>>;
 }
 interface ReauthorizeAPI {
@@ -165,6 +199,10 @@ interface SignAndSendTransactionsAPI {
     signAndSendTransactions(params: {
         options?: Readonly<{
             min_context_slot?: number;
+            commitment?: string;
+            skip_preflight?: boolean;
+            max_retries?: number;
+            wait_for_commitment_to_send_next_transaction?: boolean;
         }>;
         payloads: Base64EncodedTransaction[];
     }): Promise<Readonly<{
@@ -173,6 +211,31 @@ interface SignAndSendTransactionsAPI {
 }
 interface MobileWallet extends AuthorizeAPI, CloneAuthorizationAPI, DeauthorizeAPI, GetCapabilitiesAPI, ReauthorizeAPI, SignMessagesAPI, SignTransactionsAPI, SignAndSendTransactionsAPI {
 }
+// optional features
+declare const SolanaSignTransactions = "solana:signTransactions";
+declare const SolanaCloneAuthorization = "solana:cloneAuthorization";
+declare const SolanaSignInWithSolana = "solana:signInWithSolana";
+type SignInPayload = Readonly<{
+    domain?: string;
+    address?: string;
+    statement?: string;
+    uri?: string;
+    version?: string;
+    chainId?: string;
+    nonce?: string;
+    issuedAt?: string;
+    expirationTime?: string;
+    notBefore?: string;
+    requestId?: string;
+    resources?: readonly string[];
+}> | SolanaSignInInput;
+type SignInPayloadWithRequiredFields = Partial<SignInPayload> & Required<Pick<SignInPayload, "domain" | "address">>;
+type SignInResult = Readonly<{
+    address: Base64EncodedAddress;
+    signed_message: Base64EncodedSignedMessage;
+    signature: Base64EncodedAddress;
+    signature_type?: string;
+}>;
 declare function transact<TReturn>(callback: (wallet: MobileWallet) => TReturn, config?: WalletAssociationConfig): Promise<TReturn>;
-export { SolanaMobileWalletAdapterErrorCode, SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterProtocolErrorCode, SolanaMobileWalletAdapterProtocolError, transact, Account, AppIdentity, AssociationKeypair, AuthorizationResult, AuthToken, Base64EncodedAddress, Base64EncodedTransaction, Cluster, Finality, WalletAssociationConfig, AuthorizeAPI, CloneAuthorizationAPI, DeauthorizeAPI, GetCapabilitiesAPI, ReauthorizeAPI, SignMessagesAPI, SignTransactionsAPI, SignAndSendTransactionsAPI, MobileWallet };
+export { SolanaMobileWalletAdapterErrorCode, SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterProtocolErrorCode, SolanaMobileWalletAdapterProtocolError, transact, Account, AppIdentity, AssociationKeypair, ProtocolVersion, SessionProperties, AuthorizationResult, AuthToken, Base64EncodedAddress, Base64EncodedTransaction, Cluster, Chain, Finality, WalletAssociationConfig, AuthorizeAPI, CloneAuthorizationAPI, DeauthorizeAPI, GetCapabilitiesAPI, ReauthorizeAPI, SignMessagesAPI, SignTransactionsAPI, SignAndSendTransactionsAPI, MobileWallet, SolanaSignTransactions, SolanaCloneAuthorization, SolanaSignInWithSolana, SignInPayload, SignInPayloadWithRequiredFields, SignInResult };
 //# sourceMappingURL=index.browser.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.browser.d.ts","sourceRoot":"","sources":["../../src/index.ts","../../src/errors.ts","../../src/createHelloReq.ts","../../src/createSequenceNumberVector.ts","../../src/generateAssociationKeypair.ts","../../src/generateECDHKeypair.ts","../../src/parseHelloRsp.ts","../../src/jsonRpcMessage.ts","../../src/associationPort.ts","../../src/arrayBufferToBase64String.ts","../../src/getStringWithURLUnsafeBase64CharactersReplaced.ts","../../src/getAssociateAndroidIntentURL.ts","../../src/startSession.ts","../../src/types.ts","../../src/transact.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.browser.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/getAssociateAndroidIntentURL.ts","../../src/startSession.ts","../../src/transact.ts"],"names":[],"mappings":""}