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

package/lib/esm/index.mjs

@@ -0,0 +1,338 @@
+import { withLocalWallet } from '@solana-mobile/mobile-wallet-adapter-protocol';
+import { BaseMessageSignerWalletAdapter, WalletReadyState, WalletNotReadyError, WalletPublicKeyError, WalletConnectionError, WalletDisconnectedError, WalletNotConnectedError, WalletSignTransactionError, WalletSendTransactionError, WalletSignMessageError } from '@solana/wallet-adapter-base';
+import { PublicKey, Transaction } from '@solana/web3.js';
+
+/*! *****************************************************************************
+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());
+    });
+}
+
+const SolanaMobileWalletAdapterWalletName = 'Default wallet app';
+const SIGNATURE_LENGTH_IN_BYTES = 64;
+function getBase64StringFromByteArray(byteArray) {
+    return btoa(String.fromCharCode.call(null, ...byteArray));
+}
+function getByteArrayFromBase64String(base64EncodedByteArray) {
+    return new Uint8Array(atob(base64EncodedByteArray)
+        .split('')
+        .map((c) => c.charCodeAt(0)));
+}
+class SolanaMobileWalletAdapter extends BaseMessageSignerWalletAdapter {
+    constructor(config) {
+        super();
+        this.name = SolanaMobileWalletAdapterWalletName;
+        this.url = 'https://solanamobile.com';
+        this.icon = 'data:image/svg+xml;base64,PHN2ZyBmaWxsPSJub25lIiBoZWlnaHQ9IjI4IiB3aWR0aD0iMjgiIHZpZXdCb3g9Ii0zIDAgMjggMjgiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PGcgZmlsbD0iI0RDQjhGRiI+PHBhdGggZD0iTTE3LjQgMTcuNEgxNXYyLjRoMi40di0yLjRabTEuMi05LjZoLTIuNHYyLjRoMi40VjcuOFoiLz48cGF0aCBkPSJNMjEuNiAzVjBoLTIuNHYzaC0zLjZWMGgtMi40djNoLTIuNHY2LjZINC41YTIuMSAyLjEgMCAxIDEgMC00LjJoMi43VjNINC41QTQuNSA0LjUgMCAwIDAgMCA3LjVWMjRoMjEuNnYtNi42aC0yLjR2NC4ySDIuNFYxMS41Yy41LjMgMS4yLjQgMS44LjVoNy41QTYuNiA2LjYgMCAwIDAgMjQgOVYzaC0yLjRabTAgNS43YTQuMiA0LjIgMCAxIDEtOC40IDBWNS40aDguNHYzLjNaIi8+PC9nPjwvc3ZnPg==';
+        this._connecting = false;
+        this._readyState = typeof window === 'undefined' ||
+            typeof document === 'undefined' ||
+            !/android/i.test(navigator.userAgent) ||
+            !window.isSecureContext
+            ? WalletReadyState.Unsupported
+            : WalletReadyState.Loadable;
+        this._authorizationResultCache = config.authorizationResultCache;
+        this._appIdentity = config.appIdentity;
+        if (this._readyState !== WalletReadyState.Unsupported) {
+            this._authorizationResultCache.get().then((authorizationResult) => {
+                if (authorizationResult) {
+                    // Having a prior authorization result is, right now, the best
+                    // indication that a mobile wallet is installed. There is no API
+                    // we can use to test for whether the association URI is supported.
+                    this.emit('readyStateChange', (this._readyState = WalletReadyState.Installed));
+                }
+            });
+        }
+    }
+    get publicKey() {
+        if (this._publicKey == null && this._authorizationResult != null) {
+            this._publicKey = new PublicKey(this._authorizationResult.publicKey);
+        }
+        return this._publicKey ? this._publicKey : null;
+    }
+    get connected() {
+        return !!this._authorizationResult;
+    }
+    get connecting() {
+        return this._connecting;
+    }
+    get readyState() {
+        return this._readyState;
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._readyState !== WalletReadyState.Installed && this._readyState !== WalletReadyState.Loadable) {
+                const err = new WalletNotReadyError();
+                this.emit('error', err);
+                throw err;
+            }
+            this._connecting = true;
+            const cachedAuthorizationResult = yield this._authorizationResultCache.get();
+            if (cachedAuthorizationResult) {
+                this._authorizationResult = cachedAuthorizationResult;
+                this._connecting = false;
+                if (this._readyState !== WalletReadyState.Installed) {
+                    this.emit('readyStateChange', (this._readyState = WalletReadyState.Installed));
+                }
+                this.emit('connect', 
+                // Having just set an `authorizationResult`, `this.publicKey` is definitely non-null
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                this.publicKey);
+                return;
+            }
+            try {
+                yield this.withWallet((mobileWallet) => __awaiter(this, void 0, void 0, function* () {
+                    const { auth_token, pub_key: base58PublicKey, wallet_uri_base, } = yield mobileWallet('authorize', { identity: this._appIdentity });
+                    try {
+                        this._publicKey = new PublicKey(base58PublicKey);
+                    }
+                    catch (e) {
+                        throw new WalletPublicKeyError((e instanceof Error && (e === null || e === void 0 ? void 0 : e.message)) || 'Unknown error', e);
+                    }
+                    this.handleAuthorizationResult({
+                        authToken: auth_token,
+                        publicKey: base58PublicKey,
+                        walletUriBase: wallet_uri_base,
+                    }); // TODO: Evaluate whether there's any threat to not `awaiting` this expression
+                    this.emit('connect', 
+                    // Having just set an `authorizationResult`, `this.publicKey` is definitely non-null
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    this.publicKey);
+                }));
+            }
+            catch (e) {
+                throw new WalletConnectionError((e instanceof Error && e.message) || 'Unknown error', e);
+            }
+            finally {
+                this._connecting = false;
+            }
+        });
+    }
+    handleAuthorizationResult(authorizationResult) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._authorizationResult = authorizationResult;
+            yield this._authorizationResultCache.set(authorizationResult);
+        });
+    }
+    performReauthorization(mobileWallet, currentAuthorizationResult) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { auth_token } = yield mobileWallet('reauthorize', {
+                    auth_token: currentAuthorizationResult.authToken,
+                });
+                if (currentAuthorizationResult.authToken !== auth_token) {
+                    this.handleAuthorizationResult(Object.assign(Object.assign({}, currentAuthorizationResult), { authToken: auth_token })); // TODO: Evaluate whether there's any threat to not `awaiting` this expression
+                }
+                return auth_token;
+            }
+            catch (e) {
+                this.disconnect();
+                throw new WalletDisconnectedError((e instanceof Error && (e === null || e === void 0 ? void 0 : e.message)) || 'Unknown error', e);
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._authorizationResultCache.clear(); // TODO: Evaluate whether there's any threat to not `awaiting` this expression
+            delete this._authorizationResult;
+            delete this._publicKey;
+            this.emit('disconnect');
+        });
+    }
+    withWallet(callback) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletUriBase = (_a = this._authorizationResult) === null || _a === void 0 ? void 0 : _a.walletUriBase;
+            const config = walletUriBase ? { baseUri: walletUriBase } : undefined;
+            return yield withLocalWallet(callback, config);
+        });
+    }
+    assertIsAuthorized() {
+        const authorizationResult = this._authorizationResult;
+        if (!authorizationResult)
+            throw new WalletNotConnectedError();
+        return authorizationResult;
+    }
+    performSignTransactions(transactions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authorizationResult = this.assertIsAuthorized();
+                try {
+                    const serializedTransactions = transactions.map((transaction) => transaction.serialize({
+                        requireAllSignatures: false,
+                        verifySignatures: false,
+                    }));
+                    const payloads = serializedTransactions.map((serializedTransaction) => serializedTransaction.toString('base64'));
+                    return yield this.withWallet((mobileWallet) => __awaiter(this, void 0, void 0, function* () {
+                        const freshAuthToken = yield this.performReauthorization(mobileWallet, authorizationResult);
+                        const { signed_payloads: base64EncodedCompiledTransactions } = yield mobileWallet('sign_transaction', { auth_token: freshAuthToken, payloads });
+                        const compiledTransactions = base64EncodedCompiledTransactions.map(getByteArrayFromBase64String);
+                        const transactions = compiledTransactions.map(Transaction.from);
+                        return transactions;
+                    }));
+                }
+                catch (error) {
+                    throw new WalletSignTransactionError(error === null || error === void 0 ? void 0 : error.message, error);
+                }
+            }
+            catch (error) {
+                this.emit('error', error);
+                throw error;
+            }
+        });
+    }
+    sendTransaction(transaction, connection, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authorizationResult = this.assertIsAuthorized();
+                try {
+                    if (transaction.feePayer == null) {
+                        transaction.feePayer = this.publicKey || undefined;
+                    }
+                    if (transaction.recentBlockhash == null) {
+                        const { blockhash } = yield connection.getRecentBlockhash(connection.commitment);
+                        transaction.recentBlockhash = blockhash;
+                    }
+                    const serializedTransaction = transaction.serialize({
+                        requireAllSignatures: false,
+                        verifySignatures: false,
+                    });
+                    const payloads = [serializedTransaction.toString('base64')];
+                    return yield this.withWallet((mobileWallet) => __awaiter(this, void 0, void 0, function* () {
+                        const freshAuthToken = yield this.performReauthorization(mobileWallet, authorizationResult);
+                        let targetCommitment;
+                        switch (connection.commitment) {
+                            case 'confirmed':
+                            case 'finalized':
+                            case 'processed':
+                                targetCommitment = connection.commitment;
+                                break;
+                            default:
+                                targetCommitment = 'finalized';
+                        }
+                        const { signatures } = yield mobileWallet('sign_and_send_transaction', {
+                            auth_token: freshAuthToken,
+                            commitment: targetCommitment,
+                            payloads,
+                        });
+                        return signatures[0];
+                    }));
+                }
+                catch (error) {
+                    throw new WalletSendTransactionError(error === null || error === void 0 ? void 0 : error.message, error);
+                }
+            }
+            catch (error) {
+                this.emit('error', error);
+                throw error;
+            }
+        });
+    }
+    signTransaction(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [signedTransaction] = yield this.performSignTransactions([transaction]);
+            return signedTransaction;
+        });
+    }
+    signAllTransactions(transactions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signedTransactions = yield this.performSignTransactions(transactions);
+            return signedTransactions;
+        });
+    }
+    signMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authorizationResult = this.assertIsAuthorized();
+                try {
+                    return yield this.withWallet((mobileWallet) => __awaiter(this, void 0, void 0, function* () {
+                        const freshAuthToken = yield this.performReauthorization(mobileWallet, authorizationResult);
+                        const { signed_payloads: [base64EncodedSignedMessage], } = yield mobileWallet('sign_message', {
+                            auth_token: freshAuthToken,
+                            payloads: [getBase64StringFromByteArray(message)],
+                        });
+                        const signedMessage = getByteArrayFromBase64String(base64EncodedSignedMessage);
+                        const signature = signedMessage.slice(-SIGNATURE_LENGTH_IN_BYTES);
+                        return signature;
+                    }));
+                }
+                catch (error) {
+                    throw new WalletSignMessageError(error === null || error === void 0 ? void 0 : error.message, error);
+                }
+            }
+            catch (error) {
+                this.emit('error', error);
+                throw error;
+            }
+        });
+    }
+}
+
+const CACHE_KEY = 'SolanaMobileWalletAdapterDefaultAuthorizationCache';
+function createDefaultAuthorizationResultCache() {
+    let storage;
+    try {
+        storage = window.localStorage;
+        // eslint-disable-next-line no-empty
+    }
+    catch (_a) { }
+    return {
+        clear() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!storage) {
+                    return;
+                }
+                try {
+                    storage.removeItem(CACHE_KEY);
+                    // eslint-disable-next-line no-empty
+                }
+                catch (_a) { }
+            });
+        },
+        get() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!storage) {
+                    return;
+                }
+                try {
+                    return JSON.parse(storage.getItem(CACHE_KEY)) || undefined;
+                    // eslint-disable-next-line no-empty
+                }
+                catch (_a) { }
+            });
+        },
+        set(authorizationResult) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!storage) {
+                    return;
+                }
+                try {
+                    storage.setItem(CACHE_KEY, JSON.stringify(authorizationResult));
+                    // eslint-disable-next-line no-empty
+                }
+                catch (_a) { }
+            });
+        },
+    };
+}
+
+export { SolanaMobileWalletAdapter, SolanaMobileWalletAdapterWalletName, createDefaultAuthorizationResultCache };

package/lib/esm/package.json

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

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

@@ -0,0 +1,42 @@
+import { AppIdentity, AuthorizationResult } from "@solana-mobile/mobile-wallet-adapter-protocol";
+import { BaseMessageSignerWalletAdapter, WalletName, WalletReadyState } from "@solana/wallet-adapter-base";
+import { Connection, PublicKey, SendOptions, Transaction, TransactionSignature } from "@solana/web3.js";
+interface AuthorizationResultCache {
+    clear(): Promise<void>;
+    get(): Promise<AuthorizationResult | undefined>;
+    set(authorizationResult: AuthorizationResult): Promise<void>;
+}
+declare const SolanaMobileWalletAdapterWalletName: WalletName;
+declare class SolanaMobileWalletAdapter extends BaseMessageSignerWalletAdapter {
+    name: WalletName;
+    url: string;
+    icon: string;
+    private _appIdentity;
+    private _authorizationResult;
+    private _authorizationResultCache;
+    private _connecting;
+    private _publicKey;
+    private _readyState;
+    constructor(config: {
+        appIdentity: AppIdentity;
+        authorizationResultCache: AuthorizationResultCache;
+    });
+    get publicKey(): PublicKey | null;
+    get connected(): boolean;
+    get connecting(): boolean;
+    get readyState(): WalletReadyState;
+    connect(): Promise<void>;
+    private handleAuthorizationResult;
+    private performReauthorization;
+    disconnect(): Promise<void>;
+    private withWallet;
+    private assertIsAuthorized;
+    private performSignTransactions;
+    sendTransaction(transaction: Transaction, connection: Connection, _options?: SendOptions): Promise<TransactionSignature>;
+    signTransaction(transaction: Transaction): Promise<Transaction>;
+    signAllTransactions(transactions: Transaction[]): Promise<Transaction[]>;
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
+}
+declare function createDefaultAuthorizationResultCache(): AuthorizationResultCache;
+export { AuthorizationResultCache, SolanaMobileWalletAdapterWalletName, SolanaMobileWalletAdapter, createDefaultAuthorizationResultCache };
+//# 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/adapter.ts","../../src/createDefaultAuthorizationResultCache.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,42 @@
+import { AppIdentity, AuthorizationResult } from "@solana-mobile/mobile-wallet-adapter-protocol";
+import { BaseMessageSignerWalletAdapter, WalletName, WalletReadyState } from "@solana/wallet-adapter-base";
+import { Connection, PublicKey, SendOptions, Transaction, TransactionSignature } from "@solana/web3.js";
+interface AuthorizationResultCache {
+    clear(): Promise<void>;
+    get(): Promise<AuthorizationResult | undefined>;
+    set(authorizationResult: AuthorizationResult): Promise<void>;
+}
+declare const SolanaMobileWalletAdapterWalletName: WalletName;
+declare class SolanaMobileWalletAdapter extends BaseMessageSignerWalletAdapter {
+    name: WalletName;
+    url: string;
+    icon: string;
+    private _appIdentity;
+    private _authorizationResult;
+    private _authorizationResultCache;
+    private _connecting;
+    private _publicKey;
+    private _readyState;
+    constructor(config: {
+        appIdentity: AppIdentity;
+        authorizationResultCache: AuthorizationResultCache;
+    });
+    get publicKey(): PublicKey | null;
+    get connected(): boolean;
+    get connecting(): boolean;
+    get readyState(): WalletReadyState;
+    connect(): Promise<void>;
+    private handleAuthorizationResult;
+    private performReauthorization;
+    disconnect(): Promise<void>;
+    private withWallet;
+    private assertIsAuthorized;
+    private performSignTransactions;
+    sendTransaction(transaction: Transaction, connection: Connection, _options?: SendOptions): Promise<TransactionSignature>;
+    signTransaction(transaction: Transaction): Promise<Transaction>;
+    signAllTransactions(transactions: Transaction[]): Promise<Transaction[]>;
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
+}
+declare function createDefaultAuthorizationResultCache(): AuthorizationResultCache;
+export { AuthorizationResultCache, SolanaMobileWalletAdapterWalletName, SolanaMobileWalletAdapter, createDefaultAuthorizationResultCache };
+//# sourceMappingURL=index.browser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.browser.d.ts","sourceRoot":"","sources":["../../src/index.ts","../../src/adapter.ts","../../src/createDefaultAuthorizationResultCache.ts"],"names":[],"mappings":""}

package/lib/types/index.d.mts

@@ -0,0 +1,42 @@
+import { AppIdentity, AuthorizationResult } from "@solana-mobile/mobile-wallet-adapter-protocol";
+import { BaseMessageSignerWalletAdapter, WalletName, WalletReadyState } from "@solana/wallet-adapter-base";
+import { Connection, PublicKey, SendOptions, Transaction, TransactionSignature } from "@solana/web3.js";
+interface AuthorizationResultCache {
+    clear(): Promise<void>;
+    get(): Promise<AuthorizationResult | undefined>;
+    set(authorizationResult: AuthorizationResult): Promise<void>;
+}
+declare const SolanaMobileWalletAdapterWalletName: WalletName;
+declare class SolanaMobileWalletAdapter extends BaseMessageSignerWalletAdapter {
+    name: WalletName;
+    url: string;
+    icon: string;
+    private _appIdentity;
+    private _authorizationResult;
+    private _authorizationResultCache;
+    private _connecting;
+    private _publicKey;
+    private _readyState;
+    constructor(config: {
+        appIdentity: AppIdentity;
+        authorizationResultCache: AuthorizationResultCache;
+    });
+    get publicKey(): PublicKey | null;
+    get connected(): boolean;
+    get connecting(): boolean;
+    get readyState(): WalletReadyState;
+    connect(): Promise<void>;
+    private handleAuthorizationResult;
+    private performReauthorization;
+    disconnect(): Promise<void>;
+    private withWallet;
+    private assertIsAuthorized;
+    private performSignTransactions;
+    sendTransaction(transaction: Transaction, connection: Connection, _options?: SendOptions): Promise<TransactionSignature>;
+    signTransaction(transaction: Transaction): Promise<Transaction>;
+    signAllTransactions(transactions: Transaction[]): Promise<Transaction[]>;
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
+}
+declare function createDefaultAuthorizationResultCache(): AuthorizationResultCache;
+export { AuthorizationResultCache, SolanaMobileWalletAdapterWalletName, SolanaMobileWalletAdapter, createDefaultAuthorizationResultCache };
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/index.ts","../../src/adapter.ts","../../src/createDefaultAuthorizationResultCache.ts"],"names":[],"mappings":""}

package/lib/types/index.d.ts

@@ -0,0 +1,42 @@
+import { AppIdentity, AuthorizationResult } from "@solana-mobile/mobile-wallet-adapter-protocol";
+import { BaseMessageSignerWalletAdapter, WalletName, WalletReadyState } from "@solana/wallet-adapter-base";
+import { Connection, PublicKey, SendOptions, Transaction, TransactionSignature } from "@solana/web3.js";
+interface AuthorizationResultCache {
+    clear(): Promise<void>;
+    get(): Promise<AuthorizationResult | undefined>;
+    set(authorizationResult: AuthorizationResult): Promise<void>;
+}
+declare const SolanaMobileWalletAdapterWalletName: WalletName;
+declare class SolanaMobileWalletAdapter extends BaseMessageSignerWalletAdapter {
+    name: WalletName;
+    url: string;
+    icon: string;
+    private _appIdentity;
+    private _authorizationResult;
+    private _authorizationResultCache;
+    private _connecting;
+    private _publicKey;
+    private _readyState;
+    constructor(config: {
+        appIdentity: AppIdentity;
+        authorizationResultCache: AuthorizationResultCache;
+    });
+    get publicKey(): PublicKey | null;
+    get connected(): boolean;
+    get connecting(): boolean;
+    get readyState(): WalletReadyState;
+    connect(): Promise<void>;
+    private handleAuthorizationResult;
+    private performReauthorization;
+    disconnect(): Promise<void>;
+    private withWallet;
+    private assertIsAuthorized;
+    private performSignTransactions;
+    sendTransaction(transaction: Transaction, connection: Connection, _options?: SendOptions): Promise<TransactionSignature>;
+    signTransaction(transaction: Transaction): Promise<Transaction>;
+    signAllTransactions(transactions: Transaction[]): Promise<Transaction[]>;
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
+}
+declare function createDefaultAuthorizationResultCache(): AuthorizationResultCache;
+export { AuthorizationResultCache, SolanaMobileWalletAdapterWalletName, SolanaMobileWalletAdapter, createDefaultAuthorizationResultCache };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts","../../src/adapter.ts","../../src/createDefaultAuthorizationResultCache.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,46 @@
+{
+    "name": "@solana-mobile/wallet-adapter-mobile",
+    "description": "An adapter for mobile wallet apps that conform to the Solana Mobile Wallet Adapter protocol",
+    "version": "0.0.1-alpha.0",
+    "author": "Steven Luscher <steven.luscher@solanamobile.com>",
+    "repository": "https://github.com/solana-mobile/wallet-adapter-mobile",
+    "license": "Apache-2.0",
+    "type": "module",
+    "sideEffects": false,
+    "main": "lib/cjs/index.js",
+    "module": "lib/esm/index.mjs",
+    "types": "lib/types/index.d.ts",
+    "browser": {
+        "./lib/cjs/index.js": "./lib/cjs/index.browser.js",
+        "./lib/esm/index.mjs": "./lib/esm/index.browser.mjs"
+    },
+    "exports": {
+        "import": "./lib/esm/index.mjs",
+        "require": "./lib/cjs/index.js"
+    },
+    "files": [
+        "lib",
+        "LICENSE"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "clean": "shx rm -rf lib/*",
+        "build": "yarn clean && rollup --config ../../rollup.config.ts --configPlugin rollup-plugin-ts",
+        "build:watch": "yarn clean && rollup --config ../../rollup.config.ts --configPlugin rollup-plugin-ts --watch",
+        "postbuild": "echo '{\"type\":\"commonjs\"}' | npx json > lib/cjs/package.json && echo '{\"type\":\"module\"} ' | npx json > lib/esm/package.json",
+        "prepublishOnly": "agadoo"
+    },
+    "peerDependencies": {
+        "@solana/web3.js": "^1.36.0"
+    },
+    "dependencies": {
+        "@solana-mobile/mobile-wallet-adapter-protocol": "^0.0.1-alpha.0",
+        "@solana/wallet-adapter-base": "^0.9.0",
+        "@solana/web3.js": "^1.20.0"
+    },
+    "devDependencies": {
+        "agadoo": "^2.0.0"
+    }
+}