@ksangkuk10/wallet-controller 1.7.14

package/modules/extension-router/types.d.ts

@@ -0,0 +1,35 @@
+import { XplaWebExtensionFeatures, WebExtensionNetworkInfo, WebExtensionWalletInfo } from '@ksangkuk10/web-extension-interface';
+import { ExtensionInfo } from './multiChannel';
+export declare enum ExtensionRouterConnectorType {
+    LEGACY = "LEGACY",
+    WEB_EXTENSION = "WEB_EXTENSION"
+}
+export declare enum ExtensionRouterStatus {
+    INITIALIZING = "INITIALIZING",
+    NO_AVAILABLE = "NO_AVAILABLE",
+    WALLET_NOT_CONNECTED = "WALLET_NOT_CONNECTED",
+    WALLET_CONNECTED = "WALLET_CONNECTED"
+}
+export interface ExtensionRouterInitializing {
+    type: ExtensionRouterStatus.INITIALIZING;
+    network: WebExtensionNetworkInfo;
+}
+export interface ExtensionRouterNoAvailable {
+    type: ExtensionRouterStatus.NO_AVAILABLE;
+    network: WebExtensionNetworkInfo;
+    isConnectorExists: boolean;
+    isApproved?: boolean;
+}
+export interface ExtensionRouterWalletNotConnected {
+    type: ExtensionRouterStatus.WALLET_NOT_CONNECTED;
+    network: WebExtensionNetworkInfo;
+}
+export interface ExtensionRouterWalletConnected {
+    type: ExtensionRouterStatus.WALLET_CONNECTED;
+    network: WebExtensionNetworkInfo;
+    wallet: WebExtensionWalletInfo;
+    connectorType: ExtensionRouterConnectorType;
+    supportFeatures: Set<XplaWebExtensionFeatures>;
+    extensionInfo: ExtensionInfo;
+}
+export type ExtensionRouterStates = ExtensionRouterInitializing | ExtensionRouterNoAvailable | ExtensionRouterWalletNotConnected | ExtensionRouterWalletConnected;

package/modules/extension-router/types.js

