@portkey/socket 0.0.2-alpha.2

package/README.md

@@ -0,0 +1,54 @@
+# `@portkey/socket`
+
+![ES Version](https://img.shields.io/badge/ES-2020-yellow)
+![Node Version](https://img.shields.io/badge/node-14.x-green)
+[![NPM Package Version][npm-image-version]][npm-url]
+
+
+It is already possible to follow [the standard abp tutorial](https://docs.abp.io/en/abp/latest/SignalR-Integration) to add [SignalR](https://docs.abp.io/en/abp/latest/SignalR-Integration) to your application. However, Portkey provides SignalR integration packages those simplify the integration and usage.
+
+
+## Installation
+
+### Using NPM
+
+```bash
+npm install @portkey/socket
+```
+
+### Using Yarn
+
+```bash
+yarn add @portkey/socket
+```
+
+## Prerequisites
+
+- :gear: [NodeJS](https://nodejs.org/) (LTS/Fermium)
+- :toolbox: [Yarn](https://yarnpkg.com/)/[Lerna](https://lerna.js.org/)
+
+## Package.json Scripts
+
+| Script   | Description                                        |
+| -------- | -------------------------------------------------- |
+| clean    | Uses `rm` to remove `dist/`                        |
+| build    | Uses `tsc` to build package and dependent packages |
+| lint     | Uses `eslint` to lint package                      |
+| lint:fix | Uses `eslint` to check and fix any warnings        |
+| format   | Uses `prettier` to format the code                 |
+
+# Basic Usage
+
+```typescript
+import { DIDSignalr } from '@portkey/socket'
+
+// new signalr instance
+const didSignalr = new DIDSignalr();
+// open link
+didSignalr.doOpen({ url: 'your did signalr url', clientId: 'your clientId' });
+// Scan code feedback
+didSignalr.onScanLogin(({ body }) => console.log(body));
+```
+
+[npm-image-version]: https://img.shields.io/npm/v/@portkey/socket
+[npm-url]: https://npmjs.org/package/@portkey/socket

package/dist/commonjs/didSignalr.d.ts

@@ -0,0 +1,16 @@
+import { BaseSignalr } from './signalr';
+import { BaseSocketMessage, ISignalrOptions, CaAccountRecoverResult, CaAccountRegisterResult, DefaultDIDListenListType, IDIDSignalr } from './types';
+export declare class DIDSignalr<T extends DefaultDIDListenListType = DefaultDIDListenListType> extends BaseSignalr<T> implements IDIDSignalr<T> {
+    constructor(options?: ISignalrOptions<T>);
+    Ack(clientId: string, requestId: string): void;
+    onCaAccountRegister({ clientId, requestId }: {
+        clientId: string;
+        requestId: string;
+    }, callback: (data: CaAccountRegisterResult) => void): import("./types").IListen;
+    onCaAccountRecover({ clientId, requestId }: {
+        clientId: string;
+        requestId: string;
+    }, callback: (data: CaAccountRecoverResult) => void): import("./types").IListen;
+    onScanLoginSuccess(callback: (data: BaseSocketMessage) => void): import("./types").IListen;
+    onScanLogin(callback: (data: BaseSocketMessage) => void): import("./types").IListen;
+}

package/dist/commonjs/didSignalr.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DIDSignalr = void 0;
+const signalr_1 = require("./signalr");
+const types_1 = require("./types");
+class DIDSignalr extends signalr_1.BaseSignalr {
+    constructor(options) {
+        const { listenList = types_1.DefaultDIDListenList } = options || {};
+        super({ listenList });
+    }
+    Ack(clientId, requestId) {
+        this.invoke('Ack', clientId, requestId);
+    }
+    onCaAccountRegister({ clientId, requestId }, callback) {
+        return this.listen('caAccountRegister', (data) => {
+            if (data.requestId === requestId) {
+                if (data.body.registerStatus !== 'pending') {
+                    this.Ack(clientId, requestId);
+                }
+                callback(data);
+            }
+        });
+    }
+    onCaAccountRecover({ clientId, requestId }, callback) {
+        return this.listen('caAccountRecover', (data) => {
+            if (data.requestId === requestId) {
+                if (data.body.recoveryStatus !== 'pending') {
+                    this.Ack(clientId, requestId);
+                }
+                callback(data);
+            }
+        });
+    }
+    onScanLoginSuccess(callback) {
+        return this.listen('onScanLoginSuccess', (data) => {
+            if (typeof (data === null || data === void 0 ? void 0 : data.body) === 'string') {
+                callback(data);
+                this.stop();
+            }
+        });
+    }
+    onScanLogin(callback) {
+        return this.listen('onScanLogin', (data) => {
+            if (typeof (data === null || data === void 0 ? void 0 : data.body) === 'string') {
+                callback(data);
+                this.stop();
+            }
+        });
+    }
+}
+exports.DIDSignalr = DIDSignalr;

package/dist/commonjs/index.d.ts

@@ -0,0 +1,4 @@
+export * from './didSignalr';
+export * from './signalr';
+export * from './sellSignalr';
+export * from './types';

package/dist/commonjs/index.js

@@ -0,0 +1,20 @@
+"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("./didSignalr"), exports);
+__exportStar(require("./signalr"), exports);
+__exportStar(require("./sellSignalr"), exports);
+__exportStar(require("./types"), exports);

package/dist/commonjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/dist/commonjs/sellSignalr.d.ts

@@ -0,0 +1,21 @@
+import { BaseSignalr } from './signalr';
+import { AchTxAddressReceivedType, NFTOrderChangedData, RequestOrderTransferredType } from './types/sell';
+export declare class SignalrSell extends BaseSignalr {
+    requestAchTxAddress(clientId: string, orderId: string): Promise<any>;
+    onAchTxAddressReceived({ orderId }: {
+        clientId: string;
+        orderId: string;
+    }, callback: (data: AchTxAddressReceivedType | null) => void): import("./types").IListen;
+    requestOrderTransferred(clientId: string, orderId: string): Promise<any>;
+    onRequestOrderTransferred({ orderId }: {
+        clientId: string;
+        orderId: string;
+    }, callback: (data: RequestOrderTransferredType | null) => void): import("./types").IListen;
+    requestNFTOrderStatus(clientId: string, orderId: string): Promise<any>;
+    OnNFTOrderChanged({ orderId }: {
+        clientId: string;
+        orderId: string;
+    }, callback: (data: NFTOrderChangedData | null) => void): import("./types").IListen;
+}
+export declare const sellListenList: readonly ["onAchTxAddressReceived", "onOrderTransferredReceived", "OnNFTOrderChanged"];
+export declare const signalrSell: BaseSignalr<readonly ["onAchTxAddressReceived", "onOrderTransferredReceived", "OnNFTOrderChanged"]> & SignalrSell;

package/dist/commonjs/sellSignalr.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signalrSell = exports.sellListenList = exports.SignalrSell = void 0;
+const signalr_1 = require("./signalr");
+class SignalrSell extends signalr_1.BaseSignalr {
+    requestAchTxAddress(clientId, orderId) {
+        console.log('invoke RequestAchTxAddress', clientId, orderId);
+        return this.invoke('RequestAchTxAddress', {
+            TargetClientId: clientId,
+            OrderId: orderId,
+        });
+    }
+    onAchTxAddressReceived({ orderId }, callback) {
+        return this.listen('onAchTxAddressReceived', (data) => {
+            var _a;
+            if (((_a = data === null || data === void 0 ? void 0 : data.body) === null || _a === void 0 ? void 0 : _a.orderId) === orderId) {
+                callback(data.body);
+            }
+            else {
+                callback(null);
+            }
+        });
+    }
+    requestOrderTransferred(clientId, orderId) {
+        console.log('invoke RequestOrderTransferred', clientId, orderId);
+        return this.invoke('RequestOrderTransferred', {
+            TargetClientId: clientId,
+            OrderId: orderId,
+        });
+    }
+    onRequestOrderTransferred({ orderId }, callback) {
+        return this.listen('onOrderTransferredReceived', (data) => {
+            var _a;
+            if (((_a = data === null || data === void 0 ? void 0 : data.body) === null || _a === void 0 ? void 0 : _a.orderId) === orderId) {
+                callback(data.body);
+            }
+            else {
+                callback(null);
+            }
+        });
+    }
+    requestNFTOrderStatus(clientId, orderId) {
+        console.log('invoke RequestNFTOrderStatus', clientId, orderId);
+        return this.invoke('RequestNFTOrderStatus', {
+            targetClientId: clientId,
+            orderId: orderId,
+        });
+    }
+    OnNFTOrderChanged({ orderId }, callback) {
+        return this.listen('OnNFTOrderChanged', (data) => {
+            var _a;
+            console.log('OnNFTOrderChanged:', data, orderId);
+            if (((_a = data === null || data === void 0 ? void 0 : data.body) === null || _a === void 0 ? void 0 : _a.orderId) === orderId) {
+                callback(data.body);
+            }
+            else {
+                callback(null);
+            }
+        });
+    }
+}
+exports.SignalrSell = SignalrSell;
+exports.sellListenList = ['onAchTxAddressReceived', 'onOrderTransferredReceived', 'OnNFTOrderChanged'];
+exports.signalrSell = new SignalrSell({
+    listenList: exports.sellListenList,
+});

package/dist/commonjs/signalr.d.ts

@@ -0,0 +1,24 @@
+import { HubConnection } from '@microsoft/signalr';
+import { IListen, ISignalr, ISignalrOptions } from './types';
+export declare class BaseSignalr<ListenList = any> implements ISignalr<ListenList> {
+    url?: string;
+    signalr: HubConnection | null;
+    connectionId: string;
+    private _messageMap;
+    private _listenList;
+    constructor({ listenList }: ISignalrOptions<ListenList>);
+    doOpen: ({ url, clientId }: {
+        url: string;
+        clientId: string;
+    }) => Promise<HubConnection>;
+    listen: (name: ListenList[keyof ListenList], handler: (data?: any) => void) => IListen;
+    start: HubConnection['start'];
+    on: HubConnection['on'];
+    invoke: HubConnection['invoke'];
+    onClose: HubConnection['onclose'];
+    stop: HubConnection['stop'];
+    destroy: HubConnection['stop'];
+    private _listener;
+    private _onReceiver;
+    private _checkSignalr;
+}

package/dist/commonjs/signalr.js

@@ -0,0 +1,87 @@
+"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.BaseSignalr = void 0;
+const signalr_1 = require("@microsoft/signalr");
+const utils_1 = require("@portkey/utils");
+const types_1 = require("./types");
+class BaseSignalr {
+    constructor({ listenList }) {
+        this.doOpen = ({ url, clientId }) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const signalr = new signalr_1.HubConnectionBuilder().withUrl(url).withAutomaticReconnect().build();
+            this._listener(signalr);
+            if (this.signalr)
+                yield this.signalr.stop();
+            yield signalr.start();
+            yield signalr.invoke('Connect', clientId);
+            this.connectionId = (_a = signalr.connectionId) !== null && _a !== void 0 ? _a : '';
+            this.signalr = signalr;
+            this.url = url;
+            return signalr;
+        });
+        this.listen = (name, handler) => {
+            const key = (0, utils_1.randomId)();
+            let _name = name;
+            if (!this._messageMap[_name])
+                this._messageMap[_name] = {};
+            this._messageMap[_name][key] = handler;
+            return {
+                remove: () => {
+                    delete this._messageMap[_name][key];
+                },
+            };
+        };
+        this.start = (...args) => {
+            return this._checkSignalr().start(...args);
+        };
+        this.on = (...args) => {
+            return this._checkSignalr().on(...args);
+        };
+        this.invoke = (...args) => {
+            return this._checkSignalr().invoke(...args);
+        };
+        this.onClose = (...args) => {
+            return this._checkSignalr().onclose(...args);
+        };
+        this.stop = (...args) => {
+            return this._checkSignalr().stop(...args);
+        };
+        this.destroy = () => {
+            this._messageMap = {};
+            return this._checkSignalr().stop();
+        };
+        this.connectionId = '';
+        this._messageMap = {};
+        this.signalr = null;
+        this._listenList = listenList;
+    }
+    _listener(signalr) {
+        this._listenList.forEach(listenType => {
+            signalr.on(listenType, (data) => {
+                this._onReceiver({ Event: listenType, Data: data });
+            });
+        });
+    }
+    _onReceiver(data) {
+        const callback = this._messageMap[data.Event];
+        callback &&
+            Object.values(callback).forEach(handler => {
+                handler(data.Data);
+            });
+    }
+    _checkSignalr() {
+        if (!this.signalr)
+            throw types_1.SocketError.notConnect;
+        return this.signalr;
+    }
+}
+exports.BaseSignalr = BaseSignalr;

package/dist/commonjs/types/did.d.ts

@@ -0,0 +1,36 @@
+import { BaseSocketMessage, IListen, ISignalr } from './signalr';
+export declare const DefaultDIDListenList: readonly ["caAccountRegister", "caAccountRecover", "onScanLoginSuccess", "onScanLogin"];
+export type DefaultDIDListenListType = typeof DefaultDIDListenList;
+export type RegisterStatus = 'pass' | 'pending' | 'fail' | null;
+export interface RegisterBody {
+    caAddress: string;
+    caHash: string;
+    registerMessage: null | string;
+    registerStatus: RegisterStatus;
+}
+export interface RecoverBody {
+    caAddress: string;
+    caHash: string;
+    recoveryMessage: null | string;
+    recoveryStatus: RegisterStatus;
+}
+export interface CaAccountRegisterResult {
+    requestId: string;
+    body: RegisterBody;
+}
+export interface CaAccountRecoverResult {
+    requestId: string;
+    body: RecoverBody;
+}
+export interface IDIDSignalr<T> extends ISignalr<T> {
+    onCaAccountRegister({ clientId, requestId }: {
+        clientId: string;
+        requestId: string;
+    }, callback: (data: CaAccountRegisterResult) => void): IListen;
+    onCaAccountRecover({ clientId, requestId }: {
+        clientId: string;
+        requestId: string;
+    }, callback: (data: CaAccountRecoverResult) => void): IListen;
+    onScanLoginSuccess(callback: (data: BaseSocketMessage) => void): IListen;
+    onScanLogin(callback: (data: BaseSocketMessage) => void): IListen;
+}

package/dist/commonjs/types/did.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultDIDListenList = void 0;
+exports.DefaultDIDListenList = [
+    'caAccountRegister',
+    'caAccountRecover',
+    'onScanLoginSuccess',
+    'onScanLogin',
+];

package/dist/commonjs/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './did';
+export * from './signalr';
+export * from './sell';

package/dist/commonjs/types/index.js

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

package/dist/commonjs/types/sell.d.ts

@@ -0,0 +1,34 @@
+export type PaymentMerchantType = 'Alchemy';
+export interface AchTxAddressReceivedType {
+    merchantName: PaymentMerchantType;
+    orderId: string;
+    crypto: string;
+    network: string;
+    cryptoAmount: string;
+    address: string;
+}
+export interface RequestOrderTransferredType extends AchTxAddressReceivedType {
+    status: 'Transferred' | 'TransferFailed';
+}
+export type TransDirectType = 'TokenBuy' | 'TokenSell' | 'NFTBuy' | 'NFTSell';
+export declare enum OrderStatusEnum {
+    Initialized = "Initialized",
+    Created = "Created",
+    Pending = "Pending",
+    StartTransfer = "StartTransfer",
+    Transferring = "Transferring",
+    Transferred = "Transferred",
+    TransferFailed = "TransferFailed",
+    Failed = "Failed",
+    Finish = "Finish"
+}
+export interface NFTOrderChangedData {
+    orderId: string;
+    merchantName: string;
+    address: string;
+    network: string;
+    crypto: string;
+    cryptoAmount: string;
+    status: `${OrderStatusEnum}`;
+    transDirect: 'NFTBuy';
+}

package/dist/commonjs/types/sell.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderStatusEnum = void 0;
+var OrderStatusEnum;
+(function (OrderStatusEnum) {
+    // The order is initialized, and no callback from the payment supplier is received at this time.
+    OrderStatusEnum["Initialized"] = "Initialized";
+    // The supplier calls back a new order and the user has not paid successfully. When the front end jumps back to Portkey, this is the most likely state.
+    OrderStatusEnum["Created"] = "Created";
+    // Order payment successful
+    OrderStatusEnum["Pending"] = "Pending";
+    // Start settling ELF with merchants
+    OrderStatusEnum["StartTransfer"] = "StartTransfer";
+    // The transfer transaction has been sent, but the transaction has not been packaged yet
+    OrderStatusEnum["Transferring"] = "Transferring";
+    // The transaction has been packaged and is waiting for LIB (the transaction is in Mined status)
+    OrderStatusEnum["Transferred"] = "Transferred";
+    // Transfer transaction failed, ready to try again (When the Pending status is waiting for packaging, other statuses other than Mined are queried)
+    OrderStatusEnum["TransferFailed"] = "TransferFailed";
+    // User payment failed
+    OrderStatusEnum["Failed"] = "Failed";
+    // LIB confirmed
+    OrderStatusEnum["Finish"] = "Finish";
+})(OrderStatusEnum = exports.OrderStatusEnum || (exports.OrderStatusEnum = {}));

package/dist/commonjs/types/signalr.d.ts

@@ -0,0 +1,35 @@
+import { HubConnection } from '@microsoft/signalr';
+export interface ISignalrOptions<T> {
+    listenList: T;
+}
+export interface IMessageMap {
+    [eventName: string]: {
+        [key: string]: (data?: any) => void;
+    };
+}
+export interface Receive {
+    Event: string;
+    Data?: any;
+}
+export declare enum SocketError {
+    notConnect = "Signalr is null, please doOpen"
+}
+export type BaseSocketMessage = {
+    body: string;
+};
+export interface IListen {
+    remove(): void;
+}
+export interface ISignalr<T> {
+    doOpen: ({ url, clientId }: {
+        url: string;
+        clientId: string;
+    }) => Promise<HubConnection>;
+    listen: (name: T[keyof T], handler: (data?: any) => void) => IListen;
+    start: HubConnection['start'];
+    invoke: HubConnection['invoke'];
+    onClose: HubConnection['onclose'];
+    stop: HubConnection['stop'];
+    on: HubConnection['on'];
+    destroy: HubConnection['stop'];
+}

package/dist/commonjs/types/signalr.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketError = void 0;
+var SocketError;
+(function (SocketError) {
+    SocketError["notConnect"] = "Signalr is null, please doOpen";
+})(SocketError = exports.SocketError || (exports.SocketError = {}));

package/dist/esm/didSignalr.d.ts

@@ -0,0 +1,16 @@
+import { BaseSignalr } from './signalr.js';
+import { BaseSocketMessage, ISignalrOptions, CaAccountRecoverResult, CaAccountRegisterResult, DefaultDIDListenListType, IDIDSignalr } from './types/index.js';
+export declare class DIDSignalr<T extends DefaultDIDListenListType = DefaultDIDListenListType> extends BaseSignalr<T> implements IDIDSignalr<T> {
+    constructor(options?: ISignalrOptions<T>);
+    Ack(clientId: string, requestId: string): void;
+    onCaAccountRegister({ clientId, requestId }: {
+        clientId: string;
+        requestId: string;
+    }, callback: (data: CaAccountRegisterResult) => void): import("./types").IListen;
+    onCaAccountRecover({ clientId, requestId }: {
+        clientId: string;
+        requestId: string;
+    }, callback: (data: CaAccountRecoverResult) => void): import("./types").IListen;
+    onScanLoginSuccess(callback: (data: BaseSocketMessage) => void): import("./types").IListen;
+    onScanLogin(callback: (data: BaseSocketMessage) => void): import("./types").IListen;
+}

package/dist/esm/didSignalr.js

@@ -0,0 +1,47 @@
+import { BaseSignalr } from './signalr.js';
+import { DefaultDIDListenList, } from './types/index.js';
+export class DIDSignalr extends BaseSignalr {
+    constructor(options) {
+        const { listenList = DefaultDIDListenList } = options || {};
+        super({ listenList });
+    }
+    Ack(clientId, requestId) {
+        this.invoke('Ack', clientId, requestId);
+    }
+    onCaAccountRegister({ clientId, requestId }, callback) {
+        return this.listen('caAccountRegister', (data) => {
+            if (data.requestId === requestId) {
+                if (data.body.registerStatus !== 'pending') {
+                    this.Ack(clientId, requestId);
+                }
+                callback(data);
+            }
+        });
+    }
+    onCaAccountRecover({ clientId, requestId }, callback) {
+        return this.listen('caAccountRecover', (data) => {
+            if (data.requestId === requestId) {
+                if (data.body.recoveryStatus !== 'pending') {
+                    this.Ack(clientId, requestId);
+                }
+                callback(data);
+            }
+        });
+    }
+    onScanLoginSuccess(callback) {
+        return this.listen('onScanLoginSuccess', (data) => {
+            if (typeof (data === null || data === void 0 ? void 0 : data.body) === 'string') {
+                callback(data);
+                this.stop();
+            }
+        });
+    }
+    onScanLogin(callback) {
+        return this.listen('onScanLogin', (data) => {
+            if (typeof (data === null || data === void 0 ? void 0 : data.body) === 'string') {
+                callback(data);
+                this.stop();
+            }
+        });
+    }
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+export * from './didSignalr.js';
+export * from './signalr.js';
+export * from './sellSignalr.js';
+export * from './types/index.js';

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+export * from './didSignalr.js';
+export * from './signalr.js';
+export * from './sellSignalr.js';
+export * from './types/index.js';

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type": "module"}

package/dist/esm/sellSignalr.d.ts

@@ -0,0 +1,21 @@
+import { BaseSignalr } from './signalr.js';
+import { AchTxAddressReceivedType, NFTOrderChangedData, RequestOrderTransferredType } from './types/sell.js';
+export declare class SignalrSell extends BaseSignalr {
+    requestAchTxAddress(clientId: string, orderId: string): Promise<any>;
+    onAchTxAddressReceived({ orderId }: {
+        clientId: string;
+        orderId: string;
+    }, callback: (data: AchTxAddressReceivedType | null) => void): import("./types").IListen;
+    requestOrderTransferred(clientId: string, orderId: string): Promise<any>;
+    onRequestOrderTransferred({ orderId }: {
+        clientId: string;
+        orderId: string;
+    }, callback: (data: RequestOrderTransferredType | null) => void): import("./types").IListen;
+    requestNFTOrderStatus(clientId: string, orderId: string): Promise<any>;
+    OnNFTOrderChanged({ orderId }: {
+        clientId: string;
+        orderId: string;
+    }, callback: (data: NFTOrderChangedData | null) => void): import("./types").IListen;
+}
+export declare const sellListenList: readonly ["onAchTxAddressReceived", "onOrderTransferredReceived", "OnNFTOrderChanged"];
+export declare const signalrSell: BaseSignalr<readonly ["onAchTxAddressReceived", "onOrderTransferredReceived", "OnNFTOrderChanged"]> & SignalrSell;