@onekeyfe/onekey-stellar-provider 2.2.56-alpha.1

package/LICENSE.md

@@ -0,0 +1,51 @@
+# ONEKEY 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/OnekeyStellarProvider.d.ts

@@ -0,0 +1,158 @@
+import type { IInpageProviderConfig } from '@onekeyfe/cross-inpage-provider-core';
+import { ProviderStellarBase } from './ProviderStellarBase';
+import type { IJsonRpcRequest } from '@onekeyfe/cross-inpage-provider-types';
+export declare enum PROVIDER_EVENTS {
+    accountsChanged = "accountsChanged",
+    disconnect = "disconnect",
+    message_low_level = "message_low_level"
+}
+type StellarProviderEventsMap = {
+    [PROVIDER_EVENTS.accountsChanged]: (address: string | null) => void;
+    [PROVIDER_EVENTS.disconnect]: () => void;
+    [PROVIDER_EVENTS.message_low_level]: (payload: IJsonRpcRequest) => void;
+};
+export declare enum StellarRequestMethods {
+    stellar_getAddress = "stellar_getAddress",
+    stellar_signTransaction = "stellar_signTransaction",
+    stellar_signAuthEntry = "stellar_signAuthEntry",
+    stellar_signMessage = "stellar_signMessage",
+    stellar_getNetwork = "stellar_getNetwork",
+    stellar_disconnect = "stellar_disconnect"
+}
+export type GetAddressParams = {
+    path?: string;
+    skipRequestAccess?: boolean;
+};
+export type GetAddressResult = {
+    address: string;
+};
+export type SignTransactionParams = {
+    xdr: string;
+    networkPassphrase?: string;
+    address?: string;
+    path?: string;
+    submit?: boolean;
+    submitUrl?: string;
+};
+export type SignTransactionResult = {
+    signedTxXdr: string;
+    signerAddress?: string;
+};
+export type SignAuthEntryParams = {
+    authEntry: string;
+    networkPassphrase?: string;
+    address?: string;
+    path?: string;
+};
+export type SignAuthEntryResult = {
+    signedAuthEntry: string;
+    signerAddress?: string;
+};
+export type SignMessageParams = {
+    message: string;
+    networkPassphrase?: string;
+    address?: string;
+    path?: string;
+};
+export type SignMessageResult = {
+    signedMessage: string;
+    signerAddress?: string;
+};
+export type GetNetworkResult = {
+    network: string;
+    networkPassphrase: string;
+};
+export interface IProviderStellar extends ProviderStellarBase {
+    /**
+     * Get the public key from the active account or specific path
+     */
+    getAddress(params?: GetAddressParams): Promise<GetAddressResult>;
+    /**
+     * Sign a transaction in XDR format
+     */
+    signTransaction(xdr: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+        path?: string;
+        submit?: boolean;
+        submitUrl?: string;
+    }): Promise<SignTransactionResult>;
+    /**
+     * Sign an AuthEntry XDR
+     */
+    signAuthEntry(authEntry: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+        path?: string;
+    }): Promise<SignAuthEntryResult>;
+    /**
+     * Sign an arbitrary message
+     */
+    signMessage(message: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+        path?: string;
+    }): Promise<SignMessageResult>;
+    /**
+     * Get the current selected network
+     */
+    getNetwork(): Promise<GetNetworkResult>;
+    /**
+     * Disconnect from the wallet
+     */
+    disconnect(): Promise<void>;
+}
+export type OneKeyStellarProviderProps = IInpageProviderConfig & {
+    timeout?: number;
+};
+export declare class ProviderStellar extends ProviderStellarBase implements IProviderStellar {
+    private _address?;
+    constructor(props: OneKeyStellarProviderProps);
+    private _registerEvents;
+    private _callBridge;
+    private _handleDisconnected;
+    isAccountsChanged(address: string | undefined): boolean;
+    private _handleAccountChange;
+    on<E extends keyof StellarProviderEventsMap>(event: E, listener: StellarProviderEventsMap[E]): this;
+    emit<E extends keyof StellarProviderEventsMap>(event: E, ...args: Parameters<StellarProviderEventsMap[E]>): boolean;
+    removeListener<E extends keyof StellarProviderEventsMap>(eventName: E, listener: StellarProviderEventsMap[E]): this;
+    /**
+     * Get the address from the wallet
+     */
+    getAddress(params?: GetAddressParams): Promise<GetAddressResult>;
+    /**
+     * Sign a transaction
+     */
+    signTransaction(xdr: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+        path?: string;
+        submit?: boolean;
+        submitUrl?: string;
+    }): Promise<SignTransactionResult>;
+    /**
+     * Sign an AuthEntry
+     */
+    signAuthEntry(authEntry: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+        path?: string;
+    }): Promise<SignAuthEntryResult>;
+    /**
+     * Sign a message
+     */
+    signMessage(message: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+        path?: string;
+    }): Promise<SignMessageResult>;
+    /**
+     * Get the current network
+     */
+    getNetwork(): Promise<GetNetworkResult>;
+    /**
+     * Disconnect from the wallet
+     */
+    disconnect(): Promise<void>;
+}
+export {};

