@onekeyfe/onekey-algo-provider 2.0.0-alpha.7

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/ProviderAlgo.d.ts

@@ -0,0 +1,34 @@
+import { IInpageProviderConfig } from '@onekeyfe/cross-inpage-provider-core';
+import { ProviderAlgoBase } from './ProviderAlgoBase';
+import { AlgoProviderEventsMap, BaseHTTPClient, DisplayEncoding, EnableOpts, EnableResult, IProviderAlgo, PostTxnsResult, SignTxnsResult, TransactionResult, WalletTransaction } from './types';
+declare class ProviderAlgo extends ProviderAlgoBase implements IProviderAlgo {
+    readonly isExodus = true;
+    readonly isOneKey = true;
+    isConnected: boolean;
+    address: string | null;
+    constructor(props: IInpageProviderConfig);
+    private _registerEvents;
+    private _handleConnected;
+    private _handleDisconnected;
+    private _handleAccountChange;
+    on<E extends keyof AlgoProviderEventsMap>(event: E, listener: AlgoProviderEventsMap[E]): this;
+    off<E extends keyof AlgoProviderEventsMap>(event: E, listener: AlgoProviderEventsMap[E]): this;
+    emit<E extends keyof AlgoProviderEventsMap>(event: E, ...args: Parameters<AlgoProviderEventsMap[E]>): boolean;
+    enable(opts?: EnableOpts): Promise<EnableResult>;
+    signTxns(transactions: WalletTransaction[]): Promise<SignTxnsResult>;
+    postTxns(transactions: string[]): Promise<PostTxnsResult>;
+    signAndPostTxns(transactions: WalletTransaction[]): Promise<PostTxnsResult>;
+    getAlgodv2Client(): Promise<BaseHTTPClient>;
+    getIndexerClient(): Promise<BaseHTTPClient>;
+    connect(): Promise<{
+        address: string;
+    }>;
+    disconnect(): Promise<void>;
+    signAndSendTransaction(transactions: Uint8Array[]): Promise<TransactionResult>;
+    signTransaction(transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    signMessage(encodedMessage: Uint8Array, display?: DisplayEncoding | undefined): Promise<{
+        signature: Uint8Array;
+        address: string;
+    }>;
+}
+export { ProviderAlgo };

package/dist/ProviderAlgo.js

@@ -0,0 +1,115 @@
+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 { ProviderAlgoBase } from './ProviderAlgoBase';
+import { PROVIDER_EVENTS, } from './types';
+import { isWalletEventMethodMatch } from './utils';
+class ProviderAlgo extends ProviderAlgoBase {
+    constructor(props) {
+        super(props);
+        this.isExodus = true;
+        this.isOneKey = true;
+        this.isConnected = false;
+        this.address = null;
+        this._registerEvents();
+    }
+    _registerEvents() {
+        window.addEventListener('onekey_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);
+            }
+        });
+    }
+    _handleConnected(connectInfo) {
+        this.isConnected = true;
+        this.address = connectInfo.address;
+        this.emit(PROVIDER_EVENTS.connect, connectInfo);
+        this.emit(PROVIDER_EVENTS.accountChanged, connectInfo.address);
+    }
+    _handleDisconnected(options = { emit: true }) {
+        this.isConnected = false;
+        this.address = null;
+        if (options.emit && this.isConnectionStatusChanged('disconnected')) {
+            this.emit(PROVIDER_EVENTS.disconnect);
+            this.emit(PROVIDER_EVENTS.accountChanged, '');
+        }
+    }
+    _handleAccountChange(address) {
+        this.emit(PROVIDER_EVENTS.accountChanged, address);
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    enable(opts) {
+        return this.request({ method: 'algo_enable', params: opts });
+    }
+    signTxns(transactions) {
+        return this.request({ method: 'algo_signTxns', params: transactions });
+    }
+    postTxns(transactions) {
+        return this.request({ method: 'algo_postTxns', params: transactions });
+    }
+    signAndPostTxns(transactions) {
+        return this.request({ method: 'algo_signAndPostTxns', params: transactions });
+    }
+    getAlgodv2Client() {
+        return this.request({ method: 'algo_getAlgodv2Client' });
+    }
+    getIndexerClient() {
+        return this.request({ method: 'algo_getIndexerClient' });
+    }
+    // legacy
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const addresses = yield this.request({ method: 'algo_requestAccounts' });
+            const address = addresses[0];
+            this._handleConnected({ address });
+            return { address };
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.request({ method: 'algo_disconnect' });
+            this._handleDisconnected();
+        });
+    }
+    signAndSendTransaction(transactions) {
+        return this.request({
+            method: 'algo_signAndSendTransaction',
+            params: transactions,
+        });
+    }
+    signTransaction(transactions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.request({
+                method: 'algo_signTransaction',
+                params: transactions,
+            });
+            const rawTxs = result.split(',').map((tx) => Uint8Array.from(Buffer.from(tx, 'base64')));
+            return rawTxs;
+        });
+    }
+    signMessage(encodedMessage, display) {
+        return this.request({
+            method: 'algo_signMessage',
+            params: { encodedMessage, display },
+        });
+    }
+}
+export { ProviderAlgo };

