@fivenorth/loop-sdk 0.10.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();
+        });
+    }
+}

package/dist/server/index.d.ts

@@ -0,0 +1,23 @@
+import { Provider } from '../provider';
+import type { Network, TransactionPayload } from '../types';
+import { Signer } from './signer';
+export declare class LoopSDK {
+    private signer?;
+    private provider?;
+    private connection?;
+    private isAuthenticated;
+    private session?;
+    init({ privateKey, partyId, network, walletUrl, apiUrl }: {
+        privateKey: string;
+        partyId: string;
+        network?: Network;
+        walletUrl?: string;
+        apiUrl?: string;
+    }): void;
+    authenticate(): Promise<void>;
+    getSigner(): Signer;
+    getProvider(): Provider;
+    executeTransaction(payload: TransactionPayload): Promise<any>;
+}
+export declare const loop: LoopSDK;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAsB,MAAM,aAAa,CAAC;AAG3D,OAAO,KAAK,EAAE,OAAO,EAAyE,kBAAkB,EAAyD,MAAM,UAAU,CAAC;AAE1L,OAAO,EAAa,MAAM,EAAE,MAAM,UAAU,CAAC;AA4C7C,qBAAa,OAAO;IAChB,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,CAAc;IAC/B,OAAO,CAAC,UAAU,CAAC,CAAa;IAChC,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,OAAO,CAAC,CAAc;IAE9B,IAAI,CAAC,EAAC,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAC;IASzI,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAoCnC,SAAS,IAAI,MAAM;IAOnB,WAAW,IAAI,QAAQ;IAOjB,kBAAkB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,GAAG,CAAC;CAuB7E;AAED,eAAO,MAAM,IAAI,SAAgB,CAAC"}

package/dist/server/index.js

@@ -0,0 +1,117 @@
+import { Provider } from '../provider';
+import { Connection } from '../connection';
+import { SessionInfo } from '../session';
+import { getSigner } from './signer';
+class RpcProvider extends Provider {
+    ticket_id;
+    user_api_key;
+    session;
+    constructor({ connection, party_id, public_key, auth_token, ticket_id, user_api_key, email, hooks }) {
+        super({ connection, party_id, public_key, auth_token, email, hooks });
+        this.ticket_id = ticket_id;
+        this.user_api_key = user_api_key;
+        this.session = new SessionInfo({
+            userApiKey: user_api_key,
+            ticketId: ticket_id,
+            partyId: party_id,
+            publicKey: public_key,
+            email: email,
+            sessionId: "",
+        });
+    }
+    async prepareSubmission(payload) {
+        return await this.connection.prepareTransaction(this.session, payload);
+    }
+    async executeSubmission(payload) {
+        return await this.connection.executeTransaction(this.session, payload);
+    }
+    async transfer(recipient, amount, instrument, options) {
+        return await this.connection.prepareTransfer(this.getAuthToken(), {
+            recipient,
+            amount: amount.toString(),
+            instrument: {
+                instrument_admin: instrument?.instrument_admin,
+                instrument_id: instrument?.instrument_id || 'Amulet',
+            },
+            requested_at: options?.requestedAt instanceof Date ? options?.requestedAt.toISOString() : options?.requestedAt || undefined,
+            execute_before: options?.executeBefore instanceof Date ? options?.executeBefore.toISOString() : options?.executeBefore || undefined,
+        });
+    }
+}
+export class LoopSDK {
+    signer;
+    provider;
+    connection;
+    isAuthenticated = false;
+    session;
+    init({ privateKey, partyId, network, walletUrl, apiUrl }) {
+        this.signer = getSigner(privateKey, partyId);
+        this.connection = new Connection({ network: network || 'local', walletUrl, apiUrl });
+        this.isAuthenticated = false;
+    }
+    // authenticate the user with the signer
+    // upon succesfully authenticated, the provider will be initialized and ready to send and sign tx
+    async authenticate() {
+        if (!this.signer || !this.connection) {
+            throw new Error('Signer and connection are required');
+        }
+        const publicKey = this.signer.getPublicKey();
+        const epoch = Date.now();
+        const signature = this.signer.signMessageAsHex(`Exchange API Key for ${this.signer.getPartyId()}\nTimestamp: ${epoch}`);
+        const apiKey = await this.connection.exchangeApiKey({ publicKey, signature, epoch });
+        if (!apiKey?.api_key) {
+            throw new Error('Failed to get API key from server.');
+        }
+        this.isAuthenticated = true;
+        this.session = new SessionInfo({
+            userApiKey: apiKey?.api_key,
+            authToken: apiKey?.auth_token,
+            email: apiKey?.email,
+            ticketId: apiKey?.ticket_id,
+            sessionId: apiKey?.session_id,
+            partyId: this.signer.getPartyId(),
+            publicKey: publicKey,
+        });
+        this.provider = new RpcProvider({
+            ticket_id: this.session?.ticketId,
+            connection: this.connection,
+            party_id: this.signer.getPartyId(),
+            user_api_key: apiKey?.api_key,
+            auth_token: this.session?.authToken,
+            public_key: publicKey,
+            email: this.session?.email,
+        });
+    }
+    getSigner() {
+        if (!this.signer) {
+            throw new Error('Signer not initialized');
+        }
+        return this.signer;
+    }
+    getProvider() {
+        if (!this.provider) {
+            throw new Error('Provider not initialized');
+        }
+        return this.provider;
+    }
+    async executeTransaction(payload) {
+        if (!this.provider || !this.signer) {
+            throw new Error('Provider and signer are required');
+        }
+        // Prepare the transaction with interactive submission to get unsigned transaction hash
+        const preparedPayload = await this.provider?.prepareSubmission(payload);
+        if (!preparedPayload) {
+            throw new Error('Failed to prepare submission');
+        }
+        // now we sign the transaction hash which is base64 encoded from the response
+        const signedTransactionHash = this.getSigner().signTransactionHash(preparedPayload.transaction_hash);
+        // Combine the signed transaction hash with the transaction data to submit to the ledger
+        const submissionResponse = await this.provider?.executeSubmission({
+            command_id: preparedPayload.command_id,
+            transaction_data: preparedPayload.transaction_data,
+            signature: signedTransactionHash,
+        });
+        return submissionResponse;
+    }
+}
+export const loop = new LoopSDK();

