@unicitylabs/sphere-sdk 0.14.11 → 0.15.0

package/dist/token-engine/index.cjs

@@ -337,7 +337,15 @@ function resolveProofTimeoutMs(configured) {
   return configured;
 }
 var TRANSIENT_HTTP_STATUSES = /* @__PURE__ */ new Set([408, 425, 429, 500, 502, 503, 504]);
+var TransientSubmitAnswer = class extends Error {
+  constructor(status) {
+    super(`gateway is not ready to certify yet (${status})`);
+    this.status = status;
+    this.name = "TransientSubmitAnswer";
+  }
+};
 function isTransientGatewayError(err) {
+  if (err instanceof TransientSubmitAnswer) return true;
   return err instanceof import_JsonRpcNetworkError.JsonRpcNetworkError && TRANSIENT_HTTP_STATUSES.has(err.status);
 }
 function pause(ms, signal) {
@@ -471,37 +479,9 @@ function randomUUID() {
   return `${h[0]}${h[1]}${h[2]}${h[3]}-${h[4]}${h[5]}-${h[6]}${h[7]}-${h[8]}${h[9]}-${h[10]}${h[11]}${h[12]}${h[13]}${h[14]}${h[15]}`;
 }
 
-// token-engine/token-blob.ts
-var TOKEN_BLOB_TAG = 39051n;
-var TOKEN_BLOB_VERSION = 1;
-function decodeTokenBlob(bytes) {
-  const tag = import_CborDeserializer.CborDeserializer.decodeTag(bytes);
-  if (tag.tag !== TOKEN_BLOB_TAG) {
-    throw new import_CborError.CborError(`Invalid TokenBlob tag: ${tag.tag}`);
-  }
-  const fields = import_CborDeserializer.CborDeserializer.decodeArray(tag.data, 4);
-  const v = Number(import_CborDeserializer.CborDeserializer.decodeUnsignedInteger(fields[0]));
-  if (v !== TOKEN_BLOB_VERSION) {
-    throw new import_CborError.CborError(`Unsupported TokenBlob version: ${v}`);
-  }
-  return {
-    v,
-    network: Number(import_CborDeserializer.CborDeserializer.decodeUnsignedInteger(fields[1])),
-    tokenId: import_CborDeserializer.CborDeserializer.decodeTextString(fields[2]),
-    token: import_CborDeserializer.CborDeserializer.decodeByteString(fields[3])
-  };
-}
-function unwrapTokenBlobBytes(bytes) {
-  try {
-    return decodeTokenBlob(bytes).token;
-  } catch {
-    return bytes;
-  }
-}
-
 // token-engine/blob-keys.ts
 async function deriveDeliveryKeys(blobBytes) {
-  const token = await import_Token.Token.fromCBOR(unwrapTokenBlobBytes(blobBytes));
+  const token = await import_Token.Token.fromCBOR(blobBytes);
   const stateHash = import_HexConverter.HexConverter.encode((await token.latestTransaction.calculateStateHash()).imprint);
   return { tokenId: import_HexConverter.HexConverter.encode(token.id.bytes), stateHash };
 }
@@ -975,8 +955,8 @@ function deriveRealization(privKeyHex, transferId, index, field) {
 }
 
 // token-engine/split-checkpoint.ts
-var CHECKPOINT_VERSION = 1;
-var CHECKPOINT_SDK_VERSION = "@unicitylabs/state-transition-sdk@2.0.2";
+var CHECKPOINT_VERSION = 2;
+var CHECKPOINT_SDK_VERSION = "@unicitylabs/state-transition-sdk@3.0.1";
 function bytesEqual(a, b) {
   if (a.length !== b.length) return false;
   for (let i = 0; i < a.length; i++) {
@@ -1126,13 +1106,11 @@ var SphereTokenEngine = class {
     const data = params.value ? await SpherePaymentData.fromValue(params.value).encode() : null;
     const transferId = this.resolveTransferId(options);
     const opIndex = this.resolveOpIndex(options);
-    const mintTx = await import_MintTransaction.MintTransaction.create(
-      this.deps.networkId,
-      recipient,
+    const mintTx = await import_MintTransaction.MintTransaction.create(this.deps.networkId, recipient, {
       data,
-      new import_TokenType.TokenType(deriveRealization(this.privateKeyHex, transferId, opIndex, "tokenType")),
-      import_TokenSalt.TokenSalt.fromBytes(deriveRealization(this.privateKeyHex, transferId, opIndex, "mint"))
-    );
+      tokenType: new import_TokenType.TokenType(deriveRealization(this.privateKeyHex, transferId, opIndex, "tokenType")),
+      salt: import_TokenSalt.TokenSalt.fromBytes(deriveRealization(this.privateKeyHex, transferId, opIndex, "mint"))
+    });
     const certificationData = await import_CertificationData.CertificationData.fromMintTransaction(mintTx);
     const proof = await this.submitAndAwaitProof(
       certificationData,
@@ -1149,7 +1127,7 @@ var SphereTokenEngine = class {
     const recipient = import_SignaturePredicate.SignaturePredicate.create(params.recipientPubkey);
     const tokenType = params.tokenType ? new import_TokenType.TokenType(params.tokenType) : import_TokenType.TokenType.generate();
     const salt = params.salt ? import_TokenSalt.TokenSalt.fromBytes(params.salt) : import_TokenSalt.TokenSalt.generate();
-    const mintTx = await import_MintTransaction.MintTransaction.create(this.deps.networkId, recipient, params.data, tokenType, salt);
+    const mintTx = await import_MintTransaction.MintTransaction.create(this.deps.networkId, recipient, { data: params.data, tokenType, salt });
     const certificationData = await import_CertificationData.CertificationData.fromMintTransaction(mintTx);
     const proof = await this.submitAndAwaitProof(
       certificationData,
@@ -1169,7 +1147,9 @@ var SphereTokenEngine = class {
     const stateMask = import_StateMask.StateMask.fromBytes(
       deriveRealization(this.privateKeyHex, transferId, this.resolveOpIndex(options), "stateMask")
     );
-    const transferTx = await import_TransferTransaction.TransferTransaction.create(params.token.sdkToken, recipient, stateMask, params.data ?? null);
+    const transferTx = await import_TransferTransaction.TransferTransaction.create(params.token.sdkToken, recipient, stateMask, {
+      data: params.data ?? null
+    });
     const unlockScript = await import_SignaturePredicateUnlockScript.SignaturePredicateUnlockScript.create(transferTx, this.deps.signingService);
     const certificationData = await import_CertificationData.CertificationData.fromTransaction(transferTx, unlockScript);
     const proof = await this.submitAndAwaitProof(
@@ -1196,12 +1176,11 @@ var SphereTokenEngine = class {
         import_TokenSalt.TokenSalt.fromBytes(deriveRealization(this.privateKeyHex, transferId, i, "salt"))
       )
     );
-    const split = await import_TokenSplit.TokenSplit.split(
-      params.token.sdkToken,
-      decodeSpherePaymentData,
-      requests,
-      import_StateMask.StateMask.fromBytes(deriveRealization(this.privateKeyHex, transferId, this.resolveOpIndex(options), "burn"))
-    );
+    const split = await import_TokenSplit.TokenSplit.split(params.token.sdkToken, decodeSpherePaymentData, requests, {
+      burnStateMask: import_StateMask.StateMask.fromBytes(
+        deriveRealization(this.privateKeyHex, transferId, this.resolveOpIndex(options), "burn")
+      )
+    });
     const burntToken = await this.resolveBurntToken({ params, split, transferId, options });
     const settled = [];
     for (let start = 0; start < split.tokens.length; start += MAX_MINT_CONCURRENCY) {
@@ -1281,9 +1260,14 @@ var SphereTokenEngine = class {
     await Promise.all(
       ctx.split.tokens.map(async (leg) => {
         const data = await leg.paymentData.encode();
-        const probe = await import_MintTransaction.MintTransaction.create(leg.networkId, leg.recipient, data, leg.tokenType, leg.salt, null);
+        const probe = await import_MintTransaction.MintTransaction.create(leg.networkId, leg.recipient, {
+          data,
+          tokenType: leg.tokenType,
+          salt: leg.salt,
+          justification: null
+        });
         const response = await this.deps.client.getInclusionProof(await import_StateId.StateId.fromTransaction(probe));
-        if (response.inclusionProof.certificationData !== null) {
+        if (response.inclusionProof !== null) {
           throw new SplitCheckpointLostError(
             "a split mint leaf is certified on-chain but no burn checkpoint exists \u2014 outputs are unrecoverable"
           );
@@ -1295,14 +1279,12 @@ var SphereTokenEngine = class {
   async mintSplitOutput(splitToken, burntToken, options) {
     const data = await splitToken.paymentData.encode();
     const justification = import_SplitMintJustification.SplitMintJustification.create(burntToken, splitToken.proofs).toCBOR();
-    const mintTx = await import_MintTransaction.MintTransaction.create(
-      splitToken.networkId,
-      splitToken.recipient,
+    const mintTx = await import_MintTransaction.MintTransaction.create(splitToken.networkId, splitToken.recipient, {
       data,
-      splitToken.tokenType,
-      splitToken.salt,
+      tokenType: splitToken.tokenType,
+      salt: splitToken.salt,
       justification
-    );
+    });
     const certData = await import_CertificationData.CertificationData.fromMintTransaction(mintTx);
     const proof = await this.submitSplitMintLeg(certData, mintTx, options);
     const certified = await mintTx.toCertifiedTransaction(this.deps.trustBase, this.deps.predicateVerifier, this.deps.unicityCertificateVerifier, proof);
@@ -1347,7 +1329,7 @@ var SphereTokenEngine = class {
     );
     const stateId = await import_StateId.StateId.fromTransaction(probe);
     const response = await this.deps.client.getInclusionProof(stateId);
-    return response.inclusionProof.certificationData !== null;
+    return response.inclusionProof !== null;
   }
   // ── serialization ────────────────────────────────────────────────────────────
   /** @inheritDoc — SDK-derived (Token.fromCBOR → latestTransaction.calculateStateHash().imprint). */
@@ -1431,7 +1413,13 @@ var SphereTokenEngine = class {
     let submitRejectedCleanly = false;
     try {
       const { value: response, retried } = await retryTransient(
-        () => this.deps.client.submitCertificationRequest(certificationData),
+        async () => {
+          const answer = await this.deps.client.submitCertificationRequest(certificationData);
+          if (String(answer.status) === String(import_CertificationResponse.CertificationStatus.SERVICE_NOT_READY)) {
+            throw new TransientSubmitAnswer(String(answer.status));
+          }
+          return answer;
+        },
         signal,
         this.deps.proofPollIntervalMs ?? DEFAULT_PROOF_POLL_INTERVAL_MS
       );
@@ -1486,8 +1474,6 @@ var SphereTokenEngine = class {
       }
     }
     const blob = {
-      v: TOKEN_BLOB_VERSION,
-      network: sdkToken.genesis.networkId.id,
       tokenId: import_HexConverter.HexConverter.encode(sdkToken.id.bytes),
       token: sdkToken.toCBOR()
     };