package/dist/ProviderAlgoBase.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 ProviderAlgoBase extends ProviderBase {
+    constructor(props: IInpageProviderConfig);
+    protected readonly providerName = IInjectedProviderNames.algo;
+    request<T>(data: unknown): Promise<T>;
+}
+export { ProviderAlgoBase };

package/dist/ProviderAlgoBase.js

@@ -0,0 +1,23 @@
+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 { IInjectedProviderNames } from '@onekeyfe/cross-inpage-provider-types';
+import { ProviderBase } from '@onekeyfe/cross-inpage-provider-core';
+class ProviderAlgoBase extends ProviderBase {
+    constructor(props) {
+        super(props);
+        this.providerName = IInjectedProviderNames.algo;
+    }
+    request(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.bridgeRequest(data));
+        });
+    }
+}
+export { ProviderAlgoBase };

package/dist/cjs/ProviderAlgo.js

@@ -0,0 +1,118 @@
+"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.ProviderAlgo = void 0;
+const ProviderAlgoBase_1 = require("./ProviderAlgoBase");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+class ProviderAlgo extends ProviderAlgoBase_1.ProviderAlgoBase {
+    constructor(props) {
+        super(props);
+        this.isExodus = true;
+        this.isOneKey = true;
+        this.isConnected = false;
+        this.address = null;
+        this._registerEvents();
+    }
+    _registerEvents() {
+        window.addEventListener('onekey_bridge_disconnect', () => {
+            this._handleDisconnected();
+        });
+        this.on(types_1.PROVIDER_EVENTS.message_low_level, (payload) => {
+            const { method, params } = payload;
+            if ((0, utils_1.isWalletEventMethodMatch)(method, types_1.PROVIDER_EVENTS.accountChanged)) {
+                this._handleAccountChange(params);
+            }
+        });
+    }
+    _handleConnected(connectInfo) {
+        this.isConnected = true;
+        this.address = connectInfo.address;
+        this.emit(types_1.PROVIDER_EVENTS.connect, connectInfo);
+        this.emit(types_1.PROVIDER_EVENTS.accountChanged, connectInfo.address);
+    }
+    _handleDisconnected(options = { emit: true }) {
+        this.isConnected = false;
+        this.address = null;
+        if (options.emit && this.isConnectionStatusChanged('disconnected')) {
+            this.emit(types_1.PROVIDER_EVENTS.disconnect);
+            this.emit(types_1.PROVIDER_EVENTS.accountChanged, '');
+        }
+    }
+    _handleAccountChange(address) {
+        this.emit(types_1.PROVIDER_EVENTS.accountChanged, address);
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    enable(opts) {
+        return this.request({ method: 'algo_enable', params: opts });
+    }
+    signTxns(transactions) {
+        return this.request({ method: 'algo_signTxns', params: transactions });
+    }
+    postTxns(transactions) {
+        return this.request({ method: 'algo_postTxns', params: transactions });
+    }
+    signAndPostTxns(transactions) {
+        return this.request({ method: 'algo_signAndPostTxns', params: transactions });
+    }
+    getAlgodv2Client() {
+        return this.request({ method: 'algo_getAlgodv2Client' });
+    }
+    getIndexerClient() {
+        return this.request({ method: 'algo_getIndexerClient' });
+    }
+    // legacy
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const addresses = yield this.request({ method: 'algo_requestAccounts' });
+            const address = addresses[0];
+            this._handleConnected({ address });
+            return { address };
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.request({ method: 'algo_disconnect' });
+            this._handleDisconnected();
+        });
+    }
+    signAndSendTransaction(transactions) {
+        return this.request({
+            method: 'algo_signAndSendTransaction',
+            params: transactions,
+        });
+    }
+    signTransaction(transactions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.request({
+                method: 'algo_signTransaction',
+                params: transactions,
+            });
+            const rawTxs = result.split(',').map((tx) => Uint8Array.from(Buffer.from(tx, 'base64')));
+            return rawTxs;
+        });
+    }
+    signMessage(encodedMessage, display) {
+        return this.request({
+            method: 'algo_signMessage',
+            params: { encodedMessage, display },
+        });
+    }
+}
+exports.ProviderAlgo = ProviderAlgo;

