@1tokenfe/onetoken-solana-provider 2.2.46

package/LICENSE.md

@@ -0,0 +1,51 @@
+# ONETOKEN STANDARD SOURCE LICENSE (O-SSL)
+
+This license governs use of the accompanying software. If you use the software,
+you accept this license. If you do not accept the license, do not use the
+software.
+
+## 1. Definitions
+
+The terms "reproduce," "reproduction" and "distribution" have the same meaning
+here as under Hong Kong copyright law.
+
+"You" means the licensee of the software.
+
+"Your company" means the company you worked for when you downloaded the
+software.
+
+"Reference use" means use of the software within your company as a reference,
+in read only form, for the sole purposes of debugging your products,
+maintaining your products, or enhancing the interoperability of your products
+with the software, and specifically excludes the right to distribute the
+software outside of your company.
+
+"Licensed patents" means any Licensor patent claims which read directly on the
+software as distributed by the Licensor under this license.
+
+## 2. Grant of Rights
+
+(A) Copyright Grant - Subject to the terms of this license, the Licensor grants
+you a non-transferable, non-exclusive, worldwide, royalty-free copyright
+license to reproduce the software for reference use.
+
+(B) Patent Grant - Subject to the terms of this license, the Licensor grants
+you a non-transferable, non-exclusive, worldwide, royalty-free patent license
+under licensed patents for reference use.
+
+## 3. Limitations
+
+(A) No Trademark License - This license does not grant you any rights to use
+the Licensor's name, logo, or trademarks.
+
+(B) If you begin patent litigation against the Licensor over patents that you
+think may apply to the software (including a cross-claim or counterclaim in
+a lawsuit), your license to the software ends automatically.
+
+(C) The software is licensed "as-is." You bear the risk of using it. The
+Licensor gives no express warranties, guarantees or conditions. You may have
+additional consumer rights under your local laws which this license cannot
+change. To the extent permitted under your local laws, the Licensor excludes
+the implied warranties of merchantability, fitness for a particular purpose and
+non-infringement.This license agreement is governed by the laws of Hong Kong, 
+and any disputes related to this license agreement shall be resolved in accordance with Hong Kong law.

package/README.md

@@ -0,0 +1 @@
+# cross-inpage-provider

package/dist/ProviderSolana.d.ts

