@sogni-ai/sogni-client 5.80.1 → 5.82.0

package/AGENTS.md

@@ -29,6 +29,7 @@ Current public API anchors:
 - Project cost helpers are `sogni.projects.estimateCost()`, `estimateVideoCost()`, and `estimateAudioCost()`.
 - `sogni.projects.assets` manages private subscriber uploads (`upload`, `list`, `remove`, `bind`). Supported servers automatically reuse matching files passed to `projects.create()`; saved IDs do not replace file parameters.
 - `checkAuth()` is only for cookie-auth browser flows. API-key auth auto-authenticates during `createInstance()`, and token auth uses `login()` or `setTokens()`.
+- Optional media encryption: `createInstance({ mediaEncryption: 'auto' })` encrypts eligible new projects once encryption is available for the account (`sogni.mediaEncryption.available`). Unset, nothing changes. Read results through `job.getResultData()` or `sogni.mediaEncryption.fetchDecrypted()`, which return the media either way. `declareMediaCapability: false` keeps encrypting but has result links serve the media itself.
 - `ChatCompletionResult` is SDK-shaped (`content`, `role`, `finishReason`, `tool_calls`, `usage`, `cost`). Streaming chunks expose `chunk.content` and optional `chunk.tool_calls`.
 
 ## Public Release Security
@@ -72,7 +73,7 @@ Public chat and workflow media rules:
 
 ## Overview
 
-This is the **Sogni SDK for JavaScript/Node.js** - a TypeScript client library for the Sogni Supernet, a DePIN protocol for creative AI inference. The SDK supports image generation (Stable Diffusion, Flux, Z-Image / Z-Image Turbo, Krea 2 Turbo, Krea 2 Identity Edit, Chroma v.46 Flash / v.48 Detail / Chroma1-HD, Qwen image-edit models, GPT Image 2 and 2.5, Seedream 5.0 Pro Uncensored, plus community fine-tunes such as Dark Beast Z-Image Turbo v9, Dark Beast KREA 2, Dark Beast Krea 2 Identity Edit, and One Obsession v22), video generation (WAN 2.2, Wan 3, LTX-2.3, Seedance 2.0 and 2.5, HappyHorse 1.1, MiniMax H3, and MiniMax H3 Turbo), promptless video upscaling (FlashVSR v1.1), audio generation (MiniMax Music 3 by default, ACE-Step 1.5), LLM chat with tool calling, hosted creative tools, durable creative workflows, replay records, and multimodal vision chat (Qwen3.6 35B VLM, default `qwen3.6-35b-a3b-gguf-iq4xs`). The model catalog is discovered dynamically at runtime (`sogni.projects.getAvailableModels()`); model ids listed here are illustrative.
+This is the **Sogni SDK for JavaScript/Node.js** - a TypeScript client library for the Sogni Supernet, a DePIN protocol for creative AI inference. The SDK supports image generation (Stable Diffusion, Flux, Z-Image / Z-Image Turbo, Krea 2 Turbo, Krea 2 Identity Edit, Chroma v.46 Flash / v.48 Detail / Chroma1-HD, Qwen image-edit models, GPT Image 2 and 2.5, Seedream 5.0 Pro Uncensored and Seedream 5.5 Uncensored, plus community fine-tunes such as Dark Beast Z-Image Turbo v9, Dark Beast KREA 2, Dark Beast Krea 2 Identity Edit, and One Obsession v22), video generation (WAN 2.2, Wan 3, LTX-2.3, Seedance 2.0 and 2.5, HappyHorse 1.1, MiniMax H3, and MiniMax H3 Turbo), promptless video upscaling (FlashVSR v1.1), audio generation (MiniMax Music 3 by default, ACE-Step 1.5), LLM chat with tool calling, hosted creative tools, durable creative workflows, replay records, and multimodal vision chat (Qwen3.6 35B VLM, default `qwen3.6-35b-a3b-gguf-iq4xs`). The model catalog is discovered dynamically at runtime (`sogni.projects.getAvailableModels()`); model ids listed here are illustrative.
 
 Choosing an image-edit model: pick by what the edit has to preserve, not by step count or quality tier. When a person or character must stay recognisable through the edit — style transfer, makeover, clothing or person swap, face swap, new pose or expression, character sheet — use Krea 2 Identity Edit (`krea2_identity_edit_v1_2`, or `dark_beast_krea2_identity_edit_v1_2` uncensored) with 1-2 context images. For general-purpose editing — photo transforms, in-image text, multi-person changes, combining up to 3 references — use a Qwen image-edit model. A higher-step general-purpose editor does not beat the identity model at a likeness task; it reinterprets the subject instead of preserving it. See `llms.txt` for parameters.
 

