@fivenorth/loop-sdk 0.6.4 → 0.7.0

package/README.md

@@ -184,6 +184,23 @@ Common instrument overrides (pass into the `instrument` argument above):
 
 Swap in the admin/id for the specific instrument you hold in the Loop wallet.
 
+#### USDC withdraw helper
+
+```javascript
+await loop.wallet.extension.usdcBridge.withdrawalUSDCxToEthereum(
+  '0xYourEthAddress',
+  '10.5', // amount in USDCx
+  {
+    reference: 'optional memo',
+    requestTimeout: 5 * 60 * 1000, // optional override (ms)
+  },
+);
+```
+
+Notes:
+- Uses the connect-based withdraw endpoint to prepare the transaction and sends it over Wallet Connect.
+- The helper auto-reconnects the websocket if it was closed before sending the request.
+
 # API
 
 Coming soon

package/dist/index.js

@@ -2073,6 +2073,9 @@ class Connection {
   apiUrl = "https://cantonloop.com";
   ws = null;
   network = "main";
+  ticketId = null;
+  onMessageHandler = null;
+  reconnectPromise = null;
   constructor({ network, walletUrl, apiUrl }) {
     this.network = network || "main";
     switch (this.network) {
@@ -2213,16 +2216,67 @@ class Connection {
   websocketUrl(ticketId) {
     return `${this.network === "local" ? "ws" : "wss"}://${this.apiUrl.replace("https://", "").replace("http://", "")}/api/v1/.connect/pair/ws/${ticketId}`;
   }
-  connectWebSocket(ticketId, onMessage) {
+  attachWebSocket(ticketId, onMessage, onOpen, onError, onClose) {
     const wsUrl = this.websocketUrl(ticketId);
-    this.ws = new WebSocket(wsUrl);
-    this.ws.onmessage = onMessage;
-    this.ws.onopen = () => {
+    const ws = new WebSocket(wsUrl);
+    ws.onmessage = onMessage;
+    ws.onopen = () => {
       console.log("Connected to ticket server.");
+      onOpen?.();
     };
-    this.ws.onclose = () => {
+    ws.onclose = (event) => {
+      if (this.ws === ws) {
+        this.ws = null;
+      }
       console.log("Disconnected from ticket server.");
+      onClose?.(event);
+    };
+    ws.onerror = (event) => {
+      if (this.ws === ws) {
+        this.ws = null;
+      }
+      onError?.(event);
     };
+    this.ws = ws;
+  }
+  connectWebSocket(ticketId, onMessage) {
+    this.ticketId = ticketId;
+    this.onMessageHandler = onMessage;
+    this.attachWebSocket(ticketId, onMessage);
+  }
+  reconnect() {
+    if (!this.ticketId || !this.onMessageHandler) {
+      return Promise.reject(new Error("Cannot reconnect without a known ticket."));
+    }
+    if (this.reconnectPromise) {
+      return this.reconnectPromise;
+    }
+    this.reconnectPromise = new Promise((resolve, reject) => {
+      let opened = false;
+      this.attachWebSocket(this.ticketId, this.onMessageHandler, () => {
+        opened = true;
+        resolve();
+      }, () => {
+        if (opened) {
+          return;
+        }
+        reject(new Error("Failed to reconnect to ticket server."));
+      }, () => {
+        if (opened) {
+          return;
+        }
+        reject(new Error("Failed to reconnect to ticket server."));
+      });
+    }).finally(() => {
+      this.reconnectPromise = null;
+    });
+    return this.reconnectPromise;
+  }
+  async reconnectWebSocket() {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      return;
+    }
+    return this.reconnect();
   }
 }
 
@@ -2269,6 +2323,7 @@ class Provider {
   email;
   auth_token;
   requests = new Map;
+  requestTimeout = DEFAULT_REQUEST_TIMEOUT_MS;
   constructor({ connection, party_id, public_key, auth_token, email }) {
     if (!connection) {
       throw new Error("Provider requires a connection object.");
@@ -2279,6 +2334,9 @@ class Provider {
     this.email = email;
     this.auth_token = auth_token;
   }
+  getAuthToken() {
+    return this.auth_token;
+  }
   handleResponse(message) {
     console.log("Received response:", message);
     if (message.request_id) {
@@ -2334,48 +2392,124 @@ class Provider {
   async signMessage(message) {
     return this.sendRequest("sign_raw_message" /* SIGN_RAW_MESSAGE */, message);
   }
+  async ensureConnected() {
+    if (this.connection.ws && this.connection.ws.readyState === WebSocket.OPEN) {
+      return;
+    }
+    if (typeof this.connection.reconnectWebSocket === "function") {
+      await this.connection.reconnectWebSocket();
+      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) => {
-      if (!this.connection.ws || this.connection.ws.readyState !== WebSocket.OPEN) {
-        return reject(new Error("Not connected."));
-      }
-      const requestId = generateRequestId();
-      const requestTimeout = options?.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT_MS;
-      this.connection.ws.send(JSON.stringify({
-        request_id: requestId,
-        type: messageType,
-        payload: params
-      }));
-      const intervalTime = 300;
-      let elapsedTime = 0;
-      const intervalId = setInterval(() => {
-        const response = this.requests.get(requestId);
-        if (response) {
-          clearInterval(intervalId);
-          this.requests.delete(requestId);
-          if (response.type === "reject_request" /* REJECT_REQUEST */) {
-            reject(new RejectRequestError);
-          } else {
-            resolve(response.payload);
-          }
-        } else {
-          elapsedTime += intervalTime;
-          if (elapsedTime >= requestTimeout) {
+      const ensure = async () => {
+        try {
+          await this.ensureConnected();
+        } catch (error) {
+          reject(error);
+          return;
+        }
+        const requestId = generateRequestId();
+        this.connection.ws.send(JSON.stringify({
+          request_id: requestId,
+          type: messageType,
+          payload: params
+        }));
+        const intervalTime = 300;
+        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);
-            reject(new RequestTimeoutError(requestTimeout));
+            if (response.type === "reject_request" /* REJECT_REQUEST */) {
+              reject(new RejectRequestError);
+            } else {
+              resolve(response.payload);
+            }
+          } else {
+            elapsedTime += intervalTime;
+            if (elapsedTime >= timeoutMs) {
+              clearInterval(intervalId);
+              this.requests.delete(requestId);
+              reject(new RequestTimeoutError(timeoutMs));
+            }
           }
-        }
-      }, intervalTime);
+        }, intervalTime);
+      };
+      ensure();
     });
   }
 }
 
+// src/extensions/usdc/index.ts
+class UsdcBridge {
+  getProvider;
+  constructor(getProvider) {
+    this.getProvider = getProvider;
+  }
+  requireProvider() {
+    const provider = this.getProvider();
+    if (!provider) {
+      throw new Error("SDK not connected. Call connect() and wait for acceptance first.");
+    }
+    return provider;
+  }
+  withdrawalUSDCxToEthereum(recipient, amount, options) {
+    const provider = this.requireProvider();
+    const amountStr = typeof amount === "number" ? amount.toString() : amount;
+    const withdrawRequest = {
+      recipient,
+      amount: amountStr,
+      reference: options?.reference
+    };
+    return prepareUsdcWithdraw(provider.connection, provider.getAuthToken(), withdrawRequest).then((preparedPayload) => provider.submitTransaction({
+      commands: preparedPayload.commands,
+      disclosedContracts: preparedPayload.disclosedContracts,
+      packageIdSelectionPreference: preparedPayload.packageIdSelectionPreference,
+      actAs: preparedPayload.actAs,
+      readAs: preparedPayload.readAs,
+      synchronizerId: preparedPayload.synchronizerId
+    }, { requestTimeout: options?.requestTimeout }));
+  }
+}
+async function prepareUsdcWithdraw(connection, authToken, params) {
+  const payload = {
+    recipient: params.recipient,
+    amount: params.amount
+  };
+  if (params.reference) {
+    payload.reference = params.reference;
+  }
+  const response = await fetch(`${connection.apiUrl}/api/v1/.connect/pair/usdc/withdraw`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${authToken}`
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to prepare USDC withdrawal.");
+  }
+  const data = await response.json();
+  return data.payload;
+}
+
 // src/wallet.ts
 class LoopWallet {
   getProvider;
+  extension;
   constructor(getProvider) {
     this.getProvider = getProvider;
+    this.extension = {
+      usdcBridge: new UsdcBridge(this.getProvider)
+    };
   }
   requireProvider() {
     const provider = this.getProvider();
@@ -2531,9 +2665,6 @@ class LoopSDK {
       this.onReject?.();
       this.hideQrCode();
       console.log("[LoopSDK] HANDSHAKE_REJECT: closing popup (if exists)");
-      if (this.popupWindow && !this.popupWindow.closed) {
-        this.popupWindow.close();
-      }
       this.popupWindow = null;
     } else if (this.provider) {
       this.provider.handleResponse(message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fivenorth/loop-sdk",
-  "version": "0.6.4",
+  "version": "0.7.0",
   "author": "hello@fivenorth.io",
   "main": "dist/index.js",
   "module": "dist/index.js",