@fivenorth/loop-sdk 0.11.0 → 0.11.1

package/dist/provider.js

@@ -0,0 +1,247 @@
+import { MessageType } from './types';
+import { RejectRequestError, RequestTimeoutError, UnauthorizedError, extractErrorCode, isUnauthCode } from './errors';
+export const DEFAULT_REQUEST_TIMEOUT_MS = 300000; // 5 minutes
+// Use polyfill only on HTTP (crypt.randomUUID requires HTTPS or localhost)
+// In production (HTTPS), native randomUUID will be used
+function generateUUID() {
+    return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, (c) => {
+        const gCrypto = globalThis.crypto;
+        if (!gCrypto?.getRandomValues) { // fallback for if crypto is not available
+            const n = Number(c);
+            return ((n ^ (Math.random() * 16) >> (n / 4))).toString(16);
+        }
+        // use crypto API
+        const arr = gCrypto.getRandomValues(new Uint8Array(1));
+        const byte = arr[0];
+        const n = Number(c);
+        return ((n ^ ((byte & 15) >> (n / 4)))).toString(16);
+    });
+}
+export function generateRequestId() {
+    const gCrypto = globalThis.crypto;
+    if (gCrypto?.randomUUID) {
+        return gCrypto.randomUUID();
+    }
+    return generateUUID();
+}
+export class Provider {
+    connection;
+    party_id;
+    public_key;
+    email;
+    auth_token;
+    requests = new Map();
+    requestTimeout = DEFAULT_REQUEST_TIMEOUT_MS;
+    hooks;
+    constructor({ connection, party_id, public_key, auth_token, email, hooks }) {
+        if (!connection) {
+            throw new Error('Provider requires a connection object.');
+        }
+        this.connection = connection;
+        this.party_id = party_id;
+        this.public_key = public_key;
+        this.email = email;
+        this.auth_token = auth_token;
+        this.hooks = hooks;
+    }
+    getAuthToken() {
+        return this.auth_token;
+    }
+    // handle all responses from the websocket except for handshake_accept, handshake_reject
+    handleResponse(message) {
+        console.log('Received response:', message);
+        if (message?.type === MessageType.TRANSACTION_COMPLETED &&
+            (message?.payload?.update_id || message?.payload?.update_data || message?.payload?.status)) {
+            if (message?.payload?.error_message) {
+                message.payload.error = { error_message: message.payload.error_message };
+                delete message.payload.error_message;
+            }
+            this.hooks?.onTransactionUpdate?.(message.payload, message);
+        }
+        if (message.request_id) {
+            this.requests.set(message.request_id, message);
+        }
+    }
+    getHolding() {
+        return this.connection.getHolding(this.auth_token);
+    }
+    // get the current account connected to the provider
+    // This is useful for dApps to know if the user has pre approval or merge delegation permissions to ensure UTXO consolidation is in place
+    getAccount() {
+        return this.connection.verifySession(this.auth_token);
+    }
+    getActiveContracts(params) {
+        return this.connection.getActiveContracts(this.auth_token, params);
+    }
+    // submit a transaction to be signed by the wallet to the websocket
+    async submitTransaction(payload, options) {
+        const requestPayload = options?.estimateTraffic ? { ...payload, estimate_traffic: true } : payload;
+        const executionMode = options?.executionMode;
+        const finalPayload = executionMode === 'wait'
+            ? { ...requestPayload, execution_mode: 'wait' }
+            : requestPayload;
+        return this.sendRequest(MessageType.RUN_TRANSACTION, finalPayload, options);
+    }
+    async submitAndWaitForTransaction(payload, options) {
+        const requestPayload = options?.estimateTraffic ? { ...payload, estimate_traffic: true } : payload;
+        return this.sendRequest(MessageType.RUN_TRANSACTION, { ...requestPayload, execution_mode: 'wait' }, options);
+    }
+    async transfer(recipient, amount, instrument, options) {
+        const amountStr = typeof amount === 'number' ? amount.toString() : amount;
+        const { requestedAt, executeBefore, requestTimeout, estimateTraffic, memo } = options || {};
+        const message = options?.message;
+        const resolveDate = (value, fallbackMs) => {
+            if (value instanceof Date) {
+                return value.toISOString();
+            }
+            if (typeof value === 'string' && value.length > 0) {
+                return value;
+            }
+            if (fallbackMs) {
+                return new Date(Date.now() + fallbackMs).toISOString();
+            }
+            return new Date().toISOString();
+        };
+        const requestedAtIso = resolveDate(requestedAt);
+        const executeBeforeIso = resolveDate(executeBefore, 24 * 60 * 60 * 1000);
+        const transferRequest = {
+            recipient,
+            amount: amountStr,
+            instrument: {
+                instrument_admin: instrument?.instrument_admin,
+                instrument_id: instrument?.instrument_id || 'Amulet',
+            },
+            requested_at: requestedAtIso,
+            execute_before: executeBeforeIso,
+        };
+        if (memo) {
+            transferRequest.memo = memo;
+        }
+        const preparedPayload = await this.connection.prepareTransfer(this.auth_token, transferRequest);
+        const submitFn = options?.executionMode === 'wait'
+            ? this.submitAndWaitForTransaction.bind(this)
+            : this.submitTransaction.bind(this);
+        return submitFn({
+            commands: preparedPayload.commands,
+            disclosedContracts: preparedPayload.disclosedContracts,
+            packageIdSelectionPreference: preparedPayload.packageIdSelectionPreference,
+            actAs: preparedPayload.actAs,
+            readAs: preparedPayload.readAs,
+            synchronizerId: preparedPayload.synchronizerId,
+        }, { requestTimeout, message, estimateTraffic });
+    }
+    // submit a raw message to be signed by the wallet to the websocket
+    async signMessage(message) {
+        return this.sendRequest(MessageType.SIGN_RAW_MESSAGE, message);
+    }
+    async ensureConnected() {
+        if (this.connection.ws && this.connection.ws.readyState === WebSocket.OPEN) {
+            return Promise.resolve();
+        }
+        await this.connection.reconnect();
+        if (this.connection.ws && this.connection.ws.readyState === WebSocket.OPEN) {
+            return;
+        }
+        throw new Error('Not connected.');
+    }
+    sendRequest(messageType, params = {}, options) {
+        return new Promise((resolve, reject) => {
+            const requestId = generateRequestId();
+            let requestContext;
+            const ensure = async () => {
+                try {
+                    await this.ensureConnected();
+                    requestContext = await this.hooks?.onRequestStart?.(messageType, options?.requestLabel);
+                }
+                catch (error) {
+                    console.error('[LoopSDK] error when checking connection status', error);
+                    this.hooks?.onRequestFinish?.({
+                        status: 'error',
+                        messageType,
+                        requestLabel: options?.requestLabel,
+                        requestContext,
+                    });
+                    reject(error);
+                    return;
+                }
+                const requestBody = {
+                    request_id: requestId,
+                    type: messageType,
+                    payload: params,
+                };
+                if (options?.message) {
+                    requestBody.ticket = { message: options.message };
+                    if (typeof params === 'object' && params !== null && !Array.isArray(params)) {
+                        requestBody.payload = {
+                            ...params,
+                            ticket: { message: options.message },
+                        };
+                    }
+                }
+                try {
+                    this.connection.ws.send(JSON.stringify(requestBody));
+                }
+                catch (error) {
+                    console.error('[LoopSDK] error when sending request', error);
+                    reject(error);
+                    return;
+                }
+                const intervalTime = 300; // 300ms
+                let elapsedTime = 0;
+                const timeoutMs = options?.requestTimeout ?? this.requestTimeout;
+                const intervalId = setInterval(() => {
+                    const response = this.requests.get(requestId);
+                    if (response) {
+                        clearInterval(intervalId);
+                        this.requests.delete(requestId);
+                        const code = extractErrorCode(response);
+                        if (isUnauthCode(code)) {
+                            this.hooks?.onRequestFinish?.({
+                                status: 'error',
+                                messageType,
+                                requestLabel: options?.requestLabel,
+                                requestContext,
+                                errorCode: code,
+                            });
+                            reject(new UnauthorizedError(code));
+                            return;
+                        }
+                        if (response.type === MessageType.REJECT_REQUEST) {
+                            this.hooks?.onRequestFinish?.({
+                                status: 'rejected',
+                                messageType,
+                                requestLabel: options?.requestLabel,
+                                requestContext,
+                            });
+                            reject(new RejectRequestError());
+                        }
+                        else {
+                            this.hooks?.onRequestFinish?.({
+                                status: 'success',
+                                messageType,
+                                requestLabel: options?.requestLabel,
+                                requestContext,
+                            });
+                            resolve(response.payload);
+                        }
+                    }
+                    else {
+                        elapsedTime += intervalTime;
+                        if (elapsedTime >= timeoutMs) {
+                            clearInterval(intervalId);
+                            this.requests.delete(requestId);
+                            this.hooks?.onRequestFinish?.({
+                                status: 'timeout',
+                                messageType,
+                                requestLabel: options?.requestLabel,
+                                requestContext,
+                            });
+                            reject(new RequestTimeoutError(timeoutMs));
+                        }
+                    }
+                }, intervalTime);
+            };
+            void ensure();
+        });
+    }
+}