package/dist/OnekeyStellarProvider.js

@@ -0,0 +1,163 @@
+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 { getOrCreateExtInjectedJsBridge } from '@onekeyfe/extension-bridge-injected';
+import { ProviderStellarBase } from './ProviderStellarBase';
+export var PROVIDER_EVENTS;
+(function (PROVIDER_EVENTS) {
+    PROVIDER_EVENTS["accountsChanged"] = "accountsChanged";
+    PROVIDER_EVENTS["disconnect"] = "disconnect";
+    PROVIDER_EVENTS["message_low_level"] = "message_low_level";
+})(PROVIDER_EVENTS || (PROVIDER_EVENTS = {}));
+// Stellar request method names
+export var StellarRequestMethods;
+(function (StellarRequestMethods) {
+    StellarRequestMethods["stellar_getAddress"] = "stellar_getAddress";
+    StellarRequestMethods["stellar_signTransaction"] = "stellar_signTransaction";
+    StellarRequestMethods["stellar_signAuthEntry"] = "stellar_signAuthEntry";
+    StellarRequestMethods["stellar_signMessage"] = "stellar_signMessage";
+    StellarRequestMethods["stellar_getNetwork"] = "stellar_getNetwork";
+    StellarRequestMethods["stellar_disconnect"] = "stellar_disconnect";
+})(StellarRequestMethods || (StellarRequestMethods = {}));
+function isWalletEventMethodMatch({ method, name }) {
+    return method === `wallet_events_${name}`;
+}
+export class ProviderStellar extends ProviderStellarBase {
+    constructor(props) {
+        super(Object.assign(Object.assign({}, props), { bridge: props.bridge || getOrCreateExtInjectedJsBridge({ timeout: props.timeout }) }));
+        this._registerEvents();
+    }
+    _registerEvents() {
+        window.addEventListener('onekey_bridge_disconnect', () => {
+            this._handleDisconnected();
+        });
+        this.on(PROVIDER_EVENTS.message_low_level, (payload) => {
+            if (!payload)
+                return;
+            const { method, params } = payload;
+            if (isWalletEventMethodMatch({ method, name: PROVIDER_EVENTS.accountsChanged })) {
+                this._handleAccountChange(params);
+            }
+        });
+    }
+    _callBridge(params) {
+        return this.bridgeRequest(params);
+    }
+    _handleDisconnected(options = { emit: true }) {
+        this._address = undefined;
+        if (options.emit && this.isConnectionStatusChanged('disconnected')) {
+            this.connectionStatus = 'disconnected';
+            this.emit(PROVIDER_EVENTS.disconnect);
+        }
+    }
+    isAccountsChanged(address) {
+        if (!address)
+            return false;
+        if (!this._address)
+            return true;
+        return address !== this._address;
+    }
+    // trigger by bridge account change event
+    _handleAccountChange(payload) {
+        const address = payload;
+        if (this.isAccountsChanged(address)) {
+            this._address = address;
+            this.emit(PROVIDER_EVENTS.accountsChanged, address || null);
+        }
+        if (!address) {
+            this._handleDisconnected();
+            return;
+        }
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    removeListener(eventName, listener) {
+        return super.removeListener(eventName, listener);
+    }
+    /**
+     * Get the address from the wallet
+     */
+    getAddress(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._callBridge({
+                method: StellarRequestMethods.stellar_getAddress,
+                params,
+            });
+            // Store the address for account change tracking
+            if (result.address) {
+                this._address = result.address;
+            }
+            return result;
+        });
+    }
+    /**
+     * Sign a transaction
+     */
+    signTransaction(xdr, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._callBridge({
+                method: StellarRequestMethods.stellar_signTransaction,
+                params: Object.assign({ xdr }, opts),
+            });
+            return result;
+        });
+    }
+    /**
+     * Sign an AuthEntry
+     */
+    signAuthEntry(authEntry, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._callBridge({
+                method: StellarRequestMethods.stellar_signAuthEntry,
+                params: Object.assign({ authEntry }, opts),
+            });
+            return result;
+        });
+    }
+    /**
+     * Sign a message
+     */
+    signMessage(message, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._callBridge({
+                method: StellarRequestMethods.stellar_signMessage,
+                params: Object.assign({ message }, opts),
+            });
+            return result;
+        });
+    }
+    /**
+     * Get the current network
+     */
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._callBridge({
+                method: StellarRequestMethods.stellar_getNetwork,
+                params: void 0,
+            });
+            return result;
+        });
+    }
+    /**
+     * Disconnect from the wallet
+     */
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._callBridge({
+                method: StellarRequestMethods.stellar_disconnect,
+                params: void 0,
+            });
+            this._handleDisconnected();
+        });
+    }
+}

