@invisible-labs/sdk 0.9.0-devnet → 0.11.0-devnet

package/dist/stats.js

@@ -1,4 +1,4 @@
-import { NotImplementedError } from './chunk-RWKG7N7I.js';
+import { NotImplementedError } from './chunk-A4R3DHKN.js';
 import './chunk-VR6T6OJS.js';
 
 // src/stats/index.ts

package/dist/storage.js

@@ -1,5 +1,5 @@
-export { browserStorage, extensionStorage, inMemoryStorage } from './chunk-AIKC2XQS.js';
-import './chunk-RWKG7N7I.js';
+export { browserStorage, extensionStorage, inMemoryStorage } from './chunk-YYTRFM2F.js';
+import './chunk-A4R3DHKN.js';
 import './chunk-VR6T6OJS.js';
 //# sourceMappingURL=storage.js.map
 //# sourceMappingURL=storage.js.map

package/dist/{types.generated-DrM2M4DZ.d.ts → types.generated-BpbFQlYB.d.ts}

@@ -29,7 +29,7 @@ type StorageErrorCode = "STORAGE_NOT_AVAILABLE" | "STORAGE_INVALID_ADAPTER" | "S
 /** Wallet-adapter failures. Bubble to the integrator UX. */
 type WalletErrorCode = "WALLET_NOT_CONNECTED" | "WALLET_USER_REJECTED" | "WALLET_INVALID_SIGNATURE";
 /** LP lifecycle local state that callers can branch on. */
-type LpLifecycleErrorCode = "LP_POSITION_AUTH_MISSING" | "LP_REDEMPTION_RECONCILING";
+type LpLifecycleErrorCode = "LP_POSITION_AUTH_MISSING" | "LP_REDEMPTION_RECONCILING" | "LP_DKG_BUSY" | "LP_CLIENT_INVALIDATED" | "LP_DKG_WORKER_FAILED";
 /** Skeleton-only: a surface that exists but has no implementation yet. */
 type NotImplementedErrorCode = "NOT_IMPLEMENTED";
 /** Every code the SDK can surface, across all classes. */
@@ -146,6 +146,12 @@ type RuntimeMeasurements = {
     readonly rtmr2: string;
     readonly rtmr3: string;
 };
