@solana-mobile/mobile-wallet-adapter-protocol 0.0.1-alpha.0

package/lib/esm/index.mjs

@@ -0,0 +1,466 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function createHelloReq(ecdhPublicKey, associationKeypairPrivateKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const publicKeyBuffer = yield crypto.subtle.exportKey('raw', ecdhPublicKey);
+        const signatureBuffer = yield 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;
+    });
+}
+
+class SolanaMobileWalletAdapterSecureContextRequiredError extends Error {
+    constructor() {
+        super('The mobile wallet adapter protocol must be used in a secure context (`https`).');
+        this.name = 'SolanaMobileWalletAdapterSecureContextRequiredError';
+    }
+}
+class SolanaMobileWalletAdapterForbiddenWalletBaseURLError extends Error {
+    constructor() {
+        super('Base URLs supplied by wallets must be valid `https` URLs');
+        this.name = 'SolanaMobileWalletAdapterForbiddenWalletBaseURLError';
+    }
+}
+class SolanaMobileWalletAdapterWalletNotInstalledError extends Error {
+    constructor() {
+        super(`Found no installed wallet that supports the mobile wallet protocol.`);
+        this.name = 'SolanaMobileWalletAdapterWalletNotInstalledError';
+    }
+}
+class SolanaMobileWalletAdapterProtocolSessionEstablishmentError extends Error {
+    constructor(port) {
+        super(`Failed to connect to the wallet websocket on port ${port}.`);
+        this.name = 'SolanaMobileWalletAdapterProtocolSessionEstablishmentError';
+    }
+}
+class SolanaMobileWalletAdapterProtocolAssociationPortOutOfRangeError extends Error {
+    constructor(port) {
+        super(`Association port number must be between 49152 and 65535. ${port} given.`);
+        this.name = 'SolanaMobileWalletAdapterProtocolAssociationPortOutOfRangeError';
+    }
+}
+class SolanaMobileWalletAdapterProtocolSessionClosedError extends Error {
+    constructor(code, reason) {
+        super(`The wallet session dropped unexpectedly (${code}: ${reason}).`);
+        this.name = 'SolanaMobileWalletAdapterProtocolSessionClosedError';
+    }
+}
+class SolanaMobileWalletAdapterProtocolReauthorizeError extends Error {
+    constructor() {
+        super('The auth token provided has gone stale and needs reauthorization.');
+        this.name = 'SolanaMobileWalletAdapterProtocolReauthorizeError';
+    }
+}
+// Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/
+const SolanaMobileWalletAdapterProtocolError = {
+    ERROR_REAUTHORIZE: -1,
+    ERROR_AUTHORIZATION_FAILED: -2,
+    ERROR_INVALID_PAYLOAD: -3,
+    ERROR_NOT_SIGNED: -4,
+    ERROR_NOT_COMMITTED: -5,
+    ERROR_ATTEST_ORIGIN_ANDROID: -100,
+};
+class SolanaMobileWalletAdapterProtocolJsonRpcError extends Error {
+    constructor(...args) {
+        const [jsonRpcMessageId, code, message, data] = args;
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.jsonRpcMessageId = jsonRpcMessageId;
+        this.name = 'SolanaNativeWalletAdapterJsonRpcError';
+    }
+}
+
+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) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const plaintext = JSON.stringify(jsonRpcMessage);
+        const initializationVector = new Uint8Array(INITIALIZATION_VECTOR_BYTES);
+        crypto.getRandomValues(initializationVector);
+        const ciphertext = yield crypto.subtle.encrypt(getAlgorithmParams(initializationVector), sharedSecret, Buffer.from(plaintext));
+        const response = new Uint8Array(initializationVector.byteLength + ciphertext.byteLength);
+        response.set(new Uint8Array(initializationVector), 0);
+        response.set(new Uint8Array(ciphertext), initializationVector.byteLength);
+        return response;
+    });
+}
+function decryptJsonRpcMessage(message, sharedSecret) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const initializationVector = message.slice(0, INITIALIZATION_VECTOR_BYTES);
+        const ciphertext = message.slice(INITIALIZATION_VECTOR_BYTES);
+        const plaintextBuffer = yield crypto.subtle.decrypt(getAlgorithmParams(initializationVector), sharedSecret, ciphertext);
+        const plaintext = getUtf8Decoder().decode(plaintextBuffer);
+        const jsonRpcMessage = JSON.parse(plaintext);
+        if (Object.hasOwnProperty.call(jsonRpcMessage, 'error')) {
+            throw new SolanaMobileWalletAdapterProtocolJsonRpcError(jsonRpcMessage.id, jsonRpcMessage.error.code, jsonRpcMessage.error.message);
+        }
+        return jsonRpcMessage;
+    });
+}
+function getAlgorithmParams(initializationVector) {
+    return {
+        iv: initializationVector,
+        name: 'AES-GCM',
+        tagLength: 128, // 16 byte tag => 128 bits
+    };
+}
+let _utf8Decoder;
+function getUtf8Decoder() {
+    if (_utf8Decoder === undefined) {
+        _utf8Decoder = new TextDecoder('utf-8');
+    }
+    return _utf8Decoder;
+}
+
+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 */),
+        ]);
+        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 */);
+        const aesKeyMaterialVal = yield crypto.subtle.deriveKey({
+            name: 'HKDF',
+            hash: 'SHA-256',
+            salt: new Uint8Array(associationPublicKeyBuffer),
+            info: new Uint8Array(),
+        }, ecdhSecretKey, { name: 'AES-GCM', length: 128 }, false /* extractable */, ['encrypt', 'decrypt']);
+        return aesKeyMaterialVal;
+    });
+}
+
+function getRandomAssociationPort() {
+    return assertAssociationPort(49152 + Math.floor(Math.random() * (65535 - 49152 + 1)));
+}
+function assertAssociationPort(port) {
+    if (port < 49152 || port > 65535) {
+        throw new SolanaMobileWalletAdapterProtocolAssociationPortOutOfRangeError(port);
+    }
+    return port;
+}
+
+// https://stackoverflow.com/a/9458996/802047
+function arrayBufferToBase64String(buffer) {
+    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);
+}
+
+function getStringWithURLUnsafeCharactersReplaced(unsafeBase64EncodedString) {
+    return unsafeBase64EncodedString.replace(/[/+=]/g, (m) => ({
+        '/': '_',
+        '+': '-',
+        '=': '.',
+    }[m]));
+}
+
+const INTENT_NAME = 'solana-wallet';
+function getPathParts(pathString) {
+    return (pathString
+        // Strip leading and trailing slashes
+        .replace(/(^\/+|\/+$)/g, '')
+        // Return an array of directories
+        .split('/'));
+}
+function getIntentURL(methodPathname, intentUrlBase) {
+    let baseUrl = null;
+    if (intentUrlBase) {
+        try {
+            baseUrl = new URL(intentUrlBase);
+        }
+        catch (_a) { } // eslint-disable-line no-empty
+        if ((baseUrl === null || baseUrl === void 0 ? void 0 : baseUrl.protocol) !== 'https:') {
+            throw new SolanaMobileWalletAdapterForbiddenWalletBaseURLError();
+        }
+    }
+    baseUrl || (baseUrl = new URL(`${INTENT_NAME}:/`));
+    const pathname = methodPathname.startsWith('/')
+        ? // Method is an absolute path. Replace it wholesale.
+            methodPathname
+        : // Method is a relative path. Merge it with the existing one.
+            [...getPathParts(baseUrl.pathname), ...getPathParts(methodPathname)].join('/');
+    return new URL(pathname, baseUrl);
+}
+function getAssociateAndroidIntentURL(associationPublicKey, putativePort, associationURLBase) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const associationPort = assertAssociationPort(putativePort);
+        const exportedKey = yield crypto.subtle.exportKey('raw', associationPublicKey);
+        const encodedKey = arrayBufferToBase64String(exportedKey);
+        const url = getIntentURL('v1/associate/local', associationURLBase);
+        url.searchParams.set('association', getStringWithURLUnsafeCharactersReplaced(encodedKey));
+        url.searchParams.set('port', `${associationPort}`);
+        return url;
+    });
+}
+
+// Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/
+const Browser = {
+    Firefox: 0,
+    Other: 1,
+};
+function assertUnreachable(x) {
+    return x;
+}
+function getBrowser() {
+    return navigator.userAgent.indexOf('Firefox/') !== -1 ? Browser.Firefox : Browser.Other;
+}
+function getDetectionPromise() {
+    // Chrome and others silently fail if a custom protocol is not supported.
+    // For these, we wait to see if the browser is navigated away from in
+    // a reasonable amount of time (ie. the native wallet opened).
+    return new Promise((resolve, reject) => {
+        function cleanup() {
+            clearTimeout(timeoutId);
+            window.removeEventListener('blur', handleBlur);
+        }
+        function handleBlur() {
+            cleanup();
+            resolve();
+        }
+        window.addEventListener('blur', handleBlur);
+        const timeoutId = setTimeout(() => {
+            cleanup();
+            reject();
+        }, 2000);
+    });
+}
+let _frame = null;
+function launchUrlThroughHiddenFrame(url) {
+    if (_frame == null) {
+        _frame = document.createElement('iframe');
+        _frame.style.display = 'none';
+        document.body.appendChild(_frame);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    _frame.contentWindow.location.href = url.toString();
+}
+function startSession(associationPublicKey, associationURLBase) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const randomAssociationPort = getRandomAssociationPort();
+        const associationUrl = yield getAssociateAndroidIntentURL(associationPublicKey, randomAssociationPort, associationURLBase);
+        if (associationUrl.protocol === 'https:') {
+            // The association URL is an Android 'App Link' or iOS 'Universal Link'.
+            // These are regular web URLs that are designed to launch an app if it
+            // is installed or load the actual target webpage if not.
+            window.location.assign(associationUrl);
+        }
+        else {
+            // The association URL has a custom protocol (eg. `solana-wallet:`)
+            try {
+                const browser = getBrowser();
+                switch (browser) {
+                    case Browser.Firefox:
+                        // If a custom protocol is not supported in Firefox, it throws.
+                        launchUrlThroughHiddenFrame(associationUrl);
+                        // If we reached this line, it's supported.
+                        break;
+                    case Browser.Other: {
+                        const detectionPromise = getDetectionPromise();
+                        window.location.assign(associationUrl);
+                        yield detectionPromise;
+                        break;
+                    }
+                    default:
+                        assertUnreachable(browser);
+                }
+            }
+            catch (e) {
+                throw new SolanaMobileWalletAdapterWalletNotInstalledError();
+            }
+        }
+        return randomAssociationPort;
+    });
+}
+
+const WEBSOCKET_CONNECTION_CONFIG = {
+    maxAttempts: 34,
+    /**
+     * 300 milliseconds is a generally accepted threshold for what someone
+     * would consider an acceptable response time for a user interface
+     * after having performed a low-attention tapping task. We set the
+     * interval at which we wait for the wallet to set up the websocket at
+     * half this, as per the Nyquist frequency.
+     */
+    retryDelayMs: 150,
+};
+const WEBSOCKET_PROTOCOL = 'com.solana.mobilewalletadapter.v1';
+function assertSecureContext() {
+    if (typeof window === 'undefined' || window.isSecureContext !== true) {
+        throw new SolanaMobileWalletAdapterSecureContextRequiredError();
+    }
+}
+function withLocalWallet(callback, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        assertSecureContext();
+        const associationKeypair = yield generateAssociationKeypair();
+        const sessionPort = yield startSession(associationKeypair.publicKey, config === null || config === void 0 ? void 0 : config.baseUri);
+        const websocketURL = `ws://localhost:${sessionPort}/solana-wallet`;
+        let nextJsonRpcMessageId = 1;
+        let state = { __type: 'disconnected' };
+        return new Promise((resolve, reject) => {
+            let attempts = 0;
+            let socket;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const jsonRpcResponsePromises = {};
+            const handleOpen = () => __awaiter(this, void 0, void 0, function* () {
+                if (state.__type !== 'connecting') {
+                    console.warn('Expected adapter state to be `connecting` at the moment the websocket opens. ' +
+                        `Got \`${state.__type}\`.`);
+                    return;
+                }
+                const { associationKeypair } = state;
+                socket.removeEventListener('open', handleOpen);
+                const ecdhKeypair = yield generateECDHKeypair();
+                socket.send(yield createHelloReq(ecdhKeypair.publicKey, associationKeypair.privateKey));
+                state = {
+                    __type: 'hello_req_sent',
+                    associationPublicKey: associationKeypair.publicKey,
+                    ecdhPrivateKey: ecdhKeypair.privateKey,
+                };
+            });
+            const handleClose = (evt) => {
+                if (evt.wasClean) {
+                    state = { __type: 'disconnected' };
+                }
+                else {
+                    reject(new SolanaMobileWalletAdapterProtocolSessionClosedError(evt.code, evt.reason));
+                }
+                disposeSocket();
+            };
+            const handleError = (_evt) => __awaiter(this, void 0, void 0, function* () {
+                disposeSocket();
+                if (++attempts >= WEBSOCKET_CONNECTION_CONFIG.maxAttempts) {
+                    reject(new SolanaMobileWalletAdapterProtocolSessionEstablishmentError(sessionPort));
+                }
+                else {
+                    yield new Promise((resolve) => {
+                        retryWaitTimeoutId = window.setTimeout(resolve, WEBSOCKET_CONNECTION_CONFIG.retryDelayMs);
+                    });
+                    attemptSocketConnection();
+                }
+            });
+            const handleMessage = (evt) => __awaiter(this, void 0, void 0, function* () {
+                const responseBuffer = yield evt.data.arrayBuffer();
+                switch (state.__type) {
+                    case 'connected':
+                        try {
+                            const jsonRpcMessage = yield decryptJsonRpcMessage(responseBuffer, state.sharedSecret);
+                            const responsePromise = jsonRpcResponsePromises[jsonRpcMessage.id];
+                            delete jsonRpcResponsePromises[jsonRpcMessage.id];
+                            responsePromise.resolve(jsonRpcMessage.result);
+                        }
+                        catch (e) {
+                            if (e instanceof SolanaMobileWalletAdapterProtocolJsonRpcError) {
+                                const responsePromise = jsonRpcResponsePromises[e.jsonRpcMessageId];
+                                delete jsonRpcResponsePromises[e.jsonRpcMessageId];
+                                responsePromise.reject(e);
+                            }
+                            else {
+                                throw e;
+                            }
+                        }
+                        break;
+                    case 'hello_req_sent': {
+                        const sharedSecret = yield parseHelloRsp(responseBuffer, state.associationPublicKey, state.ecdhPrivateKey);
+                        state = { __type: 'connected', sharedSecret };
+                        const wallet = (method, params) => __awaiter(this, void 0, void 0, function* () {
+                            const id = nextJsonRpcMessageId++;
+                            socket.send(yield encryptJsonRpcMessage({
+                                id,
+                                jsonrpc: '2.0',
+                                method,
+                                params,
+                            }, sharedSecret));
+                            return new Promise((resolve, reject) => {
+                                jsonRpcResponsePromises[id] = { resolve, reject };
+                            });
+                        });
+                        try {
+                            resolve(yield callback(wallet));
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                        finally {
+                            disposeSocket();
+                            socket.close();
+                        }
+                        break;
+                    }
+                }
+            });
+            let disposeSocket;
+            let retryWaitTimeoutId;
+            const attemptSocketConnection = () => {
+                if (disposeSocket) {
+                    disposeSocket();
+                }
+                state = { __type: 'connecting', associationKeypair };
+                socket = new WebSocket(websocketURL, [WEBSOCKET_PROTOCOL]);
+                socket.addEventListener('open', handleOpen);
+                socket.addEventListener('close', handleClose);
+                socket.addEventListener('error', handleError);
+                socket.addEventListener('message', handleMessage);
+                disposeSocket = () => {
+                    window.clearTimeout(retryWaitTimeoutId);
+                    socket.removeEventListener('open', handleOpen);
+                    socket.removeEventListener('close', handleClose);
+                    socket.removeEventListener('error', handleError);
+                    socket.removeEventListener('message', handleMessage);
+                };
+            };
+            attemptSocketConnection();
+        });
+    });
+}
+
+export { SolanaMobileWalletAdapterForbiddenWalletBaseURLError, SolanaMobileWalletAdapterProtocolAssociationPortOutOfRangeError, SolanaMobileWalletAdapterProtocolError, SolanaMobileWalletAdapterProtocolJsonRpcError, SolanaMobileWalletAdapterProtocolReauthorizeError, SolanaMobileWalletAdapterProtocolSessionClosedError, SolanaMobileWalletAdapterProtocolSessionEstablishmentError, SolanaMobileWalletAdapterSecureContextRequiredError, SolanaMobileWalletAdapterWalletNotInstalledError, withLocalWallet };