package/dist/server/signer.d.ts

@@ -0,0 +1,15 @@
+import * as forge from 'node-forge';
+export declare const getSigner: (privateKeyHex: string, partyId: string) => Signer;
+export declare class Signer {
+    private privateKey;
+    private publicKey;
+    private publicKeyHex;
+    private partyId;
+    constructor(privateKeyHex: string, partyId: string);
+    getPublicKey(): string;
+    signMessage(message: string): forge.Bytes;
+    signMessageAsHex(message: string): string;
+    getPartyId(): string;
+    signTransactionHash(transactionHash: string): string;
+}
+//# sourceMappingURL=signer.d.ts.map

package/dist/server/signer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer.d.ts","sourceRoot":"","sources":["../../src/server/signer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AAEpC,eAAO,MAAM,SAAS,GAAI,eAAe,MAAM,EAAE,SAAS,MAAM,KAAG,MAElE,CAAA;AAED,qBAAa,MAAM;IACf,OAAO,CAAC,UAAU,CAAc;IAChC,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,OAAO,CAAS;gBAEZ,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAc3C,YAAY,IAAI,MAAM;IAItB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAAC,KAAK;IAQzC,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IASzC,UAAU,IAAI,MAAM;IAKpB,mBAAmB,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM;CAa9D"}

package/dist/server/signer.js