package/dist/ProviderStellarBase.d.ts

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

package/dist/ProviderStellarBase.js

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

package/dist/ProviderStellarHana.d.ts

@@ -0,0 +1,65 @@
+import type { ProviderStellar } from './OnekeyStellarProvider';
+export type SignTransactionProps = {
+    xdr: string;
+    accountToSign?: string;
+    networkPassphrase?: string;
+};
+export type SignBlobProps = {
+    blob: string;
+    accountToSign?: string;
+};
+export type SignAuthEntryProps = {
+    xdr: string;
+    accountToSign?: string;
+};
+export type SignMessageProps = {
+    message: string;
+    accountToSign?: string;
+};
+/**
+ * Hana Wallet compatible wrapper for ProviderStellar
+ * Adapts OneKey Stellar Provider to match Hana wallet's interface
+ */
+export declare class ProviderStellarHana {
+    private provider;
+    constructor(provider: ProviderStellar);
+    /**
+     * Get the public key of the current account
+     * @returns Promise<string> - The public key/address
+     */
+    getPublicKey(): Promise<string>;
+    /**
+     * Sign a transaction in XDR format
+     * @param params - Transaction signing parameters
+     * @returns Promise<string> - The signed transaction XDR
+     */
+    signTransaction({ xdr, accountToSign, networkPassphrase }: SignTransactionProps): Promise<string>;
+    /**
+     * Sign a blob (arbitrary data)
+     * Note: This is implemented using signMessage as ProviderStellar doesn't have a separate blob signing method
+     * @param params - Blob signing parameters
+     * @returns Promise<string> - The signed blob
+     */
+    signBlob({ blob, accountToSign }: SignBlobProps): Promise<string>;
+    /**
+     * Sign an AuthEntry in XDR format
+     * @param params - AuthEntry signing parameters
+     * @returns Promise<string> - The signed AuthEntry XDR
+     */
+    signAuthEntry({ xdr, accountToSign }: SignAuthEntryProps): Promise<string>;
+    /**
+     * Sign an arbitrary message
+     * @param params - Message signing parameters
+     * @returns Promise<string> - The signed message
+     */
+    signMessage({ message, accountToSign }: SignMessageProps): Promise<string>;
+    /**
+     * Get the current network configuration
+     * @returns Promise<{network: string, networkPassphrase: string}>
+     */
+    getNetwork(): Promise<import("./OnekeyStellarProvider").GetNetworkResult>;
+    /**
+     * Disconnect from the wallet
+     */
+    disconnect(): Promise<void>;
+}

