@unicitylabs/sphere-sdk 0.12.0-dev.1 → 0.13.0

package/dist/impl/nodejs/connect/index.cjs

@@ -324,7 +324,7 @@ var SPHERE_NETWORKS = {
 
 // connect/protocol.ts
 var SPHERE_CONNECT_NAMESPACE = "sphere-connect";
-var SPHERE_CONNECT_VERSION = "2.0";
+var SPHERE_CONNECT_VERSION = "2.1";
 var RPC_METHODS = {
   GET_IDENTITY: "sphere_getIdentity",
   GET_BALANCE: "sphere_getBalance",
@@ -360,6 +360,75 @@ var INTENT_ACTIONS = {
   SET_AUTO_RETURN: "set_auto_return",
   MINT: "mint"
 };
+var ERROR_CODES = {
+  // Standard JSON-RPC
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  // Sphere Connect (4xxx)
+  NOT_CONNECTED: 4001,
+  PERMISSION_DENIED: 4002,
+  USER_REJECTED: 4003,
+  SESSION_EXPIRED: 4004,
+  ORIGIN_BLOCKED: 4005,
+  RATE_LIMITED: 4006,
+  UNSUPPORTED_PROTOCOL_VERSION: 4007,
+  // Connect MAJOR mismatch (incompatible era)
+  INCOMPATIBLE_NETWORK: 4008,
+  // dApp targets a different network than the wallet
+  // Wallet locked; THE SESSION IS STILL ALIVE. A QUERY may be retried after wallet:unlocked.
+  // An INTENT already delegated to the wallet is NEVER answered with this code — it gets
+  // INTENT_OUTCOME_UNKNOWN (4201) instead, because a retry could double-spend.
+  WALLET_LOCKED: 4009,
+  INSUFFICIENT_BALANCE: 4100,
+  INVALID_RECIPIENT: 4101,
+  TRANSFER_FAILED: 4102,
+  INTENT_CANCELLED: 4200,
+  /**
+   * The intent was DELEGATED to the wallet and the host lost track of the answer — a host
+   * deadline fired, or the wallet locked / logged out mid-flight. **The outcome is UNKNOWN:
+   * the money may or may not have moved.**
+   *
+   * A dApp MUST NOT retry on this code. Reconcile out of band (poll the recipient, the
+   * aggregator, or your own backend) and only then decide.
+   *
+   * This code exists because every other answer would be a lie. `INTENT_CANCELLED` (4200)
+   * asserts the user declined and nothing happened; `WALLET_LOCKED` (4009) invites a retry
+   * after the unlock. Sending either for an intent the wallet had already submitted is how a
+   * paid-but-not-credited order — and then a double spend on retry — happens.
+   */
+  INTENT_OUTCOME_UNKNOWN: 4201
+};
+var WALLET_EVENTS = {
+  /** Wallet is LOCKED — the session is STILL ALIVE. Requests are answered
+   *  WALLET_LOCKED (4009) until `wallet:unlocked`. The dApp must NOT disconnect,
+   *  must NOT clear its sessionId, and must NOT re-handshake.
+   *  Payload: {@link WalletLockedPayload}. Pushed by ConnectHost.setLocked() and
+   *  immediately after a handshake response carrying `locked: true`. */
+  LOCKED: "wallet:locked",
+  /** Wallet was unlocked — the SAME session continues: no re-handshake, no re-approval,
+   *  no re-subscribe (the host re-arms the dApp's subscriptions before pushing this).
+   *  Payload: {@link WalletUnlockedPayload} — carries the CURRENT identity, which may
+   *  differ from the one the dApp connected with. Pushed by ConnectHost.updateSphere()
+   *  on the locked -> live edge only. */
+  UNLOCKED: "wallet:unlocked",
+  /** The session is GONE (logout, wallet deleted, dApp sphere_disconnect, expiry seen at
+   *  unlock, a different seed behind the lock screen, host destroy).
+   *  The dApp must clear its session and re-handshake to continue. Unlocking does not cure it.
+   *  Payload: {@link WalletDisconnectedPayload}. Pushed by ConnectHost.revokeSession(). */
+  DISCONNECTED: "wallet:disconnected",
+  /** Active wallet address changed. dApp should update displayed identity.
+   *  Pushed automatically by ConnectHost — no sphere_subscribe needed. */
+  IDENTITY_CHANGED: "identity:changed"
+};
+var AUTO_PUSHED_EVENTS = [
+  WALLET_EVENTS.LOCKED,
+  WALLET_EVENTS.UNLOCKED,
+  WALLET_EVENTS.DISCONNECTED,
+  WALLET_EVENTS.IDENTITY_CHANGED
+];
 function isSphereConnectMessage(msg) {
   if (!msg || typeof msg !== "object") return false;
   const m = msg;
@@ -426,6 +495,37 @@ var INTENT_PERMISSIONS = {
   [INTENT_ACTIONS.MINT]: PERMISSION_SCOPES.MINT_REQUEST
 };
 
+// connect/host/host-state.ts
+var WALLET_LOCKED_MESSAGE = "Wallet is locked";
+var NOT_CONNECTED_MESSAGE = "Not connected";
+var LOCKED_ALLOWLIST = /* @__PURE__ */ new Set([
+  RPC_METHODS.GET_IDENTITY,
+  RPC_METHODS.SUBSCRIBE,
+  RPC_METHODS.UNSUBSCRIBE,
+  RPC_METHODS.DISCONNECT
+]);
+var REFUSE_NOT_CONNECTED = {
+  kind: "refuse",
+  error: { code: ERROR_CODES.NOT_CONNECTED, message: NOT_CONNECTED_MESSAGE }
+};
+var REFUSE_LOCKED = {
+  kind: "refuse",
+  error: {
+    code: ERROR_CODES.WALLET_LOCKED,
+    message: WALLET_LOCKED_MESSAGE,
+    data: { reason: "locked" }
+  }
+};
+
+// connect/host/WalletSnapshot.ts
+var EMPTY_WALLET_SNAPSHOT = Object.freeze({ capturedAt: 0 });
+
+// connect/host/ConnectHost.ts
+var CHANNEL_ONLY_CODES = /* @__PURE__ */ new Set([
+  ERROR_CODES.WALLET_LOCKED,
+  ERROR_CODES.NOT_CONNECTED
+]);
+
 // transport/websocket.ts
 var WebSocketReadyState = {
   CONNECTING: 0,