@fivenorth/loop-sdk 0.11.0 → 0.11.2

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.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.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,
+        });
+    }
+}

package/dist/types.js

@@ -0,0 +1,10 @@
+export var MessageType;
+(function (MessageType) {
+    MessageType["HANDSHAKE_ACCEPT"] = "handshake_accept";
+    MessageType["HANDSHAKE_REJECT"] = "handshake_reject";
+    MessageType["RUN_TRANSACTION"] = "run_transaction";
+    MessageType["TRANSACTION_COMPLETED"] = "transaction_completed";
+    MessageType["SIGN_RAW_MESSAGE"] = "sign_raw_message";
+    MessageType["SIGN_RAW_MESSAGE_RESPONSE"] = "sign_raw_message_response";
+    MessageType["REJECT_REQUEST"] = "reject_request";
+})(MessageType || (MessageType = {}));

package/dist/wallet.js

@@ -0,0 +1,22 @@
+import { UsdcBridge } from './extensions/usdc';
+export class LoopWallet {
+    getProvider;
+    extension;
+    constructor(getProvider) {
+        this.getProvider = getProvider;
+        this.extension = {
+            usdcBridge: new UsdcBridge(this.getProvider),
+        };
+    }
+    requireProvider() {
+        const provider = this.getProvider();
+        if (!provider) {
+            throw new Error('SDK not connected. Call connect() and wait for acceptance first.');
+        }
+        return provider;
+    }
+    transfer(recipient, amount, instrument, options) {
+        const provider = this.requireProvider();
+        return provider.transfer(recipient, amount, instrument, options);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@fivenorth/loop-sdk",
-	"version": "0.11.0",
+	"version": "0.11.2",
 	"author": "support@fivenorth.io",
 	"main": "dist/index.js",
 	"module": "dist/index.js",
@@ -9,7 +9,13 @@
 		"@types/node-forge": "^1.3.14"
 	},
 	"peerDependencies": {
-		"typescript": "^5"
+		"typescript": "^5",
+		"node-forge": "^1.3.3"
+	},
+	"peerDependenciesMeta": {
+		"node-forge": {
+			"optional": true
+		}
 	},
 	"files": [
 		"dist"
@@ -19,7 +25,7 @@
 	},
 	"repository": "github:fivenorth-io/loop-sdk",
 	"scripts": {
-		"build": "bun tsc && bun build ./src/index.ts ./src/server/index.ts --outdir ./dist --declaration",
+		"build": "bun tsc && bun build ./src/index.ts --outdir ./dist --target browser --format esm",
 		"prepublishOnly": "bun run build",
 		"start": "bun run src/server.ts"
 	},
@@ -38,8 +44,5 @@
 	"dependencies": {
 		"@types/qrcode": "^1.5.6",
 		"qrcode": "^1.5.4"
-	},
-	"optionalDependencies": {
-		"node-forge": "^1.3.3"
 	}
 }