@pooflabs/web 0.0.75 → 0.0.77

package/dist/index.browser-C9bFQZyQ.esm.js

@@ -0,0 +1,1373 @@
+import { VersionedMessage, Transaction, VersionedTransaction, SIGNATURE_LENGTH_IN_BYTES } from '@solana/web3.js';
+
+/**
+ * TODO: docs
+ */
+function createSignInMessageText(input) {
+    // ${domain} wants you to sign in with your Solana account:
+    // ${address}
+    //
+    // ${statement}
+    //
+    // URI: ${uri}
+    // Version: ${version}
+    // Chain ID: ${chain}
+    // Nonce: ${nonce}
+    // Issued At: ${issued-at}
+    // Expiration Time: ${expiration-time}
+    // Not Before: ${not-before}
+    // Request ID: ${request-id}
+    // Resources:
+    // - ${resources[0]}
+    // - ${resources[1]}
+    // ...
+    // - ${resources[n]}
+    let message = `${input.domain} wants you to sign in with your Solana account:\n`;
+    message += `${input.address}`;
+    if (input.statement) {
+        message += `\n\n${input.statement}`;
+    }
+    const fields = [];
+    if (input.uri) {
+        fields.push(`URI: ${input.uri}`);
+    }
+    if (input.version) {
+        fields.push(`Version: ${input.version}`);
+    }
+    if (input.chainId) {
+        fields.push(`Chain ID: ${input.chainId}`);
+    }
+    if (input.nonce) {
+        fields.push(`Nonce: ${input.nonce}`);
+    }
+    if (input.issuedAt) {
+        fields.push(`Issued At: ${input.issuedAt}`);
+    }
+    if (input.expirationTime) {
+        fields.push(`Expiration Time: ${input.expirationTime}`);
+    }
+    if (input.notBefore) {
+        fields.push(`Not Before: ${input.notBefore}`);
+    }
+    if (input.requestId) {
+        fields.push(`Request ID: ${input.requestId}`);
+    }
+    if (input.resources) {
+        fields.push(`Resources:`);
+        for (const resource of input.resources) {
+            fields.push(`- ${resource}`);
+        }
+    }
+    if (fields.length) {
+        message += `\n\n${fields.join('\n')}`;
+    }
+    return message;
+}
+
+function createDecoder(decoder) {
+  return Object.freeze({
+    ...decoder,
+    decode: (bytes, offset = 0) => decoder.read(bytes, offset)[0]
+  });
+}
+
+var getBaseXDecoder = (alphabet4) => {
+  return createDecoder({
+    read(rawBytes, offset) {
+      const bytes = offset === 0 ? rawBytes : rawBytes.slice(offset);
+      if (bytes.length === 0) return ["", 0];
+      let trailIndex = bytes.findIndex((n) => n !== 0);
+      trailIndex = trailIndex === -1 ? bytes.length : trailIndex;
+      const leadingZeroes = alphabet4[0].repeat(trailIndex);
+      if (trailIndex === bytes.length) return [leadingZeroes, rawBytes.length];
+      const base10Number = bytes.slice(trailIndex).reduce((sum, byte) => sum * 256n + BigInt(byte), 0n);
+      const tailChars = getBaseXFromBigInt(base10Number, alphabet4);
+      return [leadingZeroes + tailChars, rawBytes.length];
+    }
+  });
+};
+function getBaseXFromBigInt(value, alphabet4) {
+  const base = BigInt(alphabet4.length);
+  const tailChars = [];
+  while (value > 0n) {
+    tailChars.unshift(alphabet4[Number(value % base)]);
+    value /= base;
+  }
+  return tailChars.join("");
+}
+
+// src/base58.ts
+var alphabet2 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var getBase58Decoder = () => getBaseXDecoder(alphabet2);
+
+// 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',
+    ERROR_FORBIDDEN_WALLET_BASE_URL: 'ERROR_FORBIDDEN_WALLET_BASE_URL',
+    ERROR_SECURE_CONTEXT_REQUIRED: 'ERROR_SECURE_CONTEXT_REQUIRED',
+    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 {
+    data;
+    code;
+    constructor(...args) {
+        const [code, message, data] = args;
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = 'SolanaMobileWalletAdapterError';
+    }
+}
+class SolanaMobileWalletAdapterProtocolError extends Error {
+    data;
+    code;
+    jsonRpcMessageId;
+    constructor(...args) {
+        const [jsonRpcMessageId, code, message, data] = args;
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.jsonRpcMessageId = jsonRpcMessageId;
+        this.name = 'SolanaMobileWalletAdapterProtocolError';
+    }
+}
+
+function encode(input) {
+    return window.btoa(input);
+}
+function fromUint8Array$1(byteArray, urlsafe) {
+    const base64 = window.btoa(String.fromCharCode.call(null, ...byteArray));
+    if (urlsafe) {
+        return base64
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=+$/, '');
+    }
+    else
+        return base64;
+}
+function toUint8Array$1(base64EncodedByteArray) {
+    return new Uint8Array(window
+        .atob(base64EncodedByteArray)
+        .split('')
+        .map((c) => c.charCodeAt(0)));
+}
+
+async function createHelloReq(ecdhPublicKey, associationKeypairPrivateKey) {
+    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;
+}
+
+function createSIWSMessage(payload) {
+    return createSignInMessageText(payload);
+}
+function createSIWSMessageBase64Url(payload) {
+    return encode(createSIWSMessage(payload))
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=+$/, ''); // convert to base64url encoding;
+}
+
+// optional features
+const SolanaSignTransactions = 'solana:signTransactions';
+const SolanaCloneAuthorization = 'solana:cloneAuthorization';
+
+function fromUint8Array$2(byteArray) {
+    return getBase58Decoder().decode(byteArray);
+}
+function base64ToBase58(base64EncodedString) {
+    return fromUint8Array$2(toUint8Array$1(base64EncodedString));
+}
+
+/**
+ * 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) {
+            // 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) {
+                    const { method, params } = handleMobileWalletRequest(p, inputParams, protocolVersion);
+                    const result = await 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'] = await 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 {
+                        ...capabilities,
+                        features: features,
+                    };
+                }
+                case 'v1': {
+                    return {
+                        ...capabilities,
+                        supports_sign_and_send_transactions: true,
+                        supports_clone_authorization: capabilities.features.includes(SolanaCloneAuthorization)
+                    };
+                }
+            }
+        }
+    }
+    return response;
+}
+async function signInFallback(signInPayload, authorizationResult, protocolRequestHandler) {
+    const domain = signInPayload.domain ?? window.location.host;
+    const address = authorizationResult.accounts[0].address;
+    const siwsMessage = createSIWSMessageBase64Url({ ...signInPayload, domain, address: base64ToBase58(address) });
+    const signMessageResult = await protocolRequestHandler('sign_messages', {
+        addresses: [address],
+        payloads: [siwsMessage]
+    });
+    const signedPayload = toUint8Array$1(signMessageResult.signed_payloads[0]);
+    const signedMessage = fromUint8Array$1(signedPayload.slice(0, signedPayload.length - 64));
+    const signature = fromUint8Array$1(signedPayload.slice(signedPayload.length - 64));
+    const signInResult = {
+        address: address,
+        // Workaround: some wallets have been observed to only reply with the message signature.
+        // This is non-compliant with the spec, but in the interest of maximizing compatibility,
+        // detect this case and reuse the original message.
+        signed_message: signedMessage.length == 0 ? siwsMessage : signedMessage,
+        signature
+    };
+    return signInResult;
+}
+
+const SEQUENCE_NUMBER_BYTES = 4;
+function createSequenceNumberVector(sequenceNumber) {
+    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);
+}
+
+const INITIALIZATION_VECTOR_BYTES = 12;
+const ENCODED_PUBLIC_KEY_LENGTH_BYTES = 65;
+async function encryptMessage(plaintext, sequenceNumber, 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;
+}
+async function decryptMessage(message, 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, initializationVector) {
+    return {
+        additionalData: sequenceNumber,
+        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;
+}
+
+async function generateAssociationKeypair() {
+    return await crypto.subtle.generateKey({
+        name: 'ECDSA',
+        namedCurve: 'P-256',
+    }, false /* extractable */, ['sign'] /* keyUsages */);
+}
+
+async function generateECDHKeypair() {
+    return await crypto.subtle.generateKey({
+        name: 'ECDH',
+        namedCurve: 'P-256',
+    }, false /* extractable */, ['deriveKey', 'deriveBits'] /* keyUsages */);
+}
+
+// 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 getRandomAssociationPort() {
+    return assertAssociationPort(49152 + Math.floor(Math.random() * (65535 - 49152 + 1)));
+}
+function assertAssociationPort(port) {
+    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;
+}
+
+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 { } // eslint-disable-line no-empty
+        if (baseUrl?.protocol !== 'https:') {
+            throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_FORBIDDEN_WALLET_BASE_URL, 'Base URLs supplied by wallets must be valid `https` URLs');
+        }
+    }
+    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);
+}
+async function getAssociateAndroidIntentURL(associationPublicKey, putativePort, associationURLBase, protocolVersions = ['v1']) {
+    const associationPort = assertAssociationPort(putativePort);
+    const exportedKey = await 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}`);
+    protocolVersions.forEach((version) => {
+        url.searchParams.set('v', version);
+    });
+    return url;
+}
+async function getRemoteAssociateAndroidIntentURL(associationPublicKey, hostAuthority, reflectorId, associationURLBase, protocolVersions = ['v1']) {
+    const exportedKey = await crypto.subtle.exportKey('raw', associationPublicKey);
+    const encodedKey = arrayBufferToBase64String(exportedKey);
+    const url = getIntentURL('v1/associate/remote', associationURLBase);
+    url.searchParams.set('association', getStringWithURLUnsafeCharactersReplaced(encodedKey));
+    url.searchParams.set('reflector', `${hostAuthority}`);
+    url.searchParams.set('id', `${fromUint8Array$1(reflectorId, true)}`);
+    protocolVersions.forEach((version) => {
+        url.searchParams.set('v', version);
+    });
+    return url;
+}
+
+async function encryptJsonRpcMessage(jsonRpcMessage, sharedSecret) {
+    const plaintext = JSON.stringify(jsonRpcMessage);
+    const sequenceNumber = jsonRpcMessage.id;
+    return encryptMessage(plaintext, sequenceNumber, sharedSecret);
+}
+async function decryptJsonRpcMessage(message, sharedSecret) {
+    const plaintext = await 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;
+}
+
+async function parseHelloRsp(payloadBuffer, // The X9.62-encoded wallet endpoint ephemeral ECDH public keypoint.
+associationPublicKey, ecdhPrivateKey) {
+    const [associationPublicKeyBuffer, walletPublicKey] = await Promise.all([
+        crypto.subtle.exportKey('raw', associationPublicKey),
+        crypto.subtle.importKey('raw', payloadBuffer.slice(0, ENCODED_PUBLIC_KEY_LENGTH_BYTES), { name: 'ECDH', namedCurve: 'P-256' }, false /* extractable */, [] /* keyUsages */),
+    ]);
+    const sharedSecret = await crypto.subtle.deriveBits({ name: 'ECDH', public: walletPublicKey }, ecdhPrivateKey, 256);
+    const ecdhSecretKey = await crypto.subtle.importKey('raw', sharedSecret, 'HKDF', false /* extractable */, ['deriveKey'] /* keyUsages */);
+    const aesKeyMaterialVal = await 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;
+}
+
+async function parseSessionProps(message, sharedSecret) {
+    const plaintext = await 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
+    });
+}
+
+// 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();
+        }, 3000);
+    });
+}
+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();
+}
+async function launchAssociation(associationUrl) {
+    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);
+                    await detectionPromise;
+                    break;
+                }
+                default:
+                    assertUnreachable(browser);
+            }
+        }
+        catch (e) {
+            throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_WALLET_NOT_FOUND, 'Found no installed wallet that supports the mobile wallet protocol.');
+        }
+    }
+}
+async function startSession(associationPublicKey, associationURLBase) {
+    const randomAssociationPort = getRandomAssociationPort();
+    const associationUrl = await getAssociateAndroidIntentURL(associationPublicKey, randomAssociationPort, associationURLBase);
+    await launchAssociation(associationUrl);
+    return randomAssociationPort;
+}
+
+const WEBSOCKET_CONNECTION_CONFIG = {
+    /**
+     * 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 initial
+     * interval at which we wait for the wallet to set up the websocket at
+     * half this, as per the Nyquist frequency, with a progressive backoff
+     * sequence from there. The total wait time is 30s, which allows for the
+     * user to be presented with a disambiguation dialog, select a wallet, and
+     * for the wallet app to subsequently start.
+     */
+    retryDelayScheduleMs: [150, 150, 200, 500, 500, 750, 750, 1000],
+    timeoutMs: 30000,
+};
+const WEBSOCKET_PROTOCOL_BINARY = 'com.solana.mobilewalletadapter.v1';
+const WEBSOCKET_PROTOCOL_BASE64 = 'com.solana.mobilewalletadapter.v1.base64';
+function assertSecureContext() {
+    if (typeof window === 'undefined' || window.isSecureContext !== true) {
+        throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_SECURE_CONTEXT_REQUIRED, 'The mobile wallet adapter protocol must be used in a secure context (`https`).');
+    }
+}
+function assertSecureEndpointSpecificURI(walletUriBase) {
+    let url;
+    try {
+        url = new URL(walletUriBase);
+    }
+    catch {
+        throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_FORBIDDEN_WALLET_BASE_URL, 'Invalid base URL supplied by wallet');
+    }
+    if (url.protocol !== 'https:') {
+        throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_FORBIDDEN_WALLET_BASE_URL, 'Base URLs supplied by wallets must be valid `https` URLs');
+    }
+}
+function getSequenceNumberFromByteArray(byteArray) {
+    const view = new DataView(byteArray);
+    return view.getUint32(0, /* littleEndian */ false);
+}
+function decodeVarLong(byteArray) {
+    var bytes = new Uint8Array(byteArray), l = byteArray.byteLength, limit = 10, value = 0, offset = 0, b;
+    do {
+        if (offset >= l || offset > limit)
+            throw new RangeError('Failed to decode varint');
+        b = bytes[offset++];
+        value |= (b & 0x7F) << (7 * offset);
+    } while (b >= 0x80);
+    return { value, offset };
+}
+function getReflectorIdFromByteArray(byteArray) {
+    let { value: length, offset } = decodeVarLong(byteArray);
+    return new Uint8Array(byteArray.slice(offset, offset + length));
+}
+async function transact$1(callback, config) {
+    const { wallet, close } = await startScenario(config);
+    try {
+        return await callback(await wallet);
+    }
+    finally {
+        close();
+    }
+}
+async function startScenario(config) {
+    assertSecureContext();
+    const associationKeypair = await generateAssociationKeypair();
+    const sessionPort = await startSession(associationKeypair.publicKey, config?.baseUri);
+    const websocketURL = `ws://localhost:${sessionPort}/solana-wallet`;
+    let connectionStartTime;
+    const getNextRetryDelayMs = (() => {
+        const schedule = [...WEBSOCKET_CONNECTION_CONFIG.retryDelayScheduleMs];
+        return () => (schedule.length > 1 ? schedule.shift() : schedule[0]);
+    })();
+    let nextJsonRpcMessageId = 1;
+    let lastKnownInboundSequenceNumber = 0;
+    let state = { __type: 'disconnected' };
+    let socket;
+    let sessionEstablished = false;
+    let handleForceClose;
+    return { close: () => {
+            socket.close();
+            handleForceClose();
+        }, wallet: new Promise((resolve, reject) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const jsonRpcResponsePromises = {};
+            const handleOpen = async () => {
+                if (state.__type !== 'connecting') {
+                    console.warn('Expected adapter state to be `connecting` at the moment the websocket opens. ' +
+                        `Got \`${state.__type}\`.`);
+                    return;
+                }
+                socket.removeEventListener('open', handleOpen);
+                // previous versions of this library and walletlib incorrectly implemented the MWA session 
+                // establishment protocol for local connections. The dapp is supposed to wait for the 
+                // APP_PING message before sending the HELLO_REQ. Instead, the dapp was sending the HELLO_REQ 
+                // immediately upon connection to the websocket server regardless of wether or not an 
+                // APP_PING was sent by the wallet/websocket server. We must continue to support this behavior 
+                // in case the user is using a wallet that has not updated their walletlib implementation. 
+                const { associationKeypair } = state;
+                const ecdhKeypair = await generateECDHKeypair();
+                socket.send(await 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 SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_CLOSED, `The wallet session dropped unexpectedly (${evt.code}: ${evt.reason}).`, { closeEvent: evt }));
+                }
+                disposeSocket();
+            };
+            const handleError = async (_evt) => {
+                disposeSocket();
+                if (Date.now() - connectionStartTime >= WEBSOCKET_CONNECTION_CONFIG.timeoutMs) {
+                    reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_TIMEOUT, `Failed to connect to the wallet websocket at ${websocketURL}.`));
+                }
+                else {
+                    await new Promise((resolve) => {
+                        const retryDelayMs = getNextRetryDelayMs();
+                        retryWaitTimeoutId = window.setTimeout(resolve, retryDelayMs);
+                    });
+                    attemptSocketConnection();
+                }
+            };
+            const handleMessage = async (evt) => {
+                const responseBuffer = await evt.data.arrayBuffer();
+                switch (state.__type) {
+                    case 'connecting':
+                        if (responseBuffer.byteLength !== 0) {
+                            throw new Error('Encountered unexpected message while connecting');
+                        }
+                        const ecdhKeypair = await generateECDHKeypair();
+                        socket.send(await createHelloReq(ecdhKeypair.publicKey, associationKeypair.privateKey));
+                        state = {
+                            __type: 'hello_req_sent',
+                            associationPublicKey: associationKeypair.publicKey,
+                            ecdhPrivateKey: ecdhKeypair.privateKey,
+                        };
+                        break;
+                    case 'connected':
+                        try {
+                            const sequenceNumberVector = responseBuffer.slice(0, SEQUENCE_NUMBER_BYTES);
+                            const sequenceNumber = getSequenceNumberFromByteArray(sequenceNumberVector);
+                            if (sequenceNumber !== (lastKnownInboundSequenceNumber + 1)) {
+                                throw new Error('Encrypted message has invalid sequence number');
+                            }
+                            lastKnownInboundSequenceNumber = sequenceNumber;
+                            const jsonRpcMessage = await decryptJsonRpcMessage(responseBuffer, state.sharedSecret);
+                            const responsePromise = jsonRpcResponsePromises[jsonRpcMessage.id];
+                            delete jsonRpcResponsePromises[jsonRpcMessage.id];
+                            responsePromise.resolve(jsonRpcMessage.result);
+                        }
+                        catch (e) {
+                            if (e instanceof SolanaMobileWalletAdapterProtocolError) {
+                                const responsePromise = jsonRpcResponsePromises[e.jsonRpcMessageId];
+                                delete jsonRpcResponsePromises[e.jsonRpcMessageId];
+                                responsePromise.reject(e);
+                            }
+                            else {
+                                throw e;
+                            }
+                        }
+                        break;
+                    case 'hello_req_sent': {
+                        // if we receive an APP_PING message (empty message), resend the HELLO_REQ (see above)
+                        if (responseBuffer.byteLength === 0) {
+                            const ecdhKeypair = await generateECDHKeypair();
+                            socket.send(await createHelloReq(ecdhKeypair.publicKey, associationKeypair.privateKey));
+                            state = {
+                                __type: 'hello_req_sent',
+                                associationPublicKey: associationKeypair.publicKey,
+                                ecdhPrivateKey: ecdhKeypair.privateKey,
+                            };
+                            break;
+                        }
+                        const sharedSecret = await parseHelloRsp(responseBuffer, state.associationPublicKey, state.ecdhPrivateKey);
+                        const sessionPropertiesBuffer = responseBuffer.slice(ENCODED_PUBLIC_KEY_LENGTH_BYTES);
+                        const sessionProperties = sessionPropertiesBuffer.byteLength !== 0
+                            ? await (async () => {
+                                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');
+                                }
+                                lastKnownInboundSequenceNumber = sequenceNumber;
+                                return parseSessionProps(sessionPropertiesBuffer, sharedSecret);
+                            })() : { protocol_version: 'legacy' };
+                        state = { __type: 'connected', sharedSecret, sessionProperties };
+                        const wallet = createMobileWalletProxy(sessionProperties.protocol_version, async (method, params) => {
+                            const id = nextJsonRpcMessageId++;
+                            socket.send(await encryptJsonRpcMessage({
+                                id,
+                                jsonrpc: '2.0',
+                                method,
+                                params: 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,
+                                };
+                            });
+                        });
+                        sessionEstablished = true;
+                        try {
+                            resolve(wallet);
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                        break;
+                    }
+                }
+            };
+            handleForceClose = () => {
+                socket.removeEventListener('message', handleMessage);
+                disposeSocket();
+                if (!sessionEstablished) {
+                    reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_CLOSED, `The wallet session was closed before connection.`, { closeEvent: new CloseEvent('socket was closed before connection') }));
+                }
+            };
+            let disposeSocket;
+            let retryWaitTimeoutId;
+            const attemptSocketConnection = () => {
+                if (disposeSocket) {
+                    disposeSocket();
+                }
+                state = { __type: 'connecting', associationKeypair };
+                if (connectionStartTime === undefined) {
+                    connectionStartTime = Date.now();
+                }
+                socket = new WebSocket(websocketURL, [WEBSOCKET_PROTOCOL_BINARY]);
+                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();
+        }) };
+}
+async function startRemoteScenario$1(config) {
+    assertSecureContext();
+    const associationKeypair = await generateAssociationKeypair();
+    const websocketURL = `wss://${config?.remoteHostAuthority}/reflect`;
+    let connectionStartTime;
+    const getNextRetryDelayMs = (() => {
+        const schedule = [...WEBSOCKET_CONNECTION_CONFIG.retryDelayScheduleMs];
+        return () => (schedule.length > 1 ? schedule.shift() : schedule[0]);
+    })();
+    let nextJsonRpcMessageId = 1;
+    let lastKnownInboundSequenceNumber = 0;
+    let encoding;
+    let state = { __type: 'disconnected' };
+    let socket;
+    let disposeSocket;
+    let decodeBytes = async (evt) => {
+        if (encoding == 'base64') { // base64 encoding
+            const message = await evt.data;
+            return toUint8Array$1(message).buffer;
+        }
+        else {
+            return await evt.data.arrayBuffer();
+        }
+    };
+    // Reflector Connection Phase
+    // here we connect to the reflector and wait for the REFLECTOR_ID message 
+    // so we build the association URL and return that back to the caller
+    const associationUrl = await new Promise((resolve, reject) => {
+        const handleOpen = async () => {
+            if (state.__type !== 'connecting') {
+                console.warn('Expected adapter state to be `connecting` at the moment the websocket opens. ' +
+                    `Got \`${state.__type}\`.`);
+                return;
+            }
+            if (socket.protocol.includes(WEBSOCKET_PROTOCOL_BASE64)) {
+                encoding = 'base64';
+            }
+            else {
+                encoding = 'binary';
+            }
+            socket.removeEventListener('open', handleOpen);
+        };
+        const handleClose = (evt) => {
+            if (evt.wasClean) {
+                state = { __type: 'disconnected' };
+            }
+            else {
+                reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_CLOSED, `The wallet session dropped unexpectedly (${evt.code}: ${evt.reason}).`, { closeEvent: evt }));
+            }
+            disposeSocket();
+        };
+        const handleError = async (_evt) => {
+            disposeSocket();
+            if (Date.now() - connectionStartTime >= WEBSOCKET_CONNECTION_CONFIG.timeoutMs) {
+                reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_TIMEOUT, `Failed to connect to the wallet websocket at ${websocketURL}.`));
+            }
+            else {
+                await new Promise((resolve) => {
+                    const retryDelayMs = getNextRetryDelayMs();
+                    retryWaitTimeoutId = window.setTimeout(resolve, retryDelayMs);
+                });
+                attemptSocketConnection();
+            }
+        };
+        const handleReflectorIdMessage = async (evt) => {
+            const responseBuffer = await decodeBytes(evt);
+            if (state.__type === 'connecting') {
+                if (responseBuffer.byteLength == 0) {
+                    throw new Error('Encountered unexpected message while connecting');
+                }
+                const reflectorId = getReflectorIdFromByteArray(responseBuffer);
+                state = {
+                    __type: 'reflector_id_received',
+                    reflectorId: reflectorId
+                };
+                const associationUrl = await getRemoteAssociateAndroidIntentURL(associationKeypair.publicKey, config.remoteHostAuthority, reflectorId, config?.baseUri);
+                socket.removeEventListener('message', handleReflectorIdMessage);
+                resolve(associationUrl);
+            }
+        };
+        let retryWaitTimeoutId;
+        const attemptSocketConnection = () => {
+            if (disposeSocket) {
+                disposeSocket();
+            }
+            state = { __type: 'connecting', associationKeypair };
+            if (connectionStartTime === undefined) {
+                connectionStartTime = Date.now();
+            }
+            socket = new WebSocket(websocketURL, [WEBSOCKET_PROTOCOL_BINARY, WEBSOCKET_PROTOCOL_BASE64]);
+            socket.addEventListener('open', handleOpen);
+            socket.addEventListener('close', handleClose);
+            socket.addEventListener('error', handleError);
+            socket.addEventListener('message', handleReflectorIdMessage);
+            disposeSocket = () => {
+                window.clearTimeout(retryWaitTimeoutId);
+                socket.removeEventListener('open', handleOpen);
+                socket.removeEventListener('close', handleClose);
+                socket.removeEventListener('error', handleError);
+                socket.removeEventListener('message', handleReflectorIdMessage);
+            };
+        };
+        attemptSocketConnection();
+    });
+    // Wallet Connection Phase
+    // here we return the association URL (containing the reflector ID) to the caller + 
+    // a promise that will resolve the MobileWallet object once the wallet connects.
+    let sessionEstablished = false;
+    let handleClose;
+    return { associationUrl, close: () => {
+            socket.close();
+            handleClose();
+        }, wallet: new Promise((resolve, reject) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const jsonRpcResponsePromises = {};
+            const handleMessage = async (evt) => {
+                const responseBuffer = await decodeBytes(evt);
+                switch (state.__type) {
+                    case 'reflector_id_received':
+                        if (responseBuffer.byteLength !== 0) {
+                            throw new Error('Encountered unexpected message while awaiting reflection');
+                        }
+                        const ecdhKeypair = await generateECDHKeypair();
+                        const binaryMsg = await createHelloReq(ecdhKeypair.publicKey, associationKeypair.privateKey);
+                        if (encoding == 'base64') {
+                            socket.send(fromUint8Array$1(binaryMsg));
+                        }
+                        else {
+                            socket.send(binaryMsg);
+                        }
+                        state = {
+                            __type: 'hello_req_sent',
+                            associationPublicKey: associationKeypair.publicKey,
+                            ecdhPrivateKey: ecdhKeypair.privateKey,
+                        };
+                        break;
+                    case 'connected':
+                        try {
+                            const sequenceNumberVector = responseBuffer.slice(0, SEQUENCE_NUMBER_BYTES);
+                            const sequenceNumber = getSequenceNumberFromByteArray(sequenceNumberVector);
+                            if (sequenceNumber !== (lastKnownInboundSequenceNumber + 1)) {
+                                throw new Error('Encrypted message has invalid sequence number');
+                            }
+                            lastKnownInboundSequenceNumber = sequenceNumber;
+                            const jsonRpcMessage = await decryptJsonRpcMessage(responseBuffer, state.sharedSecret);
+                            const responsePromise = jsonRpcResponsePromises[jsonRpcMessage.id];
+                            delete jsonRpcResponsePromises[jsonRpcMessage.id];
+                            responsePromise.resolve(jsonRpcMessage.result);
+                        }
+                        catch (e) {
+                            if (e instanceof SolanaMobileWalletAdapterProtocolError) {
+                                const responsePromise = jsonRpcResponsePromises[e.jsonRpcMessageId];
+                                delete jsonRpcResponsePromises[e.jsonRpcMessageId];
+                                responsePromise.reject(e);
+                            }
+                            else {
+                                throw e;
+                            }
+                        }
+                        break;
+                    case 'hello_req_sent': {
+                        const sharedSecret = await parseHelloRsp(responseBuffer, state.associationPublicKey, state.ecdhPrivateKey);
+                        const sessionPropertiesBuffer = responseBuffer.slice(ENCODED_PUBLIC_KEY_LENGTH_BYTES);
+                        const sessionProperties = sessionPropertiesBuffer.byteLength !== 0
+                            ? await (async () => {
+                                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');
+                                }
+                                lastKnownInboundSequenceNumber = sequenceNumber;
+                                return parseSessionProps(sessionPropertiesBuffer, sharedSecret);
+                            })() : { protocol_version: 'legacy' };
+                        state = { __type: 'connected', sharedSecret, sessionProperties };
+                        const wallet = createMobileWalletProxy(sessionProperties.protocol_version, async (method, params) => {
+                            const id = nextJsonRpcMessageId++;
+                            const binaryMsg = await encryptJsonRpcMessage({
+                                id,
+                                jsonrpc: '2.0',
+                                method,
+                                params: params ?? {},
+                            }, sharedSecret);
+                            if (encoding == 'base64') {
+                                socket.send(fromUint8Array$1(binaryMsg));
+                            }
+                            else {
+                                socket.send(binaryMsg);
+                            }
+                            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,
+                                };
+                            });
+                        });
+                        sessionEstablished = true;
+                        try {
+                            resolve(wallet);
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                        break;
+                    }
+                }
+            };
+            socket.addEventListener('message', handleMessage);
+            handleClose = () => {
+                socket.removeEventListener('message', handleMessage);
+                disposeSocket();
+                if (!sessionEstablished) {
+                    reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_CLOSED, `The wallet session was closed before connection.`, { closeEvent: new CloseEvent('socket was closed before connection') }));
+                }
+            };
+        }) };
+}
+
+// base-x encoding / decoding
+// Copyright (c) 2018 base-x contributors
+// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+function base (ALPHABET) {
+  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }
+  const BASE_MAP = new Uint8Array(256);
+  for (let j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
+  }
+  for (let i = 0; i < ALPHABET.length; i++) {
+    const x = ALPHABET.charAt(i);
+    const xc = x.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }
+    BASE_MAP[xc] = i;
+  }
+  const BASE = ALPHABET.length;
+  const LEADER = ALPHABET.charAt(0);
+  const FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
+  const iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
+  function encode (source) {
+    // eslint-disable-next-line no-empty
+    if (source instanceof Uint8Array) ; else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) { throw new TypeError('Expected Uint8Array') }
+    if (source.length === 0) { return '' }
+    // Skip & count leading zeroes.
+    let zeroes = 0;
+    let length = 0;
+    let pbegin = 0;
+    const pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    // Allocate enough space in big-endian base58 representation.
+    const size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
+    const b58 = new Uint8Array(size);
+    // Process the bytes.
+    while (pbegin !== pend) {
+      let carry = source[pbegin];
+      // Apply "b58 = b58 * 256 + ch".
+      let i = 0;
+      for (let it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
+        carry += (256 * b58[it1]) >>> 0;
+        b58[it1] = (carry % BASE) >>> 0;
+        carry = (carry / BASE) >>> 0;
+      }
+      if (carry !== 0) { throw new Error('Non-zero carry') }
+      length = i;
+      pbegin++;
+    }
+    // Skip leading zeroes in base58 result.
+    let it2 = size - length;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    // Translate the result into a string.
+    let str = LEADER.repeat(zeroes);
+    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]); }
+    return str
+  }
+  function decodeUnsafe (source) {
+    if (typeof source !== 'string') { throw new TypeError('Expected String') }
+    if (source.length === 0) { return new Uint8Array() }
+    let psz = 0;
+    // Skip and count leading '1's.
+    let zeroes = 0;
+    let length = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    // Allocate enough space in big-endian base256 representation.
+    const size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
+    const b256 = new Uint8Array(size);
+    // Process the characters.
+    while (psz < source.length) {
+      // Find code of next character
+      const charCode = source.charCodeAt(psz);
+      // Base map can not be indexed using char code
+      if (charCode > 255) { return }
+      // Decode character
+      let carry = BASE_MAP[charCode];
+      // Invalid character
+      if (carry === 255) { return }
+      let i = 0;
+      for (let it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
+        carry += (BASE * b256[it3]) >>> 0;
+        b256[it3] = (carry % 256) >>> 0;
+        carry = (carry / 256) >>> 0;
+      }
+      if (carry !== 0) { throw new Error('Non-zero carry') }
+      length = i;
+      psz++;
+    }
+    // Skip leading zeroes in b256.
+    let it4 = size - length;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    const vch = new Uint8Array(zeroes + (size - it4));
+    let j = zeroes;
+    while (it4 !== size) {
+      vch[j++] = b256[it4++];
+    }
+    return vch
+  }
+  function decode (string) {
+    const buffer = decodeUnsafe(string);
+    if (buffer) { return buffer }
+    throw new Error('Non-base' + BASE + ' character')
+  }
+  return {
+    encode,
+    decodeUnsafe,
+    decode
+  }
+}
+
+var ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+var bs58 = base(ALPHABET);
+
+function fromUint8Array(byteArray) {
+    return window.btoa(String.fromCharCode.call(null, ...byteArray));
+}
+function toUint8Array(base64EncodedByteArray) {
+    return new Uint8Array(window
+        .atob(base64EncodedByteArray)
+        .split('')
+        .map((c) => c.charCodeAt(0)));
+}
+
+function getPayloadFromTransaction(transaction) {
+    const serializedTransaction = 'version' in transaction
+        ? transaction.serialize()
+        : transaction.serialize({
+            requireAllSignatures: false,
+            verifySignatures: false,
+        });
+    const payload = fromUint8Array(serializedTransaction);
+    return payload;
+}
+function getTransactionFromWireMessage(byteArray) {
+    const numSignatures = byteArray[0];
+    const messageOffset = numSignatures * SIGNATURE_LENGTH_IN_BYTES + 1;
+    const version = VersionedMessage.deserializeMessageVersion(byteArray.slice(messageOffset, byteArray.length));
+    if (version === 'legacy') {
+        return Transaction.from(byteArray);
+    }
+    else {
+        return VersionedTransaction.deserialize(byteArray);
+    }
+}
+async function transact(callback, config) {
+    const augmentedCallback = (wallet) => {
+        return callback(augmentWalletAPI(wallet));
+    };
+    return await transact$1(augmentedCallback, config);
+}
+async function startRemoteScenario(config) {
+    const { wallet, close, associationUrl } = await startRemoteScenario$1(config);
+    const augmentedPromise = wallet.then((wallet) => {
+        return augmentWalletAPI(wallet);
+    });
+    return { wallet: augmentedPromise, close, associationUrl };
+}
+function augmentWalletAPI(wallet) {
+    return new Proxy({}, {
+        get(target, p) {
+            if (target[p] == null) {
+                switch (p) {
+                    case 'signAndSendTransactions':
+                        target[p] = async function ({ minContextSlot, commitment, skipPreflight, maxRetries, waitForCommitmentToSendNextTransaction, transactions, ...rest }) {
+                            const payloads = transactions.map(getPayloadFromTransaction);
+                            const options = {
+                                min_context_slot: minContextSlot,
+                                commitment: commitment,
+                                skip_preflight: skipPreflight,
+                                max_retries: maxRetries,
+                                wait_for_commitment_to_send_next_transaction: waitForCommitmentToSendNextTransaction
+                            };
+                            const { signatures: base64EncodedSignatures } = await wallet.signAndSendTransactions({
+                                ...rest,
+                                ...(Object.values(options).some(element => element != null)
+                                    ? { options: options }
+                                    : null),
+                                payloads,
+                            });
+                            const signatures = base64EncodedSignatures.map(toUint8Array).map(bs58.encode);
+                            return signatures;
+                        };
+                        break;
+                    case 'signMessages':
+                        target[p] = async function ({ payloads, ...rest }) {
+                            const base64EncodedPayloads = payloads.map(fromUint8Array);
+                            const { signed_payloads: base64EncodedSignedMessages } = await wallet.signMessages({
+                                ...rest,
+                                payloads: base64EncodedPayloads,
+                            });
+                            const signedMessages = base64EncodedSignedMessages.map(toUint8Array);
+                            return signedMessages;
+                        };
+                        break;
+                    case 'signTransactions':
+                        target[p] = async function ({ transactions, ...rest }) {
+                            const payloads = transactions.map(getPayloadFromTransaction);
+                            const { signed_payloads: base64EncodedCompiledTransactions } = await wallet.signTransactions({
+                                ...rest,
+                                payloads,
+                            });
+                            const compiledTransactions = base64EncodedCompiledTransactions.map(toUint8Array);
+                            const signedTransactions = compiledTransactions.map(getTransactionFromWireMessage);
+                            return signedTransactions;
+                        };
+                        break;
+                    default: {
+                        target[p] = wallet[p];
+                        break;
+                    }
+                }
+            }
+            return target[p];
+        },
+        defineProperty() {
+            return false;
+        },
+        deleteProperty() {
+            return false;
+        },
+    });
+}
+
+export { startRemoteScenario, transact };
+//# sourceMappingURL=index.browser-C9bFQZyQ.esm.js.map