@fastxyz/cli 1.0.1 → 1.0.2

package/dist/main.js

@@ -166,12 +166,12 @@ import {
 import "./chunk-MWATGKBS.js";
 import {
   NetworkConfigService
-} from "./chunk-FLS2KI2D.js";
+} from "./chunk-F4CXF26J.js";
 import {
   AppConfigLive,
   getAppName,
   getVersion
-} from "./chunk-MIRQRJSD.js";
+} from "./chunk-ECO24H3M.js";
 import {
   AccountExistsError,
   AccountNotFoundError,
@@ -213,7 +213,7 @@ import { Option as Option7 } from "effect";
 // src/app.ts
 import { Effect as Effect14, Layer as Layer6 } from "effect";
 
-// ../../packages/fast-sdk/dist/chunk-J4LYMR5I.mjs
+// ../../packages/fast-sdk/dist/chunk-2WOJNW4N.js
 import { Data } from "effect";
 
 // ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/_u64.js
@@ -602,21 +602,125 @@ var Keccak = class _Keccak {
 var genKeccak = (suffix, blockLen, outputLen, info = {}) => createHasher(() => new Keccak(blockLen, suffix, outputLen), info);
 var keccak_2562 = /* @__PURE__ */ genKeccak(1, 136, 32);
 
-// ../../packages/fast-sdk/dist/chunk-J4LYMR5I.mjs
+// ../../packages/fast-sdk/dist/chunk-2WOJNW4N.js
 import { Effect, Encoding } from "effect";
 import { Cause, Effect as Effect2, Exit, Option } from "effect";
 import { Data as Data2 } from "effect";
 import { Data as Data3 } from "effect";
 import { Data as Data4 } from "effect";
+import { Effect as Effect3, Schema as Schema19 } from "effect";
 
-// ../../packages/fast-schema/dist/index.mjs
-import { Schema as Schema5 } from "effect";
+// ../../node_modules/.pnpm/json-with-bigint@3.5.8/node_modules/json-with-bigint/json-with-bigint.js
+var intRegex = /^-?\d+$/;
+var noiseValue = /^-?\d+n+$/;
+var originalStringify = JSON.stringify;
+var originalParse = JSON.parse;
+var customFormat = /^-?\d+n$/;
+var bigIntsStringify = /([\[:])?"(-?\d+)n"($|([\\n]|\s)*(\s|[\\n])*[,\}\]])/g;
+var noiseStringify = /([\[:])?("-?\d+n+)n("$|"([\\n]|\s)*(\s|[\\n])*[,\}\]])/g;
+var JSONStringify = (value, replacer, space) => {
+  if ("rawJSON" in JSON) {
+    return originalStringify(
+      value,
+      (key, value2) => {
+        if (typeof value2 === "bigint") return JSON.rawJSON(value2.toString());
+        if (typeof replacer === "function") return replacer(key, value2);
+        if (Array.isArray(replacer) && replacer.includes(key)) return value2;
+        return value2;
+      },
+      space
+    );
+  }
+  if (!value) return originalStringify(value, replacer, space);
+  const convertedToCustomJSON = originalStringify(
+    value,
+    (key, value2) => {
+      const isNoise = typeof value2 === "string" && noiseValue.test(value2);
+      if (isNoise) return value2.toString() + "n";
+      if (typeof value2 === "bigint") return value2.toString() + "n";
+      if (typeof replacer === "function") return replacer(key, value2);
+      if (Array.isArray(replacer) && replacer.includes(key)) return value2;
+      return value2;
+    },
+    space
+  );
+  const processedJSON = convertedToCustomJSON.replace(
+    bigIntsStringify,
+    "$1$2$3"
+  );
+  const denoisedJSON = processedJSON.replace(noiseStringify, "$1$2$3");
+  return denoisedJSON;
+};
+var featureCache = /* @__PURE__ */ new Map();
+var isContextSourceSupported = () => {
+  const parseFingerprint = JSON.parse.toString();
+  if (featureCache.has(parseFingerprint)) {
+    return featureCache.get(parseFingerprint);
+  }
+  try {
+    const result2 = JSON.parse(
+      "1",
+      (_, __, context) => !!context?.source && context.source === "1"
+    );
+    featureCache.set(parseFingerprint, result2);
+    return result2;
+  } catch {
+    featureCache.set(parseFingerprint, false);
+    return false;
+  }
+};
+var convertMarkedBigIntsReviver = (key, value, context, userReviver) => {
+  const isCustomFormatBigInt = typeof value === "string" && customFormat.test(value);
+  if (isCustomFormatBigInt) return BigInt(value.slice(0, -1));
+  const isNoiseValue = typeof value === "string" && noiseValue.test(value);
+  if (isNoiseValue) return value.slice(0, -1);
+  if (typeof userReviver !== "function") return value;
+  return userReviver(key, value, context);
+};
+var JSONParseV2 = (text, reviver) => {
+  return JSON.parse(text, (key, value, context) => {
+    const isBigNumber = typeof value === "number" && (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER);
+    const isInt = context && intRegex.test(context.source);
+    const isBigInt = isBigNumber && isInt;
+    if (isBigInt) return BigInt(context.source);
+    if (typeof reviver !== "function") return value;
+    return reviver(key, value, context);
+  });
+};
+var MAX_INT = Number.MAX_SAFE_INTEGER.toString();
+var MAX_DIGITS = MAX_INT.length;
+var stringsOrLargeNumbers = /"(?:\\.|[^"])*"|-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/g;
+var noiseValueWithQuotes = /^"-?\d+n+"$/;
+var JSONParse = (text, reviver) => {
+  if (!text) return originalParse(text, reviver);
+  if (isContextSourceSupported()) return JSONParseV2(text, reviver);
+  const serializedData = text.replace(
+    stringsOrLargeNumbers,
+    (text2, digits, fractional, exponential) => {
+      const isString = text2[0] === '"';
+      const isNoise = isString && noiseValueWithQuotes.test(text2);
+      if (isNoise) return text2.substring(0, text2.length - 1) + 'n"';
+      const isFractionalOrExponential = fractional || exponential;
+      const isLessThanMaxSafeInt = digits && (digits.length < MAX_DIGITS || digits.length === MAX_DIGITS && digits <= MAX_INT);
+      if (isString || isFractionalOrExponential || isLessThanMaxSafeInt)
+        return text2;
+      return '"' + text2 + 'n"';
+    }
+  );
+  return originalParse(
+    serializedData,
+    (key, value, context) => convertMarkedBigIntsReviver(key, value, context, reviver)
+  );
+};
+
+// ../../packages/fast-schema/dist/index.js
+import { Schema as Schema6 } from "effect";
 import { bech32m } from "bech32";
 import { ParseResult, Schema } from "effect";
 import { Schema as Schema2 } from "effect";
 import { Schema as Schema3, String as Str } from "effect";
 import { Either, ParseResult as ParseResult2, Schema as Schema4 } from "effect";
-import { Schema as Schema6 } from "effect";
+import { Schema as Schema5 } from "effect";
 import { Schema as Schema7 } from "effect";
 import { Schema as Schema8 } from "effect";
 import { Schema as Schema9 } from "effect";
@@ -1612,7 +1716,7 @@ var bcs = {
   }
 };
 
-// ../../packages/fast-schema/dist/index.mjs
+// ../../packages/fast-schema/dist/index.js
 import { Schema as Schema10 } from "effect";
 import { Schema as Schema13 } from "effect";
 import { Schema as Schema12 } from "effect";
@@ -1621,6 +1725,7 @@ import { Schema as Schema14 } from "effect";
 import { Schema as Schema15 } from "effect";
 import { Schema as Schema16 } from "effect";
 import { Schema as Schema17 } from "effect";