+type LpFeePolicy = {
+    readonly version: 1;
+    readonly profile: "internal" | "partner";
+    readonly commission_bps: 0 | 6000;
+    readonly policy_hash: string;
+};
 type LpPositionView = {
     readonly id: string;
     readonly status: "dkg_pending" | "active" | "withdrawing" | "closed";
@@ -165,6 +171,74 @@ type LpPositionView = {
         readonly grantRevision: number;
         readonly observedAtMs: number;
     };
+    readonly feePolicy?: LpFeePolicy;
+    readonly lpFeePolicyVersion?: 1;
+    readonly actorSync?: {
+        readonly economicReturn?: {
+            readonly providerRewardLamports: string;
+            readonly sourceExpenseCompensationLamports: string;
+            readonly chargedReimbursementLossLamports: string;
+            readonly netEconomicReturnLamports: string;
+        };
+        readonly lpPositionId: string;
+        readonly status: "idle" | "settling" | "reimbursement_due";
+        readonly sourceLiquidityUse: "not_materialized" | "available" | "locked_for_payout" | "pending_finality" | "spent" | "released";
+        readonly redeemablePrincipalLamports?: number;
+        readonly redeemableFeeLamports?: number;
+        readonly lifetimeEarnedLamports?: number;
+        readonly redeemablePrincipalSourceCount?: number;
+        readonly redeemableFeeSourceCount?: number;
+        readonly redeemableSourceCount?: number;
+        readonly pendingReservationCount: number;
+        readonly reservedPayoutLamports: number;
+        readonly estimatedNetworkFeeLamports: number;
+        readonly reimbursementDueCount: number;
+        readonly reimbursementDueSourceCount: number;
+        readonly reimbursementDuePayoutLamports: number;
+        readonly reimbursementDueNetworkFeeLamports: number;
+        readonly withdrawalRequestedLamports: number;
+        readonly withdrawalLandedLamports: number;
+        readonly withdrawalLandedFeeLamports: number;
+        readonly withdrawalCanceledLamports: number;
+        readonly withdrawalNetworkFeeLossLamports: number;
+        readonly withdrawalTxHashes: readonly string[];
+        readonly redemptionHistory?: readonly {
+            readonly redemptionId: string;
+            readonly state: "requested" | "match_requested" | "reserved" | "pending" | "confirmed" | "rejected";
+            readonly withdrawalMode?: "exact" | "max_available";
+            readonly acceptedLamports: number;
+            readonly acceptedDepositPrincipalLamports: number;
+            readonly acceptedEarnedFeeLamports: number;
+            readonly landedLamports: number;
+            readonly landedDepositPrincipalLamports: number;
+            readonly landedEarnedFeeLamports: number;
+            readonly canceledLamports: number;
+            readonly canceledDepositPrincipalLamports: number;
+            readonly canceledEarnedFeeLamports: number;
+            readonly networkFeeLamports: number;
+            readonly networkFeeLossLamports: number;
+            readonly failedAttempts: number;
+            readonly destinationAddresses: readonly string[];
+            readonly destinationCount: number;
+            readonly txSignatures: readonly string[];
+            readonly txSignatureCount: number;
+            readonly detailsTruncated: boolean;
+            readonly stateVersion: number;
+            readonly createdAtMs: number;
+            readonly updatedAtMs: number;
+            readonly feePolicyHash?: string;
+            readonly feeBasisRevision?: number;
+        }[];
+        readonly redemptionHistoryHasMore?: boolean;
+        readonly redemptionHistoryNextCursor?: string;
+        readonly stateVersion: number;
+        readonly updatedAtMs: number;
+        readonly feePolicy?: LpFeePolicy;
+        readonly feeBasisRevision?: number;
+        readonly grossFeeLamports?: number;
+        readonly protocolCommissionLamports?: number;
+        readonly redeemableProjectionAvailable: boolean;
+    };
 };
 type PayoutDestination = {
     readonly address: string;

package/dist/user.d.ts

@@ -1,5 +1,5 @@
-import { C as CommandError, P as PayoutPolicy } from './types.generated-DrM2M4DZ.js';
-export { I as InvalidDepositAmountError } from './types.generated-DrM2M4DZ.js';
+import { C as CommandError, P as PayoutPolicy } from './types.generated-BpbFQlYB.js';
+export { I as InvalidDepositAmountError } from './types.generated-BpbFQlYB.js';
 import { S as Session } from './session-DFuy54C-.js';
 
 /**
@@ -141,6 +141,7 @@ type RunSwapParams = {
     /** No automatic policy: absent this callback, initialization busy is returned to the caller. */
     onInitializationRetry?: (retry: InitializationRetry) => Promise<void>;
     amountLamports: number;
+    batchExclusionId?: string;
     payoutSpec: PayoutSpec;
     payoutDeadlineMs?: number;
     onPolicySnapshot?: (policy: SpendingPolicySnapshot) => void;
@@ -307,8 +308,12 @@ interface ContractRequestArgs {
     /**
      * Where and how the output is delivered. V0 normal-user requests support
      * exactly one payout destination and validate the policy locally before
-     * submission. `batchExclusionId` is rejected in V0; its planned V1 meaning
-     * is campaign-scoped batch exclusion, never a stable actor identity.
+     * submission. Reuse the same `batchExclusionId` for each contract belonging
+     * to one user so liquidity from their own deposits, including deposits that
+     * later reimbursed an LP, cannot fund their own payout. The payout waits
+     * when no other liquidity is available.
+     * This opaque value is not proof of identity; integrators are responsible
+     * for assigning and retaining it.
      * `destinations[*].minDelayMs` and `destinations[*].maxDelayMs` are also
      * rejected in V0 because the current runtime does not honor them.
      * `totalDeadlineMs` selects the payout window: use `0` for instant payout,

package/dist/user.js

@@ -1,13 +1,13 @@
-import { scheduledPayoutWindowSeconds, ErrorCode } from './chunk-QF5TSUQE.js';
-import { validatePayoutPolicyShape, formatAjvErrors, persistTransferStatus, createSession, disabledClientPersistence, readPersistedTransferForResume, persistTransferReady, createExponentialBackoff, persistTransferTerminal, persistTransferRecoveryCode, persistTransferAllocation, persistTransferDkgMetadata } from './chunk-EOPZVOVP.js';
-export { getPersistedTransfer, listPersistedTransfers, purgePersistedTransfers, removePersistedTransfer } from './chunk-EOPZVOVP.js';
-import { PRODUCT_MAX_ENTRY_LAMPORTS, PRODUCT_MIN_ENTRY_LAMPORTS } from './chunk-HWRMSK7E.js';
-import { assertAttested, publicKey, solanaAddressFromPublicKeyBytes } from './chunk-EPWTRF5U.js';
-import { requestEnvelope, CoordinatorMessageType, onEnvelope, closeProtocolRuntime, EnvelopeKind } from './chunk-ISIWWGSR.js';
-import { getSessionState } from './chunk-6AKBRYKO.js';
-import './chunk-AIKC2XQS.js';
-import { PolicyValidationError, CommandError, StorageError, TransportError, normalizeError, InvalidDepositAmountError, AttestationError, RoutingError } from './chunk-RWKG7N7I.js';
-export { InvalidDepositAmountError } from './chunk-RWKG7N7I.js';
+import { scheduledPayoutWindowSeconds, ErrorCode } from './chunk-M45APS7S.js';
+import { validatePayoutPolicyShape, formatAjvErrors, persistTransferStatus, createSession, disabledClientPersistence, readPersistedTransferForResume, persistTransferReady, createExponentialBackoff, persistTransferTerminal, persistTransferRecoveryCode, persistTransferAllocation, persistTransferDkgMetadata } from './chunk-LVCDODTN.js';
+export { getPersistedTransfer, listPersistedTransfers, purgePersistedTransfers, removePersistedTransfer } from './chunk-LVCDODTN.js';
+import { PRODUCT_MAX_ENTRY_LAMPORTS, PRODUCT_MIN_ENTRY_LAMPORTS } from './chunk-TNLSUQGJ.js';
+import { assertAttested, publicKey, solanaAddressFromPublicKeyBytes } from './chunk-TYTVF3A4.js';
+import { requestEnvelope, CoordinatorMessageType, onEnvelope, closeProtocolRuntime, EnvelopeKind } from './chunk-NOKBFHDP.js';
+import { getSessionState } from './chunk-DOTYDYVB.js';
+import './chunk-YYTRFM2F.js';
+import { PolicyValidationError, CommandError, StorageError, TransportError, normalizeError, InvalidDepositAmountError, AttestationError, RoutingError } from './chunk-A4R3DHKN.js';
+export { InvalidDepositAmountError } from './chunk-A4R3DHKN.js';
 import './chunk-VR6T6OJS.js';
 
 // src/validation/payoutPolicy.ts
@@ -27,7 +27,6 @@ Math.max(...SUPPORTED_TOTAL_DEADLINE_MS);
 var SHARE_SUM_TOLERANCE = 0.01;
 var CURRENT_USER_PAYOUT_DESTINATION_LIMIT = 1;
 var CURRENT_USER_PAYOUT_DESTINATION_LIMIT_MESSAGE = "current V0 normal-user SDK and coordinator support exactly one payout destination; multi-address receive is not supported yet";
-var CURRENT_USER_BATCH_EXCLUSION_ID_UNSUPPORTED_MESSAGE = "batchExclusionId is not supported in V0 normal-user payout requests; V1 defines it as campaign-scoped batch exclusion, never a stable actor identity";
 var CURRENT_USER_MIN_DELAY_UNSUPPORTED_MESSAGE = "destinations[*].minDelayMs is not supported in V0 normal-user payout requests";
 var CURRENT_USER_MAX_DELAY_UNSUPPORTED_MESSAGE = "destinations[*].maxDelayMs is not supported in V0 normal-user payout requests";
 var CURRENT_USER_PAYOUT_FRAGMENT_LIMIT = 1;
@@ -91,12 +90,6 @@ function validatePayoutPolicy(input, ctx = {}) {
   return policy;
 }
 function assertCurrentUserUnsupportedPayoutFeatures(policy) {
-  if (policy.batchExclusionId !== void 0) {
-    throw new PolicyValidationError(
-      "INVALID_PAYOUT_PLAN",
-      CURRENT_USER_BATCH_EXCLUSION_ID_UNSUPPORTED_MESSAGE
-    );
-  }
   for (const destination of policy.destinations) {
     if (destination.minDelayMs !== void 0) {
       throw new PolicyValidationError(
@@ -172,7 +165,7 @@ function recoveryCodeFromUserInput(input) {
 var protocolPromise = null;
 var frostRuntimePromise = null;
 function loadProtocol() {
-  protocolPromise ??= import('./coordinator-DHL3AP7V.js');
+  protocolPromise ??= import('./coordinator-EQEL23A3.js');
   return protocolPromise;
 }
 function loadFrostRuntime() {
@@ -196,6 +189,10 @@ var SWAP_STATUS_RETRY_JITTER_RATIO = 0.2;
 var DEFAULT_REFUND_OUTCOME_POLL_BUDGET_MS = 5 * 60 * 1e3;
 var REFUND_OUTCOME_POLL_INTERVAL_MS = 3e3;
 var INITIALIZATION_PUSH_TIMEOUT_MS = 3e4;
+var CONTRACT_ADMISSION_BUSY_MAX_ATTEMPTS = 6;
+var CONTRACT_ADMISSION_BUSY_INITIAL_DELAY_MS = 250;
+var CONTRACT_ADMISSION_BUSY_MAX_DELAY_MS = 4e3;
+var CONTRACT_ADMISSION_BUSY_JITTER_RATIO = 0.2;
 var REFUND_OUTCOME_PER_POLL_TIMEOUT_MS = 5e3;
 var UNBOUND_RECONCILIATION_KEY = "__unbound__";
 var REQUEST_TIMEOUT_MESSAGE = "coordinator request timed out";
@@ -982,6 +979,9 @@ var UserCoordinatorSession = class {
       {
         actor: "user",
         amount_lamports: params.amountLamports,
+        ...params.batchExclusionId !== void 0 && {
+          batch_exclusion_id: params.batchExclusionId
+        },
         payout_spec: params.payoutSpec,
         sync_commitment: syncCommitment,
         resume_commitment: resumeCommitment,
@@ -1550,11 +1550,24 @@ var UserCoordinatorSession = class {
     }
   }
   async requestContract(payload, signal) {
-    if (signal?.aborted) throw createRequestAbortError();
-    return this.request(CoordinatorMessageType.ContractRequest, payload, {
-      swapId: null,
-      requireNonNullResponseSwapId: true
+    const busyBackoff = createExponentialBackoff({
+      initialDelayMs: CONTRACT_ADMISSION_BUSY_INITIAL_DELAY_MS,
+      maxDelayMs: CONTRACT_ADMISSION_BUSY_MAX_DELAY_MS,
+      jitterRatio: CONTRACT_ADMISSION_BUSY_JITTER_RATIO
     });
+    for (let attempt = 1; ; attempt += 1) {
+      if (signal?.aborted) throw createRequestAbortError();
+      try {
+        return await this.request(CoordinatorMessageType.ContractRequest, payload, {
+          swapId: null,
+          requireNonNullResponseSwapId: true
+        });
+      } catch (error) {
+        if (!(error instanceof CommandError) || error.coordinatorCode !== ErrorCode.ERR_PRESEAL_ADMISSION_BUSY || error.failedReqId === void 0 || attempt >= CONTRACT_ADMISSION_BUSY_MAX_ATTEMPTS)
+          throw error;
+        await abortableDelay(busyBackoff.nextDelayMs(), signal);
+      }
+    }
   }
   awaitPush(type, swapId, timeoutMs = 3e4) {
     return new Promise((resolve, reject) => {
@@ -1835,6 +1848,21 @@ function bytesToHex(bytes) {
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function abortableDelay(ms, signal) {
+  if (signal === void 0) return delay(ms);
+  if (signal.aborted) return Promise.reject(createRequestAbortError());
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(createRequestAbortError());
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
 function payoutWindowMsFromSpec(payoutSpec) {
   if (payoutSpec.mode === "instant") return void 0;
   return payoutSpec.window_seconds * 1e3;
@@ -1938,6 +1966,9 @@ async function contractRequest(session, args) {
   return contractRequestOnSession(session, {
     amountLamports: args.amountLamports,
     payoutSpec: wirePayoutSpec,
+    ...payoutPolicy.batchExclusionId !== void 0 && {
+      batchExclusionId: payoutPolicy.batchExclusionId
+    },
     ...args.syncSecret !== void 0 && { syncSecret: args.syncSecret },
     ...args.recoveryCommitment !== void 0 && {
       recoveryCommitment: args.recoveryCommitment