package/CHANGELOG.md

@@ -1,3 +1,28 @@
+# [5.82.0](https://github.com/Sogni-AI/sogni-client/compare/v5.81.0...v5.82.0) (2026-11-13)
+
+
+### Features
+
+* **account:** add authenticator and passkey sign-in ([4420bb3](https://github.com/Sogni-AI/sogni-client/commit/4420bb3ef8c9f3669ade0480bb5cedbb2572d492))
+* **media:** add optional media encryption ([ea7a618](https://github.com/Sogni-AI/sogni-client/commit/ea7a61882f2edc854a712b112ff30f91def701c0))
+
+# [5.81.0](https://github.com/Sogni-AI/sogni-client/compare/v5.80.1...v5.81.0) (2026-11-13)
+
+
+### Bug Fixes
+
+* **projects:** name a switch request that never left the client ([6b85108](https://github.com/Sogni-AI/sogni-client/commit/6b8510839d6f6501db5fb6e8b2ead59cb7cfb21d))
+* **projects:** report unknown switch outcomes instead of fake refusals ([736b0ad](https://github.com/Sogni-AI/sogni-client/commit/736b0ad56ddd46eb78d1941a67471ad255d662a8))
+* **projects:** treat a not_found switch reply as an unknown outcome ([c1688f5](https://github.com/Sogni-AI/sogni-client/commit/c1688f5e89e2db9e5fd850825c81aacb2ce15f66))
+
+
+### Features
+
+* **projects:** expose the pay-as-you-go offer and Premium Spark switch ([672376b](https://github.com/Sogni-AI/sogni-client/commit/672376b92070d15935d030e7360ca2ce4597d271))
+* **projects:** support seedream layer extraction ([a575eb9](https://github.com/Sogni-AI/sogni-client/commit/a575eb9d028bbda2f46a2f04b01e790f75fc3bd7))
+* **seedream:** add Seedream 5.5 transparency, layer options and larger sizes ([0977330](https://github.com/Sogni-AI/sogni-client/commit/0977330bcdf38985b604b971346286ddf8f428bd))
+* **seedream:** recognise Seedream 5.5 Uncensored as a Seedream model ([5f6235f](https://github.com/Sogni-AI/sogni-client/commit/5f6235f932fb3af4569314fe718c8c1617db55a1))
+
 ## [5.80.1](https://github.com/Sogni-AI/sogni-client/compare/v5.80.0...v5.80.1) (2026-11-10)
 
 

package/README.md

@@ -135,6 +135,51 @@ await sogni.account.login('your-username', 'your-password');
 const models = await sogni.projects.waitForModels();
 ```
 
+#### Two-factor sign-in
+
+When an account has enabled two-factor authentication, `login()` throws
+`TwoFactorRequiredError` without starting a session. Ask the person for an
+authenticator or backup code, then complete that challenge:
+
+```javascript
+import { TwoFactorRequiredError } from '@sogni-ai/sogni-client';
+
+try {
+  await sogni.account.login(username, password, rememberMe);
+} catch (error) {
+  if (!(error instanceof TwoFactorRequiredError)) throw error;
+  const code = await askForAuthenticatorOrBackupCode(); // Your application's input UI
+  await sogni.account.verifyTwoFactorLogin(error, code);
+}
+```
+
+Keep the challenge in memory and discard it when the person cancels. Do not log
+or persist challenge tokens, authenticator setup keys, or backup codes.
+The account API also provides `getTwoFactorStatus()`, `setupTwoFactor()`,
+`confirmTwoFactorSetup()`, `disableTwoFactor()`, and
+`regenerateTwoFactorBackupCodes()`. Setup and management require a password
+session; API keys cannot manage two-factor settings.
+
+Passkeys can complete the same pending sign-in from a browser. Trigger the device
+prompt from a user gesture, such as a button click:
+
+```typescript
+import { startAuthentication } from '@simplewebauthn/browser';
+
+const pending = await sogni.account.getTwoFactorPasskeyOptions(challenge);
+const assertion = await startAuthentication({ optionsJSON: pending.options });
+await sogni.account.verifyTwoFactorLogin(challenge, {
+  challengeId: pending.challengeId,
+  assertion
+});
+```
+
+Account security screens use `beginPasskeySetup` / `finishPasskeySetup`
+and `removePasskey`. Save the first registration's backup codes before finishing.
+Management accepts an authenticator/backup code or a passkey proof from
+`getTwoFactorPasskeyOptions()` without a login challenge. Keep pending proofs
+in memory. A second step adds to the Sogni password; it does not replace it.
+
 #### Restoring a deleted account at sign-in
 
 When someone signs in to an account they deleted and the account can be restored, `login()` throws
@@ -236,6 +281,35 @@ The same current fields are available on `Project.waitingReason`, `Project.jobWa
 
 Set `socketEventSubscriptions: { projectQueue: false }` to opt out. A runtime subscription reset disables this optional stream; subscribe again with `{ projectQueue: true }` if needed.
 
+#### Running a waiting plan project on Premium Spark
+
+When an Unlimited plan project has waited a while on Fast and a card outside the plan's worker pool could start it now, supported servers add an optional offer to the same queue stream. `Project.payAsYouGo` and the `payAsYouGo` field of `queueChanged` hold `{ available: true, costInSpark, coveredByPremiumSpark }`, or `null` when nothing is offered. `costInSpark` is the project's normal Premium Spark price as a decimal string. `coveredByPremiumSpark` is advisory; the server decides when you ask. The offer clears when a result starts, the project ends, the connection drops, or the server stops sending it.
+
+Nothing is charged until the owner asks:
+
+```typescript
+const result = await sogni.projects.switchToPremiumSpark(projectId); // or project.switchToPremiumSpark()
+if (result.status === 'switched') {
+  // The project now runs on Premium Spark; its price was charged once.
+} else if (result.status === 'refused') {
+  // This request costs nothing. If the server had already started its debit
+  // (for example 'payment_failed', 'no_idle_worker' or 'started'), that debit
+  // is cancelled, and the balance can take a moment to show it, so tell the
+  // member they won't be charged rather than that they weren't.
+  // result.reason says why. 'started' and 'not_eligible' clear the offer; after other refusals, such as
+  // 'insufficient_premium_spark' (offer a Spark purchase, then ask again), the
+  // server's next queue update decides whether the offer stays.
+} else {
+  // 'unknown' (result.reason: 'timeout', 'not_found', 'session_changed' or
+  // 'unrecognized_reply'): the project may have been switched and charged.
+  // Treat the payment as possibly made.
+}
+```
+
+Asking again is safe and never charges twice. It answers `switched` if the earlier request switched, a refusal from the server if it costs nothing, or `unknown` again, including `not_found` once the creation has finished. While the outcome stays unknown, check the member's Spark history or the creation's result rather than assuming either way. A `not_sent` refusal comes from the SDK itself: that request never left the client, so it says nothing about the earlier one; ask again once connected.
+
+The server reads project ids of at most 128 characters, and API-key sessions are never offered the switch and are refused with `not_eligible`. Concurrent calls for one project share a single request. If the connection drops while a request is pending, the SDK sends it once more after reconnecting. `timeoutMs` (default 45 seconds) counts from when the request is sent. Servers without the feature never send an offer.
+
 User-facing subscription limit notices are opt-in. Enable the event when a client needs live queue, concurrency, or fair-use messaging:
 
 ```typescript
@@ -610,7 +684,7 @@ Here is a full list of project parameters that you can use:
 - `negativePrompt` - text prompt that describes what you don't want to see in the image. Can be an empty string.
 - `stylePrompt` - text prompt that describes the style of the image. Can be an empty string.
 - `numberOfImages` - number of images to generate.
-- `tokenType` - select token type to pay for render. Can be either `sogni` or `spark`. External API-backed models such as GPT Image 2, Seedream 5.0 Pro Uncensored, and Seedance are Spark-only.
+- `tokenType` - select token type to pay for render. Can be either `sogni` or `spark`. External API-backed models such as GPT Image 2, Seedream 5.0 Pro Uncensored, Seedream 5.5 Uncensored, and Seedance are Spark-only.
 - `sizePreset` - optionally pass the ID of a size preset to use. If not passed, the default output is a square at
   either 512x512, 768x768 or 1024x1024 (SDXL and Flux) based on the default resolution of the selected model.
   See **Detecting available output presets** section below for available presets for your model. The token cost and
@@ -714,7 +788,61 @@ const project = await sogni.projects.create({
 });
 ```
 
-It shares the one-time likeness and consent agreement of Seedance 2.5 Uncensored: an account that has accepted it for Seedance can use Seedream, and until it is accepted in a Sogni app every Seedream job fails with `MODEL_CONSENT_REQUIRED_ERROR_CODE` (4103), whose error carries `consentRequired: { key: 'seedance-2-5-uncensored', version, modelId: 'seedream-5-0-pro-uncensored' }` and is detected by `isModelConsentRequiredError()`. `isSeedreamModel()` and `SEEDREAM_5_PRO_UNCENSORED_MODEL_ID` are exported from the package root. Hosted chat tools (`generate_image`, `edit_image`) use it only when the call names it.
+It shares the one-time likeness and consent agreement of Seedance 2.5 Uncensored: an account that has accepted it for Seedance can use Seedream, and until it is accepted in a Sogni app every Seedream job fails with `MODEL_CONSENT_REQUIRED_ERROR_CODE` (4103), whose error carries `consentRequired: { key: 'seedance-2-5-uncensored', version, modelId: 'seedream-5-0-pro-uncensored' }` and is detected by `isModelConsentRequiredError()`. `isSeedreamModel()`, `SEEDREAM_5_PRO_UNCENSORED_MODEL_ID` and `SEEDREAM_5_5_UNCENSORED_MODEL_ID` are exported from the package root. Hosted chat tools (`generate_image`, `edit_image`) use it only when the call names it.
+
+### Seedream 5.5 Uncensored
+
+Seedream 5.5 Uncensored (`seedream-5-5-uncensored`) takes the same requests as 5.0 Pro: text-to-image or edits from 1-10 `contextImages`, Spark-only, no negative prompt, seed or steps, and the same one-time agreement. It is chosen only by name; `seedream-uncensored` and the other unversioned names still select 5.0 Pro. Custom sizes run from 921,600 to 4,624,220 pixels at an aspect ratio from 1:16 to 16:1. Its native sizes are:
+
+- 1K: 1024x1024, 1152x864, 864x1152, 1424x800, 800x1424, 1248x832, 832x1248, 1568x672
+- 1.5K: 1536x1536, 1792x1344, 1344x1792, 2048x1152, 1152x2048, 1872x1248, 1248x1872, 2352x1008
+- 2K: 2048x2048, 2368x1776, 1776x2368, 2816x1584, 1584x2816, 2496x1664, 1664x2496, 3136x1344
+
+`seedreamBackground` sets transparency on 5.5 only: `'opaque'` (the default) returns an RGB image, `'transparent'` an RGBA image, and `'auto'` lets the model decide from the prompt. Transparency works for text-to-image and for edits from up to 10 references, which need no alpha channel of their own. It needs PNG (the default) or WebP output, so `'transparent'` and `'auto'` refuse `outputFormat: 'jpg'`, and it cannot combine with layer extraction.
+
+```javascript
+const sticker = await sogni.projects.create({
+  type: 'image', network: 'fast', tokenType: 'spark',
+  modelId: 'seedream-5-5-uncensored',
+  positivePrompt: 'A glossy cherry sticker with a white die-cut border',
+  numberOfMedia: 1, width: 1536, height: 1536,
+  seedreamBackground: 'transparent'
+});
+```
+
+### Seedream layer extraction
+
+Both Seedream models can split one image into a base image and transparent PNG layers. Layer extraction is opt-in with `seedreamLayerDecomposition: true`, exactly one `contextImages` entry and `numberOfMedia: 1`. Choose `seedreamLayerSize: '1K' | '1.5K' | '2K'` (default `'1.5K'`); the source determines the aspect ratio. The prompt can be empty, which splits every major element, or name the parts to extract.
+
+- Seedream 5.0 Pro Uncensored returns up to 16 layers. Its estimate reserves the maximum 17 returned images.
+- Seedream 5.5 Uncensored returns up to 99 layers. `seedreamLayerMaxImages` caps the images returned, base included, at an integer from 2 to 100 (default 17), and its estimate reserves that many. `seedreamLayerTextRecognition: true` also reads the text of regular text layers.
+
+The final charge uses the base image and layers actually returned. Pass the same layer options to `sogni.projects.estimateCost()` to quote a request. Both 5.5 options require `seedreamLayerDecomposition`, and 5.0 Pro refuses them.
+
+```javascript
+const split = await sogni.projects.create({
+  type: 'image', network: 'fast', tokenType: 'spark',
+  modelId: 'seedream-5-5-uncensored',
+  contextImages: [sourceImage], numberOfMedia: 1,
+  positivePrompt: '',
+  seedreamLayerDecomposition: true, seedreamLayerSize: '1.5K',
+  seedreamLayerMaxImages: 8, seedreamLayerTextRecognition: true
+});
+await split.waitForCompletion();
+const job = split.jobs[0];
+// job.resultUrl is the base. job.layers holds the transparent PNG layers,
+// ordered by zIndex, with names, dimensions and absolute/normalized bounds.
+for (const layer of job.layers ?? []) {
+  const freshLayerUrl = await job.getLayerUrl(layer.zIndex);
+  if (layer.textRecognition) console.log(layer.textRecognition.text);
+}
+```
+
+Each `ImageLayer` has `url`, `width`, `height`, `zIndex` (1-99; the base is 0), `boundingBox: { absolute, normalized }` (`[left, top, right, bottom]` in base-image pixels and on a 0-1000 grid), and optional `name` and `description`. A layer image is rendered near the size tier, so it can be larger than its box: scale it to `right - left` by `bottom - top` before placing it at `left, top` on the base, stacking layers in `zIndex` order.
+
+`layer.textRecognition` is present only on Seedream 5.5 layers the model classes as regular text, and only when text recognition was requested; artistic text, handwriting and other layers have none. Its shape is `{ text, lines: [{ boundingBox: { absolute, normalized }, runs: [{ text, style: { similarFontFamily, foregroundColor, bold, italic, underline, strikethrough, shadow, translucent } }] }] }`, where `text` is the layer's full text with lines separated by `\n`, `foregroundColor` is `#RRGGBB`, and `similarFontFamily` is the closest matching font or `'unknown'`.
+
+Layer metadata also appears on completed job events and recovered projects. Layer URLs expire; `job.getLayerUrl(zIndex)` refreshes a layer URL after checking ownership. Omitting the extraction options preserves ordinary generation and editing.
 
 ### Detecting available output presets
 
@@ -980,6 +1108,67 @@ clients that manage project IDs and input slots directly.
 Project history may include `byolUsed`, `personalLoras` public-source snapshots,
 and `reusedAssetCount`. Missing fields on older projects mean unknown, not zero.
 
+### Media encryption
+
+The SDK offers optional encryption of project media for the signed-in account.
+Turn it on when creating the client:
+
+```javascript
+const sogni = await SogniClient.createInstance({ appId, mediaEncryption: 'auto' });
+await sogni.account.login('username', 'password');
+
+const project = await sogni.projects.create(params);
+await project.waitForCompletion();
+const blob = await project.jobs[0].getResultData(); // the media, with its real MIME type
+```
+
+- Once media encryption is available for the account
+  (`sogni.mediaEncryption.available`), every eligible new project is encrypted.
+  Until then, and without the option, the client works exactly as before.
+- Read results with `job.getResultData()`, or
+  `sogni.mediaEncryption.fetchDecrypted(url)` for result and preview URLs, rather
+  than loading the URL in an `<img>` or `<video>` directly. Both return the
+  media whether or not it was encrypted.
+- A project is sent unencrypted when encryption is not available for it: for the
+  account at that moment, for its model (`projects.supportsMediaEncryption(modelId)`),
+  or for its network (Fast only, for now), or when an input is `true` ("already
+  uploaded"). `job.encrypted` and `project.encrypted` say which projects were
+  sent encrypted.
+- Set `mediaEncryption` on a project to override the client: `false` sends it
+  unencrypted, and `true` encrypts it or throws `MediaEncryptionError` before
+  anything is uploaded. Saved uploads work for encrypted projects too.
+- Services that pass result links on to others can add
+  `declareMediaCapability: false`: projects are still encrypted, and result,
+  preview and download URLs serve the media itself.
+- `availabilityChanged` fires when `sogni.mediaEncryption.available` changes.
+  Client-side failures throw `MediaEncryptionError` with a `code` such as
+  `locked`, `unsupported`, `wrong_account_key` or `authentication_failed`.
+
+For encrypted video and audio, `openDecrypted()` reads byte ranges without
+downloading the entire file. Offsets refer to the media itself and the end offset
+is exclusive. Use `stream()` for large reads and close the reader when finished;
+locking or changing accounts also aborts its outstanding requests.
+
+```javascript
+const media = await sogni.mediaEncryption.openDecrypted(resultUrl);
+try {
+  const header = await media.read(0, Math.min(1024, media.size));
+  // media.contentType is the media's MIME type; media.stream() reads with backpressure.
+} finally {
+  media.close();
+}
+```
+
+Browser apps can import `createEncryptedPlayback` and `serveEncryptedMedia` from
+`@sogni-ai/sogni-client/media-encryption-playback` to play encrypted video and
+audio through their own service worker. The worker must route
+`ENCRYPTED_MEDIA_PATH` requests with the requesting client's ID, and answer
+`SOGNI_ENCRYPTED_MEDIA_CLIENT` messages through their transferred port with
+`{ clientId: event.source.id }`. Pass the opened reader to
+`createEncryptedPlayback()`, use its returned `url` as the media element's
+source, and call `dispose()` when removing the element. The URL belongs to that
+tab. This requires an active service worker controlling the page.
+
 ### ControlNets
 
 **EXPERIMENTAL FEATURE:** This feature is still in development and may not work as expected. Use at your own risk.
@@ -2006,6 +2195,7 @@ scheduler and dimension bounds. Both presets accept compatible Personal LoRAs.
 | `qwen_image_edit_2511_fp8_lightning`  | **Qwen Image Edit Lightning** - Fast 4-step editing      | Rapid reference-based image generation                                                                       |
 | `qwen_image_edit_2511_fp8`            | **Qwen Image Edit** - High quality 20-step editing       | Professional image editing with context awareness                                                            |
 | `seedream-5-0-pro-uncensored`         | **Seedream 5.0 Pro Uncensored** - ByteDance, external API | Text-to-image and edits from 1-10 reference images; accept the Seedance 2.5 Uncensored agreement first (error 4103 until then) |
+| `seedream-5-5-uncensored`             | **Seedream 5.5 Uncensored** - ByteDance, external API     | Text-to-image and edits from 1-10 reference images up to 4,624,220 pixels, transparent backgrounds, up to 99 layers; same agreement |
 | `wan_v2.2-14b-fp8_t2v_lightx2v`       | **Wan 2.2 T2V** - Text-to-video                          | Generate videos from text prompts                                                                            |
 | `seedance-2-0`                        | **Seedance 2.0** - 4K external API multimodal video      | Full Seedance 2.0 24fps video generation with optional image, video, and audio context                       |
 | `seedance-2-0-mini`                   | **Seedance 2.0 Mini** - 720p external API video          | Fastest, lower-cost 24fps Seedance video generation                                                          |

package/dist/Account/TwoFactorRequiredError.d.ts

@@ -0,0 +1,8 @@
+/** Sign-in needs an authenticator or backup code before a session can begin. */
+export default class TwoFactorRequiredError extends Error {
+    readonly tempToken: string;
+    readonly walletAddress: string;
+    readonly username: string;
+    readonly name = "TwoFactorRequiredError";
+    constructor(tempToken: string, walletAddress: string, username: string);
+}

package/dist/Account/TwoFactorRequiredError.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/** Sign-in needs an authenticator or backup code before a session can begin. */
+class TwoFactorRequiredError extends Error {
+    constructor(tempToken, walletAddress, username) {
+        super('Enter your authenticator code or a backup code to finish signing in.');
+        this.tempToken = tempToken;
+        this.walletAddress = walletAddress;
+        this.username = username;
+        this.name = 'TwoFactorRequiredError';
+    }
+}
+exports.default = TwoFactorRequiredError;
+//# sourceMappingURL=TwoFactorRequiredError.js.map

package/dist/Account/TwoFactorRequiredError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TwoFactorRequiredError.js","sourceRoot":"","sources":["../../src/Account/TwoFactorRequiredError.ts"],"names":[],"mappings":";;AAAA,gFAAgF;AAChF,MAAqB,sBAAuB,SAAQ,KAAK;IAGvD,YACkB,SAAiB,EACjB,aAAqB,EACrB,QAAgB;QAEhC,KAAK,CAAC,sEAAsE,CAAC,CAAC;QAJ9D,cAAS,GAAT,SAAS,CAAQ;QACjB,kBAAa,GAAb,aAAa,CAAQ;QACrB,aAAQ,GAAR,QAAQ,CAAQ;QALzB,SAAI,GAAG,wBAAwB,CAAC;IAQzC,CAAC;CACF;AAVD,yCAUC"}

package/dist/Account/index.d.ts

@@ -1,3 +1,5 @@
+import type { AuthenticationResponseJSON, RegistrationResponseJSON, PublicKeyCredentialCreationOptionsJSON, PublicKeyCredentialRequestOptionsJSON } from '@simplewebauthn/browser';
+import TwoFactorRequiredError from './TwoFactorRequiredError.js';
 import { AccountCreateData, AccountCreateParams, Balances, ClaimOptions, FullBalances, LoginData, LoginOptions, MeData, Reward, RewardsQuery, TxHistoryEntry, TxHistoryParams } from './types.js';
 import { CreateSubscriptionCheckoutOptions, SubscriptionCheckoutResult, SubscriptionEntitlementSnapshot, SubscriptionPlanId, SubscriptionPlan, SubscriptionPortalSession, SubscriptionTerm, SubscriptionUsage, TrialEligibility } from './subscription.types.js';
 import ApiGroup, { ApiConfig } from '../ApiGroup.js';
@@ -16,6 +18,22 @@ import { SupernetType } from '../ApiClient/WebSocketClient/types.js';
  * ```
  *
  */
+export type TwoFactorProof = {
+    code: string;
+} | {
+    assertion: AuthenticationResponseJSON;
+    challengeId: string;
+};
+export interface TwoFactorStatus {
+    enabled: boolean;
+    backupCodesRemaining: number;
+    canManage: boolean;
+    authenticatorEnabled: boolean;
+    passkeys: {
+        id: string;
+        name: string;
+    }[];
+}
 declare class AccountApi extends ApiGroup {
     readonly currentAccount: CurrentAccount;
     /**
@@ -139,6 +157,31 @@ declare class AccountApi extends ApiGroup {
      * seconds).
      */
     login(username: string, password: string, rememberMe?: boolean, appSource?: string, options?: LoginOptions): Promise<LoginData>;
+    private acceptLogin;
+    /** Complete the sign-in requested by a TwoFactorRequiredError. Keep the challenge in memory. */
+    verifyTwoFactorLogin(challenge: TwoFactorRequiredError, proof: string | TwoFactorProof): Promise<LoginData>;
+    getTwoFactorStatus(): Promise<TwoFactorStatus>;
+    getTwoFactorPasskeyOptions(challenge?: TwoFactorRequiredError): Promise<{
+        challengeId: string;
+        options: PublicKeyCredentialRequestOptionsJSON;
+    }>;
+    beginPasskeySetup(username: string, password: string, name: string, proof?: TwoFactorProof): Promise<{
+        setupId: string;
+        options: PublicKeyCredentialCreationOptionsJSON;
+        backupCodes?: string[];
+    }>;
+    finishPasskeySetup(setupId: string, response: RegistrationResponseJSON): Promise<void>;
+    removePasskey(username: string, password: string, credentialId: string, proof: string | TwoFactorProof): Promise<void>;
+    private twoFactorSignature;
+    setupTwoFactor(username: string, password: string, proof?: TwoFactorProof): Promise<{
+        setupId: string;
+        secret: string;
+        qrData: string;
+        backupCodes: string[];
+    }>;
+    confirmTwoFactorSetup(setupId: string, code: string): Promise<void>;
+    disableTwoFactor(username: string, password: string, proof: string | TwoFactorProof): Promise<void>;
+    regenerateTwoFactorBackupCodes(username: string, password: string, proof: string | TwoFactorProof): Promise<string[]>;
     /**
      * Logout the user and close the WebSocket connection.
      *

package/dist/Account/index.js

@@ -12,6 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const TwoFactorRequiredError_js_1 = __importDefault(require("./TwoFactorRequiredError.js"));
 const ApiGroup_js_1 = __importDefault(require("../ApiGroup.js"));
 const requestSession_js_1 = require("../lib/requestSession.js");
 const ethers_1 = require("ethers");
@@ -43,17 +44,9 @@ function parseSubscriptionVersion(version) {
     }
     return null;
 }
-/**
- * Account API methods that let you interact with the user's account.
- * Can be accessed via `sogni.account`. Look for more samples below.
- *
- * @example Retrieve the current account balance
- * ```typescript
- * const balance = await sogni.account.refreshBalance();
- * console.log(balance);
- * ```
- *
- */
+function factorProof(value) {
+    return typeof value === 'string' ? { code: value.trim().toUpperCase() } : value;
+}
 class AccountApi extends ApiGroup_js_1.default {
     constructor(config) {
         super(config);
@@ -445,17 +438,108 @@ class AccountApi extends ApiGroup_js_1.default {
             });
             const resolvedAppSource = (appSource === null || appSource === void 0 ? void 0 : appSource.trim()) || this.client.appSource;
             const res = yield this.client.rest.post('/v1/account/login', Object.assign(Object.assign(Object.assign({ walletAddress: wallet.address, signature }, (resolvedAppSource ? { appSource: resolvedAppSource } : {})), { rememberMe }), ((options === null || options === void 0 ? void 0 : options.restoreDeletedAccount) ? { restoreDeletedAccount: true } : {})));
+            if (res.data.requires2FA) {
+                if (!res.data.tempToken)
+                    throw new Error('Unable to start verification. Please sign in again.');
+                throw new TwoFactorRequiredError_js_1.default(res.data.tempToken, wallet.address, res.data.username);
+            }
+            yield this.acceptLogin(res.data, wallet.address);
+            return res.data;
+        });
+    }
+    acceptLogin(data, walletAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
             const auth = this.client.auth;
             if (auth instanceof index_js_3.TokenAuthManager) {
-                yield auth.authenticate({ refreshToken: res.data.refreshToken, token: res.data.token });
+                yield auth.authenticate({ refreshToken: data.refreshToken, token: data.token });
             }
             else if (auth instanceof index_js_3.CookieAuthManager) {
-                auth._setSessionIdentity(wallet.address.toLowerCase());
+                auth._setSessionIdentity(walletAddress.toLowerCase());
                 yield auth.authenticate();
             }
+        });
+    }
+    /** Complete the sign-in requested by a TwoFactorRequiredError. Keep the challenge in memory. */
+    verifyTwoFactorLogin(challenge, proof) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.client.rest.post('/v1/account/2fa/verify-login', Object.assign({ tempToken: challenge.tempToken }, factorProof(proof)));
+            yield this.acceptLogin(res.data, challenge.walletAddress);
+            return Object.assign(Object.assign({}, res.data), { username: challenge.username });
+        });
+    }
+    getTwoFactorStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.client.rest.get('/v1/account/2fa/status');
             return res.data;
         });
     }
+    getTwoFactorPasskeyOptions(challenge) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.client.rest.post(challenge
+                ? '/v1/account/2fa/passkeys/login-options'
+                : '/v1/account/2fa/passkeys/authentication-options', challenge ? { tempToken: challenge.tempToken } : {});
+            return res.data;
+        });
+    }
+    beginPasskeySetup(username, password, name, proof) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signature = yield this.twoFactorSignature(username, password);
+            const res = yield this.client.rest.post('/v1/account/2fa/passkeys/registration-options', Object.assign({ signature,
+                name }, (proof ? { proof } : {})));
+            return res.data;
+        });
+    }
+    finishPasskeySetup(setupId, response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.client.rest.post('/v1/account/2fa/passkeys/register', { setupId, response });
+        });
+    }
+    removePasskey(username, password, credentialId, proof) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signature = yield this.twoFactorSignature(username, password);
+            yield this.client.rest.post('/v1/account/2fa/passkeys/remove', Object.assign({ signature,
+                credentialId }, factorProof(proof)));
+        });
+    }
+    twoFactorSignature(username, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const wallet = this.getWallet(username, password);
+            if (wallet.address.toLowerCase() !== ((_a = this.currentAccount.walletAddress) === null || _a === void 0 ? void 0 : _a.toLowerCase())) {
+                throw new Error('Incorrect password. Please try again.');
+            }
+            const nonce = yield this.getNonce(wallet.address);
+            return this.eip712.signTypedData(wallet, 'authentication', {
+                walletAddress: wallet.address,
+                nonce
+            });
+        });
+    }
+    setupTwoFactor(username, password, proof) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signature = yield this.twoFactorSignature(username, password);
+            const res = yield this.client.rest.post('/v1/account/2fa/setup', Object.assign({ signature }, (proof ? { proof } : {})));
+            return res.data;
+        });
+    }
+    confirmTwoFactorSetup(setupId, code) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.client.rest.post('/v1/account/2fa/verify-setup', { setupId, code: code.trim() });
+        });
+    }
+    disableTwoFactor(username, password, proof) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signature = yield this.twoFactorSignature(username, password);
+            yield this.client.rest.post('/v1/account/2fa/disable', Object.assign({ signature }, factorProof(proof)));
+        });
+    }
+    regenerateTwoFactorBackupCodes(username, password, proof) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signature = yield this.twoFactorSignature(username, password);
+            const res = yield this.client.rest.post('/v1/account/2fa/backup-codes', Object.assign({ signature }, factorProof(proof)));
+            return res.data.backupCodes;
+        });
+    }
     /**
      * Logout the user and close the WebSocket connection.
      *