+import { Schema as Schema18 } from "effect";
 var __defProp = Object.defineProperty;
 var __export2 = (target, all) => {
   for (var name in all)
@@ -1690,6 +1795,9 @@ var HexBigInt = Schema2.transform(Schema2.String, Schema2.BigIntFromSelf, {
   decode: (s) => {
     const sign2 = s[0] === "-" ? -1n : 1n;
     const digits = s[0] === "-" ? s.slice(1) : s;
+    if (digits.length === 0 || !/^[0-9a-fA-F]+$/.test(digits)) {
+      throw new Error(`Invalid hex string: "${s}"`);
+    }
     return sign2 * BigInt(`0x${digits}`);
   },
   encode: (n) => n.toString(16)
@@ -1697,14 +1805,23 @@ var HexBigInt = Schema2.transform(Schema2.String, Schema2.BigIntFromSelf, {
 var DecimalNumber = Schema2.NumberFromString;
 var HexNumber = Schema2.transform(Schema2.String, Schema2.Number, {
   strict: true,
-  decode: (s) => Number(`0x${s}`),
+  decode: (s) => {
+    if (s.length === 0 || !/^[0-9a-fA-F]+$/.test(s)) {
+      throw new Error(`Invalid hex string: "${s}"`);
+    }
+    return Number(`0x${s}`);
+  },
   encode: (n) => n.toString(16)
 });
-var BigIntFromNumberOrSelf = Schema2.transform(Schema2.Union(Schema2.Number, Schema2.BigIntFromSelf), Schema2.BigIntFromSelf, {
-  strict: true,
-  decode: (n) => typeof n === "bigint" ? n : BigInt(n),
-  encode: (n) => n
-});
+var BigIntFromNumberOrStringOrSelf = Schema2.transform(
+  Schema2.Union(Schema2.Number, Schema2.BigIntFromSelf, Schema2.String),
+  Schema2.BigIntFromSelf,
+  {
+    strict: true,
+    decode: (n) => typeof n === "bigint" ? n : BigInt(n),
+    encode: (n) => n
+  }
+);
 var UintNumber = (bits) => Schema2.Number.pipe(Schema2.int(), Schema2.between(0, 2 ** bits - 1), Schema2.brand(`Uint${bits}`));
 var IntNumber = (bits) => Schema2.Number.pipe(Schema2.int(), Schema2.between(-(2 ** (bits - 1)), 2 ** (bits - 1) - 1), Schema2.brand(`Int${bits}`));
 var UintBigInt = (bits) => Schema2.BigIntFromSelf.pipe(Schema2.betweenBigInt(0n, 2n ** BigInt(bits) - 1n), Schema2.brand(`Uint${bits}`));
@@ -1713,8 +1830,8 @@ var HexUintBigInt = (bits) => Schema2.compose(HexBigInt, UintBigInt(bits));
 var HexIntBigInt = (bits) => Schema2.compose(HexBigInt, IntBigInt(bits));
 var DecimalUintBigInt = (bits) => Schema2.compose(DecimalBigInt, UintBigInt(bits));
 var DecimalIntBigInt = (bits) => Schema2.compose(DecimalBigInt, IntBigInt(bits));
-var UintBigIntFromNumberOrSelf = (bits) => Schema2.compose(BigIntFromNumberOrSelf, UintBigInt(bits));
-var IntBigIntFromNumberOrSelf = (bits) => Schema2.compose(BigIntFromNumberOrSelf, IntBigInt(bits));
+var UintBigIntFromNumberOrStringOrSelf = (bits) => Schema2.compose(BigIntFromNumberOrStringOrSelf, UintBigInt(bits));
+var IntBigIntFromNumberOrStringOrSelf = (bits) => Schema2.compose(BigIntFromNumberOrStringOrSelf, IntBigInt(bits));
 var Uint8Array32 = FixedUint8Array(32);
 var Uint8Array64 = FixedUint8Array(64);
 var Uint8Array32FromNumberArray = FixedUint8ArrayFromNumberArray(32);
@@ -1738,9 +1855,9 @@ var HexInt320 = HexIntBigInt(320);
 var DecimalUint64 = DecimalUintBigInt(64);
 var DecimalUint256 = DecimalUintBigInt(256);
 var DecimalInt320 = DecimalIntBigInt(320);
-var Uint64FromNumberOrSelf = UintBigIntFromNumberOrSelf(64);
-var Uint256FromNumberOrSelf = UintBigIntFromNumberOrSelf(256);
-var Int320FromNumberOrSelf = IntBigIntFromNumberOrSelf(320);
+var Uint64FromNumberOrStringOrSelf = UintBigIntFromNumberOrStringOrSelf(64);
+var Uint256FromNumberOrStringOrSelf = UintBigIntFromNumberOrStringOrSelf(256);
+var Int320FromNumberOrStringOrSelf = IntBigIntFromNumberOrStringOrSelf(320);
 var CamelCaseStruct = (fields) => {
   const structFields = {};
   for (const key of Object.keys(fields)) {
@@ -1797,58 +1914,60 @@ var TypedVariant = (variants, options) => {
     }
   });
 };
-var AmountFromBcs = Uint256FromNumberOrSelf.pipe(Schema5.brand("Amount"));
-var BalanceFromBcs = Int320FromNumberOrSelf.pipe(Schema5.brand("Balance"));
-var NonceFromBcs = Uint64FromNumberOrSelf.pipe(Schema5.brand("Nonce"));
-var QuorumFromBcs = Uint64FromNumberOrSelf.pipe(Schema5.brand("Quorum"));
-var NetworkIdFromBcs = Schema5.Literal("fast:localnet", "fast:devnet", "fast:testnet", "fast:mainnet");
-var AddressFromBcs = Uint8Array32FromNumberArray.pipe(Schema5.brand("Address"));
-var SignatureFromBcs = Uint8Array64FromNumberArray.pipe(Schema5.brand("Signature"));
-var TokenIdFromBcs = Uint8Array32FromNumberArray.pipe(Schema5.brand("TokenId"));
-var StateKeyFromBcs = Uint8Array32FromNumberArray.pipe(Schema5.brand("StateKey"));
-var StateFromBcs = Uint8Array32FromNumberArray.pipe(Schema5.brand("State"));
-var ClaimDataFromBcs = Uint8ArrayFromNumberArray.pipe(Schema5.brand("ClaimData"));
-var UserDataFromBcs = Schema5.NullOr(Uint8Array32FromNumberArray.pipe(Schema5.brand("UserData")));
-var AmountFromInput = Schema6.Union(Uint256FromNumberOrSelf, HexUint256, DecimalUint256).pipe(Schema6.brand("Amount"));
-var BalanceFromInput = Schema6.Union(Int320FromNumberOrSelf, HexInt320, DecimalInt320).pipe(Schema6.brand("Balance"));
-var NonceFromInput = Uint64FromNumberOrSelf.pipe(Schema6.brand("Nonce"));
-var QuorumFromInput = Uint64FromNumberOrSelf.pipe(Schema6.brand("Quorum"));
-var NetworkIdFromInput = Schema6.Literal("fast:localnet", "fast:devnet", "fast:testnet", "fast:mainnet");
-var AddressFromInput = Schema6.Union(
+var Amount = Uint256.pipe(Schema5.brand("Amount"));
+var Balance = Int320.pipe(Schema5.brand("Balance"));
+var Nonce = Uint64.pipe(Schema5.brand("Nonce"));
+var Quorum = Uint64.pipe(Schema5.brand("Quorum"));
+var NetworkId = Schema5.Literal("fast:localnet", "fast:devnet", "fast:testnet", "fast:mainnet");
+var TransactionVersion = Schema5.Literal("Release20260319", "Release20260407");
+var SupportedTransactionVersions = TransactionVersion.literals;
+var LatestTransactionVersion = "Release20260407";
+var Address = Uint8Array32.pipe(Schema5.brand("Address"));
+var Signature = Uint8Array64.pipe(Schema5.brand("Signature"));
+var TokenId = Uint8Array32.pipe(Schema5.brand("TokenId"));
+var StateKey = Uint8Array32.pipe(Schema5.brand("StateKey"));
+var State = Uint8Array32.pipe(Schema5.brand("State"));
+var ClaimData = Schema5.Uint8ArrayFromSelf.pipe(Schema5.brand("ClaimData"));
+var UserData = Schema5.NullOr(Uint8Array32.pipe(Schema5.brand("UserData")));
+var AmountFromBcs = Uint256FromNumberOrStringOrSelf.pipe(Schema6.brand("Amount"));
+var BalanceFromBcs = Int320FromNumberOrStringOrSelf.pipe(Schema6.brand("Balance"));
+var NonceFromBcs = Uint64FromNumberOrStringOrSelf.pipe(Schema6.brand("Nonce"));
+var QuorumFromBcs = Uint64FromNumberOrStringOrSelf.pipe(Schema6.brand("Quorum"));
+var NetworkIdFromBcs = NetworkId;
+var AddressFromBcs = Uint8Array32FromNumberArray.pipe(Schema6.brand("Address"));
+var SignatureFromBcs = Uint8Array64FromNumberArray.pipe(Schema6.brand("Signature"));
+var TokenIdFromBcs = Uint8Array32FromNumberArray.pipe(Schema6.brand("TokenId"));
+var StateKeyFromBcs = Uint8Array32FromNumberArray.pipe(Schema6.brand("StateKey"));
+var StateFromBcs = Uint8Array32FromNumberArray.pipe(Schema6.brand("State"));
+var ClaimDataFromBcs = Uint8ArrayFromNumberArray.pipe(Schema6.brand("ClaimData"));
+var UserDataFromBcs = Schema6.NullOr(Uint8Array32FromNumberArray.pipe(Schema6.brand("UserData")));
+var AmountFromInput = Schema7.Union(Uint256FromNumberOrStringOrSelf, HexUint256, DecimalUint256).pipe(Schema7.brand("Amount"));
+var BalanceFromInput = Schema7.Union(Int320FromNumberOrStringOrSelf, HexInt320, DecimalInt320).pipe(Schema7.brand("Balance"));
+var NonceFromInput = Uint64FromNumberOrStringOrSelf.pipe(Schema7.brand("Nonce"));
+var QuorumFromInput = Uint64FromNumberOrStringOrSelf.pipe(Schema7.brand("Quorum"));
+var NetworkIdFromInput = NetworkId;
+var AddressFromInput = Schema7.Union(
   Uint8Array32,
   Uint8Array32FromNumberArray,
   Uint8Array32FromHex0x,
-  Schema6.compose(Uint8ArrayFromBech32m("fast"), Uint8Array32)
-).pipe(Schema6.brand("Address"));
-var SignatureFromInput = Schema6.Union(Uint8Array64, Uint8Array64FromNumberArray, Uint8Array64FromHex0x).pipe(Schema6.brand("Signature"));
-var TokenIdFromInput = Schema6.Union(Uint8Array32, Uint8Array32FromNumberArray, Uint8Array32FromHex0x).pipe(Schema6.brand("TokenId"));
-var StateKeyFromInput = Schema6.Union(Uint8Array32, Uint8Array32FromNumberArray, Uint8Array32FromHex0x).pipe(Schema6.brand("StateKey"));
-var StateFromInput = Schema6.Union(Uint8Array32, Uint8Array32FromNumberArray, Uint8Array32FromHex0x).pipe(Schema6.brand("State"));
-var ClaimDataFromInput = Schema6.Union(Schema6.Uint8ArrayFromSelf, Uint8ArrayFromNumberArray, Uint8ArrayFromHexOptional0x).pipe(
-  Schema6.brand("ClaimData")
+  Schema7.compose(Uint8ArrayFromBech32m("fast"), Uint8Array32)
+).pipe(Schema7.brand("Address"));
+var SignatureFromInput = Schema7.Union(Uint8Array64, Uint8Array64FromNumberArray, Uint8Array64FromHex0x).pipe(Schema7.brand("Signature"));
+var TokenIdFromInput = Schema7.Union(Uint8Array32, Uint8Array32FromNumberArray, Uint8Array32FromHex0x).pipe(Schema7.brand("TokenId"));
+var StateKeyFromInput = Schema7.Union(Uint8Array32, Uint8Array32FromNumberArray, Uint8Array32FromHex0x).pipe(Schema7.brand("StateKey"));
+var StateFromInput = Schema7.Union(Uint8Array32, Uint8Array32FromNumberArray, Uint8Array32FromHex0x).pipe(Schema7.brand("State"));
+var ClaimDataFromInput = Schema7.Union(Schema7.Uint8ArrayFromSelf, Uint8ArrayFromNumberArray, Uint8ArrayFromHexOptional0x).pipe(
+  Schema7.brand("ClaimData")
 );
-var UserDataFromInput = Schema6.NullOr(
-  Schema6.Union(Uint8Array32, Uint8Array32FromNumberArray, Uint8Array32FromHex0x).pipe(Schema6.brand("UserData"))
+var UserDataFromInput = Schema7.NullOr(
+  Schema7.Union(Uint8Array32, Uint8Array32FromNumberArray, Uint8Array32FromHex0x).pipe(Schema7.brand("UserData"))
 );
-var Amount = Uint256.pipe(Schema7.brand("Amount"));
-var Balance = Int320.pipe(Schema7.brand("Balance"));
-var Nonce = Uint64.pipe(Schema7.brand("Nonce"));
-var Quorum = Uint64.pipe(Schema7.brand("Quorum"));
-var NetworkId = Schema7.Literal("fast:localnet", "fast:devnet", "fast:testnet", "fast:mainnet");
-var TransactionVersion = Schema7.Literal("Release20260319");
-var Address = Uint8Array32.pipe(Schema7.brand("Address"));
-var Signature = Uint8Array64.pipe(Schema7.brand("Signature"));
-var TokenId = Uint8Array32.pipe(Schema7.brand("TokenId"));
-var StateKey = Uint8Array32.pipe(Schema7.brand("StateKey"));
-var State = Uint8Array32.pipe(Schema7.brand("State"));
-var ClaimData = Schema7.Uint8ArrayFromSelf.pipe(Schema7.brand("ClaimData"));
-var UserData = Schema7.NullOr(Uint8Array32.pipe(Schema7.brand("UserData")));
 var AmountFromRest = DecimalUint256.pipe(Schema8.brand("Amount"));
 var BalanceFromRest = DecimalInt320.pipe(Schema8.brand("Balance"));
-var NonceFromRest = Uint64FromNumberOrSelf.pipe(Schema8.brand("Nonce"));
-var QuorumFromRest = Uint64FromNumberOrSelf.pipe(Schema8.brand("Quorum"));
-var NetworkIdFromRest = Schema8.Literal("fast:localnet", "fast:devnet", "fast:testnet", "fast:mainnet");
-var AddressFromRest = Uint8ArrayFromBech32m("fast").pipe(Schema8.brand("Address"));
+var NonceFromRest = Uint64FromNumberOrStringOrSelf.pipe(Schema8.brand("Nonce"));
+var QuorumFromRest = Uint64FromNumberOrStringOrSelf.pipe(Schema8.brand("Quorum"));
+var NetworkIdFromRest = NetworkId;
+var AddressFromRest = Schema8.compose(Uint8ArrayFromBech32m("fast"), Uint8Array32).pipe(Schema8.brand("Address"));
 var SignatureFromRest = Uint8Array64FromHex.pipe(Schema8.brand("Signature"));
 var TokenIdFromRest = Uint8Array32FromHex.pipe(Schema8.brand("TokenId"));
 var StateKeyFromRest = Uint8Array32FromHex.pipe(Schema8.brand("StateKey"));
@@ -1857,9 +1976,9 @@ var ClaimDataFromRest = Schema8.Uint8ArrayFromHex.pipe(Schema8.brand("ClaimData"
 var UserDataFromRest = Schema8.NullOr(Uint8Array32FromHex.pipe(Schema8.brand("UserData")));
 var AmountFromRpc = HexUint256.pipe(Schema9.brand("Amount"));
 var BalanceFromRpc = HexInt320.pipe(Schema9.brand("Balance"));
-var NonceFromRpc = Uint64FromNumberOrSelf.pipe(Schema9.brand("Nonce"));
-var QuorumFromRpc = Uint64FromNumberOrSelf.pipe(Schema9.brand("Quorum"));
-var NetworkIdFromRpc = Schema9.Literal("fast:localnet", "fast:devnet", "fast:testnet", "fast:mainnet");
+var NonceFromRpc = Uint64FromNumberOrStringOrSelf.pipe(Schema9.brand("Nonce"));
+var QuorumFromRpc = Uint64FromNumberOrStringOrSelf.pipe(Schema9.brand("Quorum"));
+var NetworkIdFromRpc = NetworkId;
 var AddressFromRpc = Uint8Array32FromNumberArray.pipe(Schema9.brand("Address"));
 var SignatureFromRpc = Uint8Array64FromNumberArray.pipe(Schema9.brand("Signature"));
 var TokenIdFromRpc = Uint8Array32FromNumberArray.pipe(Schema9.brand("TokenId"));
@@ -1876,14 +1995,24 @@ __export2(bcs_layout_exports, {
   ClaimType: () => ClaimType,
   CommitteeChange: () => CommitteeChange,
   CommitteeConfig: () => CommitteeConfig,
+  Escrow: () => Escrow,
+  EscrowComplete: () => EscrowComplete,
+  EscrowCreateConfig: () => EscrowCreateConfig,
+  EscrowCreateJob: () => EscrowCreateJob,
+  EscrowReject: () => EscrowReject,
+  EscrowSubmit: () => EscrowSubmit,
   ExternalClaim: () => ExternalClaim,
   ExternalClaimBody: () => ExternalClaimBody,
+  FixedAmountOrBps: () => FixedAmountOrBps,
   Mint: () => Mint,
+  MultiSig: () => MultiSig,
+  MultiSigConfig: () => MultiSigConfig,
   Nonce: () => Nonce2,
   Operation: () => Operation,
   PublicKeyBytes: () => PublicKeyBytes,
   Quorum: () => Quorum2,
   Signature: () => Signature2,
+  SignatureOrMultiSig: () => SignatureOrMultiSig,
   State: () => State2,
   StateInitialization: () => StateInitialization,
   StateKey: () => StateKey2,
@@ -1897,6 +2026,7 @@ __export2(bcs_layout_exports, {
   TokenName: () => TokenName,
   TokenTransfer: () => TokenTransfer,
   Transaction20260319: () => Transaction20260319,
+  Transaction20260407: () => Transaction20260407,
   UserData: () => UserData2,
   ValidatorConfig: () => ValidatorConfig,
   VerifierSig: () => VerifierSig,
@@ -1915,6 +2045,19 @@ var State2 = bcs.fixedArray(32, bcs.u8());
 var Quorum2 = bcs.u64();
 var ClaimData2 = bcs.vector(bcs.u8());
 var Signature2 = bcs.fixedArray(64, bcs.u8());
+var MultiSigConfig = bcs.struct("MultiSigConfig", {
+  authorized_signers: bcs.vector(PublicKeyBytes),
+  quorum: Quorum2,
+  nonce: Nonce2
+});
+var MultiSig = bcs.struct("MultiSig", {
+  config: MultiSigConfig,
+  signatures: bcs.vector(bcs.tuple([PublicKeyBytes, Signature2]))
+});
+var SignatureOrMultiSig = bcs.enum("SignatureOrMultiSig", {
+  Signature: Signature2,
+  MultiSig
+});
 var AddressChange = bcs.enum("AddressChange", {
   Add: bcs.tuple([]),
   Remove: bcs.tuple([])
@@ -1988,6 +2131,39 @@ var CommitteeChange = bcs.struct("CommitteeChange", {
   new_committee: CommitteeConfig,
   epoch: bcs.u32()
 });
+var FixedAmountOrBps = bcs.enum("FixedAmountOrBps", {
+  Fixed: Amount2,
+  Bps: bcs.u16()
+});
+var EscrowCreateConfig = bcs.struct("EscrowCreateConfig", {
+  token_id: TokenId2,
+  evaluator: PublicKeyBytes,
+  evaluation_fee: FixedAmountOrBps,
+  min_evaluator_fee: Amount2
+});
+var EscrowCreateJob = bcs.struct("EscrowCreateJob", {
+  config_id: bcs.fixedArray(32, bcs.u8()),
+  provider: PublicKeyBytes,
+  provider_fee: Amount2,
+  description: bcs.string()
+});
+var EscrowSubmit = bcs.struct("EscrowSubmit", {
+  job_id: bcs.fixedArray(32, bcs.u8()),
+  deliverable: bcs.fixedArray(32, bcs.u8())
+});
+var EscrowReject = bcs.struct("EscrowReject", {
+  job_id: bcs.fixedArray(32, bcs.u8())
+});
+var EscrowComplete = bcs.struct("EscrowComplete", {
+  job_id: bcs.fixedArray(32, bcs.u8())
+});
+var Escrow = bcs.enum("Escrow", {
+  CreateConfig: EscrowCreateConfig,
+  CreateJob: EscrowCreateJob,
+  Submit: EscrowSubmit,
+  Reject: EscrowReject,
+  Complete: EscrowComplete
+});
 var Operation = bcs.enum("Operation", {
   TokenTransfer,
   TokenCreation,
@@ -2000,7 +2176,8 @@ var Operation = bcs.enum("Operation", {
   StateReset,
   JoinCommittee: ValidatorConfig,
   LeaveCommittee: bcs.tuple([]),
-  ChangeCommittee: CommitteeChange
+  ChangeCommittee: CommitteeChange,
+  Escrow
 });
 var ClaimType = bcs.enum("ClaimType", {
   TokenTransfer,
@@ -2015,6 +2192,7 @@ var ClaimType = bcs.enum("ClaimType", {
   JoinCommittee: ValidatorConfig,
   LeaveCommittee: bcs.tuple([]),
   ChangeCommittee: CommitteeChange,
+  Escrow,
   Batch: bcs.vector(Operation)
 });
 var Transaction20260319 = bcs.struct("Transaction", {
@@ -2026,15 +2204,25 @@ var Transaction20260319 = bcs.struct("Transaction", {
   archival: bcs.bool(),
   fee_token: bcs.option(TokenId2)
 });
+var Transaction20260407 = bcs.struct("Transaction20260407", {
+  network_id: bcs.string(),
+  sender: PublicKeyBytes,
+  nonce: Nonce2,
+  timestamp_nanos: TimestampNanos,
+  claims: bcs.vector(Operation),
+  archival: bcs.bool(),
+  fee_token: bcs.option(TokenId2)
+});
 var VersionedTransaction = bcs.enum("VersionedTransaction", {
-  Release20260319: Transaction20260319
+  Release20260319: Transaction20260319,
+  Release20260407: Transaction20260407
 });
 var FastSetErrorData = TypedVariant({
   UnexpectedNonce: CamelCaseStruct({
-    expected_nonce: BigIntFromNumberOrSelf
+    expected_nonce: BigIntFromNumberOrStringOrSelf
   }),
   InsufficientFunding: CamelCaseStruct({
-    current_balance: BigIntFromNumberOrSelf
+    current_balance: BigIntFromNumberOrStringOrSelf
   }),
   PreviousTransactionMustBeConfirmedFirst: CamelCaseStruct({
     pending_confirmation: Schema10.Unknown
@@ -2043,10 +2231,10 @@ var FastSetErrorData = TypedVariant({
     error: Schema10.String
   }),
   MissingEarlierConfirmations: CamelCaseStruct({
-    current_nonce: BigIntFromNumberOrSelf
+    current_nonce: BigIntFromNumberOrStringOrSelf
   }),
   CertificateTooYoung: CamelCaseStruct({
-    resend_after_nanos: BigIntFromNumberOrSelf
+    resend_after_nanos: BigIntFromNumberOrStringOrSelf
   }),
   NonSubmittableOperation: Schema10.Struct({
     reason: Schema10.String
@@ -2067,8 +2255,8 @@ var ProxyErrorData = TypedVariant({
   DatabaseError: Schema10.String,
   TooManyCertificatesRequested: null,
   UnexpectedNonce: CamelCaseStruct({
-    tx_nonce: BigIntFromNumberOrSelf,
-    expected_nonce: BigIntFromNumberOrSelf
+    tx_nonce: BigIntFromNumberOrStringOrSelf,
+    expected_nonce: BigIntFromNumberOrStringOrSelf
   }),
   InvalidRequest: Schema10.String
 });
@@ -2106,6 +2294,32 @@ var makeExternalClaim = (p4) => Schema11.Struct({ claim: makeExternalClaimBody(p
 var makeValidatorConfig = (p4) => CamelCaseStruct({ address: p4.Address, host: Schema11.String, rpc_port: Schema11.Number });
 var makeCommitteeConfig = (p4) => Schema11.Struct({ validators: Schema11.Array(makeValidatorConfig(p4)) });
 var makeCommitteeChange = (p4) => CamelCaseStruct({ new_committee: makeCommitteeConfig(p4), epoch: Schema11.Number });
+var makeFixedAmountOrBps = (p4, options) => TypedVariant({ Fixed: p4.Amount, Bps: Schema11.Number }, options);
+var makeEscrowCreateConfig = (p4, options) => CamelCaseStruct({
+  token_id: p4.TokenId,
+  evaluator: p4.Address,
+  evaluation_fee: makeFixedAmountOrBps(p4, options),
+  min_evaluator_fee: p4.Amount
+});
+var makeEscrowCreateJob = (p4) => CamelCaseStruct({
+  config_id: p4.TokenId,
+  provider: p4.Address,
+  provider_fee: p4.Amount,
+  description: Schema11.String
+});
+var makeEscrowSubmit = (p4) => CamelCaseStruct({ job_id: p4.TokenId, deliverable: p4.TokenId });
+var makeEscrowReject = (p4) => CamelCaseStruct({ job_id: p4.TokenId });
+var makeEscrowComplete = (p4) => CamelCaseStruct({ job_id: p4.TokenId });
+var makeEscrow = (p4, options) => TypedVariant(
+  {
+    CreateConfig: makeEscrowCreateConfig(p4, options),
+    CreateJob: makeEscrowCreateJob(p4),
+    Submit: makeEscrowSubmit(p4),
+    Reject: makeEscrowReject(p4),
+    Complete: makeEscrowComplete(p4)
+  },
+  options
+);
 var makeOperation = (p4, options) => TypedVariant(
   {
     TokenTransfer: makeTokenTransfer(p4),
@@ -2119,7 +2333,8 @@ var makeOperation = (p4, options) => TypedVariant(
     ExternalClaim: makeExternalClaim(p4),
     JoinCommittee: makeValidatorConfig(p4),
     LeaveCommittee: null,
-    ChangeCommittee: makeCommitteeChange(p4)
+    ChangeCommittee: makeCommitteeChange(p4),
+    Escrow: makeEscrow(p4, options)
   },
   options
 );
@@ -2137,11 +2352,12 @@ var makeClaimType = (p4, options) => TypedVariant(
     JoinCommittee: makeValidatorConfig(p4),
     LeaveCommittee: null,
     ChangeCommittee: makeCommitteeChange(p4),
+    Escrow: makeEscrow(p4, options),
     Batch: Schema11.Array(makeOperation(p4, options))
   },
   options
 );
-var makeTransaction = (p4, options) => CamelCaseStruct({
+var makeTransactionRelease20260319 = (p4, options) => CamelCaseStruct({
   network_id: p4.NetworkId,
   sender: p4.Address,
   nonce: p4.Nonce,
@@ -2150,7 +2366,20 @@ var makeTransaction = (p4, options) => CamelCaseStruct({
   archival: Schema12.Boolean,
   fee_token: Schema12.NullOr(p4.TokenId)
 });
-var makeVersionedTransaction = (p4, options) => TypedVariant({ Release20260319: makeTransaction(p4, options) });
+var makeTransactionRelease20260407 = (p4, options) => CamelCaseStruct({
+  network_id: p4.NetworkId,
+  sender: p4.Address,
+  nonce: p4.Nonce,
+  timestamp_nanos: p4.BigInt,
+  claims: Schema12.Array(makeOperation(p4, options)),
+  archival: Schema12.Boolean,
+  fee_token: Schema12.NullOr(p4.TokenId)
+});
+var makeTransaction = makeTransactionRelease20260407;
+var makeVersionedTransaction = (p4, options) => TypedVariant({
+  Release20260319: makeTransactionRelease20260319(p4, options),
+  Release20260407: makeTransactionRelease20260407(p4, options)
+});
 var makeMultiSigConfig = (p4) => CamelCaseStruct({ authorized_signers: Schema13.Array(p4.Address), quorum: p4.Quorum, nonce: p4.Nonce });
 var makeMultiSig = (p4) => Schema13.Struct({
   config: makeMultiSigConfig(p4),
@@ -2203,6 +2432,23 @@ var makeProxySubmitTransactionResult = (p4) => TypedVariant({
   IncompleteVerifierSigs: null,
   IncompleteMultiSig: null
 });
+var makeEscrowJobRecord = (p4) => CamelCaseStruct({
+  job_id: p4.TokenId,
+  config_id: p4.TokenId,
+  client: p4.Address,
+  provider: p4.Address,
+  evaluator: p4.Address,
+  token_id: p4.TokenId,
+  provider_fee: p4.Amount,
+  evaluator_fee: p4.Amount,
+  description: Schema14.String,
+  deliverable: Schema14.NullOr(p4.TokenId),
+  status: Schema14.String
+});
+var makeEscrowJobWithCerts = (p4) => Schema14.Struct({
+  job: makeEscrowJobRecord(p4),
+  certificates: Schema14.Array(makeTransactionCertificate(p4))
+});
 var makeSubmitTransactionParams = (p4) => makeTransactionEnvelope(p4);
 var makeFaucetDripParams = (p4) => CamelCaseStruct({
   recipient: p4.Address,
@@ -2252,6 +2498,17 @@ var GetTransactionCertificatesInput = Schema15.Struct({
   fromNonce: NonceFromInput,
   limit: Schema15.Number
 });
+var GetEscrowJobInput = Schema15.Struct({
+  jobId: TokenIdFromInput,
+  certs: Schema15.optionalWith(Schema15.Boolean, { default: () => false })
+});
+var GetEscrowJobsInput = Schema15.Struct({
+  client: Schema15.optional(AddressFromInput),
+  provider: Schema15.optional(AddressFromInput),
+  evaluator: Schema15.optional(AddressFromInput),
+  status: Schema15.optional(Schema15.String),
+  certs: Schema15.optionalWith(Schema15.Boolean, { default: () => false })
+});
 var PrivateKeyFromInput = Schema16.Union(Uint8Array32, Uint8Array32FromHex0x, Uint8Array32FromNumberArray).pipe(Schema16.brand("PrivateKey"));
 var TokenTransferInput = Schema17.Struct({
   tokenId: TokenIdFromInput,
@@ -2293,7 +2550,7 @@ var StateUpdateInput = Schema17.Struct({
   previousState: StateFromInput,
   nextState: StateFromInput,
   computeClaimTxHash: StateKeyFromInput,
-  computeClaimTxTimestamp: BigIntFromNumberOrSelf
+  computeClaimTxTimestamp: BigIntFromNumberOrStringOrSelf
 });
 var StateResetInput = Schema17.Struct({
   key: StateKeyFromInput,
@@ -2323,6 +2580,39 @@ var CommitteeChangeInput = Schema17.Struct({
   }),
   epoch: Schema17.Number
 });
+var FixedAmountOrBpsInput = Schema17.Union(
+  Schema17.Struct({ type: Schema17.Literal("Fixed"), value: AmountFromInput }),
+  Schema17.Struct({ type: Schema17.Literal("Bps"), value: Schema17.Number })
+);
+var EscrowCreateConfigInput = Schema17.Struct({
+  tokenId: TokenIdFromInput,
+  evaluator: AddressFromInput,
+  evaluationFee: FixedAmountOrBpsInput,
+  minEvaluatorFee: AmountFromInput
+});
+var EscrowCreateJobInput = Schema17.Struct({
+  configId: TokenIdFromInput,
+  provider: AddressFromInput,
+  providerFee: AmountFromInput,
+  description: Schema17.String
+});
+var EscrowSubmitInput = Schema17.Struct({
+  jobId: TokenIdFromInput,
+  deliverable: TokenIdFromInput
+});
+var EscrowRejectInput = Schema17.Struct({
+  jobId: TokenIdFromInput
+});
+var EscrowCompleteInput = Schema17.Struct({
+  jobId: TokenIdFromInput
+});
+var EscrowInput = Schema17.Union(
+  Schema17.Struct({ type: Schema17.Literal("CreateConfig"), value: EscrowCreateConfigInput }),
+  Schema17.Struct({ type: Schema17.Literal("CreateJob"), value: EscrowCreateJobInput }),
+  Schema17.Struct({ type: Schema17.Literal("Submit"), value: EscrowSubmitInput }),
+  Schema17.Struct({ type: Schema17.Literal("Reject"), value: EscrowRejectInput }),
+  Schema17.Struct({ type: Schema17.Literal("Complete"), value: EscrowCompleteInput })
+);
 var OperationInput = Schema17.Union(
   Schema17.Struct({
     type: Schema17.Literal("TokenTransfer"),
@@ -2359,6 +2649,10 @@ var OperationInput = Schema17.Union(
   Schema17.Struct({
     type: Schema17.Literal("ChangeCommittee"),
     value: CommitteeChangeInput
+  }),
+  Schema17.Struct({
+    type: Schema17.Literal("Escrow"),
+    value: EscrowInput
   })
 );
 var ClaimTypeInput = Schema17.Union(
@@ -2368,15 +2662,66 @@ var ClaimTypeInput = Schema17.Union(
     value: Schema17.Array(OperationInput)
   })
 );
-var TransactionInput = Schema17.Struct({
+var TransactionRelease20260319Input = Schema17.Struct({
   networkId: NetworkIdFromInput,
   sender: AddressFromInput,
   nonce: NonceFromInput,
-  timestampNanos: BigIntFromNumberOrSelf,
+  timestampNanos: BigIntFromNumberOrStringOrSelf,
   claim: ClaimTypeInput,
   archival: Schema17.Boolean,
   feeToken: Schema17.NullOr(TokenIdFromInput)
 });
+var TransactionRelease20260407Input = Schema17.Struct({
+  networkId: NetworkIdFromInput,
+  sender: AddressFromInput,
+  nonce: NonceFromInput,
+  timestampNanos: BigIntFromNumberOrStringOrSelf,
+  claims: Schema17.Array(OperationInput),
+  archival: Schema17.Boolean,
+  feeToken: Schema17.NullOr(TokenIdFromInput)
+});
+var TransactionVersionRegistry = {
+  Release20260319: {
+    wrapOperations(ops) {
+      if (ops.length === 0) {
+        throw new Error("Release20260319 transactions require at least one operation");
+      }
+      const claim = ops.length === 1 ? ops[0] : { type: "Batch", value: ops };
+      return { claim };
+    },
+    extractOperations(decoded) {
+      const claim = decoded.claim;
+      if (claim == null) return [];
+      if (typeof claim === "object" && !Array.isArray(claim)) {
+        const rec = claim;
+        if ("Batch" in rec && Array.isArray(rec.Batch)) {
+          return rec.Batch;
+        }
+        if (rec.type === "Batch" && Array.isArray(rec.value)) {
+          return rec.value;
+        }
+        return [claim];
+      }
+      return [];
+    },
+    inputSchema: TransactionRelease20260319Input
+  },
+  Release20260407: {
+    wrapOperations(ops) {
+      return { claims: ops };
+    },
+    extractOperations(decoded) {
+      return Array.isArray(decoded.claims) ? decoded.claims : [];
+    },
+    inputSchema: TransactionRelease20260407Input
+  }
+};
+function getTransactionVersionConfig(version) {
+  if (!(version in TransactionVersionRegistry)) {
+    throw new Error(`Unknown transaction version: ${version}`);
+  }
+  return TransactionVersionRegistry[version];
+}
 var RpcPalette = {
   Amount: AmountFromRpc,
   Balance: BalanceFromRpc,
@@ -2390,7 +2735,7 @@ var RpcPalette = {
   State: StateFromRpc,
   ClaimData: ClaimDataFromRpc,
   UserData: UserDataFromRpc,
-  BigInt: BigIntFromNumberOrSelf
+  BigInt: BigIntFromNumberOrStringOrSelf
 };
 var RestPalette = {
   Amount: AmountFromRest,
@@ -2405,7 +2750,7 @@ var RestPalette = {
   State: StateFromRest,
   ClaimData: ClaimDataFromRest,
   UserData: UserDataFromRest,
-  BigInt: BigIntFromNumberOrSelf
+  BigInt: BigIntFromNumberOrStringOrSelf
 };
 var BcsPalette = {
   Amount: AmountFromBcs,
@@ -2420,7 +2765,7 @@ var BcsPalette = {
   State: StateFromBcs,
   ClaimData: ClaimDataFromBcs,
   UserData: UserDataFromBcs,
-  BigInt: BigIntFromNumberOrSelf
+  BigInt: BigIntFromNumberOrStringOrSelf
 };
 var p = BcsPalette;
 var TokenTransferFromBcs = makeTokenTransfer(p);
@@ -2438,8 +2783,17 @@ var ValidatorConfigFromBcs = makeValidatorConfig(p);
 var CommitteeConfigFromBcs = makeCommitteeConfig(p);
 var CommitteeChangeFromBcs = makeCommitteeChange(p);
 var bcsOpts = { unitEncoding: "bcs" };
+var FixedAmountOrBpsFromBcs = makeFixedAmountOrBps(p, bcsOpts);
+var EscrowCreateConfigFromBcs = makeEscrowCreateConfig(p, bcsOpts);
+var EscrowCreateJobFromBcs = makeEscrowCreateJob(p);
+var EscrowSubmitFromBcs = makeEscrowSubmit(p);
+var EscrowRejectFromBcs = makeEscrowReject(p);
+var EscrowCompleteFromBcs = makeEscrowComplete(p);
+var EscrowFromBcs = makeEscrow(p, bcsOpts);
 var OperationFromBcs = makeOperation(p, bcsOpts);
 var ClaimTypeFromBcs = makeClaimType(p, bcsOpts);
+var TransactionRelease20260319FromBcs = makeTransactionRelease20260319(p, bcsOpts);
+var TransactionRelease20260407FromBcs = makeTransactionRelease20260407(p, bcsOpts);
 var TransactionFromBcs = makeTransaction(p, bcsOpts);
 var VersionedTransactionFromBcs = makeVersionedTransaction(p, bcsOpts);
 var MultiSigConfigFromBcs = makeMultiSigConfig(p);
@@ -2456,6 +2810,8 @@ var TokenInfoResponseFromBcs = makeTokenInfoResponse(p);
 var SubmitTransactionResponseFromBcs = makeSubmitTransactionResponse(p);
 var ConfirmTransactionResponseFromBcs = makeConfirmTransactionResponse(p);
 var ProxySubmitTransactionResultFromBcs = makeProxySubmitTransactionResult(p);
+var EscrowJobRecordFromBcs = makeEscrowJobRecord(p);
+var EscrowJobWithCertsFromBcs = makeEscrowJobWithCerts(p);
 var p2 = RestPalette;
 var TokenTransferFromRest = makeTokenTransfer(p2);
 var TokenCreationFromRest = makeTokenCreation(p2);
@@ -2471,8 +2827,17 @@ var ExternalClaimFromRest = makeExternalClaim(p2);
 var ValidatorConfigFromRest = makeValidatorConfig(p2);
 var CommitteeConfigFromRest = makeCommitteeConfig(p2);
 var CommitteeChangeFromRest = makeCommitteeChange(p2);
+var FixedAmountOrBpsFromRest = makeFixedAmountOrBps(p2);
+var EscrowCreateConfigFromRest = makeEscrowCreateConfig(p2);
+var EscrowCreateJobFromRest = makeEscrowCreateJob(p2);
+var EscrowSubmitFromRest = makeEscrowSubmit(p2);
+var EscrowRejectFromRest = makeEscrowReject(p2);
+var EscrowCompleteFromRest = makeEscrowComplete(p2);
+var EscrowFromRest = makeEscrow(p2);
 var OperationFromRest = makeOperation(p2);
 var ClaimTypeFromRest = makeClaimType(p2);
+var TransactionRelease20260319FromRest = makeTransactionRelease20260319(p2);
+var TransactionRelease20260407FromRest = makeTransactionRelease20260407(p2);
 var TransactionFromRest = makeTransaction(p2);
 var VersionedTransactionFromRest = makeVersionedTransaction(p2);
 var MultiSigConfigFromRest = makeMultiSigConfig(p2);
@@ -2489,6 +2854,8 @@ var TokenInfoResponseFromRest = makeTokenInfoResponse(p2);
 var SubmitTransactionResponseFromRest = makeSubmitTransactionResponse(p2);
 var ConfirmTransactionResponseFromRest = makeConfirmTransactionResponse(p2);
 var ProxySubmitTransactionResultFromRest = makeProxySubmitTransactionResult(p2);
+var EscrowJobRecordFromRest = makeEscrowJobRecord(p2);
+var EscrowJobWithCertsFromRest = makeEscrowJobWithCerts(p2);
 var p3 = RpcPalette;
 var TokenTransferFromRpc = makeTokenTransfer(p3);
 var TokenCreationFromRpc = makeTokenCreation(p3);
@@ -2504,8 +2871,17 @@ var ExternalClaimFromRpc = makeExternalClaim(p3);
 var ValidatorConfigFromRpc = makeValidatorConfig(p3);
 var CommitteeConfigFromRpc = makeCommitteeConfig(p3);
 var CommitteeChangeFromRpc = makeCommitteeChange(p3);
+var FixedAmountOrBpsFromRpc = makeFixedAmountOrBps(p3);
+var EscrowCreateConfigFromRpc = makeEscrowCreateConfig(p3);
+var EscrowCreateJobFromRpc = makeEscrowCreateJob(p3);
+var EscrowSubmitFromRpc = makeEscrowSubmit(p3);
+var EscrowRejectFromRpc = makeEscrowReject(p3);
+var EscrowCompleteFromRpc = makeEscrowComplete(p3);
+var EscrowFromRpc = makeEscrow(p3);
 var OperationFromRpc = makeOperation(p3);
 var ClaimTypeFromRpc = makeClaimType(p3);
+var TransactionRelease20260319FromRpc = makeTransactionRelease20260319(p3);
+var TransactionRelease20260407FromRpc = makeTransactionRelease20260407(p3);
 var TransactionFromRpc = makeTransaction(p3);
 var VersionedTransactionFromRpc = makeVersionedTransaction(p3);
 var MultiSigConfigFromRpc = makeMultiSigConfig(p3);
@@ -2522,6 +2898,8 @@ var TokenInfoResponseFromRpc = makeTokenInfoResponse(p3);
 var SubmitTransactionResponseFromRpc = makeSubmitTransactionResponse(p3);
 var ConfirmTransactionResponseFromRpc = makeConfirmTransactionResponse(p3);
 var ProxySubmitTransactionResultFromRpc = makeProxySubmitTransactionResult(p3);
+var EscrowJobRecordFromRpc = makeEscrowJobRecord(p3);
+var EscrowJobWithCertsFromRpc = makeEscrowJobWithCerts(p3);
 var SubmitTransactionParamsFromRpc = makeSubmitTransactionParams(p3);
 var FaucetDripParamsFromRpc = makeFaucetDripParams(p3);
 var GetAccountInfoParamsFromRpc = makeGetAccountInfoParams(p3);
@@ -2529,115 +2907,8 @@ var GetPendingMultisigParamsFromRpc = makeGetPendingMultisigParams(p3);
 var GetTokenInfoParamsFromRpc = makeGetTokenInfoParams(p3);
 var GetTransactionCertificatesParamsFromRpc = makeGetTransactionCertificatesParams(p3);
 
-// ../../packages/fast-sdk/dist/chunk-J4LYMR5I.mjs
-import { Schema as Schema18 } from "effect";
-import { Effect as Effect3, Schema as Schema22 } from "effect";
-
-// ../../node_modules/.pnpm/json-with-bigint@3.5.8/node_modules/json-with-bigint/json-with-bigint.js
-var intRegex = /^-?\d+$/;
-var noiseValue = /^-?\d+n+$/;
-var originalStringify = JSON.stringify;
-var originalParse = JSON.parse;
-var customFormat = /^-?\d+n$/;
-var bigIntsStringify = /([\[:])?"(-?\d+)n"($|([\\n]|\s)*(\s|[\\n])*[,\}\]])/g;
-var noiseStringify = /([\[:])?("-?\d+n+)n("$|"([\\n]|\s)*(\s|[\\n])*[,\}\]])/g;
-var JSONStringify = (value, replacer, space) => {
-  if ("rawJSON" in JSON) {
-    return originalStringify(
-      value,
-      (key, value2) => {
-        if (typeof value2 === "bigint") return JSON.rawJSON(value2.toString());
-        if (typeof replacer === "function") return replacer(key, value2);
-        if (Array.isArray(replacer) && replacer.includes(key)) return value2;
-        return value2;
-      },
-      space
-    );
-  }
-  if (!value) return originalStringify(value, replacer, space);
-  const convertedToCustomJSON = originalStringify(
-    value,
-    (key, value2) => {
-      const isNoise = typeof value2 === "string" && noiseValue.test(value2);
-      if (isNoise) return value2.toString() + "n";
-      if (typeof value2 === "bigint") return value2.toString() + "n";
-      if (typeof replacer === "function") return replacer(key, value2);
-      if (Array.isArray(replacer) && replacer.includes(key)) return value2;
-      return value2;
-    },
-    space
-  );
-  const processedJSON = convertedToCustomJSON.replace(
-    bigIntsStringify,
-    "$1$2$3"
-  );
-  const denoisedJSON = processedJSON.replace(noiseStringify, "$1$2$3");
-  return denoisedJSON;
-};
-var featureCache = /* @__PURE__ */ new Map();
-var isContextSourceSupported = () => {
-  const parseFingerprint = JSON.parse.toString();
-  if (featureCache.has(parseFingerprint)) {
-    return featureCache.get(parseFingerprint);
-  }
-  try {
-    const result2 = JSON.parse(
-      "1",
-      (_, __, context) => !!context?.source && context.source === "1"
-    );
-    featureCache.set(parseFingerprint, result2);
-    return result2;
-  } catch {
-    featureCache.set(parseFingerprint, false);
-    return false;
-  }
-};
-var convertMarkedBigIntsReviver = (key, value, context, userReviver) => {
-  const isCustomFormatBigInt = typeof value === "string" && customFormat.test(value);
-  if (isCustomFormatBigInt) return BigInt(value.slice(0, -1));
-  const isNoiseValue = typeof value === "string" && noiseValue.test(value);
-  if (isNoiseValue) return value.slice(0, -1);
-  if (typeof userReviver !== "function") return value;
-  return userReviver(key, value, context);
-};
-var JSONParseV2 = (text, reviver) => {
-  return JSON.parse(text, (key, value, context) => {
-    const isBigNumber = typeof value === "number" && (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER);
-    const isInt = context && intRegex.test(context.source);
-    const isBigInt = isBigNumber && isInt;
-    if (isBigInt) return BigInt(context.source);
-    if (typeof reviver !== "function") return value;
-    return reviver(key, value, context);
-  });
-};
-var MAX_INT = Number.MAX_SAFE_INTEGER.toString();
-var MAX_DIGITS = MAX_INT.length;
-var stringsOrLargeNumbers = /"(?:\\.|[^"])*"|-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/g;
-var noiseValueWithQuotes = /^"-?\d+n+"$/;
-var JSONParse = (text, reviver) => {
-  if (!text) return originalParse(text, reviver);
-  if (isContextSourceSupported()) return JSONParseV2(text, reviver);
-  const serializedData = text.replace(
-    stringsOrLargeNumbers,
-    (text2, digits, fractional, exponential) => {
-      const isString = text2[0] === '"';
-      const isNoise = isString && noiseValueWithQuotes.test(text2);
-      if (isNoise) return text2.substring(0, text2.length - 1) + 'n"';
-      const isFractionalOrExponential = fractional || exponential;
-      const isLessThanMaxSafeInt = digits && (digits.length < MAX_DIGITS || digits.length === MAX_DIGITS && digits <= MAX_INT);
-      if (isString || isFractionalOrExponential || isLessThanMaxSafeInt)
-        return text2;
-      return '"' + text2 + 'n"';
-    }
-  );
-  return originalParse(
-    serializedData,
-    (key, value, context) => convertMarkedBigIntsReviver(key, value, context, reviver)
-  );
-};
-
-// ../../packages/fast-sdk/dist/chunk-J4LYMR5I.mjs
-import { Effect as Effect4, Schema as Schema32 } from "effect";
+// ../../packages/fast-sdk/dist/chunk-2WOJNW4N.js
+import { Effect as Effect4, Encoding as Encoding2, Schema as Schema22 } from "effect";
 
 // ../../node_modules/.pnpm/@noble+ed25519@3.0.1/node_modules/@noble/ed25519/index.js
 var ed25519_CURVE = {
@@ -3088,9 +3359,9 @@ var wNAF = (n) => {
   return { p: p4, f };
 };
 
-// ../../packages/fast-sdk/dist/chunk-J4LYMR5I.mjs
+// ../../packages/fast-sdk/dist/chunk-2WOJNW4N.js
 import { Effect as Effect5 } from "effect";
-import { Effect as Effect6, Schema as Schema42 } from "effect";
+import { Effect as Effect6, Schema as Schema32 } from "effect";
 var BcsEncodeError = class extends Data.TaggedError("BcsEncodeError") {
 };
 var SigningError = class extends Data.TaggedError("SigningError") {
@@ -3152,30 +3423,12 @@ var ValidatorGenericError = class extends Data2.TaggedError(
 };
 var RpcTimeoutError = class extends Data3.TaggedError("RpcTimeoutError") {
 };
-var JsonRpcProtocolError = class extends Data3.TaggedError(
-  "JsonRpcProtocolError"
-) {
+var RestTimeoutError = class extends Data3.TaggedError("RestTimeoutError") {
 };
-var RpcError = class extends Data3.TaggedError("RpcError") {
+var RestError = class extends Data3.TaggedError("RestError") {
 };
 var GeneralError = class extends Data4.TaggedError("GeneralError") {
 };
-var FaucetDisabledError = class extends Data4.TaggedError(
-  "FaucetDisabledError"
-) {
-};
-var FaucetThrottledError = class extends Data4.TaggedError(
-  "FaucetThrottledError"
-) {
-};
-var FaucetTxnFailedError = class extends Data4.TaggedError(
-  "FaucetTxnFailedError"
-) {
-};
-var FaucetThresholdExceededError = class extends Data4.TaggedError(
-  "FaucetThresholdExceededError"
-) {
-};
 var VerifierSigsInvalidError = class extends Data4.TaggedError(
   "VerifierSigsInvalidError"
 ) {
@@ -3194,174 +3447,214 @@ var InvalidRequestError = class extends Data4.TaggedError(
   "InvalidRequestError"
 ) {
 };
-var toFastSetError = (message2, rpcErr) => {
-  if (rpcErr.type === "Generic") {
-    return new ValidatorGenericError({ message: rpcErr.value });
-  }
-  const err2 = rpcErr.value;
-  switch (err2.type) {
-    case "UnexpectedNonce":
-      return new UnexpectedNonceError({
-        message: message2,
-        expectedNonce: err2.value.expectedNonce
-      });
-    case "InsufficientFunding":
-      return new InsufficientFundingError({
-        message: message2,
-        currentBalance: err2.value.currentBalance
-      });
-    case "PreviousTransactionMustBeConfirmedFirst":
-      return new PreviousTransactionPendingError({
-        message: message2,
-        pendingConfirmation: err2.value.pendingConfirmation
-      });
-    case "InvalidSignature":
-      return new InvalidSignatureError({ message: message2, error: err2.value.error });
-    case "MissingEarlierConfirmations":
-      return new MissingEarlierConfirmationsError({
-        message: message2,
-        currentNonce: err2.value.currentNonce
-      });
-    case "CertificateTooYoung":
-      return new CertificateTooYoungError({
-        message: message2,
-        resendAfterNanos: err2.value.resendAfterNanos
-      });
-    case "NonSubmittableOperation":
-      return new NonSubmittableOperationError({
-        message: message2,
-        reason: err2.value.reason
-      });
-    default:
-      return new GeneralError({ message: message2 });
-  }
+var NotFoundError = class extends Data4.TaggedError("NotFoundError") {
 };
-var parseRpcError = (err2) => {
-  const { code, message: message2, data } = err2;
-  if (code <= -32600 && code >= -32700) {
-    return new JsonRpcProtocolError({ code, message: message2 });
-  }
-  let parsed2;
-  try {
-    parsed2 = Schema18.decodeUnknownSync(ProxyErrorData)(data);
-  } catch {
-    return new RpcError({ code, message: message2, data });
-  }
-  switch (parsed2.type) {
-    case "RpcError":
-      return toFastSetError(message2, parsed2.value);
-    case "UnexpectedNonce":
+var IpRateLimitedError = class extends Data4.TaggedError(
+  "IpRateLimitedError"
+) {
+};
+var UpstreamError = class extends Data4.TaggedError("UpstreamError") {
+};
+var ServiceUnavailableError = class extends Data4.TaggedError(
+  "ServiceUnavailableError"
+) {
+};
+var parseRestError = (status, err2) => {
+  const { code, message: message2, details } = err2;
+  const d = details;
+  switch (code) {
+    case "INVALID_REQUEST":
+      return new InvalidRequestError({ message: message2 });
+    case "NOT_FOUND":
+      return new NotFoundError({ message: message2 });
+    case "TOO_MANY_CERTIFICATES_REQUESTED":
+      return new TooManyCertificatesRequestedError({ message: message2 });
+    case "UNEXPECTED_NONCE":
       return new ProxyUnexpectedNonceError({
         message: message2,
-        txNonce: parsed2.value.txNonce,
-        expectedNonce: parsed2.value.expectedNonce
+        txNonce: BigInt(d?.tx_nonce ?? 0),
+        expectedNonce: BigInt(d?.expected_nonce ?? 0)
       });
-    case "GeneralError":
-      return new GeneralError({ message: parsed2.value });
-    case "FaucetDisabled":
-      return new FaucetDisabledError({ message: message2 });
-    case "FaucetThrottled":
-      return new FaucetThrottledError({ message: message2 });
-    case "FaucetTxnFailed":
-      return new FaucetTxnFailedError({ message: message2 });
-    case "FaucetThresholdExceeded":
-      return new FaucetThresholdExceededError({ message: message2 });
-    case "VerifierSigsInvalid":
+    case "VERIFIER_SIGNATURES_INVALID":
       return new VerifierSigsInvalidError({ message: message2 });
-    case "DatabaseError":
-      return new DatabaseError2({ message: parsed2.value });
-    case "TooManyCertificatesRequested":
-      return new TooManyCertificatesRequestedError({ message: message2 });
-    case "InvalidRequest":
-      return new InvalidRequestError({ message: parsed2.value });
+    case "INTERNAL_ERROR":
+      return new GeneralError({ message: message2 });
+    case "UPSTREAM_ERROR":
+      return new UpstreamError({ message: message2 });
+    case "IP_RATE_LIMITED":
+      return new IpRateLimitedError({
+        message: message2,
+        retryAfterSecs: d?.retry_after_secs ?? 0
+      });
+    case "SERVICE_UNAVAILABLE":
+      return new ServiceUnavailableError({ message: message2 });
+    case "DATABASE_ERROR":
+      return new DatabaseError2({ message: message2 });
     default:
-      return new RpcError({ code, message: message2, data });
+      return new RestError({ status, code, message: message2, details });
   }
 };
-var nextId = 1;
-var RpcResponse = Schema22.Struct({
-  jsonrpc: Schema22.Literal("2.0"),
-  id: Schema22.Number,
-  result: Schema22.optional(Schema22.Unknown),
-  error: Schema22.optional(
-    Schema22.Struct({
-      code: Schema22.Number,
-      message: Schema22.String,
-      data: Schema22.optional(Schema22.Unknown)
-    })
-  )
+var RestSuccessEnvelope = Schema19.Struct({
+  data: Schema19.Unknown,
+  meta: Schema19.Struct({ timestamp: Schema19.String })
 });
-var rpcCallEffect = (url, method, params, timeoutMs = 15e3) => Effect3.gen(function* () {
-  const id = nextId++;
-  const body = JSONStringify({ jsonrpc: "2.0", id, method, params });
-  const res = yield* Effect3.tryPromise(
-    () => fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body
-    })
+var RestErrorEnvelope = Schema19.Struct({
+  error: Schema19.Struct({
+    code: Schema19.String,
+    message: Schema19.String,
+    details: Schema19.optional(Schema19.Unknown)
+  }),
+  meta: Schema19.Struct({ timestamp: Schema19.String })
+});
+var restCallEffect = (baseUrl, opts) => {
+  const timeoutMs = opts.timeoutMs ?? 15e3;
+  return Effect3.gen(function* () {
+    const url = new URL(`${baseUrl.replace(/\/$/, "")}${opts.path}`);
+    if (opts.query) {
+      for (const [k, v] of Object.entries(opts.query)) {
+        if (v !== void 0) url.searchParams.set(k, v);
+      }
+    }
+    const fetchOpts = { method: opts.method };
+    if (opts.body !== void 0) {
+      fetchOpts.headers = { "Content-Type": "application/json" };
+      fetchOpts.body = JSONStringify(opts.body);
+    }
+    const res = yield* Effect3.tryPromise(() => fetch(url.toString(), fetchOpts));
+    const text = yield* Effect3.tryPromise(() => res.text());
+    let json;
+    try {
+      json = JSONParse(text);
+    } catch {
+      return yield* parseRestError(res.status, {
+        code: `HTTP_${res.status}`,
+        message: text.slice(0, 200)
+      });
+    }
+    if (!res.ok) {
+      const errEnv = yield* Schema19.decodeUnknown(RestErrorEnvelope)(json);
+      return yield* parseRestError(res.status, errEnv.error);
+    }
+    const okEnv = yield* Schema19.decodeUnknown(RestSuccessEnvelope)(json);
+    return okEnv.data;
+  }).pipe(
+    Effect3.timeout(`${timeoutMs} millis`),
+    Effect3.catchTag(
+      "TimeoutException",
+      () => new RestTimeoutError({ path: opts.path, timeoutMs })
+    )
   );
-  const text = yield* Effect3.tryPromise(() => res.text());
-  const json = yield* Schema22.decodeUnknown(RpcResponse)(JSONParse(text));
-  if (json.error) {
-    return yield* parseRpcError(json.error);
-  }
-  return json.result;
-}).pipe(
-  Effect3.timeout(`${timeoutMs} millis`),
-  Effect3.catchTag(
-    "TimeoutException",
-    () => new RpcTimeoutError({ method, timeoutMs })
-  )
-);
-var submitTransaction = (rpcUrl, params) => Effect4.gen(function* () {
-  const wire = yield* Schema32.encode(SubmitTransactionParamsFromRpc)(params);
-  const result2 = yield* rpcCallEffect(
-    rpcUrl,
-    "proxy_submitTransaction",
-    wire
+};
+var addressToStr = (addr) => Schema22.encodeSync(AddressFromRest)(addr);
+var tokenIdToHex = (id) => Schema22.encodeSync(TokenIdFromRest)(id);
+var submitTransaction = (url, params) => Effect4.gen(function* () {
+  const bcsEncoded = yield* Schema22.encode(VersionedTransactionFromBcs)(
+    params.transaction
+  );
+  const txBytes = yield* encode(
+    bcs_layout_exports.VersionedTransaction,
+    bcsEncoded
+  );
+  const txHex = Encoding2.encodeHex(txBytes);
+  const sigBcsEncoded = yield* Schema22.encode(SignatureOrMultiSigFromBcs)(
+    params.signature
+  );
+  const sigBytes = yield* encode(
+    bcs_layout_exports.SignatureOrMultiSig,
+    sigBcsEncoded
   );
-  return yield* Schema32.decodeUnknown(ProxySubmitTransactionResultFromRpc)(
+  const sigHex = Encoding2.encodeHex(sigBytes);
+  const result2 = yield* restCallEffect(url, {
+    method: "POST",
+    path: "/v1/submit-transaction",
+    body: {
+      transaction: txHex,
+      signature: sigHex,
+      witness_certificates: []
+    }
+  });
+  return yield* Schema22.decodeUnknown(ProxySubmitTransactionResultFromRest)(
     result2
   );
 });
-var faucetDrip = (rpcUrl, params) => Effect4.gen(function* () {
-  const wire = yield* Schema32.encode(FaucetDripParamsFromRpc)(params);
-  yield* rpcCallEffect(rpcUrl, "proxy_faucetDrip", wire);
+var getAccountInfo = (url, params) => Effect4.gen(function* () {
+  const addr = addressToStr(params.address);
+  const result2 = yield* restCallEffect(url, {
+    method: "GET",
+    path: `/v1/accounts/${addr}`,
+    query: {
+      token_balances_filter: params.tokenBalancesFilter ? params.tokenBalancesFilter.map(tokenIdToHex).join(",") : void 0,
+      state_key_filter: params.stateKeyFilter ? params.stateKeyFilter.map((k) => Encoding2.encodeHex(k)).join(",") : void 0
+    }
+  });
+  return yield* Schema22.decodeUnknown(AccountInfoResponseFromRest)(result2);
+});
+var getPendingMultisigTransactions = (url, params) => Effect4.gen(function* () {
+  const addr = addressToStr(params.address);
+  const result2 = yield* restCallEffect(url, {
+    method: "GET",
+    path: `/v1/accounts/${addr}/pending-multisig-transactions`
+  });
+  return yield* Schema22.decodeUnknown(
+    Schema22.Array(TransactionEnvelopeFromRest)
+  )(result2);
 });
-var getAccountInfo = (rpcUrl, params) => Effect4.gen(function* () {
-  const wire = yield* Schema32.encode(GetAccountInfoParamsFromRpc)(params);
-  const result2 = yield* rpcCallEffect(rpcUrl, "proxy_getAccountInfo", wire);
-  return yield* Schema32.decodeUnknown(AccountInfoResponseFromRpc)(result2);
+var getTokenInfo = (url, params) => Effect4.gen(function* () {
+  const result2 = yield* restCallEffect(url, {
+    method: "GET",
+    path: "/v1/tokens",
+    query: {
+      token_ids: params.tokenIds.map(tokenIdToHex).join(",")
+    }
+  });
+  return yield* Schema22.decodeUnknown(TokenInfoResponseFromRest)(result2);
 });
-var getPendingMultisigTransactions = (rpcUrl, params) => Effect4.gen(function* () {
-  const wire = yield* Schema32.encode(GetPendingMultisigParamsFromRpc)(params);
-  const result2 = yield* rpcCallEffect(
-    rpcUrl,
-    "proxy_getPendingMultisigTransactions",
-    wire
-  );
-  return yield* Schema32.decodeUnknown(
-    Schema32.Array(TransactionEnvelopeFromRpc)
+var getTransactionCertificates = (url, params) => Effect4.gen(function* () {
+  const addr = addressToStr(params.address);
+  const result2 = yield* restCallEffect(url, {
+    method: "GET",
+    path: `/v1/accounts/${addr}/certificates`,
+    query: {
+      from_nonce: params.fromNonce.toString(),
+      limit: params.limit.toString()
+    }
+  });
+  return yield* Schema22.decodeUnknown(
+    Schema22.Array(TransactionCertificateFromRest)
   )(result2);
 });
-var getTokenInfo = (rpcUrl, params) => Effect4.gen(function* () {
-  const wire = yield* Schema32.encode(GetTokenInfoParamsFromRpc)(params);
-  const result2 = yield* rpcCallEffect(rpcUrl, "proxy_getTokenInfo", wire);
-  return yield* Schema32.decodeUnknown(TokenInfoResponseFromRpc)(result2);
+var getEscrowJob = (url, params) => Effect4.gen(function* () {
+  const jobIdHex = tokenIdToHex(params.jobId);
+  const result2 = yield* restCallEffect(url, {
+    method: "GET",
+    path: `/v1/escrow-jobs/${jobIdHex}`,
+    query: { certs: params.certs ? "true" : void 0 }
+  });
+  if (params.certs) {
+    return yield* Schema22.decodeUnknown(EscrowJobWithCertsFromRest)(result2);
+  }
+  return yield* Schema22.decodeUnknown(EscrowJobRecordFromRest)(result2);
 });
-var getTransactionCertificates = (rpcUrl, params) => Effect4.gen(function* () {
-  const wire = yield* Schema32.encode(GetTransactionCertificatesParamsFromRpc)(
-    params
-  );
-  const result2 = yield* rpcCallEffect(
-    rpcUrl,
-    "proxy_getTransactionCertificates",
-    wire
+var getEscrowJobs = (url, params) => Effect4.gen(function* () {
+  const result2 = yield* restCallEffect(url, {
+    method: "GET",
+    path: "/v1/escrow-jobs",
+    query: {
+      client: params.client ? addressToStr(params.client) : void 0,
+      provider: params.provider ? addressToStr(params.provider) : void 0,
+      evaluator: params.evaluator ? addressToStr(params.evaluator) : void 0,
+      status: params.status,
+      certs: params.certs ? "true" : void 0
+    }
+  });
+  if (params.certs) {
+    return yield* Schema22.decodeUnknown(
+      Schema22.Array(EscrowJobWithCertsFromRest)
+    )(result2);
+  }
+  return yield* Schema22.decodeUnknown(Schema22.Array(EscrowJobRecordFromRest))(
+    result2
   );
-  return yield* Schema32.decodeUnknown(
-    Schema32.Array(TransactionCertificateFromRpc)
-  )(result2);
 });
 var signMessage = (privateKey, message2) => Effect5.tryPromise({
   try: () => signAsync(message2, privateKey),
@@ -3376,7 +3669,7 @@ var getPublicKey = (privateKey) => Effect5.tryPromise({
   catch: (cause) => new PublicKeyError({ cause })
 });
 var buildSignedEnvelope = (privateKey, transaction) => Effect6.gen(function* () {
-  const bcsEncoded = yield* Schema42.encode(VersionedTransactionFromBcs)(
+  const bcsEncoded = yield* Schema32.encode(VersionedTransactionFromBcs)(
     transaction
   );
   const rawSig = yield* signTypedData(
@@ -3384,23 +3677,23 @@ var buildSignedEnvelope = (privateKey, transaction) => Effect6.gen(function* ()
     bcs_layout_exports.VersionedTransaction,
     bcsEncoded
   );
-  const signature = yield* Schema42.decodeUnknown(SignatureFromInput)(rawSig);
+  const signature = yield* Schema32.decodeUnknown(SignatureFromInput)(rawSig);
   return {
     transaction,
     signature: { type: "Signature", value: signature }
   };
 });
 
-// ../../packages/fast-sdk/dist/index.mjs
+// ../../packages/fast-sdk/dist/index.js
 import { bech32m as bech32m2 } from "bech32";
-import { Encoding as Encoding2 } from "effect";
-import { Schema as Schema19 } from "effect";
+import { Encoding as Encoding3 } from "effect";
+import { Schema as Schema20 } from "effect";
 import { Redacted, Schema as Schema23 } from "effect";
 import { Schema as Schema33 } from "effect";
-var toHex3 = (bytes) => `0x${Encoding2.encodeHex(bytes)}`;
+var toHex3 = (bytes) => `0x${Encoding3.encodeHex(bytes)}`;
 var fromHex3 = (hex) => {
   const stripped = hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
-  const result2 = Encoding2.decodeHex(stripped);
+  const result2 = Encoding3.decodeHex(stripped);
   if (result2._tag === "Left") throw new Error(`Invalid hex string: ${hex}`);
   return result2.right;
 };
@@ -3413,53 +3706,61 @@ var fromFastAddress = (address) => {
 };
 var hashHex2 = (schema, message2) => run(hashHex(schema, message2));
 var FastProvider = class {
-  _rpcUrl;
+  _url;
   constructor(opts) {
-    this._rpcUrl = opts.rpcUrl;
+    this._url = opts.url;
   }
-  /** The proxy RPC URL this provider was constructed with. */
-  get rpcUrl() {
-    return this._rpcUrl;
+  /** The proxy base URL this provider was constructed with. */
+  get url() {
+    return this._url;
   }
   /**
    * Submit a signed transaction envelope to the network.
    * The envelope should be produced by {@link TransactionBuilder.sign}.
    */
   async submitTransaction(params) {
-    return run(submitTransaction(this._rpcUrl, params));
-  }
-  /** Request a faucet drip for the given recipient. */
-  async faucetDrip(params) {
-    const internal = Schema19.decodeUnknownSync(FaucetDripInput)(params);
-    return run(faucetDrip(this._rpcUrl, internal));
+    return run(submitTransaction(this._url, params));
   }
   /**
    * Fetch account information including balance, nonce, token balances, and state.
    * Use filters to request specific token balances or state keys.
    */
   async getAccountInfo(params) {
-    const internal = Schema19.decodeUnknownSync(GetAccountInfoInput)(params);
-    return run(getAccountInfo(this._rpcUrl, internal));
+    const internal = Schema20.decodeUnknownSync(GetAccountInfoInput)(params);
+    return run(getAccountInfo(this._url, internal));
   }
   /** Fetch pending multisig transactions for the given address. */
   async getPendingMultisigTransactions(params) {
-    const internal = Schema19.decodeUnknownSync(GetPendingMultisigInput)(params);
-    return run(getPendingMultisigTransactions(this._rpcUrl, internal));
+    const internal = Schema20.decodeUnknownSync(GetPendingMultisigInput)(params);
+    return run(getPendingMultisigTransactions(this._url, internal));
   }
   /** Fetch metadata for one or more tokens by their IDs. */
   async getTokenInfo(params) {
-    const internal = Schema19.decodeUnknownSync(GetTokenInfoInput)(params);
-    return run(getTokenInfo(this._rpcUrl, internal));
+    const internal = Schema20.decodeUnknownSync(GetTokenInfoInput)(params);
+    return run(getTokenInfo(this._url, internal));
   }
   /**
    * Fetch finalized transaction certificates for an address.
    * Results are paginated by nonce range.
    */
   async getTransactionCertificates(params) {
-    const internal = Schema19.decodeUnknownSync(GetTransactionCertificatesInput)(
+    const internal = Schema20.decodeUnknownSync(GetTransactionCertificatesInput)(
       params
     );
-    return run(getTransactionCertificates(this._rpcUrl, internal));
+    return run(getTransactionCertificates(this._url, internal));
+  }
+  /** Fetch a single escrow job by ID, optionally including certificates. */
+  async getEscrowJob(params) {
+    const internal = Schema20.decodeUnknownSync(GetEscrowJobInput)(params);
+    return run(getEscrowJob(this._url, internal));
+  }
+  /**
+   * List escrow jobs filtered by role (client, provider, or evaluator).
+   * Optionally filter by status and include certificates.
+   */
+  async getEscrowJobs(params) {
+    const internal = Schema20.decodeUnknownSync(GetEscrowJobsInput)(params);
+    return run(getEscrowJobs(this._url, internal));
   }
 };
 var Signer = class {
@@ -3560,6 +3861,11 @@ var TransactionBuilder = class {
     this.operations.push({ type: "LeaveCommittee" });
     return this;
   }
+  /** Add an escrow operation (CreateConfig, CreateJob, Submit, Reject, Complete). */
+  addEscrow(params) {
+    this.operations.push({ type: "Escrow", value: params });
+    return this;
+  }
   /** Update the nonce for the next {@link sign} call. */
   setNonce(nonce) {
     this.options = { ...this.options, nonce };
@@ -3585,22 +3891,24 @@ var TransactionBuilder = class {
    * @returns A signed {@link TransactionEnvelope} ready for submission.
    */
   async sign() {
+    if (this.operations.length === 0) {
+      throw new Error("TransactionBuilder.sign() requires at least one operation");
+    }
     const { signer, networkId, nonce, version, archival, feeToken } = this.options;
     const sender = await signer.getPublicKey();
     const privateKey = await signer.getPrivateKey();
     const ops = this.operations;
-    const claim = ops.length === 1 ? ops[0] : { type: "Batch", value: ops };
-    const txInput = {
+    const type = version ?? LatestTransactionVersion;
+    const config = getTransactionVersionConfig(type);
+    const internal = Schema33.decodeUnknownSync(config.inputSchema)({
       networkId,
       sender,
       nonce,
       timestampNanos: BigInt(Date.now()) * 1000000n,
-      claim,
+      ...config.wrapOperations(ops),
       archival: archival ?? false,
       feeToken: feeToken ?? null
-    };
-    const internal = Schema33.decodeUnknownSync(TransactionInput)(txInput);
-    const type = version ?? "Release20260319";
+    });
     const versioned = { type, value: internal };
     return run(buildSignedEnvelope(privateKey, versioned));
   }
@@ -9827,7 +10135,7 @@ function fromAbi(abi2, name, options) {
     return "name" in abiItem2 && abiItem2.name === name;
   });
   if (abiItems.length === 0)
-    throw new NotFoundError({ name });
+    throw new NotFoundError2({ name });
   if (abiItems.length === 1)
     return {
       ...abiItems[0],
@@ -9879,7 +10187,7 @@ function fromAbi(abi2, name, options) {
     return { ...abiItem2, overloads };
   })();
   if (!abiItem)
-    throw new NotFoundError({ name });
+    throw new NotFoundError2({ name });
   return {
     ...abiItem,
     ...prepare ? { hash: getSignatureHash(abiItem) } : {}
@@ -9942,7 +10250,7 @@ var AmbiguityError = class extends BaseError2 {
     });
   }
 };
-var NotFoundError = class extends BaseError2 {
+var NotFoundError2 = class extends BaseError2 {
   constructor({ name, data, type = "item" }) {
     const selector = (() => {
       if (name)
@@ -9979,7 +10287,7 @@ function from11(abiConstructor) {
 function fromAbi2(abi2) {
   const item = abi2.find((item2) => item2.type === "constructor");
   if (!item)
-    throw new NotFoundError({ name: "constructor" });
+    throw new NotFoundError2({ name: "constructor" });
   return item;
 }
 
@@ -10007,7 +10315,7 @@ function from12(abiFunction, options = {}) {
 function fromAbi3(abi2, name, options) {
   const item = fromAbi(abi2, name, options);
   if (item.type !== "function")
-    throw new NotFoundError({ name, type: "function" });
+    throw new NotFoundError2({ name, type: "function" });
   return item;
 }
 function getSelector2(abiItem) {
@@ -12329,7 +12637,7 @@ var sepolia = /* @__PURE__ */ defineChain({
 });
 
 // ../../packages/allset-sdk/dist/index.js
-import { Schema as Schema20 } from "effect";
+import { Schema as Schema21 } from "effect";
 function fastAddressToBytes(address) {
   try {
     return fromFastAddress(address);
@@ -12865,7 +13173,7 @@ async function approveErc20(clients, token, spender, amount) {
   }
 }
 async function evmSign(certificate, crossSignUrl) {
-  const wireFormat = Schema20.encodeSync(TransactionCertificateFromRpc)(
+  const wireFormat = Schema21.encodeSync(TransactionCertificateFromRpc)(
     certificate
   );
   const serialized = bigIntToNumber(wireFormat);
@@ -13182,9 +13490,9 @@ var FastRpcLive = Layer3.effect(
     const config = yield* ClientConfig;
     const getRpcUrl = () => networkConfig.resolve(config.network).pipe(
       Effect8.map((n) => {
-        if (config.debug) process.stderr.write(`[debug] rpcUrl: ${n.rpcUrl}
+        if (config.debug) process.stderr.write(`[debug] url: ${n.url}
 `);
-        return n.rpcUrl;
+        return n.url;
       }),
       Effect8.mapError(
         (e) => new FastSdkError({ message: e.message, cause: e })
@@ -13228,7 +13536,7 @@ var FastRpcLive = Layer3.effect(
 
 // ../../packages/x402-client/dist/bridge.js
 async function getFastBalance(wallet, options) {
-  const provider = new FastProvider({ rpcUrl: options.rpcUrl });
+  const provider = new FastProvider({ url: options.rpcUrl });
   const signer = new Signer(wallet.privateKey);
   const publicKey = await signer.getPublicKey();
   try {
@@ -13265,7 +13573,7 @@ async function bridgeFastusdcToUsdc(params) {
   log(`  From: ${fastWallet.address}`);
   log(`  To: ${evmReceiverAddress}`);
   try {
-    const provider = new FastProvider({ rpcUrl });
+    const provider = new FastProvider({ url: rpcUrl });
     const signer = new Signer(fastWallet.privateKey);
     const publicKey = await signer.getPublicKey();
     const derivedAddress = toFastAddress(publicKey);
@@ -13298,12 +13606,13 @@ async function bridgeFastusdcToUsdc(params) {
 }
 
 // ../../packages/x402-client/dist/fast.js
+import { Schema as Schema24 } from "effect";
 var fastProviders = {};
-function getFastProvider(rpcUrl) {
-  if (!fastProviders[rpcUrl]) {
-    fastProviders[rpcUrl] = new FastProvider({ rpcUrl });
+function getFastProvider(url) {
+  if (!fastProviders[url]) {
+    fastProviders[url] = new FastProvider({ url });
   }
-  return fastProviders[rpcUrl];
+  return fastProviders[url];
 }
 function toHuman(rawAmount, decimals) {
   return (Number(rawAmount) / Math.pow(10, decimals)).toString();
@@ -13408,8 +13717,7 @@ async function handleFastPayment(url, method, customHeaders, requestBody, paymen
   }
   log(`  Transaction complete in ${Date.now() - txStartTime}ms`);
   const certificate = submitResult.value;
-  const tx = certificate.envelope.transaction;
-  const bcsInput = { [tx.type]: tx.value };
+  const bcsInput = Schema24.encodeSync(VersionedTransactionFromBcs)(certificate.envelope.transaction);
   const txHash = await hashHex2(bcs_layout_exports.VersionedTransaction, bcsInput);
   log(`  txHash: ${txHash}`);
   log(`[Fast] Building x402 payment payload...`);
@@ -17780,13 +18088,13 @@ var infoStatus = {
     const defaultLabel = isDefault ? " (default)" : "";
     yield* output.humanLine(`Network: ${config.network}${defaultLabel}`);
     yield* output.humanLine(
-      `  Fast RPC:      ${network2.rpcUrl}        ${healthy ? "\u2713 healthy" : "\u2717 unreachable"}`
+      `  Fast RPC:      ${network2.url}        ${healthy ? "\u2713 healthy" : "\u2717 unreachable"}`
     );
     yield* output.humanLine(`  Explorer:      ${network2.explorerUrl}`);
     yield* output.ok({
       network: config.network,
       fast: {
-        rpcUrl: network2.rpcUrl,
+        url: network2.url,
         explorerUrl: network2.explorerUrl,
         healthy
       }
@@ -18295,7 +18603,7 @@ var pay2 = {
       privateKey: toHex3(seed),
       publicKey,
       address: fastAddress,
-      rpcUrl: network2.rpcUrl
+      rpcUrl: network2.url
     };
     const evmWallet = {
       type: "evm",
@@ -18370,7 +18678,7 @@ var pay2 = {
 
 // src/commands/send.ts
 import { bech32m as bech32m4 } from "bech32";
-import { Effect as Effect34, Schema as Schema21 } from "effect";
+import { Effect as Effect34, Schema as Schema25 } from "effect";
 var send = {
   cmd: "send",
   handler: (args) => Effect34.gen(function* () {
@@ -18553,7 +18861,7 @@ var send = {
         );
       }
       const signer = new Signer(seed);
-      const provider = new FastProvider({ rpcUrl: network2.rpcUrl });
+      const provider = new FastProvider({ url: network2.url });
       const bridgeResult = yield* bridge.withdraw({
         fastBridgeAddress: chainCfg.fastBridgeAddress,
         relayerUrl: chainCfg.relayerUrl,
@@ -18605,7 +18913,7 @@ var send = {
         })
       });
       yield* rpc.submitTransaction(envelope);
-      const bcsInput = yield* Schema21.encode(VersionedTransactionFromBcs)(
+      const bcsInput = yield* Schema25.encode(VersionedTransactionFromBcs)(
         envelope.transaction
       ).pipe(
         Effect34.mapError(
@@ -19001,9 +19309,9 @@ var resolveNetwork = async () => {
   if (parsed.network) return parsed.network;
   try {
     const { Effect: Eff, ManagedRuntime, Layer: Layer7 } = await import("effect");
-    const { NetworkConfigService: NetworkConfigService2 } = await import("./network-5PLYLKX3.js");
+    const { NetworkConfigService: NetworkConfigService2 } = await import("./network-QDRK4P6X.js");
     const { DatabaseLive: DatabaseLive2 } = await import("./database-NXA7GQKE.js");
-    const { AppConfigLive: AppConfigLive2 } = await import("./app-IJ6QEQ2I.js");
+    const { AppConfigLive: AppConfigLive2 } = await import("./app-PZWIJK2U.js");
     const layer = Layer7.provide(NetworkConfigService2.Default, Layer7.merge(DatabaseLive2, AppConfigLive2));
     const runtime = ManagedRuntime.make(layer);
     const name = await runtime.runPromise(