package/dist/cjs/ProviderAlgoBase.js

@@ -0,0 +1,26 @@
+"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.ProviderAlgoBase = 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 ProviderAlgoBase extends cross_inpage_provider_core_1.ProviderBase {
+    constructor(props) {
+        super(props);
+        this.providerName = cross_inpage_provider_types_1.IInjectedProviderNames.algo;
+    }
+    request(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.bridgeRequest(data));
+        });
+    }
+}
+exports.ProviderAlgoBase = ProviderAlgoBase;

package/dist/cjs/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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("./ProviderAlgo"), exports);
+__exportStar(require("./ProviderAlgoBase"), exports);
+__exportStar(require("./types"), exports);

package/dist/cjs/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_EVENTS = void 0;
+exports.PROVIDER_EVENTS = {
+    'connect': 'connect',
+    'disconnect': 'disconnect',
+    'accountChanged': 'accountChanged',
+    'message_low_level': 'message_low_level',
+};

package/dist/cjs/utils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWalletEventMethodMatch = void 0;
+function isWalletEventMethodMatch(method, name) {
+    return method === `metamask_${name}` || method === `wallet_events_${name}`;
+}
+exports.isWalletEventMethodMatch = isWalletEventMethodMatch;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ProviderAlgo';
+export * from './ProviderAlgoBase';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './ProviderAlgo';
+export * from './ProviderAlgoBase';
+export * from './types';

package/dist/types.d.ts