package/dist/ProviderStellarHana.js

@@ -0,0 +1,99 @@
+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());
+    });
+};
+/**
+ * Hana Wallet compatible wrapper for ProviderStellar
+ * Adapts OneKey Stellar Provider to match Hana wallet's interface
+ */
+export class ProviderStellarHana {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    /**
+     * Get the public key of the current account
+     * @returns Promise<string> - The public key/address
+     */
+    getPublicKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.provider.getAddress();
+            return result.address;
+        });
+    }
+    /**
+     * Sign a transaction in XDR format
+     * @param params - Transaction signing parameters
+     * @returns Promise<string> - The signed transaction XDR
+     */
+    signTransaction(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ xdr, accountToSign, networkPassphrase }) {
+            const result = yield this.provider.signTransaction(xdr, {
+                address: accountToSign,
+                networkPassphrase,
+            });
+            return result.signedTxXdr;
+        });
+    }
+    /**
+     * Sign a blob (arbitrary data)
+     * Note: This is implemented using signMessage as ProviderStellar doesn't have a separate blob signing method
+     * @param params - Blob signing parameters
+     * @returns Promise<string> - The signed blob
+     */
+    signBlob(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ blob, accountToSign }) {
+            const result = yield this.provider.signMessage(blob, {
+                address: accountToSign,
+            });
+            return result.signedMessage;
+        });
+    }
+    /**
+     * Sign an AuthEntry in XDR format
+     * @param params - AuthEntry signing parameters
+     * @returns Promise<string> - The signed AuthEntry XDR
+     */
+    signAuthEntry(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ xdr, accountToSign }) {
+            const result = yield this.provider.signAuthEntry(xdr, {
+                address: accountToSign,
+            });
+            return result.signedAuthEntry;
+        });
+    }
+    /**
+     * Sign an arbitrary message
+     * @param params - Message signing parameters
+     * @returns Promise<string> - The signed message
+     */
+    signMessage(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ message, accountToSign }) {
+            const result = yield this.provider.signMessage(message, {
+                address: accountToSign,
+            });
+            return result.signedMessage;
+        });
+    }
+    /**
+     * Get the current network configuration
+     * @returns Promise<{network: string, networkPassphrase: string}>
+     */
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.provider.getNetwork();
+        });
+    }
+    /**
+     * Disconnect from the wallet
+     */
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.provider.disconnect();
+        });
+    }
+}

package/dist/cjs/OnekeyStellarProvider.js