@@ -0,0 +1,13 @@
+export var ExtensionRouterConnectorType;
+(function (ExtensionRouterConnectorType) {
+    ExtensionRouterConnectorType["LEGACY"] = "LEGACY";
+    ExtensionRouterConnectorType["WEB_EXTENSION"] = "WEB_EXTENSION";
+})(ExtensionRouterConnectorType || (ExtensionRouterConnectorType = {}));
+export var ExtensionRouterStatus;
+(function (ExtensionRouterStatus) {
+    ExtensionRouterStatus["INITIALIZING"] = "INITIALIZING";
+    ExtensionRouterStatus["NO_AVAILABLE"] = "NO_AVAILABLE";
+    ExtensionRouterStatus["WALLET_NOT_CONNECTED"] = "WALLET_NOT_CONNECTED";
+    ExtensionRouterStatus["WALLET_CONNECTED"] = "WALLET_CONNECTED";
+})(ExtensionRouterStatus || (ExtensionRouterStatus = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/modules/legacy-extension/LegacyExtensionConnector.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { XplaWebExtensionConnector, XplaWebExtensionFeatures, WebExtensionPostPayload, WebExtensionSignBytesPayload, WebExtensionSignPayload, WebExtensionStates, WebExtensionTxResult } from '@ksangkuk10/web-extension-interface';
+import { CreateTxOptions, SignMode } from '@xpla/xpla.js';
+import { Observer, Subscribable } from 'rxjs';
+export declare class LegacyExtensionConnector implements XplaWebExtensionConnector {
+    private identifier;
+    private _states;
+    private _extension;
+    private hostWindow;
+    private statesSubscription;
+    supportFeatures(): XplaWebExtensionFeatures[];
+    constructor(identifier: string);
+    open: (hostWindow: Window, statesObserver: Observer<WebExtensionStates>) => void;
+    close: () => void;
+    requestApproval: () => void;
+    refetchStates: () => void;
+    post: (xplaAddress: string, tx: CreateTxOptions) => Subscribable<WebExtensionTxResult<WebExtensionPostPayload>>;
+    sign: (xplaAddress: string, tx: CreateTxOptions & {
+        sequence?: number;
+        accountNumber?: number;
+        signMode?: SignMode;
+    }) => Subscribable<WebExtensionTxResult<WebExtensionSignPayload>>;
+    signBytes: (xplaAddress: string, bytes: Buffer) => Subscribable<WebExtensionTxResult<WebExtensionSignBytesPayload>>;
+    hasCW20Tokens: () => never;
+    addCW20Tokens: () => never;
+    hasNetwork: () => never;
+    addNetwork: () => never;
+    recheckStates: () => Promise<void>;
+}

package/modules/legacy-extension/LegacyExtensionConnector.js

@@ -0,0 +1,139 @@
+import { WebExtensionStatus, WebExtensionTxStatus, } from '@ksangkuk10/web-extension-interface';
+import { AccAddress } from '@xpla/xpla.js';
+import { BehaviorSubject } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import { createFixedExtension } from './createFixedExtension';
+const supportFeatures = [
+    'post',
+    'sign',
+    'sign-bytes',
+];
+export class LegacyExtensionConnector {
+    supportFeatures() {
+        return supportFeatures;
+    }
+    constructor(identifier) {
+        this.identifier = identifier;
+        this.hostWindow = null;
+        this.statesSubscription = null;
+        this.open = (hostWindow, statesObserver) => {
+            this.hostWindow = hostWindow;
+            this.statesSubscription = this._states
+                .pipe(filter((states) => !!states))
+                .subscribe(statesObserver);
+            this.refetchStates();
+        };
+        this.close = () => {
+            this._extension.disconnect();
+        };
+        this.requestApproval = () => {
+            this.recheckStates();
+        };
+        this.refetchStates = () => {
+            this.recheckStates();
+        };
+        this.post = (xplaAddress, tx) => {
+            const subject = new BehaviorSubject({
+                status: WebExtensionTxStatus.PROGRESS,
+            });
+            this._extension
+                .post(tx)
+                .then(({ payload }) => {
+                subject.next({
+                    status: WebExtensionTxStatus.SUCCEED,
+                    payload: payload.result,
+                });
+                subject.complete();
+            })
+                .catch((error) => subject.error(error));
+            return subject.asObservable();
+        };
+        this.sign = (xplaAddress, tx) => {
+            const subject = new BehaviorSubject({
+                status: WebExtensionTxStatus.PROGRESS,
+            });
+            this._extension
+                .sign(tx)
+                .then(({ payload }) => {
+                subject.next({
+                    status: WebExtensionTxStatus.SUCCEED,
+                    payload: payload.result,
+                });
+                subject.complete();
+            })
+                .catch((error) => subject.error(error));
+            return subject.asObservable();
+        };
+        this.signBytes = (xplaAddress, bytes) => {
+            const subject = new BehaviorSubject({
+                status: WebExtensionTxStatus.PROGRESS,
+            });
+            this._extension
+                .signBytes(bytes)
+                .then(({ payload }) => {
+                subject.next({
+                    status: WebExtensionTxStatus.SUCCEED,
+                    payload: {
+                        recid: payload.result.recid,
+                        signature: payload.result.signature,
+                        public_key: {
+                            '@type': '/cosmos.crypto.secp256k1.PubKey',
+                            'key': payload.result.public_key,
+                        },
+                    },
+                });
+            })
+                .catch((error) => subject.error(error));
+            return subject.asObservable();
+        };
+        this.hasCW20Tokens = () => {
+            throw new Error('[LegacyExtensionConnector] does not support hasCW20Tokens()');
+        };
+        this.addCW20Tokens = () => {
+            throw new Error('[LegacyExtensionConnector] does not support addCW20Tokens()');
+        };
+        this.hasNetwork = () => {
+            throw new Error('[LegacyExtensionConnector] does not support hasNetwork()');
+        };
+        this.addNetwork = () => {
+            throw new Error('[LegacyExtensionConnector] does not support addNetwork()');
+        };
+        // ---------------------------------------------
+        // internal
+        // ---------------------------------------------
+        this.recheckStates = async () => {
+            if (this._extension.inTransactionProgress()) {
+                return;
+            }
+            const infoResult = await this._extension.info();
+            const connectResult = await this._extension.connect();
+            if (connectResult.address && AccAddress.validate(connectResult.address)) {
+                this._states.next({
+                    type: WebExtensionStatus.READY,
+                    network: infoResult,
+                    focusedWalletAddress: connectResult.address,
+                    wallets: [
+                        {
+                            name: '',
+                            xplaAddress: connectResult.address,
+                            design: 'xpla',
+                        },
+                    ],
+                });
+            }
+            else {
+                this._states.next({
+                    type: WebExtensionStatus.READY,
+                    network: infoResult,
+                    focusedWalletAddress: undefined,
+                    wallets: [],
+                });
+            }
+        };
+        this._states = new BehaviorSubject({
+            type: WebExtensionStatus.INITIALIZING,
+        });
+        this._extension = createFixedExtension(identifier);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"LegacyExtensionConnector.js","sourceRoot":"","sources":["../../../../../src/@ksangkuk10/wallet-controller/modules/legacy-extension/LegacyExtensionConnector.ts"],"names":[],"mappings":"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","sourcesContent":["import { NetworkInfo } from '@ksangkuk10/wallet-types';\nimport {\n  XplaWebExtensionConnector,\n  XplaWebExtensionFeatures,\n  WebExtensionPostPayload,\n  WebExtensionSignBytesPayload,\n  WebExtensionSignPayload,\n  WebExtensionStates,\n  WebExtensionStatus,\n  WebExtensionTxResult,\n  WebExtensionTxStatus,\n} from '@ksangkuk10/web-extension-interface';\nimport { AccAddress, CreateTxOptions, SignMode } from '@xpla/xpla.js';\nimport { BehaviorSubject, Observer, Subscribable, Subscription } from 'rxjs';\nimport { filter } from 'rxjs/operators';\nimport { createFixedExtension, FixedExtension } from './createFixedExtension';\n\nconst supportFeatures: XplaWebExtensionFeatures[] = [\n  'post',\n  'sign',\n  'sign-bytes',\n];\n\nexport class LegacyExtensionConnector implements XplaWebExtensionConnector {\n  private _states: BehaviorSubject<WebExtensionStates>;\n  private _extension: FixedExtension;\n  private hostWindow: Window | null = null;\n  private statesSubscription: Subscription | null = null;\n\n  supportFeatures() {\n    return supportFeatures;\n  }\n\n  constructor(private identifier: string) {\n    this._states = new BehaviorSubject<WebExtensionStates>({\n      type: WebExtensionStatus.INITIALIZING,\n    });\n\n    this._extension = createFixedExtension(identifier);\n  }\n\n  open = (hostWindow: Window, statesObserver: Observer<WebExtensionStates>) => {\n    this.hostWindow = hostWindow;\n    this.statesSubscription = this._states\n      .pipe(\n        filter(\n          (states: WebExtensionStates | null): states is WebExtensionStates =>\n            !!states,\n        ),\n      )\n      .subscribe(statesObserver);\n\n    this.refetchStates();\n  };\n\n  close = () => {\n    this._extension.disconnect();\n  };\n\n  requestApproval = () => {\n    this.recheckStates();\n  };\n\n  refetchStates = () => {\n    this.recheckStates();\n  };\n\n  post = (\n    xplaAddress: string,\n    tx: CreateTxOptions,\n  ): Subscribable<WebExtensionTxResult<WebExtensionPostPayload>> => {\n    const subject = new BehaviorSubject<\n      WebExtensionTxResult<WebExtensionPostPayload>\n    >({\n      status: WebExtensionTxStatus.PROGRESS,\n    });\n\n    this._extension\n      .post(tx)\n      .then(({ payload }) => {\n        subject.next({\n          status: WebExtensionTxStatus.SUCCEED,\n          payload: payload.result,\n        });\n        subject.complete();\n      })\n      .catch((error) => subject.error(error));\n\n    return subject.asObservable();\n  };\n\n  sign = (\n    xplaAddress: string,\n    tx: CreateTxOptions & {\n      sequence?: number;\n      accountNumber?: number;\n      signMode?: SignMode;\n    },\n  ): Subscribable<WebExtensionTxResult<WebExtensionSignPayload>> => {\n    const subject = new BehaviorSubject<\n      WebExtensionTxResult<WebExtensionSignPayload>\n    >({\n      status: WebExtensionTxStatus.PROGRESS,\n    });\n\n    this._extension\n      .sign(tx)\n      .then(({ payload }) => {\n        subject.next({\n          status: WebExtensionTxStatus.SUCCEED,\n          payload: payload.result,\n        });\n        subject.complete();\n      })\n      .catch((error) => subject.error(error));\n\n    return subject.asObservable();\n  };\n\n  signBytes = (\n    xplaAddress: string,\n    bytes: Buffer,\n  ): Subscribable<WebExtensionTxResult<WebExtensionSignBytesPayload>> => {\n    const subject = new BehaviorSubject<\n      WebExtensionTxResult<WebExtensionSignBytesPayload>\n    >({\n      status: WebExtensionTxStatus.PROGRESS,\n    });\n\n    this._extension\n      .signBytes(bytes)\n      .then(({ payload }) => {\n        subject.next({\n          status: WebExtensionTxStatus.SUCCEED,\n          payload: {\n            recid: payload.result.recid,\n            signature: payload.result.signature,\n            public_key: {\n              '@type': '/cosmos.crypto.secp256k1.PubKey',\n              'key': payload.result.public_key,\n            },\n          },\n        });\n      })\n      .catch((error) => subject.error(error));\n\n    return subject.asObservable();\n  };\n\n  hasCW20Tokens = () => {\n    throw new Error(\n      '[LegacyExtensionConnector] does not support hasCW20Tokens()',\n    );\n  };\n\n  addCW20Tokens = () => {\n    throw new Error(\n      '[LegacyExtensionConnector] does not support addCW20Tokens()',\n    );\n  };\n\n  hasNetwork = () => {\n    throw new Error('[LegacyExtensionConnector] does not support hasNetwork()');\n  };\n\n  addNetwork = () => {\n    throw new Error('[LegacyExtensionConnector] does not support addNetwork()');\n  };\n\n  // ---------------------------------------------\n  // internal\n  // ---------------------------------------------\n  recheckStates = async () => {\n    if (this._extension.inTransactionProgress()) {\n      return;\n    }\n\n    const infoResult: NetworkInfo = await this._extension.info();\n    const connectResult: { address?: string } = await this._extension.connect();\n\n    if (connectResult.address && AccAddress.validate(connectResult.address)) {\n      this._states.next({\n        type: WebExtensionStatus.READY,\n        network: infoResult,\n        focusedWalletAddress: connectResult.address,\n        wallets: [\n          {\n            name: '',\n            xplaAddress: connectResult.address,\n            design: 'xpla',\n          },\n        ],\n      });\n    } else {\n      this._states.next({\n        type: WebExtensionStatus.READY,\n        network: infoResult,\n        focusedWalletAddress: undefined,\n        wallets: [],\n      });\n    }\n  };\n}\n"]}

package/modules/legacy-extension/createFixedExtension.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { NetworkInfo } from '@ksangkuk10/wallet-types';
+import { CreateTxOptions, SignMode, Tx } from '@xpla/xpla.js';
+type ConnectResponse = {
+    address?: string;
+};
+type PostResponse = {
+    payload: {
+        result: {
+            height: number;
+            raw_log: string;
+            txhash: string;
+        };
+    };
+};
+type SignResponse = {
+    payload: {
+        result: Tx.Data;
+    };
+};
+type SignBytesResponse = {
+    payload: {
+        result: {
+            public_key: string;
+            recid: number;
+            signature: string;
+        };
+    };
+};
+type InfoResponse = NetworkInfo;
+export interface FixedExtension {
+    post: (data: CreateTxOptions) => Promise<PostResponse>;
+    sign: (data: CreateTxOptions & {
+        sequence?: number;
+        accountNumber?: number;
+        signMode?: SignMode;
+    }) => Promise<SignResponse>;
+    signBytes: (bytes: Buffer) => Promise<SignBytesResponse>;
+    info: () => Promise<InfoResponse>;
+    connect: () => Promise<ConnectResponse>;
+    inTransactionProgress: () => boolean;
+    disconnect: () => void;
+}
+export declare function createFixedExtension(identifier: string): FixedExtension;
+export {};

package/modules/legacy-extension/createFixedExtension.js

@@ -0,0 +1,232 @@
+import { WebExtensionCreateTxFailed, WebExtensionTxFailed, WebExtensionTxUnspecifiedError, WebExtensionUserDenied, } from '@ksangkuk10/web-extension-interface';
+import { Extension } from '@xpla/xpla.js';
+function getErrorMessage(error) {
+    try {
+        if (typeof error.message === 'string') {
+            return error.message;
+        }
+        else {
+            return JSON.stringify(error);
+        }
+    }
+    catch (_a) {
+        return String(error);
+    }
+}
+function toExplicitError(error) {
+    if (error && 'code' in error) {
+        switch (error.code) {
+            // @see https://github.com/terra-project/station/blob/main/src/extension/Confirm.tsx#L182
+            case 1:
+                return new WebExtensionUserDenied();
+            // @see https://github.com/terra-project/station/blob/main/src/extension/Confirm.tsx#L137
+            case 2:
+                if (error.data) {
+                    const { txhash } = error.data;
+                    return new WebExtensionTxFailed(txhash, getErrorMessage(error), null);
+                }
+                else {
+                    return new WebExtensionTxFailed(undefined, getErrorMessage(error), null);
+                }
+            // @see https://github.com/terra-project/station/blob/main/src/extension/Confirm.tsx#L153
+            case 3:
+                return new WebExtensionCreateTxFailed(getErrorMessage(error));
+            default:
+                return new WebExtensionTxUnspecifiedError(getErrorMessage(error));
+        }
+    }
+    else {
+        return new WebExtensionTxUnspecifiedError(getErrorMessage(error));
+    }
+}
+function isValidResult({ error, ...payload }) {
+    if (typeof payload.success !== 'boolean') {
+        return false;
+    }
+    else if (typeof payload.result === 'undefined' &&
+        typeof error === 'undefined') {
+        return false;
+    }
+    return true;
+}
+const pool = new Map();
+export function createFixedExtension(identifier) {
+    if (pool.has(identifier)) {
+        return pool.get(identifier);
+    }
+    const extension = new Extension(identifier);
+    let _inTransactionProgress = false;
+    const postResolvers = new Map();
+    const signResolvers = new Map();
+    const signBytesResolvers = new Map();
+    const infoResolvers = new Set();
+    const connectResolvers = new Set();
+    extension.on('onPost', (result) => {
+        if (!result || !isValidResult(result)) {
+            return;
+        }
+        const { error, ...payload } = result;
+        if (!postResolvers.has(payload.id)) {
+            return;
+        }
+        const [resolve, reject] = postResolvers.get(payload.id);
+        if (!payload.success) {
+            reject(toExplicitError(error));
+        }
+        else if (resolve) {
+            resolve({ name: 'onPost', payload });
+        }
+        postResolvers.delete(payload.id);
+        if (postResolvers.size === 0) {
+            _inTransactionProgress = false;
+        }
+    });
+    extension.on('onSign', (result) => {
+        if (!result || !isValidResult(result)) {
+            return;
+        }
+        const { error, ...payload } = result;
+        if (signResolvers.has(payload.id)) {
+            const [resolve, reject] = signResolvers.get(payload.id);
+            if (!payload.success) {
+                reject(toExplicitError(error));
+            }
+            else if (resolve) {
+                resolve({ name: 'onSign', payload });
+            }
+            signResolvers.delete(payload.id);
+            if (signResolvers.size === 0) {
+                _inTransactionProgress = false;
+            }
+        }
+        else if (signBytesResolvers.has(payload.id)) {
+            const [resolve, reject] = signBytesResolvers.get(payload.id);
+            if (!payload.success) {
+                reject(toExplicitError(error));
+            }
+            else if (resolve) {
+                resolve({ name: 'onSignBytes', payload });
+            }
+            signBytesResolvers.delete(payload.id);
+            if (signBytesResolvers.size === 0) {
+                _inTransactionProgress = false;
+            }
+        }
+    });
+    extension.on('onInfo', (result) => {
+        if (!result)
+            return;
+        const { error, ...payload } = result;
+        for (const [resolve, reject] of infoResolvers) {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(payload);
+            }
+        }
+        infoResolvers.clear();
+    });
+    extension.on('onConnect', (result) => {
+        if (!result)
+            return;
+        const { error, ...payload } = result;
+        for (const [resolve, reject] of connectResolvers) {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(payload);
+            }
+        }
+        connectResolvers.clear();
+    });
+    function post(data) {
+        return new Promise((...resolver) => {
+            _inTransactionProgress = true;
+            const id = extension.post({
+                ...data,
+                purgeQueue: true,
+            });
+            postResolvers.set(id, resolver);
+            setTimeout(() => {
+                if (postResolvers.has(id)) {
+                    postResolvers.delete(id);
+                    if (postResolvers.size === 0) {
+                        _inTransactionProgress = false;
+                    }
+                }
+            }, 1000 * 120);
+        });
+    }
+    function sign(data) {
+        return new Promise((...resolver) => {
+            _inTransactionProgress = true;
+            const id = extension.sign({
+                ...data,
+                purgeQueue: true,
+            });
+            signResolvers.set(id, resolver);
+            setTimeout(() => {
+                if (signResolvers.has(id)) {
+                    signResolvers.delete(id);
+                    if (signResolvers.size === 0) {
+                        _inTransactionProgress = false;
+                    }
+                }
+            }, 1000 * 120);
+        });
+    }
+    function signBytes(bytes) {
+        return new Promise((...resolver) => {
+            _inTransactionProgress = true;
+            const id = extension.signBytes({
+                bytes,
+                purgeQueue: true,
+            });
+            signBytesResolvers.set(id, resolver);
+            setTimeout(() => {
+                if (signBytesResolvers.has(id)) {
+                    signBytesResolvers.delete(id);
+                    if (signBytesResolvers.size === 0) {
+                        _inTransactionProgress = false;
+                    }
+                }
+            }, 1000 * 120);
+        });
+    }
+    function connect() {
+        return new Promise((...resolver) => {
+            connectResolvers.add(resolver);
+            extension.connect();
+        });
+    }
+    function info() {
+        return new Promise((...resolver) => {
+            infoResolvers.add(resolver);
+            extension.info();
+        });
+    }
+    function disconnect() {
+        connectResolvers.clear();
+        infoResolvers.clear();
+        postResolvers.clear();
+        signResolvers.clear();
+        signBytesResolvers.clear();
+    }
+    function inTransactionProgress() {
+        return _inTransactionProgress;
+    }
+    const result = {
+        post,
+        sign,
+        signBytes,
+        connect,
+        info,
+        disconnect,
+        inTransactionProgress,
+    };
+    pool.set(identifier, result);
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"createFixedExtension.js","sourceRoot":"","sources":["../../../../../src/@ksangkuk10/wallet-controller/modules/legacy-extension/createFixedExtension.ts"],"names":[],"mappings":"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","sourcesContent":["import { NetworkInfo } from '@ksangkuk10/wallet-types';\nimport {\n  WebExtensionCreateTxFailed,\n  WebExtensionTxFailed,\n  WebExtensionTxUnspecifiedError,\n  WebExtensionUserDenied,\n} from '@ksangkuk10/web-extension-interface';\nimport { CreateTxOptions, Extension, SignMode, Tx } from '@xpla/xpla.js';\n\ntype ConnectResponse = { address?: string };\ntype PostResponse = {\n  payload: {\n    result: {\n      height: number;\n      raw_log: string;\n      txhash: string;\n    };\n  };\n};\ntype SignResponse = {\n  payload: {\n    result: Tx.Data;\n  };\n};\ntype SignBytesResponse = {\n  payload: {\n    result: {\n      public_key: string;\n      recid: number;\n      signature: string;\n    };\n  };\n};\ntype InfoResponse = NetworkInfo;\n\nexport interface FixedExtension {\n  post: (data: CreateTxOptions) => Promise<PostResponse>;\n  sign: (\n    data: CreateTxOptions & {\n      sequence?: number;\n      accountNumber?: number;\n      signMode?: SignMode;\n    }\n  ) => Promise<SignResponse>;\n  signBytes: (bytes: Buffer) => Promise<SignBytesResponse>;\n  info: () => Promise<InfoResponse>;\n  connect: () => Promise<ConnectResponse>;\n  inTransactionProgress: () => boolean;\n  disconnect: () => void;\n}\n\nfunction getErrorMessage(error: any): string {\n  try {\n    if (typeof error.message === 'string') {\n      return error.message;\n    } else {\n      return JSON.stringify(error);\n    }\n  } catch {\n    return String(error);\n  }\n}\n\nfunction toExplicitError(error: any) {\n  if (error && 'code' in error) {\n    switch (error.code) {\n      // @see https://github.com/terra-project/station/blob/main/src/extension/Confirm.tsx#L182\n      case 1:\n        return new WebExtensionUserDenied();\n      // @see https://github.com/terra-project/station/blob/main/src/extension/Confirm.tsx#L137\n      case 2:\n        if (error.data) {\n          const { txhash } = error.data;\n          return new WebExtensionTxFailed(txhash, getErrorMessage(error), null);\n        } else {\n          return new WebExtensionTxFailed(\n            undefined,\n            getErrorMessage(error),\n            null,\n          );\n        }\n      // @see https://github.com/terra-project/station/blob/main/src/extension/Confirm.tsx#L153\n      case 3:\n        return new WebExtensionCreateTxFailed(getErrorMessage(error));\n      default:\n        return new WebExtensionTxUnspecifiedError(getErrorMessage(error));\n    }\n  } else {\n    return new WebExtensionTxUnspecifiedError(getErrorMessage(error));\n  }\n}\n\nfunction isValidResult({ error, ...payload }: any): boolean {\n  if (typeof payload.success !== 'boolean') {\n    return false;\n  } else if (\n    typeof payload.result === 'undefined' &&\n    typeof error === 'undefined'\n  ) {\n    return false;\n  }\n  return true;\n}\n\nconst pool = new Map<string, FixedExtension>();\n\nexport function createFixedExtension(identifier: string): FixedExtension {\n  if (pool.has(identifier)) {\n    return pool.get(identifier)!;\n  }\n\n  const extension = new Extension(identifier);\n\n  let _inTransactionProgress = false;\n\n  const postResolvers = new Map<\n    number,\n    [(data: any) => void, (error: any) => void]\n  >();\n\n  const signResolvers = new Map<\n    number,\n    [(data: any) => void, (error: any) => void]\n  >();\n\n  const signBytesResolvers = new Map<\n    number,\n    [(data: any) => void, (error: any) => void]\n  >();\n\n  const infoResolvers = new Set<[(data: any) => void, (error: any) => void]>();\n\n  const connectResolvers = new Set<\n    [(data: any) => void, (error: any) => void]\n  >();\n\n  extension.on('onPost', (result) => {\n    if (!result || !isValidResult(result)) {\n      return;\n    }\n\n    const { error, ...payload } = result;\n\n    if (!postResolvers.has(payload.id)) {\n      return;\n    }\n\n    const [resolve, reject] = postResolvers.get(payload.id)!;\n\n    if (!payload.success) {\n      reject(toExplicitError(error));\n    } else if (resolve) {\n      resolve({ name: 'onPost', payload });\n    }\n\n    postResolvers.delete(payload.id);\n\n    if (postResolvers.size === 0) {\n      _inTransactionProgress = false;\n    }\n  });\n\n  extension.on('onSign', (result) => {\n    if (!result || !isValidResult(result)) {\n      return;\n    }\n\n    const { error, ...payload } = result;\n\n    if (signResolvers.has(payload.id)) {\n      const [resolve, reject] = signResolvers.get(payload.id)!;\n\n      if (!payload.success) {\n        reject(toExplicitError(error));\n      } else if (resolve) {\n        resolve({ name: 'onSign', payload });\n      }\n\n      signResolvers.delete(payload.id);\n\n      if (signResolvers.size === 0) {\n        _inTransactionProgress = false;\n      }\n    } else if (signBytesResolvers.has(payload.id)) {\n      const [resolve, reject] = signBytesResolvers.get(payload.id)!;\n\n      if (!payload.success) {\n        reject(toExplicitError(error));\n      } else if (resolve) {\n        resolve({ name: 'onSignBytes', payload });\n      }\n\n      signBytesResolvers.delete(payload.id);\n\n      if (signBytesResolvers.size === 0) {\n        _inTransactionProgress = false;\n      }\n    }\n  });\n\n  extension.on('onInfo', (result) => {\n    if (!result) return;\n    const { error, ...payload } = result;\n\n    for (const [resolve, reject] of infoResolvers) {\n      if (error) {\n        reject(error);\n      } else {\n        resolve(payload);\n      }\n    }\n\n    infoResolvers.clear();\n  });\n\n  extension.on('onConnect', (result) => {\n    if (!result) return;\n    const { error, ...payload } = result;\n\n    for (const [resolve, reject] of connectResolvers) {\n      if (error) {\n        reject(error);\n      } else {\n        resolve(payload);\n      }\n    }\n\n    connectResolvers.clear();\n  });\n\n  function post(data: object) {\n    return new Promise<PostResponse>((...resolver) => {\n      _inTransactionProgress = true;\n\n      const id = extension.post({\n        ...(data as any),\n        purgeQueue: true,\n      });\n\n      postResolvers.set(id, resolver);\n\n      setTimeout(() => {\n        if (postResolvers.has(id)) {\n          postResolvers.delete(id);\n\n          if (postResolvers.size === 0) {\n            _inTransactionProgress = false;\n          }\n        }\n      }, 1000 * 120);\n    });\n  }\n\n  function sign(data: object) {\n    return new Promise<SignResponse>((...resolver) => {\n      _inTransactionProgress = true;\n\n      const id = extension.sign({\n        ...(data as any),\n        purgeQueue: true,\n      });\n\n      signResolvers.set(id, resolver);\n\n      setTimeout(() => {\n        if (signResolvers.has(id)) {\n          signResolvers.delete(id);\n\n          if (signResolvers.size === 0) {\n            _inTransactionProgress = false;\n          }\n        }\n      }, 1000 * 120);\n    });\n  }\n\n  function signBytes(bytes: Buffer) {\n    return new Promise<SignBytesResponse>((...resolver) => {\n      _inTransactionProgress = true;\n\n      const id = extension.signBytes({\n        bytes,\n        purgeQueue: true,\n      });\n\n      signBytesResolvers.set(id, resolver);\n\n      setTimeout(() => {\n        if (signBytesResolvers.has(id)) {\n          signBytesResolvers.delete(id);\n\n          if (signBytesResolvers.size === 0) {\n            _inTransactionProgress = false;\n          }\n        }\n      }, 1000 * 120);\n    });\n  }\n\n  function connect() {\n    return new Promise<ConnectResponse>((...resolver) => {\n      connectResolvers.add(resolver);\n      extension.connect();\n    });\n  }\n\n  function info() {\n    return new Promise<InfoResponse>((...resolver) => {\n      infoResolvers.add(resolver);\n      extension.info();\n    });\n  }\n\n  function disconnect() {\n    connectResolvers.clear();\n    infoResolvers.clear();\n    postResolvers.clear();\n    signResolvers.clear();\n    signBytesResolvers.clear();\n  }\n\n  function inTransactionProgress() {\n    return _inTransactionProgress;\n  }\n\n  const result: FixedExtension = {\n    post,\n    sign,\n    signBytes,\n    connect,\n    info,\n    disconnect,\n    inTransactionProgress,\n  };\n\n  pool.set(identifier, result);\n\n  return result;\n}\n"]}

package/modules/legacy-extension/index.d.ts

@@ -0,0 +1,2 @@
+export * from './LegacyExtensionConnector';
+export * from './createFixedExtension';

package/modules/legacy-extension/index.js

@@ -0,0 +1,3 @@
+export * from './LegacyExtensionConnector';
+export * from './createFixedExtension';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvQGtzYW5na3VrMTAvd2FsbGV0LWNvbnRyb2xsZXIvbW9kdWxlcy9sZWdhY3ktZXh0ZW5zaW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vTGVnYWN5RXh0ZW5zaW9uQ29ubmVjdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vY3JlYXRlRml4ZWRFeHRlbnNpb24nO1xuIl19

package/modules/readonly-wallet/connect.d.ts

@@ -0,0 +1,8 @@
+import { ReadonlyWalletSession } from './types';
+export interface ReadonlyWalletController extends ReadonlyWalletSession {
+    disconnect: () => void;
+}
+export interface ReadonlyWalletOptions extends ReadonlyWalletSession {
+}
+export declare function connectIfSessionExists(): ReadonlyWalletController | null;
+export declare function connect(options: ReadonlyWalletOptions): ReadonlyWalletController;

package/modules/readonly-wallet/connect.js

@@ -0,0 +1,19 @@
+import { clearStoredSession, getStoredSession, storeSession } from './storage';
+export function connectIfSessionExists() {
+    const storedSession = getStoredSession();
+    if (!!storedSession) {
+        return connect(storedSession);
+    }
+    return null;
+}
+export function connect(options) {
+    storeSession(options);
+    function disconnect() {
+        clearStoredSession();
+    }
+    return {
+        ...options,
+        disconnect,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9Aa3NhbmdrdWsxMC93YWxsZXQtY29udHJvbGxlci9tb2R1bGVzL3JlYWRvbmx5LXdhbGxldC9jb25uZWN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxnQkFBZ0IsRUFBRSxZQUFZLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFTL0UsTUFBTSxVQUFVLHNCQUFzQjtJQUNwQyxNQUFNLGFBQWEsR0FBRyxnQkFBZ0IsRUFBRSxDQUFDO0lBRXpDLElBQUksQ0FBQyxDQUFDLGFBQWEsRUFBRTtRQUNuQixPQUFPLE9BQU8sQ0FBQyxhQUFhLENBQUMsQ0FBQztLQUMvQjtJQUVELE9BQU8sSUFBSSxDQUFDO0FBQ2QsQ0FBQztBQUVELE1BQU0sVUFBVSxPQUFPLENBQ3JCLE9BQThCO0lBRTlCLFlBQVksQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUV0QixTQUFTLFVBQVU7UUFDakIsa0JBQWtCLEVBQUUsQ0FBQztJQUN2QixDQUFDO0lBRUQsT0FBTztRQUNMLEdBQUcsT0FBTztRQUNWLFVBQVU7S0FDWCxDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGNsZWFyU3RvcmVkU2Vzc2lvbiwgZ2V0U3RvcmVkU2Vzc2lvbiwgc3RvcmVTZXNzaW9uIH0gZnJvbSAnLi9zdG9yYWdlJztcbmltcG9ydCB7IFJlYWRvbmx5V2FsbGV0U2Vzc2lvbiB9IGZyb20gJy4vdHlwZXMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFJlYWRvbmx5V2FsbGV0Q29udHJvbGxlciBleHRlbmRzIFJlYWRvbmx5V2FsbGV0U2Vzc2lvbiB7XG4gIGRpc2Nvbm5lY3Q6ICgpID0+IHZvaWQ7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUmVhZG9ubHlXYWxsZXRPcHRpb25zIGV4dGVuZHMgUmVhZG9ubHlXYWxsZXRTZXNzaW9uIHt9XG5cbmV4cG9ydCBmdW5jdGlvbiBjb25uZWN0SWZTZXNzaW9uRXhpc3RzKCk6IFJlYWRvbmx5V2FsbGV0Q29udHJvbGxlciB8IG51bGwge1xuICBjb25zdCBzdG9yZWRTZXNzaW9uID0gZ2V0U3RvcmVkU2Vzc2lvbigpO1xuXG4gIGlmICghIXN0b3JlZFNlc3Npb24pIHtcbiAgICByZXR1cm4gY29ubmVjdChzdG9yZWRTZXNzaW9uKTtcbiAgfVxuXG4gIHJldHVybiBudWxsO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gY29ubmVjdChcbiAgb3B0aW9uczogUmVhZG9ubHlXYWxsZXRPcHRpb25zLFxuKTogUmVhZG9ubHlXYWxsZXRDb250cm9sbGVyIHtcbiAgc3RvcmVTZXNzaW9uKG9wdGlvbnMpO1xuXG4gIGZ1bmN0aW9uIGRpc2Nvbm5lY3QoKSB7XG4gICAgY2xlYXJTdG9yZWRTZXNzaW9uKCk7XG4gIH1cblxuICByZXR1cm4ge1xuICAgIC4uLm9wdGlvbnMsXG4gICAgZGlzY29ubmVjdCxcbiAgfTtcbn1cbiJdfQ==

package/modules/readonly-wallet/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './connect';
+export * from './modal';

package/modules/readonly-wallet/index.js

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './connect';
+export * from './modal';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvQGtzYW5na3VrMTAvd2FsbGV0LWNvbnRyb2xsZXIvbW9kdWxlcy9yZWFkb25seS13YWxsZXQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbmV4cG9ydCAqIGZyb20gJy4vY29ubmVjdCc7XG5leHBvcnQgKiBmcm9tICcuL21vZGFsJztcbiJdfQ==

package/modules/readonly-wallet/modal.d.ts

@@ -0,0 +1,7 @@
+import { NetworkInfo } from '@ksangkuk10/wallet-types';
+import { ReadonlyWalletSession } from './types';
+interface Options {
+    networks: NetworkInfo[];
+}
+export declare function readonlyWalletModal({ networks, }: Options): Promise<ReadonlyWalletSession | null>;
+export {};