@@ -0,0 +1,156 @@
+import { PublicKey, VersionedTransaction } from '@solana/web3.js';
+import type { SendOptions, Transaction } from '@solana/web3.js';
+import { IInpageProviderConfig } from '@1tokenfe/cross-inpage-provider-core';
+import { IJsonRpcRequest } from '@1tokenfe/cross-inpage-provider-types';
+import { ProviderSolanaBase } from './ProviderSolanaBase';
+import type * as TypeUtils from './type-utils';
+export type DisplayEncoding = 'utf8' | 'hex';
+export type ConnectOptions = {
+    onlyIfTrusted?: boolean;
+};
+export type SolanaRequest = {
+    'connect': (params: ConnectOptions | undefined) => Promise<{
+        publicKey: PublicKey;
+    }>;
+    'disconnect': () => Promise<void>;
+    'signMessage': (params: {
+        message: string;
+        display?: DisplayEncoding;
+    }) => Promise<{
+        signature: string;
+        publicKey: string;
+    }>;
+    'solSignOffchainMessage': (params: {
+        message: string;
+        version?: number;
+    }) => Promise<{
+        signature: string;
+        publicKey: string;
+    }>;
+    'signTransaction': (params: {
+        message: string;
+    }) => Promise<Transaction>;
+    'signAllTransactions': (params: {
+        message: string[];
+    }) => Promise<Transaction[]>;
+    'signAndSendTransaction': (params: {
+        message: string;
+        options?: SendOptions;
+    }) => Promise<{
+        signature: string;
+        publicKey: string;
+    }>;
+};
+export type JsBridgeRequest = {
+    [K in keyof SolanaRequest]: (params: Parameters<SolanaRequest[K]>[0]) => Promise<TypeUtils.WireStringified<TypeUtils.ResolvePromise<ReturnType<SolanaRequest[K]>>>>;
+};
+declare const PROVIDER_EVENTS: {
+    readonly connect: "connect";
+    readonly disconnect: "disconnect";
+    readonly accountChanged: "accountChanged";
+    readonly message_low_level: "message_low_level";
+};
+type SolanaProviderEventsMap = {
+    [PROVIDER_EVENTS.connect]: (publicKey: PublicKey) => void;
+    [PROVIDER_EVENTS.disconnect]: () => void;
+    [PROVIDER_EVENTS.accountChanged]: (publicKey: PublicKey | null) => void;
+    [PROVIDER_EVENTS.message_low_level]: (payload: IJsonRpcRequest) => void;
+};
+type SolanaAccountInfo = {
+    publicKey: string;
+};
+interface IProviderSolana extends ProviderSolanaBase {
+    readonly isPhantom: true;
+    readonly isSolflare: true;
+    isConnected: boolean;
+    publicKey: PublicKey | null;
+    /**
+     * Connect wallet, and get wallet public key
+     * @param {Object} options - Connection options
+     * @param {string} options.onlyIfTrusted - Only connect when user have connected before, otherwise would throw an error
+     * @emits `connect` on success
+     */
+    connect(options?: ConnectOptions): Promise<{
+        publicKey: PublicKey;
+    }>;
+    /**
+     * Disconnect wallet
+     */
+    disconnect(): Promise<void>;
+    /**
+     * @deprecated
+     * Sign multiple transactions
+     * @returns Transaction[]
+     */
+    signAllTransactions(transactions: (Transaction | VersionedTransaction)[]): Promise<(Transaction | VersionedTransaction)[]>;
+    /**
+     * @deprecated
+     * Sign one transaction
+     * @returns Transaction
+     */
+    signTransaction(transaction: Transaction | VersionedTransaction): Promise<Transaction | VersionedTransaction>;
+    /**
+     * Sign and send a transaction
+     * @returns {Object} Signature and public key
+     */
+    signAndSendTransaction(transaction: Transaction | VersionedTransaction, options?: SendOptions): Promise<{
+        publicKey: string;
+        signature: string;
+    }>;
+    /** Sign a message
+     * @param message - The message to be signed.
+     * @param {string} [display='utf8'] - Specify how the message should be displayed. (default: 'uft8')
+     */
+    signMessage(message: Uint8Array, display?: DisplayEncoding): Promise<{
+        signature: Uint8Array;
+        publicKey: PublicKey;
+    }>;
+}
+type OneTokenSolanaProviderProps = IInpageProviderConfig & {
+    timeout?: number;
+};
+declare class ProviderSolana extends ProviderSolanaBase implements IProviderSolana {
+    readonly isPhantom = true;
+    readonly isSolflare = true;
+    private _publicKey;
+    get publicKey(): PublicKey | null;
+    get isConnected(): boolean;
+    constructor(props: OneTokenSolanaProviderProps);
+    private _registerEvents;
+    private _callBridge;
+    private postMessage;
+    connect(options?: ConnectOptions): Promise<{
+        publicKey: PublicKey;
+    }>;
+    private _handleConnected;
+    disconnect(): Promise<void>;
+    private _handleDisconnected;
+    isAccountsChanged(account: SolanaAccountInfo | undefined): boolean;
+    private _handleAccountChange;
+    signAndSendTransaction(transaction: Transaction | VersionedTransaction, options?: Partial<SendOptions>): Promise<{
+        publicKey: string;
+        signature: string;
+    }>;
+    private _handleSignAndSendTransaction;
+    signTransaction(transaction: Transaction | VersionedTransaction): Promise<Transaction | VersionedTransaction>;
+    private _handleSignTransaction;
+    signAllTransactions(transactions: (Transaction | VersionedTransaction)[]): Promise<(Transaction | VersionedTransaction)[]>;
+    private _handleSignAllTransactions;
+    signMessage(message: Uint8Array, display?: DisplayEncoding): Promise<{
+        signature: Uint8Array;
+        publicKey: PublicKey;
+    }>;
+    solSignOffchainMessage(message: Uint8Array, version?: number): Promise<{
+        signature: Uint8Array;
+        publicKey: PublicKey;
+    }>;
+    private _handleSignMessage;
+    request<T extends keyof SolanaRequest>(method: T, params: Parameters<SolanaRequest[T]>[0]): ReturnType<SolanaRequest[T]>;
+    request<T extends keyof SolanaRequest>(payload: {
+        method: T;
+        params: Parameters<SolanaRequest[T]>[0];
+    }): ReturnType<SolanaRequest[T]>;
+    on<E extends keyof SolanaProviderEventsMap>(event: E, listener: SolanaProviderEventsMap[E]): this;
+    emit<E extends keyof SolanaProviderEventsMap>(event: E, ...args: Parameters<SolanaProviderEventsMap[E]>): boolean;
+}
+export { ProviderSolana };