package/lib/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

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

@@ -0,0 +1,133 @@
+/**
+ * Properties that wallets may present to users when an app
+ * asks for authorization to execute privileged methods (see
+ * {@link PrivilegedMethods}).
+ */
+type AppIdentity = Readonly<{
+    uri?: string;
+    icon?: string;
+    name?: string;
+}>;
+/**
+ * An ephemeral elliptic-curve keypair on the P-256 curve.
+ * This public key is used to create the association token.
+ * The private key is used during session establishment.
+ */
+type AssociationKeypair = CryptoKeyPair;
+/**
+ * The context returned from a wallet after having authorized a given
+ * account for use with a given application. You can cache this and
+ * use it later to invoke privileged methods.
+ */
+type AuthorizationResult = Readonly<{
+    authToken: string;
+    publicKey: string;
+    walletUriBase: string;
+}>;
+type AuthToken = string;
+type Base58EncodedSignature = string;
+type Base64EncodedMessage = string;
+type Base64EncodedSignedMessage = string;
+type Base64EncodedSignedTransaction = string;
+type Base64EncodedTransaction = string;
+interface MobileWallet {
+    (method: "authorize", params: {
+        identity: AppIdentity;
+    }): Promise<Readonly<{
+        auth_token: AuthToken;
+        pub_key: string;
+        wallet_uri_base: string;
+    }>>;
+    (method: "clone_authorization", params: {
+        auth_token: AuthToken;
+    }): Promise<Readonly<{
+        auth_token: AuthToken;
+    }>>;
+    (method: "deauthorize", params: {
+        auth_token: AuthToken;
+    }): Promise<Readonly<Record<string, never>>>;
+    (method: "reauthorize", params: {
+        auth_token: AuthToken;
+    }): Promise<Readonly<{
+        auth_token: AuthToken;
+    }>>;
+    (method: "sign_message", params: {
+        auth_token: AuthToken;
+        payloads: Base64EncodedMessage[];
+    }): Promise<Readonly<{
+        signed_payloads: Base64EncodedSignedMessage[];
+    }>>;
+    (method: "sign_transaction", params: {
+        auth_token: AuthToken;
+        payloads: Base64EncodedTransaction[];
+    }): Promise<Readonly<{
+        signed_payloads: Base64EncodedSignedTransaction[];
+    }>>;
+    (method: "sign_and_send_transaction", params: {
+        auth_token: AuthToken;
+        commitment: "confirmed" | "finalized" | "processed";
+        payloads: Base64EncodedTransaction[];
+    }): Promise<Readonly<{
+        signatures: Base58EncodedSignature[];
+    }>>;
+}
+type Config = Readonly<{
+    baseUri?: string;
+}>;
+declare function withLocalWallet<TReturn>(callback: (wallet: MobileWallet) => TReturn, config?: Config): Promise<TReturn>;
+declare class SolanaMobileWalletAdapterSecureContextRequiredError extends Error {
+    constructor();
+}
+declare class SolanaMobileWalletAdapterForbiddenWalletBaseURLError extends Error {
+    constructor();
+}
+declare class SolanaMobileWalletAdapterWalletNotInstalledError extends Error {
+    constructor();
+}
+declare class SolanaMobileWalletAdapterProtocolSessionEstablishmentError extends Error {
+    constructor(port: number);
+}
+declare class SolanaMobileWalletAdapterProtocolAssociationPortOutOfRangeError extends Error {
+    constructor(port: number);
+}
+declare class SolanaMobileWalletAdapterProtocolSessionClosedError extends Error {
+    constructor(code: number, reason: string);
+}
+declare class SolanaMobileWalletAdapterProtocolReauthorizeError extends Error {
+    constructor();
+}
+type JSONRPCErrorCode = number;
+// Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/
+declare const SolanaMobileWalletAdapterProtocolError: {
+    readonly ERROR_REAUTHORIZE: -1;
+    readonly ERROR_AUTHORIZATION_FAILED: -2;
+    readonly ERROR_INVALID_PAYLOAD: -3;
+    readonly ERROR_NOT_SIGNED: -4;
+    readonly ERROR_NOT_COMMITTED: -5;
+    readonly ERROR_ATTEST_ORIGIN_ANDROID: -100;
+};
+type SolanaMobileWalletAdapterProtocolErrorEnum = (typeof SolanaMobileWalletAdapterProtocolError)[keyof typeof SolanaMobileWalletAdapterProtocolError];
+type ErrorDataTypeMap = {
+    [SolanaMobileWalletAdapterProtocolError.ERROR_ATTEST_ORIGIN_ANDROID]: {
+        attest_origin_uri: string;
+        challenge: string;
+        context: string;
+    };
+};
+declare class SolanaMobileWalletAdapterProtocolJsonRpcError<TErrorCode extends keyof ErrorDataTypeMap> extends Error {
+    data: ErrorDataTypeMap[TErrorCode] extends Record<string, unknown> ? ErrorDataTypeMap[TErrorCode] : undefined;
+    code: SolanaMobileWalletAdapterProtocolErrorEnum | JSONRPCErrorCode;
+    jsonRpcMessageId: number;
+    constructor(...args: ErrorDataTypeMap[TErrorCode] extends Record<string, unknown> ? [
+        jsonRpcMessageId: number,
+        code: SolanaMobileWalletAdapterProtocolErrorEnum | JSONRPCErrorCode,
+        message: string,
+        data: ErrorDataTypeMap[TErrorCode]
+    ] : [
+        jsonRpcMessageId: number,
+        code: SolanaMobileWalletAdapterProtocolErrorEnum | JSONRPCErrorCode,
+        message: string
+    ]);
+}
+export { withLocalWallet, SolanaMobileWalletAdapterSecureContextRequiredError, SolanaMobileWalletAdapterForbiddenWalletBaseURLError, SolanaMobileWalletAdapterWalletNotInstalledError, SolanaMobileWalletAdapterProtocolSessionEstablishmentError, SolanaMobileWalletAdapterProtocolAssociationPortOutOfRangeError, SolanaMobileWalletAdapterProtocolSessionClosedError, SolanaMobileWalletAdapterProtocolReauthorizeError, SolanaMobileWalletAdapterProtocolError, SolanaMobileWalletAdapterProtocolJsonRpcError, AppIdentity, AssociationKeypair, AuthorizationResult, AuthToken, MobileWallet };
+//# sourceMappingURL=index.browser.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.browser.d.mts","sourceRoot":"","sources":["../../src/index.ts","../../src/createHelloReq.ts","../../src/errors.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/withLocalWallet.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,2jBAA8B,CAA0B"}