@@ -0,0 +1,167 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderStellar = exports.StellarRequestMethods = exports.PROVIDER_EVENTS = void 0;
+const extension_bridge_injected_1 = require("@onekeyfe/extension-bridge-injected");
+const ProviderStellarBase_1 = require("./ProviderStellarBase");
+var PROVIDER_EVENTS;
+(function (PROVIDER_EVENTS) {
+    PROVIDER_EVENTS["accountsChanged"] = "accountsChanged";
+    PROVIDER_EVENTS["disconnect"] = "disconnect";
+    PROVIDER_EVENTS["message_low_level"] = "message_low_level";
+})(PROVIDER_EVENTS || (exports.PROVIDER_EVENTS = PROVIDER_EVENTS = {}));
+// Stellar request method names
+var StellarRequestMethods;
+(function (StellarRequestMethods) {
+    StellarRequestMethods["stellar_getAddress"] = "stellar_getAddress";
+    StellarRequestMethods["stellar_signTransaction"] = "stellar_signTransaction";
+    StellarRequestMethods["stellar_signAuthEntry"] = "stellar_signAuthEntry";
+    StellarRequestMethods["stellar_signMessage"] = "stellar_signMessage";
+    StellarRequestMethods["stellar_getNetwork"] = "stellar_getNetwork";
+    StellarRequestMethods["stellar_disconnect"] = "stellar_disconnect";
+})(StellarRequestMethods || (exports.StellarRequestMethods = StellarRequestMethods = {}));
+function isWalletEventMethodMatch({ method, name }) {
+    return method === `wallet_events_${name}`;
+}
+class ProviderStellar extends ProviderStellarBase_1.ProviderStellarBase {
+    constructor(props) {
+        super(Object.assign(Object.assign({}, props), { bridge: props.bridge || (0, extension_bridge_injected_1.getOrCreateExtInjectedJsBridge)({ timeout: props.timeout }) }));
+        this._registerEvents();
+    }
+    _registerEvents() {
+        window.addEventListener('onekey_bridge_disconnect', () => {
+            this._handleDisconnected();
+        });
+        this.on(PROVIDER_EVENTS.message_low_level, (payload) => {
+            if (!payload)
+                return;
+            const { method, params } = payload;
+            if (isWalletEventMethodMatch({ method, name: PROVIDER_EVENTS.accountsChanged })) {
+                this._handleAccountChange(params);
+            }
+        });
+    }
+    _callBridge(params) {
+        return this.bridgeRequest(params);
+    }
+    _handleDisconnected(options = { emit: true }) {
+        this._address = undefined;
+        if (options.emit && this.isConnectionStatusChanged('disconnected')) {
+            this.connectionStatus = 'disconnected';
+            this.emit(PROVIDER_EVENTS.disconnect);
+        }
+    }
+    isAccountsChanged(address) {
+        if (!address)
+            return false;
+        if (!this._address)
+            return true;
+        return address !== this._address;
+    }
+    // trigger by bridge account change event
+    _handleAccountChange(payload) {
+        const address = payload;
+        if (this.isAccountsChanged(address)) {
+            this._address = address;
+            this.emit(PROVIDER_EVENTS.accountsChanged, address || null);
+        }
+        if (!address) {
+            this._handleDisconnected();
+            return;
+        }
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    removeListener(eventName, listener) {
+        return super.removeListener(eventName, listener);
+    }
+    /**
+     * Get the address from the wallet
+     */
+    getAddress(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._callBridge({
+                method: StellarRequestMethods.stellar_getAddress,
+                params,
+            });
+            // Store the address for account change tracking
+            if (result.address) {
+                this._address = result.address;
+            }
+            return result;
+        });
+    }
+    /**
+     * Sign a transaction
+     */
+    signTransaction(xdr, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._callBridge({
+                method: StellarRequestMethods.stellar_signTransaction,
+                params: Object.assign({ xdr }, opts),
+            });
+            return result;
+        });
+    }
+    /**
+     * Sign an AuthEntry
+     */
+    signAuthEntry(authEntry, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._callBridge({
+                method: StellarRequestMethods.stellar_signAuthEntry,
+                params: Object.assign({ authEntry }, opts),
+            });
+            return result;
+        });
+    }
+    /**
+     * Sign a message
+     */
+    signMessage(message, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._callBridge({
+                method: StellarRequestMethods.stellar_signMessage,
+                params: Object.assign({ message }, opts),
+            });
+            return result;
+        });
+    }
+    /**
+     * Get the current network
+     */
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._callBridge({
+                method: StellarRequestMethods.stellar_getNetwork,
+                params: void 0,
+            });
+            return result;
+        });
+    }
+    /**
+     * Disconnect from the wallet
+     */
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._callBridge({
+                method: StellarRequestMethods.stellar_disconnect,
+                params: void 0,
+            });
+            this._handleDisconnected();
+        });
+    }
+}
+exports.ProviderStellar = ProviderStellar;

package/dist/cjs/ProviderStellarBase.js

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

package/dist/cjs/ProviderStellarHana.js