@@ -0,0 +1,87 @@
+import { IJsonRpcRequest } from '@onekeyfe/cross-inpage-provider-types';
+export interface EnableNetworkOpts {
+    genesisID?: string;
+    genesisHash?: string;
+}
+export interface EnableAccountsOpts {
+    accounts?: string[];
+}
+export declare type EnableOpts = EnableNetworkOpts & EnableAccountsOpts;
+export interface EnableNetworkResult {
+    genesisID: string;
+    genesisHash: string;
+}
+export interface EnableAccountsResult {
+    accounts: string[];
+}
+export declare type EnableResult = EnableNetworkResult & EnableAccountsResult;
+export declare type SignTxnsResult = (string | null)[];
+export interface WalletTransaction {
+    txn: string;
+    authAddr?: string;
+    signers?: string[];
+    stxn?: string;
+}
+export interface PostTxnsResult {
+    txnIDs: string[];
+}
+export declare type Query<F> = {
+    format?: F;
+    [key: string]: any;
+};
+export interface BaseHTTPClientResponse {
+    body: Uint8Array;
+    status: number;
+    headers: Record<string, string>;
+}
+export interface BaseHTTPClientError {
+    response: BaseHTTPClientResponse;
+}
+export interface BaseHTTPClient {
+    get(relativePath: string, query?: Query<string>, requestHeaders?: Record<string, string>): Promise<BaseHTTPClientResponse>;
+    post(relativePath: string, data: Uint8Array, query?: Query<string>, requestHeaders?: Record<string, string>): Promise<BaseHTTPClientResponse>;
+    delete(relativePath: string, data: Uint8Array, query?: Query<string>, requestHeaders?: Record<string, string>): Promise<BaseHTTPClientResponse>;
+}
+interface ConnectionOptions {
+    onlyIfTrusted?: boolean;
+}
+export declare type ConnectInfo = {
+    address: string;
+};
+export interface TransactionResult {
+    txId: string;
+}
+export declare type DisplayEncoding = 'utf8' | 'hex';
+export interface IProviderAlgo {
+    isConnected: boolean;
+    isExodus: boolean;
+    isOneKey: boolean;
+    address: string | null;
+    enable(opts?: EnableOpts): Promise<EnableResult>;
+    signTxns(transactions: WalletTransaction[]): Promise<SignTxnsResult>;
+    postTxns(transactions: string[]): Promise<PostTxnsResult>;
+    signAndPostTxns(transactions: WalletTransaction[]): Promise<PostTxnsResult>;
+    getAlgodv2Client(): Promise<BaseHTTPClient>;
+    getIndexerClient(): Promise<BaseHTTPClient>;
+    connect(options?: ConnectionOptions): Promise<ConnectInfo>;
+    disconnect(): void;
+    signAndSendTransaction(transactions: Uint8Array[]): Promise<TransactionResult>;
+    signTransaction(transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    signMessage(encodedMessage: Uint8Array, display?: DisplayEncoding): Promise<{
+        signature: Uint8Array;
+        address: string;
+    }>;
+}
+export declare const PROVIDER_EVENTS: {
+    readonly connect: "connect";
+    readonly disconnect: "disconnect";
+    readonly accountChanged: "accountChanged";
+    readonly message_low_level: "message_low_level";
+};
+export declare type AlgoProviderEventsMap = {
+    [PROVIDER_EVENTS.connect]: (connectInfo: ConnectInfo) => void;
+    [PROVIDER_EVENTS.disconnect]: () => void;
+    [PROVIDER_EVENTS.accountChanged]: (address: string) => void;
+    [PROVIDER_EVENTS.message_low_level]: (payload: IJsonRpcRequest) => void;
+};
+export {};

package/dist/types.js

@@ -0,0 +1,6 @@
+export const PROVIDER_EVENTS = {
+    'connect': 'connect',
+    'disconnect': 'disconnect',
+    'accountChanged': 'accountChanged',
+    'message_low_level': 'message_low_level',
+};

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export declare function isWalletEventMethodMatch(method: string, name: string): boolean;

package/dist/utils.js

@@ -0,0 +1,3 @@
+export function isWalletEventMethodMatch(method, name) {
+    return method === `metamask_${name}` || method === `wallet_events_${name}`;
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@onekeyfe/onekey-algo-provider",
+  "version": "2.0.0-alpha.7",
+  "keywords": [
+    "cross-inpage-provider"
+  ],
+  "author": "dev-fe@onekey.so",
+  "repository": "https://github.com/OneKeyHQ/cross-inpage-provider",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "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.0.0-alpha.7",
+    "@onekeyfe/cross-inpage-provider-errors": "2.0.0-alpha.7",
+    "@onekeyfe/cross-inpage-provider-types": "2.0.0-alpha.7",
+    "@onekeyfe/extension-bridge-injected": "2.0.0-alpha.7"
+  },
+  "gitHead": "365f8bcf8ae4b5a66409fcf2f5d17cc07a0aba2c"
+}