@@ -0,0 +1,56 @@
+import * as forge from 'node-forge';
+export const getSigner = (privateKeyHex, partyId) => {
+    return new Signer(privateKeyHex, partyId);
+};
+export class Signer {
+    privateKey;
+    publicKey;
+    publicKeyHex;
+    partyId;
+    constructor(privateKeyHex, partyId) {
+        if (!privateKeyHex || !partyId) {
+            throw new Error('Private key and party ID are required');
+        }
+        this.privateKey = forge.util.hexToBytes(privateKeyHex);
+        this.partyId = partyId;
+        const publicKey = forge.pki.ed25519.publicKeyFromPrivateKey({
+            privateKey: this.privateKey,
+        });
+        this.publicKey = publicKey;
+        this.publicKeyHex = forge.util.bytesToHex(publicKey);
+    }
+    getPublicKey() {
+        return this.publicKeyHex;
+    }
+    signMessage(message) {
+        return forge.pki.ed25519.sign({
+            message: message,
+            encoding: 'utf8',
+            privateKey: this.privateKey,
+        });
+    }
+    signMessageAsHex(message) {
+        const signature = forge.pki.ed25519.sign({
+            message: message,
+            encoding: 'utf8',
+            privateKey: this.privateKey,
+        });
+        return forge.util.bytesToHex(signature);
+    }
+    getPartyId() {
+        return this.partyId;
+    }
+    // sign the transaction hash in base64 format and return the signature in hex format
+    signTransactionHash(transactionHash) {
+        if (!transactionHash) {
+            throw new Error('Transaction hash is required');
+        }
+        // Now we will sign the transaction hash
+        const signedRequest = forge.pki.ed25519.sign({
+            message: forge.util.decode64(transactionHash),
+            encoding: 'binary',
+            privateKey: this.privateKey,
+        });
+        return forge.util.bytesToHex(signedRequest);
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":""}

package/dist/server.js

@@ -0,0 +1,38 @@
+import { join } from 'path';
+const server = Bun.serve({
+    port: 3030,
+    async fetch(req) {
+        const url = new URL(req.url);
+        const pathname = url.pathname;
+        // Serve the test page
+        if (pathname === '/') {
+            return new Response(Bun.file(join(import.meta.dir, '..', '/demo/test.html')));
+        }
+        // Intercept the request for the SDK and compile it on the fly
+        if (pathname === '/dist/index.js') {
+            console.log('Bundling src/index.ts for development...');
+            const build = await Bun.build({
+                entrypoints: [join(import.meta.dir, 'index.ts')],
+                target: 'browser',
+                sourcemap: 'inline', // Good for debugging
+            });
+            if (!build.success) {
+                console.error("Build failed:");
+                for (const message of build.logs) {
+                    console.error(message);
+                }
+                return new Response('Build failed', { status: 500 });
+            }
+            // Serve the first build artifact (the JS file)
+            return new Response(build.outputs[0], {
+                headers: { 'Content-Type': 'application/javascript; charset=utf-8' },
+            });
+        }
+        return new Response('Not Found', { status: 404 });
+    },
+    error(error) {
+        console.error(error);
+        return new Response('Internal Server Error', { status: 500 });
+    },
+});
+console.log(`Listening on http://localhost:${server.port}`);

package/dist/session.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Session LifeCycle:
+ * 1. Initialize a new session with a session id
+ * 2. Set the ticket id when we exchange session id/appname, and user approve it and now we have a ticket id
+ * 3. Set the session as authorized when we succesfully validate the session with the backend
+ * 4. Save the session to localStorage
+ * 5. Reset the session when we need to start a new session
+ * 6. Validate the session when we need to check if the session is valid
+ * 7. Is authorized means the session is valid and the user is authenticated
+ * 8. Save the session to localStorage
+ */
+export declare class SessionInfo {
+    sessionId: string;
+    ticketId?: string;
+    authToken?: string;
+    partyId?: string;
+    publicKey?: string;
+    email?: string;
+    userApiKey?: string;
+    private _isAuthorized;
+    constructor({ sessionId, ticketId, authToken, partyId, publicKey, email, userApiKey }: {
+        sessionId: string;
+        ticketId?: string;
+        authToken?: string;
+        partyId?: string;
+        publicKey?: string;
+        email?: string;
+        userApiKey?: string;
+    });
+    setTicketId(ticketId: string): void;
+    authorized(): void;
+    isPreAuthorized(): boolean;
+    isAuthorized(): boolean;
+    save(): void;
+    reset(): void;
+    static fromStorage(): SessionInfo;
+    private toJson;
+}
+//# sourceMappingURL=session.d.ts.map

package/dist/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,qBAAa,WAAW;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,aAAa,CAAkB;gBAE3B,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,UAAU,EAAE,EAAE;QAAG,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE;IAW/N,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAMnC,UAAU,IAAI,IAAI;IAQlB,eAAe,IAAI,OAAO;IAK1B,YAAY,IAAI,OAAO;IAKvB,IAAI,IAAI,IAAI;IAKZ,KAAK,IAAI,IAAI;IAab,MAAM,CAAC,WAAW,IAAI,WAAW;IAqBjC,OAAO,CAAC,MAAM;CAUf"}

package/dist/session.js

@@ -0,0 +1,92 @@
+import { generateRequestId } from './provider';
+const STORAGE_KEY_LOOP_CONNECT = 'loop_connect';
+/**
+ * Session LifeCycle:
+ * 1. Initialize a new session with a session id
+ * 2. Set the ticket id when we exchange session id/appname, and user approve it and now we have a ticket id
+ * 3. Set the session as authorized when we succesfully validate the session with the backend
+ * 4. Save the session to localStorage
+ * 5. Reset the session when we need to start a new session
+ * 6. Validate the session when we need to check if the session is valid
+ * 7. Is authorized means the session is valid and the user is authenticated
+ * 8. Save the session to localStorage
+ */
+export class SessionInfo {
+    sessionId;
+    ticketId;
+    authToken;
+    partyId;
+    publicKey;
+    email;
+    userApiKey;
+    _isAuthorized = false;
+    constructor({ sessionId, ticketId, authToken, partyId, publicKey, email, userApiKey }) {
+        this.sessionId = sessionId;
+        this.ticketId = ticketId;
+        this.authToken = authToken;
+        this.partyId = partyId;
+        this.publicKey = publicKey;
+        this.email = email;
+        this.userApiKey = userApiKey;
+    }
+    // set the ticket id when we exchange session id/appname, and user approve it and now we have a ticket id
+    setTicketId(ticketId) {
+        this.ticketId = ticketId;
+        this.save();
+    }
+    // set the session as authorized when we succesfully validate the session with the backend
+    authorized() {
+        if (this.ticketId === undefined || this.sessionId === undefined || this.authToken === undefined || this.partyId === undefined || this.publicKey === undefined) {
+            throw new Error('Session cannot be authorized without all required fields.');
+        }
+        this._isAuthorized = true;
+    }
+    // is pre authorized means the session is initialized and the ticket id is set together with auth and user information but we haven't validated the session with the backend yet
+    isPreAuthorized() {
+        return !this._isAuthorized && this.ticketId !== undefined && this.sessionId !== undefined && this.authToken !== undefined && this.partyId !== undefined && this.publicKey !== undefined;
+    }
+    // is authorized means the session is valid and the user is authenticated
+    isAuthorized() {
+        return this._isAuthorized;
+    }
+    // save persisted session info to localStorage
+    save() {
+        localStorage.setItem('loop_connect', this.toJson());
+    }
+    reset() {
+        localStorage.removeItem(STORAGE_KEY_LOOP_CONNECT);
+        this.sessionId = generateRequestId();
+        this._isAuthorized = false;
+        this.ticketId = undefined;
+        this.authToken = undefined;
+        this.partyId = undefined;
+        this.publicKey = undefined;
+        this.email = undefined;
+    }
+    static fromStorage() {
+        const existingConnectionRaw = localStorage.getItem(STORAGE_KEY_LOOP_CONNECT);
+        if (!existingConnectionRaw) {
+            return new SessionInfo({ sessionId: generateRequestId() });
+        }
+        let session = null;
+        try {
+            session = new SessionInfo(JSON.parse(existingConnectionRaw));
+        }
+        catch (error) {
+            console.error('Failed to parse existing connection info, local storage is corrupted.', error);
+            localStorage.removeItem(STORAGE_KEY_LOOP_CONNECT);
+            session = new SessionInfo({ sessionId: generateRequestId() });
+        }
+        return session;
+    }
+    toJson() {
+        return JSON.stringify({
+            sessionId: this.sessionId,
+            ticketId: this.ticketId,
+            authToken: this.authToken,
+            partyId: this.partyId,
+            publicKey: this.publicKey,
+            email: this.email,
+        });
+    }
+}