package/dist/ProviderSolana.js

@@ -0,0 +1,264 @@
+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());
+    });
+};
+import { PublicKey } from '@solana/web3.js';
+import { getOrCreateExtInjectedJsBridge } from '@1tokenfe/extension-bridge-injected';
+import base58 from 'bs58';
+import { ProviderSolanaBase } from './ProviderSolanaBase';
+import { decodeSignedTransaction, encodeTransaction, isWalletEventMethodMatch } from './utils';
+const PROVIDER_EVENTS = {
+    'connect': 'connect',
+    'disconnect': 'disconnect',
+    'accountChanged': 'accountChanged',
+    'message_low_level': 'message_low_level',
+};
+class ProviderSolana extends ProviderSolanaBase {
+    get publicKey() {
+        return this._publicKey;
+    }
+    get isConnected() {
+        return this._publicKey !== null;
+    }
+    constructor(props) {
+        super(Object.assign(Object.assign({}, props), { bridge: props.bridge || 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 (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 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 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: 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: 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 decodeSignedTransaction({
+                message: result,
+                onlyVersionedTx,
+            });
+        });
+    }
+    signAllTransactions(transactions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._handleSignAllTransactions({
+                message: transactions.map(encodeTransaction),
+            });
+        });
+    }
+    _handleSignAllTransactions(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._callBridge({
+                method: 'signAllTransactions',
+                params,
+            });
+            return result.map((message) => 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 : base58.encode(message),
+                    version,
+                },
+            });
+            return {
+                signature: base58.decode(result.signature),
+                publicKey: new 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 : base58.encode(message),
+                    display,
+                },
+            });
+            return {
+                signature: base58.decode(result.signature),
+                publicKey: new 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);
+    }
+}
+export { ProviderSolana };

package/dist/ProviderSolanaBase.d.ts

@@ -0,0 +1,8 @@
+import { IInjectedProviderNames } from '@1tokenfe/cross-inpage-provider-types';
+import { ProviderBase, IInpageProviderConfig } from '@1tokenfe/cross-inpage-provider-core';
+declare class ProviderSolanaBase extends ProviderBase {
+    constructor(props: IInpageProviderConfig);
+    protected providerName: IInjectedProviderNames;
+    request(data: unknown): Promise<unknown>;
+}
+export { ProviderSolanaBase };

package/dist/ProviderSolanaBase.js

@@ -0,0 +1,12 @@
+import { IInjectedProviderNames } from '@1tokenfe/cross-inpage-provider-types';
+import { ProviderBase } from '@1tokenfe/cross-inpage-provider-core';
+class ProviderSolanaBase extends ProviderBase {
+    constructor(props) {
+        super(props);
+        this.providerName = IInjectedProviderNames.solana;
+    }
+    request(data) {
+        return this.bridgeRequest(data);
+    }
+}
+export { ProviderSolanaBase };