@@ -0,0 +1,103 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderStellarHana = void 0;
+/**
+ * Hana Wallet compatible wrapper for ProviderStellar
+ * Adapts OneKey Stellar Provider to match Hana wallet's interface
+ */
+class ProviderStellarHana {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    /**
+     * Get the public key of the current account
+     * @returns Promise<string> - The public key/address
+     */
+    getPublicKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.provider.getAddress();
+            return result.address;
+        });
+    }
+    /**
+     * Sign a transaction in XDR format
+     * @param params - Transaction signing parameters
+     * @returns Promise<string> - The signed transaction XDR
+     */
+    signTransaction(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ xdr, accountToSign, networkPassphrase }) {
+            const result = yield this.provider.signTransaction(xdr, {
+                address: accountToSign,
+                networkPassphrase,
+            });
+            return result.signedTxXdr;
+        });
+    }
+    /**
+     * Sign a blob (arbitrary data)
+     * Note: This is implemented using signMessage as ProviderStellar doesn't have a separate blob signing method
+     * @param params - Blob signing parameters
+     * @returns Promise<string> - The signed blob
+     */
+    signBlob(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ blob, accountToSign }) {
+            const result = yield this.provider.signMessage(blob, {
+                address: accountToSign,
+            });
+            return result.signedMessage;
+        });
+    }
+    /**
+     * Sign an AuthEntry in XDR format
+     * @param params - AuthEntry signing parameters
+     * @returns Promise<string> - The signed AuthEntry XDR
+     */
+    signAuthEntry(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ xdr, accountToSign }) {
+            const result = yield this.provider.signAuthEntry(xdr, {
+                address: accountToSign,
+            });
+            return result.signedAuthEntry;
+        });
+    }
+    /**
+     * Sign an arbitrary message
+     * @param params - Message signing parameters
+     * @returns Promise<string> - The signed message
+     */
+    signMessage(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ message, accountToSign }) {
+            const result = yield this.provider.signMessage(message, {
+                address: accountToSign,
+            });
+            return result.signedMessage;
+        });
+    }
+    /**
+     * Get the current network configuration
+     * @returns Promise<{network: string, networkPassphrase: string}>
+     */
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.provider.getNetwork();
+        });
+    }
+    /**
+     * Disconnect from the wallet
+     */
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.provider.disconnect();
+        });
+    }
+}
+exports.ProviderStellarHana = ProviderStellarHana;

package/dist/cjs/index.js

@@ -0,0 +1,18 @@
+"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("./OnekeyStellarProvider"), exports);
+__exportStar(require("./ProviderStellarHana"), exports);

package/dist/cjs/type-utils.js

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

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './OnekeyStellarProvider';
+export * from './ProviderStellarHana';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './OnekeyStellarProvider';
+export * from './ProviderStellarHana';

package/dist/type-utils.d.ts

@@ -0,0 +1,4 @@
+export type WireStringified<T> = T extends Array<infer P> ? Array<WireStringified<P>> : T extends object ? {
+    [K in keyof T]: WireStringified<T[K]>;
+} : T;
+export type ResolvePromise<T> = T extends Promise<infer P> ? P : T;

package/dist/type-utils.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@onekeyfe/onekey-stellar-provider",
+  "version": "2.2.56-alpha.1",
+  "keywords": [
+    "cross-inpage-provider"
+  ],
+  "author": "dev-fe@onekey.so",
+  "repository": "https://github.com/OneKeyHQ/cross-inpage-provider",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/*"
+  ],
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "import": "./dist/index.js",
+    "require": "./dist/cjs/index.js"
+  },
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "main": "./dist/cjs/index.js",
+  "scripts": {
+    "prebuild": "rm -rf dist",
+    "build": "tsc && tsc --project tsconfig.cjs.json",
+    "start": "tsc --watch"
+  },
+  "dependencies": {
+    "@onekeyfe/cross-inpage-provider-core": "2.2.56-alpha.1",
+    "@onekeyfe/cross-inpage-provider-errors": "2.2.56-alpha.1",
+    "@onekeyfe/cross-inpage-provider-types": "2.2.56-alpha.1",
+    "@onekeyfe/extension-bridge-injected": "2.2.56-alpha.1"
+  },
+  "gitHead": "a1dfd47ff2a01a6aadbf7276f902b5f612c718c1"
+}