@solana-mobile/mobile-wallet-adapter-protocol-web3js 0.0.1-alpha.1

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2022 Solana Mobile Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,3 @@
+# `@solana-mobile/mobile-wallet-adapter-protocol-web3js`
+
+This is a convenience wrapper that makes it easy to use common primitives from [@solana/web3.js](https://github.com/solana-labs/solana-web3.js) – such as `Transaction` and `Uint8Array` – with [@solana-mobile/mobile-wallet-adapter-protocol](https://github.com/solana-mobile/mobile-wallet-adapter/tree/main/js/packages/mobile-wallet-adapter-protocol).

package/lib/cjs/index.browser.js

@@ -0,0 +1,135 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var web3_js = require('@solana/web3.js');
+var mobileWalletAdapterProtocol = require('@solana-mobile/mobile-wallet-adapter-protocol');
+
+/******************************************************************************
+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 getBase64StringFromByteArray(byteArray) {
+    return window.btoa(String.fromCharCode.call(null, ...byteArray));
+}
+function getByteArrayFromBase64String(base64EncodedByteArray) {
+    return new Uint8Array(window
+        .atob(base64EncodedByteArray)
+        .split('')
+        .map((c) => c.charCodeAt(0)));
+}
+function transact(callback, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const augmentedCallback = (walletAPI) => {
+            const augmentedAPI = ((apiCall) => __awaiter(this, void 0, void 0, function* () {
+                let latestBlockhashPromise;
+                function getLatestBlockhash(connection) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        if (latestBlockhashPromise == null) {
+                            latestBlockhashPromise = connection.getLatestBlockhash({
+                                commitment: connection.commitment,
+                            });
+                        }
+                        return yield latestBlockhashPromise;
+                    });
+                }
+                switch (apiCall.method) {
+                    case 'authorize':
+                        return yield walletAPI(apiCall);
+                    case 'clone_authorization':
+                        return yield walletAPI(apiCall);
+                    case 'deauthorize':
+                        return yield walletAPI(apiCall);
+                    case 'reauthorize':
+                        return yield walletAPI(apiCall);
+                    case 'sign_and_send_transaction': {
+                        const payloads = yield Promise.all(apiCall.transactions.map((transaction) => __awaiter(this, void 0, void 0, function* () {
+                            if (transaction.feePayer == null) {
+                                transaction.feePayer = apiCall.fee_payer;
+                            }
+                            if (transaction.recentBlockhash == null) {
+                                const { blockhash } = yield getLatestBlockhash(apiCall.connection);
+                                transaction.recentBlockhash = blockhash;
+                            }
+                            const serializedTransaction = transaction.serialize({
+                                requireAllSignatures: false,
+                                verifySignatures: false,
+                            });
+                            return serializedTransaction.toString('base64');
+                        })));
+                        let targetCommitment;
+                        switch (apiCall.connection.commitment) {
+                            case 'confirmed':
+                            case 'finalized':
+                            case 'processed':
+                                targetCommitment = apiCall.connection.commitment;
+                                break;
+                            default:
+                                targetCommitment = 'finalized';
+                        }
+                        const { signatures } = yield walletAPI({
+                            method: 'sign_and_send_transaction',
+                            auth_token: apiCall.auth_token,
+                            commitment: targetCommitment,
+                            payloads,
+                        });
+                        return signatures;
+                    }
+                    case 'sign_message': {
+                        const payloads = apiCall.byteArrays.map(getBase64StringFromByteArray);
+                        const { signed_payloads: base64EncodedSignedMessages } = yield walletAPI({
+                            method: 'sign_message',
+                            auth_token: apiCall.auth_token,
+                            payloads,
+                        });
+                        const signedMessages = base64EncodedSignedMessages.map(getByteArrayFromBase64String);
+                        return signedMessages;
+                    }
+                    case 'sign_transaction': {
+                        const serializedTransactions = apiCall.transactions.map((transaction) => transaction.serialize({
+                            requireAllSignatures: false,
+                            verifySignatures: false,
+                        }));
+                        const payloads = serializedTransactions.map((serializedTransaction) => serializedTransaction.toString('base64'));
+                        const { signed_payloads: base64EncodedCompiledTransactions } = yield walletAPI({
+                            method: 'sign_transaction',
+                            auth_token: apiCall.auth_token,
+                            payloads,
+                        });
+                        const compiledTransactions = base64EncodedCompiledTransactions.map(getByteArrayFromBase64String);
+                        const transactions = compiledTransactions.map(web3_js.Transaction.from);
+                        return transactions;
+                    }
+                    default:
+                        // If this switch is exhausive, this should be unreachable.
+                        return ((_) => undefined)();
+                }
+            }));
+            return callback(augmentedAPI);
+        };
+        return yield mobileWalletAdapterProtocol.transact(augmentedCallback, config);
+    });
+}
+
+exports.transact = transact;

package/lib/cjs/index.js

@@ -0,0 +1,135 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var web3_js = require('@solana/web3.js');
+var mobileWalletAdapterProtocol = require('@solana-mobile/mobile-wallet-adapter-protocol');
+
+/******************************************************************************
+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 getBase64StringFromByteArray(byteArray) {
+    return window.btoa(String.fromCharCode.call(null, ...byteArray));
+}
+function getByteArrayFromBase64String(base64EncodedByteArray) {
+    return new Uint8Array(window
+        .atob(base64EncodedByteArray)
+        .split('')
+        .map((c) => c.charCodeAt(0)));
+}
+function transact(callback, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const augmentedCallback = (walletAPI) => {
+            const augmentedAPI = ((apiCall) => __awaiter(this, void 0, void 0, function* () {
+                let latestBlockhashPromise;
+                function getLatestBlockhash(connection) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        if (latestBlockhashPromise == null) {
+                            latestBlockhashPromise = connection.getLatestBlockhash({
+                                commitment: connection.commitment,
+                            });
+                        }
+                        return yield latestBlockhashPromise;
+                    });
+                }
+                switch (apiCall.method) {
+                    case 'authorize':
+                        return yield walletAPI(apiCall);
+                    case 'clone_authorization':
+                        return yield walletAPI(apiCall);
+                    case 'deauthorize':
+                        return yield walletAPI(apiCall);
+                    case 'reauthorize':
+                        return yield walletAPI(apiCall);
+                    case 'sign_and_send_transaction': {
+                        const payloads = yield Promise.all(apiCall.transactions.map((transaction) => __awaiter(this, void 0, void 0, function* () {
+                            if (transaction.feePayer == null) {
+                                transaction.feePayer = apiCall.fee_payer;
+                            }
+                            if (transaction.recentBlockhash == null) {
+                                const { blockhash } = yield getLatestBlockhash(apiCall.connection);
+                                transaction.recentBlockhash = blockhash;
+                            }
+                            const serializedTransaction = transaction.serialize({
+                                requireAllSignatures: false,
+                                verifySignatures: false,
+                            });
+                            return serializedTransaction.toString('base64');
+                        })));
+                        let targetCommitment;
+                        switch (apiCall.connection.commitment) {
+                            case 'confirmed':
+                            case 'finalized':
+                            case 'processed':
+                                targetCommitment = apiCall.connection.commitment;
+                                break;
+                            default:
+                                targetCommitment = 'finalized';
+                        }
+                        const { signatures } = yield walletAPI({
+                            method: 'sign_and_send_transaction',
+                            auth_token: apiCall.auth_token,
+                            commitment: targetCommitment,
+                            payloads,
+                        });
+                        return signatures;
+                    }
+                    case 'sign_message': {
+                        const payloads = apiCall.byteArrays.map(getBase64StringFromByteArray);
+                        const { signed_payloads: base64EncodedSignedMessages } = yield walletAPI({
+                            method: 'sign_message',
+                            auth_token: apiCall.auth_token,
+                            payloads,
+                        });
+                        const signedMessages = base64EncodedSignedMessages.map(getByteArrayFromBase64String);
+                        return signedMessages;
+                    }
+                    case 'sign_transaction': {
+                        const serializedTransactions = apiCall.transactions.map((transaction) => transaction.serialize({
+                            requireAllSignatures: false,
+                            verifySignatures: false,
+                        }));
+                        const payloads = serializedTransactions.map((serializedTransaction) => serializedTransaction.toString('base64'));
+                        const { signed_payloads: base64EncodedCompiledTransactions } = yield walletAPI({
+                            method: 'sign_transaction',
+                            auth_token: apiCall.auth_token,
+                            payloads,
+                        });
+                        const compiledTransactions = base64EncodedCompiledTransactions.map(getByteArrayFromBase64String);
+                        const transactions = compiledTransactions.map(web3_js.Transaction.from);
+                        return transactions;
+                    }
+                    default:
+                        // If this switch is exhausive, this should be unreachable.
+                        return ((_) => undefined)();
+                }
+            }));
+            return callback(augmentedAPI);
+        };
+        return yield mobileWalletAdapterProtocol.transact(augmentedCallback, config);
+    });
+}
+
+exports.transact = transact;

package/lib/cjs/index.native.js

@@ -0,0 +1,135 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var web3_js = require('@solana/web3.js');
+var mobileWalletAdapterProtocol = require('@solana-mobile/mobile-wallet-adapter-protocol');
+
+/******************************************************************************
+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 getBase64StringFromByteArray(byteArray) {
+    return window.btoa(String.fromCharCode.call(null, ...byteArray));
+}
+function getByteArrayFromBase64String(base64EncodedByteArray) {
+    return new Uint8Array(window
+        .atob(base64EncodedByteArray)
+        .split('')
+        .map((c) => c.charCodeAt(0)));
+}
+function transact(callback, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const augmentedCallback = (walletAPI) => {
+            const augmentedAPI = ((apiCall) => __awaiter(this, void 0, void 0, function* () {
+                let latestBlockhashPromise;
+                function getLatestBlockhash(connection) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        if (latestBlockhashPromise == null) {
+                            latestBlockhashPromise = connection.getLatestBlockhash({
+                                commitment: connection.commitment,
+                            });
+                        }
+                        return yield latestBlockhashPromise;
+                    });
+                }
+                switch (apiCall.method) {
+                    case 'authorize':
+                        return yield walletAPI(apiCall);
+                    case 'clone_authorization':
+                        return yield walletAPI(apiCall);
+                    case 'deauthorize':
+                        return yield walletAPI(apiCall);
+                    case 'reauthorize':
+                        return yield walletAPI(apiCall);
+                    case 'sign_and_send_transaction': {
+                        const payloads = yield Promise.all(apiCall.transactions.map((transaction) => __awaiter(this, void 0, void 0, function* () {
+                            if (transaction.feePayer == null) {
+                                transaction.feePayer = apiCall.fee_payer;
+                            }
+                            if (transaction.recentBlockhash == null) {
+                                const { blockhash } = yield getLatestBlockhash(apiCall.connection);
+                                transaction.recentBlockhash = blockhash;
+                            }
+                            const serializedTransaction = transaction.serialize({
+                                requireAllSignatures: false,
+                                verifySignatures: false,
+                            });
+                            return serializedTransaction.toString('base64');
+                        })));
+                        let targetCommitment;
+                        switch (apiCall.connection.commitment) {
+                            case 'confirmed':
+                            case 'finalized':
+                            case 'processed':
+                                targetCommitment = apiCall.connection.commitment;
+                                break;
+                            default:
+                                targetCommitment = 'finalized';
+                        }
+                        const { signatures } = yield walletAPI({
+                            method: 'sign_and_send_transaction',
+                            auth_token: apiCall.auth_token,
+                            commitment: targetCommitment,
+                            payloads,
+                        });
+                        return signatures;
+                    }
+                    case 'sign_message': {
+                        const payloads = apiCall.byteArrays.map(getBase64StringFromByteArray);
+                        const { signed_payloads: base64EncodedSignedMessages } = yield walletAPI({
+                            method: 'sign_message',
+                            auth_token: apiCall.auth_token,
+                            payloads,
+                        });
+                        const signedMessages = base64EncodedSignedMessages.map(getByteArrayFromBase64String);
+                        return signedMessages;
+                    }
+                    case 'sign_transaction': {
+                        const serializedTransactions = apiCall.transactions.map((transaction) => transaction.serialize({
+                            requireAllSignatures: false,
+                            verifySignatures: false,
+                        }));
+                        const payloads = serializedTransactions.map((serializedTransaction) => serializedTransaction.toString('base64'));
+                        const { signed_payloads: base64EncodedCompiledTransactions } = yield walletAPI({
+                            method: 'sign_transaction',
+                            auth_token: apiCall.auth_token,
+                            payloads,
+                        });
+                        const compiledTransactions = base64EncodedCompiledTransactions.map(getByteArrayFromBase64String);
+                        const transactions = compiledTransactions.map(web3_js.Transaction.from);
+                        return transactions;
+                    }
+                    default:
+                        // If this switch is exhausive, this should be unreachable.
+                        return ((_) => undefined)();
+                }
+            }));
+            return callback(augmentedAPI);
+        };
+        return yield mobileWalletAdapterProtocol.transact(augmentedCallback, config);
+    });
+}
+
+exports.transact = transact;

package/lib/cjs/package.json

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

package/lib/esm/index.browser.mjs

@@ -0,0 +1,131 @@
+import { Transaction } from '@solana/web3.js';
+import { transact as transact$1 } from '@solana-mobile/mobile-wallet-adapter-protocol';
+
+/******************************************************************************
+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 getBase64StringFromByteArray(byteArray) {
+    return window.btoa(String.fromCharCode.call(null, ...byteArray));
+}
+function getByteArrayFromBase64String(base64EncodedByteArray) {
+    return new Uint8Array(window
+        .atob(base64EncodedByteArray)
+        .split('')
+        .map((c) => c.charCodeAt(0)));
+}
+function transact(callback, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const augmentedCallback = (walletAPI) => {
+            const augmentedAPI = ((apiCall) => __awaiter(this, void 0, void 0, function* () {
+                let latestBlockhashPromise;
+                function getLatestBlockhash(connection) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        if (latestBlockhashPromise == null) {
+                            latestBlockhashPromise = connection.getLatestBlockhash({
+                                commitment: connection.commitment,
+                            });
+                        }
+                        return yield latestBlockhashPromise;
+                    });
+                }
+                switch (apiCall.method) {
+                    case 'authorize':
+                        return yield walletAPI(apiCall);
+                    case 'clone_authorization':
+                        return yield walletAPI(apiCall);
+                    case 'deauthorize':
+                        return yield walletAPI(apiCall);
+                    case 'reauthorize':
+                        return yield walletAPI(apiCall);
+                    case 'sign_and_send_transaction': {
+                        const payloads = yield Promise.all(apiCall.transactions.map((transaction) => __awaiter(this, void 0, void 0, function* () {
+                            if (transaction.feePayer == null) {
+                                transaction.feePayer = apiCall.fee_payer;
+                            }
+                            if (transaction.recentBlockhash == null) {
+                                const { blockhash } = yield getLatestBlockhash(apiCall.connection);
+                                transaction.recentBlockhash = blockhash;
+                            }
+                            const serializedTransaction = transaction.serialize({
+                                requireAllSignatures: false,
+                                verifySignatures: false,
+                            });
+                            return serializedTransaction.toString('base64');
+                        })));
+                        let targetCommitment;
+                        switch (apiCall.connection.commitment) {
+                            case 'confirmed':
+                            case 'finalized':
+                            case 'processed':
+                                targetCommitment = apiCall.connection.commitment;
+                                break;
+                            default:
+                                targetCommitment = 'finalized';
+                        }
+                        const { signatures } = yield walletAPI({
+                            method: 'sign_and_send_transaction',
+                            auth_token: apiCall.auth_token,
+                            commitment: targetCommitment,
+                            payloads,
+                        });
+                        return signatures;
+                    }
+                    case 'sign_message': {
+                        const payloads = apiCall.byteArrays.map(getBase64StringFromByteArray);
+                        const { signed_payloads: base64EncodedSignedMessages } = yield walletAPI({
+                            method: 'sign_message',
+                            auth_token: apiCall.auth_token,
+                            payloads,
+                        });
+                        const signedMessages = base64EncodedSignedMessages.map(getByteArrayFromBase64String);
+                        return signedMessages;
+                    }
+                    case 'sign_transaction': {
+                        const serializedTransactions = apiCall.transactions.map((transaction) => transaction.serialize({
+                            requireAllSignatures: false,
+                            verifySignatures: false,
+                        }));
+                        const payloads = serializedTransactions.map((serializedTransaction) => serializedTransaction.toString('base64'));
+                        const { signed_payloads: base64EncodedCompiledTransactions } = yield walletAPI({
+                            method: 'sign_transaction',
+                            auth_token: apiCall.auth_token,
+                            payloads,
+                        });
+                        const compiledTransactions = base64EncodedCompiledTransactions.map(getByteArrayFromBase64String);
+                        const transactions = compiledTransactions.map(Transaction.from);
+                        return transactions;
+                    }
+                    default:
+                        // If this switch is exhausive, this should be unreachable.
+                        return ((_) => undefined)();
+                }
+            }));
+            return callback(augmentedAPI);
+        };
+        return yield transact$1(augmentedCallback, config);
+    });
+}
+
+export { transact };

package/lib/esm/index.mjs

@@ -0,0 +1,131 @@
+import { Transaction } from '@solana/web3.js';
+import { transact as transact$1 } from '@solana-mobile/mobile-wallet-adapter-protocol';
+
+/******************************************************************************
+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 getBase64StringFromByteArray(byteArray) {
+    return window.btoa(String.fromCharCode.call(null, ...byteArray));
+}
+function getByteArrayFromBase64String(base64EncodedByteArray) {
+    return new Uint8Array(window
+        .atob(base64EncodedByteArray)
+        .split('')
+        .map((c) => c.charCodeAt(0)));
+}
+function transact(callback, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const augmentedCallback = (walletAPI) => {
+            const augmentedAPI = ((apiCall) => __awaiter(this, void 0, void 0, function* () {
+                let latestBlockhashPromise;
+                function getLatestBlockhash(connection) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        if (latestBlockhashPromise == null) {
+                            latestBlockhashPromise = connection.getLatestBlockhash({
+                                commitment: connection.commitment,
+                            });
+                        }
+                        return yield latestBlockhashPromise;
+                    });
+                }
+                switch (apiCall.method) {
+                    case 'authorize':
+                        return yield walletAPI(apiCall);
+                    case 'clone_authorization':
+                        return yield walletAPI(apiCall);
+                    case 'deauthorize':
+                        return yield walletAPI(apiCall);
+                    case 'reauthorize':
+                        return yield walletAPI(apiCall);
+                    case 'sign_and_send_transaction': {
+                        const payloads = yield Promise.all(apiCall.transactions.map((transaction) => __awaiter(this, void 0, void 0, function* () {
+                            if (transaction.feePayer == null) {
+                                transaction.feePayer = apiCall.fee_payer;
+                            }
+                            if (transaction.recentBlockhash == null) {
+                                const { blockhash } = yield getLatestBlockhash(apiCall.connection);
+                                transaction.recentBlockhash = blockhash;
+                            }
+                            const serializedTransaction = transaction.serialize({
+                                requireAllSignatures: false,
+                                verifySignatures: false,
+                            });
+                            return serializedTransaction.toString('base64');
+                        })));
+                        let targetCommitment;
+                        switch (apiCall.connection.commitment) {
+                            case 'confirmed':
+                            case 'finalized':
+                            case 'processed':
+                                targetCommitment = apiCall.connection.commitment;
+                                break;
+                            default:
+                                targetCommitment = 'finalized';
+                        }
+                        const { signatures } = yield walletAPI({
+                            method: 'sign_and_send_transaction',
+                            auth_token: apiCall.auth_token,
+                            commitment: targetCommitment,
+                            payloads,
+                        });
+                        return signatures;
+                    }
+                    case 'sign_message': {
+                        const payloads = apiCall.byteArrays.map(getBase64StringFromByteArray);
+                        const { signed_payloads: base64EncodedSignedMessages } = yield walletAPI({
+                            method: 'sign_message',
+                            auth_token: apiCall.auth_token,
+                            payloads,
+                        });
+                        const signedMessages = base64EncodedSignedMessages.map(getByteArrayFromBase64String);
+                        return signedMessages;
+                    }
+                    case 'sign_transaction': {
+                        const serializedTransactions = apiCall.transactions.map((transaction) => transaction.serialize({
+                            requireAllSignatures: false,
+                            verifySignatures: false,
+                        }));
+                        const payloads = serializedTransactions.map((serializedTransaction) => serializedTransaction.toString('base64'));
+                        const { signed_payloads: base64EncodedCompiledTransactions } = yield walletAPI({
+                            method: 'sign_transaction',
+                            auth_token: apiCall.auth_token,
+                            payloads,
+                        });
+                        const compiledTransactions = base64EncodedCompiledTransactions.map(getByteArrayFromBase64String);
+                        const transactions = compiledTransactions.map(Transaction.from);
+                        return transactions;
+                    }
+                    default:
+                        // If this switch is exhausive, this should be unreachable.
+                        return ((_) => undefined)();
+                }
+            }));
+            return callback(augmentedAPI);
+        };
+        return yield transact$1(augmentedCallback, config);
+    });
+}
+
+export { transact };

package/lib/esm/package.json

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

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

@@ -0,0 +1,24 @@
+import { Connection, PublicKey, Transaction, TransactionSignature } from "@solana/web3.js";
+import { AuthorizeAPI, AuthToken, CloneAuthorizationAPI, DeauthorizeAPI, ReauthorizeAPI, WalletAssociationConfig } from "@solana-mobile/mobile-wallet-adapter-protocol";
+interface Web3MobileWalletAPI extends AuthorizeAPI, CloneAuthorizationAPI, DeauthorizeAPI, ReauthorizeAPI {
+    (apiCall: {
+        method: "sign_and_send_transaction";
+        auth_token: AuthToken;
+        connection: Connection;
+        fee_payer?: PublicKey;
+        transactions: Transaction[];
+    }): Promise<TransactionSignature[]>;
+    (apiCall: {
+        method: "sign_transaction";
+        auth_token: AuthToken;
+        transactions: Transaction[];
+    }): Promise<Transaction[]>;
+    (apiCall: {
+        method: "sign_message";
+        auth_token: AuthToken;
+        byteArrays: Uint8Array[];
+    }): Promise<Uint8Array[]>;
+}
+declare function transact<TReturn>(callback: (walletAPI: Web3MobileWalletAPI) => TReturn, config?: WalletAssociationConfig): Promise<TReturn>;
+export { Web3MobileWalletAPI, transact };
+//# 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/transact.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,24 @@
+import { Connection, PublicKey, Transaction, TransactionSignature } from "@solana/web3.js";
+import { AuthorizeAPI, AuthToken, CloneAuthorizationAPI, DeauthorizeAPI, ReauthorizeAPI, WalletAssociationConfig } from "@solana-mobile/mobile-wallet-adapter-protocol";
+interface Web3MobileWalletAPI extends AuthorizeAPI, CloneAuthorizationAPI, DeauthorizeAPI, ReauthorizeAPI {
+    (apiCall: {
+        method: "sign_and_send_transaction";
+        auth_token: AuthToken;
+        connection: Connection;
+        fee_payer?: PublicKey;
+        transactions: Transaction[];
+    }): Promise<TransactionSignature[]>;
+    (apiCall: {
+        method: "sign_transaction";
+        auth_token: AuthToken;
+        transactions: Transaction[];
+    }): Promise<Transaction[]>;
+    (apiCall: {
+        method: "sign_message";
+        auth_token: AuthToken;
+        byteArrays: Uint8Array[];
+    }): Promise<Uint8Array[]>;
+}
+declare function transact<TReturn>(callback: (walletAPI: Web3MobileWalletAPI) => TReturn, config?: WalletAssociationConfig): Promise<TReturn>;
+export { Web3MobileWalletAPI, transact };
+//# 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/transact.ts"],"names":[],"mappings":""}

package/lib/types/index.d.mts

@@ -0,0 +1,24 @@
+import { Connection, PublicKey, Transaction, TransactionSignature } from "@solana/web3.js";
+import { AuthorizeAPI, AuthToken, CloneAuthorizationAPI, DeauthorizeAPI, ReauthorizeAPI, WalletAssociationConfig } from "@solana-mobile/mobile-wallet-adapter-protocol";
+interface Web3MobileWalletAPI extends AuthorizeAPI, CloneAuthorizationAPI, DeauthorizeAPI, ReauthorizeAPI {
+    (apiCall: {
+        method: "sign_and_send_transaction";
+        auth_token: AuthToken;
+        connection: Connection;
+        fee_payer?: PublicKey;
+        transactions: Transaction[];
+    }): Promise<TransactionSignature[]>;
+    (apiCall: {
+        method: "sign_transaction";
+        auth_token: AuthToken;
+        transactions: Transaction[];
+    }): Promise<Transaction[]>;
+    (apiCall: {
+        method: "sign_message";
+        auth_token: AuthToken;
+        byteArrays: Uint8Array[];
+    }): Promise<Uint8Array[]>;
+}
+declare function transact<TReturn>(callback: (walletAPI: Web3MobileWalletAPI) => TReturn, config?: WalletAssociationConfig): Promise<TReturn>;
+export { Web3MobileWalletAPI, transact };
+//# 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/transact.ts"],"names":[],"mappings":""}

package/lib/types/index.d.ts

@@ -0,0 +1,24 @@
+import { Connection, PublicKey, Transaction, TransactionSignature } from "@solana/web3.js";
+import { AuthorizeAPI, AuthToken, CloneAuthorizationAPI, DeauthorizeAPI, ReauthorizeAPI, WalletAssociationConfig } from "@solana-mobile/mobile-wallet-adapter-protocol";
+interface Web3MobileWalletAPI extends AuthorizeAPI, CloneAuthorizationAPI, DeauthorizeAPI, ReauthorizeAPI {
+    (apiCall: {
+        method: "sign_and_send_transaction";
+        auth_token: AuthToken;
+        connection: Connection;
+        fee_payer?: PublicKey;
+        transactions: Transaction[];
+    }): Promise<TransactionSignature[]>;
+    (apiCall: {
+        method: "sign_transaction";
+        auth_token: AuthToken;
+        transactions: Transaction[];
+    }): Promise<Transaction[]>;
+    (apiCall: {
+        method: "sign_message";
+        auth_token: AuthToken;
+        byteArrays: Uint8Array[];
+    }): Promise<Uint8Array[]>;
+}
+declare function transact<TReturn>(callback: (walletAPI: Web3MobileWalletAPI) => TReturn, config?: WalletAssociationConfig): Promise<TReturn>;
+export { Web3MobileWalletAPI, transact };
+//# 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/transact.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,24 @@
+import { Connection, PublicKey, Transaction, TransactionSignature } from "@solana/web3.js";
+import { AuthorizeAPI, AuthToken, CloneAuthorizationAPI, DeauthorizeAPI, ReauthorizeAPI, WalletAssociationConfig } from "@solana-mobile/mobile-wallet-adapter-protocol";
+interface Web3MobileWalletAPI extends AuthorizeAPI, CloneAuthorizationAPI, DeauthorizeAPI, ReauthorizeAPI {
+    (apiCall: {
+        method: "sign_and_send_transaction";
+        auth_token: AuthToken;
+        connection: Connection;
+        fee_payer?: PublicKey;
+        transactions: Transaction[];
+    }): Promise<TransactionSignature[]>;
+    (apiCall: {
+        method: "sign_transaction";
+        auth_token: AuthToken;
+        transactions: Transaction[];
+    }): Promise<Transaction[]>;
+    (apiCall: {
+        method: "sign_message";
+        auth_token: AuthToken;
+        byteArrays: Uint8Array[];
+    }): Promise<Uint8Array[]>;
+}
+declare function transact<TReturn>(callback: (walletAPI: Web3MobileWalletAPI) => TReturn, config?: WalletAssociationConfig): Promise<TReturn>;
+export { Web3MobileWalletAPI, transact };
+//# sourceMappingURL=index.native.d.ts.map

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

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

package/package.json

@@ -0,0 +1,49 @@
+{
+    "name": "@solana-mobile/mobile-wallet-adapter-protocol-web3js",
+    "description": "A convenience wrapper that enables you to call Solana Mobile Stack protocol methods using objects from @solana/web3.js",
+    "version": "0.0.1-alpha.1",
+    "author": "Steven Luscher <steven.luscher@solanamobile.com>",
+    "repository": "https://github.com/solana-mobile/mobile-wallet-adapter",
+    "license": "Apache-2.0",
+    "type": "module",
+    "sideEffects": false,
+    "main": "lib/cjs/index.js",
+    "react-native": "lib/cjs/index.native.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": {
+        "./package.json": "./package.json",
+        ".": {
+            "import": "./lib/esm/index.mjs",
+            "require": "./lib/esm/index.cjs"
+        }
+    },
+    "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.48.0"
+    },
+    "dependencies": {
+        "@solana-mobile/mobile-wallet-adapter-protocol": "^0.0.1-alpha.1"
+    },
+    "devDependencies": {
+        "agadoo": "^2.0.0"
+    },
+    "gitHead": "9af0298849fd011355f15ad4391063de343094ec"
+}