@1tokenfe/onetoken-solana-provider 2.2.46

package/dist/cjs/ProviderSolana.js

@@ -0,0 +1,270 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderSolana = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const extension_bridge_injected_1 = require("@1tokenfe/extension-bridge-injected");
+const bs58_1 = __importDefault(require("bs58"));
+const ProviderSolanaBase_1 = require("./ProviderSolanaBase");
+const utils_1 = require("./utils");
+const PROVIDER_EVENTS = {
+    'connect': 'connect',
+    'disconnect': 'disconnect',
+    'accountChanged': 'accountChanged',
+    'message_low_level': 'message_low_level',
+};
+class ProviderSolana extends ProviderSolanaBase_1.ProviderSolanaBase {
+    get publicKey() {
+        return this._publicKey;
+    }
+    get isConnected() {
+        return this._publicKey !== null;
+    }
+    constructor(props) {
+        super(Object.assign(Object.assign({}, props), { bridge: props.bridge || (0, extension_bridge_injected_1.getOrCreateExtInjectedJsBridge)({ timeout: props.timeout }) }));
+        this.isPhantom = true;
+        this.isSolflare = true;
+        this._publicKey = null;
+        this._registerEvents = this._registerEvents.bind(this);
+        this._callBridge = this._callBridge.bind(this);
+        this._handleAccountChange = this._handleAccountChange.bind(this);
+        this._handleConnected = this._handleConnected.bind(this);
+        this._handleDisconnected = this._handleDisconnected.bind(this);
+        this._handleSignAndSendTransaction = this._handleSignAndSendTransaction.bind(this);
+        this._handleSignTransaction = this._handleSignTransaction.bind(this);
+        this._handleSignAllTransactions = this._handleSignAllTransactions.bind(this);
+        this._handleSignMessage = this._handleSignMessage.bind(this);
+        this.request = this.request.bind(this);
+        this.connect = this.connect.bind(this);
+        this.disconnect = this.disconnect.bind(this);
+        this.signAndSendTransaction = this.signAndSendTransaction.bind(this);
+        this.signTransaction = this.signTransaction.bind(this);
+        this.signAllTransactions = this.signAllTransactions.bind(this);
+        this.signMessage = this.signMessage.bind(this);
+        this.isAccountsChanged = this.isAccountsChanged.bind(this);
+        this.bridgeRequest = this.bridgeRequest.bind(this);
+        this._registerEvents();
+    }
+    _registerEvents() {
+        window.addEventListener('onetoken_bridge_disconnect', () => {
+            this._handleDisconnected();
+        });
+        this.on(PROVIDER_EVENTS.message_low_level, (payload) => {
+            const { method, params } = payload;
+            if ((0, utils_1.isWalletEventMethodMatch)(method, PROVIDER_EVENTS.accountChanged)) {
+                this._handleAccountChange(params);
+            }
+        });
+    }
+    _callBridge(params) {
+        return this.bridgeRequest(params);
+    }
+    postMessage(param) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        return this._callBridge(param);
+    }
+    connect(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.publicKey) {
+                return { publicKey: this.publicKey };
+            }
+            // TODO: pass options to connect
+            const result = yield this._callBridge({
+                method: 'connect',
+                params: options,
+            });
+            const publicKey = new web3_js_1.PublicKey(result.publicKey);
+            this._handleConnected(publicKey, { emit: true });
+            return { publicKey };
+        });
+    }
+    _handleConnected(publicKey, options = { emit: true }) {
+        this._publicKey = publicKey;
+        if (options.emit && this.isConnectionStatusChanged('connected')) {
+            this.connectionStatus = 'connected';
+            this.emit('connect', publicKey);
+            this.emit('accountChanged', publicKey);
+        }
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._callBridge({
+                method: 'disconnect',
+                params: void 0,
+            });
+            this._handleDisconnected();
+        });
+    }
+    _handleDisconnected(options = { emit: true }) {
+        this._publicKey = null;
+        if (options.emit && this.isConnectionStatusChanged('disconnected')) {
+            this.connectionStatus = 'disconnected';
+            this.emit('disconnect');
+            this.emit('accountChanged', null);
+        }
+    }
+    isAccountsChanged(account) {
+        var _a;
+        return (account === null || account === void 0 ? void 0 : account.publicKey) !== ((_a = this._publicKey) === null || _a === void 0 ? void 0 : _a.toBase58());
+    }
+    // trigger by bridge account change event
+    _handleAccountChange(payload) {
+        const account = payload.accounts[0];
+        let publicKey;
+        try {
+            publicKey = new web3_js_1.PublicKey(account.publicKey);
+        }
+        catch (error) {
+            // noop
+        }
+        if (this.isAccountsChanged(account)) {
+            this.emit('accountChanged', publicKey || null);
+        }
+        if (!account) {
+            this._handleDisconnected();
+            return;
+        }
+        if (publicKey) {
+            this._handleConnected(publicKey, { emit: false });
+        }
+    }
+    signAndSendTransaction(transaction, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._handleSignAndSendTransaction({
+                message: (0, utils_1.encodeTransaction)(transaction),
+                options,
+            });
+        });
+    }
+    _handleSignAndSendTransaction(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._callBridge({
+                method: 'signAndSendTransaction',
+                params,
+            });
+            return result;
+        });
+    }
+    signTransaction(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasVersionedTx = 'version' in transaction;
+            return this._handleSignTransaction({
+                message: (0, utils_1.encodeTransaction)(transaction),
+            }, {
+                onlyVersionedTx: hasVersionedTx,
+            });
+        });
+    }
+    _handleSignTransaction(params, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { onlyVersionedTx } = options || {};
+            const result = yield this._callBridge({
+                method: 'signTransaction',
+                params,
+            });
+            return (0, utils_1.decodeSignedTransaction)({
+                message: result,
+                onlyVersionedTx,
+            });
+        });
+    }
+    signAllTransactions(transactions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._handleSignAllTransactions({
+                message: transactions.map(utils_1.encodeTransaction),
+            });
+        });
+    }
+    _handleSignAllTransactions(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._callBridge({
+                method: 'signAllTransactions',
+                params,
+            });
+            return result.map((message) => (0, utils_1.decodeSignedTransaction)({ message }));
+        });
+    }
+    signMessage(message, display) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._handleSignMessage({ message, display });
+        });
+    }
+    solSignOffchainMessage(message, version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._callBridge({
+                method: 'solSignOffchainMessage',
+                params: {
+                    message: typeof message === 'string' ? message : bs58_1.default.encode(message),
+                    version,
+                },
+            });
+            return {
+                signature: bs58_1.default.decode(result.signature),
+                publicKey: new web3_js_1.PublicKey(result.publicKey),
+            };
+        });
+    }
+    _handleSignMessage(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { message, display } = params;
+            const result = yield this._callBridge({
+                method: 'signMessage',
+                params: {
+                    message: typeof message === 'string' ? message : bs58_1.default.encode(message),
+                    display,
+                },
+            });
+            return {
+                signature: bs58_1.default.decode(result.signature),
+                publicKey: new web3_js_1.PublicKey(result.publicKey),
+            };
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    request(...args) {
+        let method;
+        let params;
+        if (typeof args[0] === 'string') {
+            method = args[0];
+            params = args[1];
+        }
+        else {
+            const payload = args[0];
+            method = payload.method;
+            params = payload.params;
+        }
+        switch (method) {
+            case 'connect':
+                return this.connect(params);
+            case 'disconnect':
+                return this.disconnect();
+            case 'signTransaction':
+                return this._handleSignTransaction(params);
+            case 'signAllTransactions':
+                return this._handleSignAllTransactions(params);
+            case 'signMessage':
+                return this._handleSignMessage(params);
+            case 'signAndSendTransaction':
+                return this._handleSignAndSendTransaction(params);
+        }
+        return this._callBridge({ method, params });
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+}
+exports.ProviderSolana = ProviderSolana;

package/dist/cjs/ProviderSolanaBase.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderSolanaBase = void 0;
+const cross_inpage_provider_types_1 = require("@1tokenfe/cross-inpage-provider-types");
+const cross_inpage_provider_core_1 = require("@1tokenfe/cross-inpage-provider-core");
+class ProviderSolanaBase extends cross_inpage_provider_core_1.ProviderBase {
+    constructor(props) {
+        super(props);
+        this.providerName = cross_inpage_provider_types_1.IInjectedProviderNames.solana;
+    }
+    request(data) {
+        return this.bridgeRequest(data);
+    }
+}
+exports.ProviderSolanaBase = ProviderSolanaBase;

package/dist/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ProviderSolana"), exports);
+__exportStar(require("./ProviderSolanaBase"), exports);
+__exportStar(require("./wallet-standard/index"), exports);

package/dist/cjs/type-utils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeSignedTransaction = exports.encodeTransaction = void 0;
+exports.isWalletEventMethodMatch = isWalletEventMethodMatch;
+exports.bytesEqual = bytesEqual;
+exports.arraysEqual = arraysEqual;
+exports.parseToNativeTx = parseToNativeTx;
+const web3_js_1 = require("@solana/web3.js");
+const bs58_1 = __importDefault(require("bs58"));
+const encodeTransaction = (transaction) => {
+    return bs58_1.default.encode(transaction.serialize({ requireAllSignatures: false }));
+};
+exports.encodeTransaction = encodeTransaction;
+const decodeSignedTransaction = ({ message, onlyVersionedTx, }) => {
+    const txByte = bs58_1.default.decode(message);
+    if (onlyVersionedTx) {
+        return web3_js_1.VersionedTransaction.deserialize(txByte);
+    }
+    try {
+        return web3_js_1.Transaction.from(txByte);
+    }
+    catch (_a) {
+        return web3_js_1.VersionedTransaction.deserialize(txByte);
+    }
+};
+exports.decodeSignedTransaction = decodeSignedTransaction;
+function isWalletEventMethodMatch(method, name) {
+    return method === `metamask_${name}` || method === `wallet_events_${name}`;
+}
+function bytesEqual(a, b) {
+    return arraysEqual(a, b);
+}
+function arraysEqual(a, b) {
+    if (a === b)
+        return true;
+    const length = a.length;
+    if (length !== b.length)
+        return false;
+    for (let i = 0; i < length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+function parseToNativeTx(txByte) {
+    try {
+        return web3_js_1.Transaction.from(txByte);
+    }
+    catch (e) {
+        return web3_js_1.VersionedTransaction.deserialize(txByte);
+    }
+}

package/dist/cjs/wallet-standard/account.js

@@ -0,0 +1,58 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _OneTokenSolanaWalletAccount_address, _OneTokenSolanaWalletAccount_publicKey, _OneTokenSolanaWalletAccount_chains, _OneTokenSolanaWalletAccount_features, _OneTokenSolanaWalletAccount_label, _OneTokenSolanaWalletAccount_icon;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneTokenSolanaWalletAccount = void 0;
+const wallet_standard_features_1 = require("@solana/wallet-standard-features");
+const solana_1 = require("./solana");
+const chains = solana_1.SOLANA_CHAINS;
+const features = [wallet_standard_features_1.SolanaSignAndSendTransaction, wallet_standard_features_1.SolanaSignTransaction, wallet_standard_features_1.SolanaSignMessage];
+class OneTokenSolanaWalletAccount {
+    get address() {
+        return __classPrivateFieldGet(this, _OneTokenSolanaWalletAccount_address, "f");
+    }
+    get publicKey() {
+        return __classPrivateFieldGet(this, _OneTokenSolanaWalletAccount_publicKey, "f").slice();
+    }
+    get chains() {
+        return __classPrivateFieldGet(this, _OneTokenSolanaWalletAccount_chains, "f").slice();
+    }
+    get features() {
+        return __classPrivateFieldGet(this, _OneTokenSolanaWalletAccount_features, "f").slice();
+    }
+    get label() {
+        return __classPrivateFieldGet(this, _OneTokenSolanaWalletAccount_label, "f");
+    }
+    get icon() {
+        return __classPrivateFieldGet(this, _OneTokenSolanaWalletAccount_icon, "f");
+    }
+    constructor({ address, publicKey, label, icon }) {
+        _OneTokenSolanaWalletAccount_address.set(this, void 0);
+        _OneTokenSolanaWalletAccount_publicKey.set(this, void 0);
+        _OneTokenSolanaWalletAccount_chains.set(this, void 0);
+        _OneTokenSolanaWalletAccount_features.set(this, void 0);
+        _OneTokenSolanaWalletAccount_label.set(this, void 0);
+        _OneTokenSolanaWalletAccount_icon.set(this, void 0);
+        if (new.target === OneTokenSolanaWalletAccount) {
+            Object.freeze(this);
+        }
+        __classPrivateFieldSet(this, _OneTokenSolanaWalletAccount_address, address, "f");
+        __classPrivateFieldSet(this, _OneTokenSolanaWalletAccount_publicKey, publicKey, "f");
+        __classPrivateFieldSet(this, _OneTokenSolanaWalletAccount_chains, chains, "f");
+        __classPrivateFieldSet(this, _OneTokenSolanaWalletAccount_features, features, "f");
+        __classPrivateFieldSet(this, _OneTokenSolanaWalletAccount_label, label, "f");
+        __classPrivateFieldSet(this, _OneTokenSolanaWalletAccount_icon, icon, "f");
+    }
+}
+exports.OneTokenSolanaWalletAccount = OneTokenSolanaWalletAccount;
+_OneTokenSolanaWalletAccount_address = new WeakMap(), _OneTokenSolanaWalletAccount_publicKey = new WeakMap(), _OneTokenSolanaWalletAccount_chains = new WeakMap(), _OneTokenSolanaWalletAccount_features = new WeakMap(), _OneTokenSolanaWalletAccount_label = new WeakMap(), _OneTokenSolanaWalletAccount_icon = new WeakMap();

package/dist/cjs/wallet-standard/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneTokenSolanaStandardWallet = exports.registerSolanaWallet = void 0;
+var register_js_1 = require("./register.js");
+Object.defineProperty(exports, "registerSolanaWallet", { enumerable: true, get: function () { return register_js_1.registerSolanaWallet; } });
+var wallet_js_1 = require("./wallet.js");
+Object.defineProperty(exports, "OneTokenSolanaStandardWallet", { enumerable: true, get: function () { return wallet_js_1.OneTokenSolanaStandardWallet; } });

package/dist/cjs/wallet-standard/register.js

@@ -0,0 +1,82 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _RegisterWalletEvent_detail;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWallet = registerWallet;
+exports.DEPRECATED_registerWallet = DEPRECATED_registerWallet;
+exports.registerSolanaWallet = registerSolanaWallet;
+const wallet_1 = require("./wallet");
+function registerWallet(wallet) {
+    const callback = ({ register }) => register(wallet);
+    try {
+        window.dispatchEvent(new RegisterWalletEvent(callback));
+    }
+    catch (error) {
+        console.error('wallet-standard:register-wallet event could not be dispatched\n', error);
+    }
+    try {
+        window.addEventListener('wallet-standard:app-ready', ({ detail: api }) => callback(api));
+    }
+    catch (error) {
+        console.error('wallet-standard:app-ready event listener could not be added\n', error);
+    }
+}
+class RegisterWalletEvent extends Event {
+    get detail() {
+        return __classPrivateFieldGet(this, _RegisterWalletEvent_detail, "f");
+    }
+    get type() {
+        return 'wallet-standard:register-wallet';
+    }
+    constructor(callback) {
+        super('wallet-standard:register-wallet', {
+            bubbles: false,
+            cancelable: false,
+            composed: false,
+        });
+        _RegisterWalletEvent_detail.set(this, void 0);
+        __classPrivateFieldSet(this, _RegisterWalletEvent_detail, callback, "f");
+    }
+    /** @deprecated */
+    preventDefault() {
+        throw new Error('preventDefault cannot be called');
+    }
+    /** @deprecated */
+    stopImmediatePropagation() {
+        throw new Error('stopImmediatePropagation cannot be called');
+    }
+    /** @deprecated */
+    stopPropagation() {
+        throw new Error('stopPropagation cannot be called');
+    }
+}
+_RegisterWalletEvent_detail = new WeakMap();
+/** @deprecated */
+function DEPRECATED_registerWallet(wallet) {
+    var _a;
+    registerWallet(wallet);
+    try {
+        ((_a = window.navigator).wallets || (_a.wallets = [])).push(({ register }) => register(wallet));
+    }
+    catch (error) {
+        console.error('window.navigator.wallets could not be pushed\n', error);
+    }
+}
+function registerSolanaWallet(provider, options) {
+    try {
+        registerWallet(new wallet_1.OneTokenSolanaStandardWallet(provider, options));
+    }
+    catch (error) {
+        console.error(error);
+    }
+}

package/dist/cjs/wallet-standard/solana.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOLANA_CHAINS = exports.SOLANA_LOCALNET_CHAIN = exports.SOLANA_TESTNET_CHAIN = exports.SOLANA_DEVNET_CHAIN = exports.SOLANA_MAINNET_CHAIN = void 0;
+exports.isSolanaChain = isSolanaChain;
+exports.SOLANA_MAINNET_CHAIN = 'solana:mainnet';
+exports.SOLANA_DEVNET_CHAIN = 'solana:devnet';
+exports.SOLANA_TESTNET_CHAIN = 'solana:testnet';
+exports.SOLANA_LOCALNET_CHAIN = 'solana:localnet';
+exports.SOLANA_CHAINS = [
+    exports.SOLANA_MAINNET_CHAIN,
+    exports.SOLANA_DEVNET_CHAIN,
+    exports.SOLANA_TESTNET_CHAIN,
+    exports.SOLANA_LOCALNET_CHAIN,
+];
+function isSolanaChain(chain) {
+    return exports.SOLANA_CHAINS.includes(chain);
+}

package/dist/cjs/wallet-standard/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });