@interest-protocol/vortex-sdk 11.3.0 → 11.3.1

package/dist/index.mjs

@@ -2835,12 +2835,12 @@ const InnerTypeTag = bcs.enum("TypeTag", {
   address: null,
   signer: null,
   vector: bcs.lazy(() => InnerTypeTag),
-  struct: bcs.lazy(() => StructTag$1),
+  struct: bcs.lazy(() => StructTag),
   u16: null,
   u32: null,
   u256: null
 });
-const TypeTag$1 = InnerTypeTag.transform({
+const TypeTag = InnerTypeTag.transform({
   input: (typeTag) => typeof typeTag === "string" ? TypeTagSerializer.parseFromStr(typeTag, true) : typeTag,
   output: (typeTag) => TypeTagSerializer.tagToString(typeTag)
 });
@@ -2854,7 +2854,7 @@ const ProgrammableMoveCall$1 = bcs.struct("ProgrammableMoveCall", {
   package: Address,
   module: bcs.string(),
   function: bcs.string(),
-  typeArguments: bcs.vector(TypeTag$1),
+  typeArguments: bcs.vector(TypeTag),
   arguments: bcs.vector(Argument$1)
 });
 const Command$1 = bcs.enum("Command", {
@@ -2903,7 +2903,7 @@ const Command$1 = bcs.enum("Command", {
   //  * so this call serves a utility function.
   //  */
   MakeMoveVec: bcs.struct("MakeMoveVec", {
-    type: optionEnum(TypeTag$1).transform({
+    type: optionEnum(TypeTag).transform({
       input: (val) => val === null ? {
         None: true
       } : {
@@ -2935,11 +2935,11 @@ const TransactionKind = bcs.enum("TransactionKind", {
   Genesis: null,
   ConsensusCommitPrologue: null
 });
-const TransactionExpiration$3 = bcs.enum("TransactionExpiration", {
+const TransactionExpiration$2 = bcs.enum("TransactionExpiration", {
   None: null,
   Epoch: unsafe_u64()
 });
-const StructTag$1 = bcs.struct("StructTag", {
+const StructTag = bcs.struct("StructTag", {
   address: Address,
   module: bcs.string(),
   name: bcs.string(),
@@ -2955,7 +2955,7 @@ const TransactionDataV1 = bcs.struct("TransactionDataV1", {
   kind: TransactionKind,
   sender: Address,
   gasData: GasData$1,
-  expiration: TransactionExpiration$3
+  expiration: TransactionExpiration$2
 });
 const TransactionData = bcs.enum("TransactionData", {
   V1: TransactionDataV1
@@ -3281,14 +3281,14 @@ const suiBcs = {
   SenderSignedData,
   SenderSignedTransaction,
   SharedObjectRef,
-  StructTag: StructTag$1,
+  StructTag,
   SuiObjectRef,
   TransactionData,
   TransactionDataV1,
   TransactionEffects,
-  TransactionExpiration: TransactionExpiration$3,
+  TransactionExpiration: TransactionExpiration$2,
   TransactionKind,
-  TypeTag: TypeTag$1
+  TypeTag
 };
 
 function deriveDynamicFieldID(parentId, typeTag, key) {
@@ -3422,8 +3422,8 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-const PACKAGE_VERSION = "1.43.2";
-const TARGETED_RPC_VERSION = "1.60.0";
+const PACKAGE_VERSION = "1.45.2";
+const TARGETED_RPC_VERSION = "1.62.0";
 
 const CODE_TO_ERROR_TYPE = {
   "-32700": "ParseError",
@@ -3824,783 +3824,914 @@ class Experimental_BaseClient {
   }
 }
 
-// src/actions/await/awaitAsync.ts
-
-// src/storages/globalConfig/globalConfig.ts
-var store;
-function getGlobalConfig(config2) {
-  return {
-    lang: config2?.lang ?? store?.lang,
-    message: config2?.message,
-    abortEarly: config2?.abortEarly ?? store?.abortEarly,
-    abortPipeEarly: config2?.abortPipeEarly ?? store?.abortPipeEarly
-  };
+//#region src/storages/globalConfig/globalConfig.ts
+let store$4;
+/**
+* Returns the global configuration.
+*
+* @param config The config to merge.
+*
+* @returns The configuration.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getGlobalConfig(config$1) {
+	return {
+		lang: config$1?.lang ?? store$4?.lang,
+		message: config$1?.message,
+		abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
+		abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
+	};
 }
 
-// src/storages/globalMessage/globalMessage.ts
-var store2;
+//#endregion
+//#region src/storages/globalMessage/globalMessage.ts
+let store$3;
+/**
+* Returns a global error message.
+*
+* @param lang The language of the message.
+*
+* @returns The error message.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function getGlobalMessage(lang) {
-  return store2?.get(lang);
+	return store$3?.get(lang);
 }
 
-// src/storages/schemaMessage/schemaMessage.ts
-var store3;
+//#endregion
+//#region src/storages/schemaMessage/schemaMessage.ts
+let store$2;
+/**
+* Returns a schema error message.
+*
+* @param lang The language of the message.
+*
+* @returns The error message.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function getSchemaMessage(lang) {
-  return store3?.get(lang);
+	return store$2?.get(lang);
 }
 
-// src/storages/specificMessage/specificMessage.ts
-var store4;
+//#endregion
+//#region src/storages/specificMessage/specificMessage.ts
+let store$1;
+/**
+* Returns a specific error message.
+*
+* @param reference The identifier reference.
+* @param lang The language of the message.
+*
+* @returns The error message.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function getSpecificMessage(reference, lang) {
-  return store4?.get(reference)?.get(lang);
+	return store$1?.get(reference)?.get(lang);
 }
 
-// src/utils/_stringify/_stringify.ts
+//#endregion
+//#region src/utils/_stringify/_stringify.ts
+/**
+* Stringifies an unknown input to a literal or type string.
+*
+* @param input The unknown input.
+*
+* @returns A literal or type string.
+*
+* @internal
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function _stringify(input) {
-  const type = typeof input;
-  if (type === "string") {
-    return `"${input}"`;
-  }
-  if (type === "number" || type === "bigint" || type === "boolean") {
-    return `${input}`;
-  }
-  if (type === "object" || type === "function") {
-    return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
-  }
-  return type;
+	const type = typeof input;
+	if (type === "string") return `"${input}"`;
+	if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
+	if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+	return type;
 }
 
-// src/utils/_addIssue/_addIssue.ts
-function _addIssue(context, label, dataset, config2, other) {
-  const input = other && "input" in other ? other.input : dataset.value;
-  const expected = other?.expected ?? context.expects ?? null;
-  const received = other?.received ?? _stringify(input);
-  const issue = {
-    kind: context.kind,
-    type: context.type,
-    input,
-    expected,
-    received,
-    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
-    // @ts-expect-error
-    requirement: context.requirement,
-    path: other?.path,
-    issues: other?.issues,
-    lang: config2.lang,
-    abortEarly: config2.abortEarly,
-    abortPipeEarly: config2.abortPipeEarly
-  };
-  const isSchema = context.kind === "schema";
-  const message = other?.message ?? // @ts-expect-error
-  context.message ?? getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? getSchemaMessage(issue.lang) : null) ?? config2.message ?? getGlobalMessage(issue.lang);
-  if (message) {
-    issue.message = typeof message === "function" ? message(issue) : message;
-  }
-  if (isSchema) {
-    dataset.typed = false;
-  }
-  if (dataset.issues) {
-    dataset.issues.push(issue);
-  } else {
-    dataset.issues = [issue];
-  }
+//#endregion
+//#region src/utils/_addIssue/_addIssue.ts
+/**
+* Adds an issue to the dataset.
+*
+* @param context The issue context.
+* @param label The issue label.
+* @param dataset The input dataset.
+* @param config The configuration.
+* @param other The optional props.
+*
+* @internal
+*/
+function _addIssue(context, label, dataset, config$1, other) {
+	const input = other && "input" in other ? other.input : dataset.value;
+	const expected = other?.expected ?? context.expects ?? null;
+	const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+	const issue = {
+		kind: context.kind,
+		type: context.type,
+		input,
+		expected,
+		received,
+		message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+		requirement: context.requirement,
+		path: other?.path,
+		issues: other?.issues,
+		lang: config$1.lang,
+		abortEarly: config$1.abortEarly,
+		abortPipeEarly: config$1.abortPipeEarly
+	};
+	const isSchema = context.kind === "schema";
+	const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+	if (message$1 !== void 0) issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
+	if (isSchema) dataset.typed = false;
+	if (dataset.issues) dataset.issues.push(issue);
+	else dataset.issues = [issue];
 }
 
-// src/utils/_isValidObjectKey/_isValidObjectKey.ts
-function _isValidObjectKey(object2, key) {
-  return Object.hasOwn(object2, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+//#endregion
+//#region src/utils/_getStandardProps/_getStandardProps.ts
+/**
+* Returns the Standard Schema properties.
+*
+* @param context The schema context.
+*
+* @returns The Standard Schema properties.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function _getStandardProps(context) {
+	return {
+		version: 1,
+		vendor: "valibot",
+		validate(value$1) {
+			return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
+		}
+	};
 }
 
-// src/utils/ValiError/ValiError.ts
+//#endregion
+//#region src/utils/_isValidObjectKey/_isValidObjectKey.ts
+/**
+* Disallows inherited object properties and prevents object prototype
+* pollution by disallowing certain keys.
+*
+* @param object The object to check.
+* @param key The key to check.
+*
+* @returns Whether the key is allowed.
+*
+* @internal
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function _isValidObjectKey(object$1, key) {
+	return Object.hasOwn(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+}
+
+//#endregion
+//#region src/utils/_joinExpects/_joinExpects.ts
+/**
+* Joins multiple `expects` values with the given separator.
+*
+* @param values The `expects` values.
+* @param separator The separator.
+*
+* @returns The joined `expects` property.
+*
+* @internal
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function _joinExpects(values$1, separator) {
+	const list = [...new Set(values$1)];
+	if (list.length > 1) return `(${list.join(` ${separator} `)})`;
+	return list[0] ?? "never";
+}
+
+//#endregion
+//#region src/utils/ValiError/ValiError.ts
+/**
+* A Valibot error with useful information.
+*/
 var ValiError = class extends Error {
-  /**
-   * The error issues.
-   */
-  issues;
-  /**
-   * Creates a Valibot error with useful information.
-   *
-   * @param issues The error issues.
-   */
-  constructor(issues) {
-    super(issues[0].message);
-    this.name = "ValiError";
-    this.issues = issues;
-  }
+	/**
+	* Creates a Valibot error with useful information.
+	*
+	* @param issues The error issues.
+	*/
+	constructor(issues) {
+		super(issues[0].message);
+		this.name = "ValiError";
+		this.issues = issues;
+	}
 };
 
-// src/actions/check/check.ts
-function check(requirement, message) {
-  return {
-    kind: "validation",
-    type: "check",
-    reference: check,
-    async: false,
-    expects: null,
-    requirement,
-    message,
-    _run(dataset, config2) {
-      if (dataset.typed && !this.requirement(dataset.value)) {
-        _addIssue(this, "input", dataset, config2);
-      }
-      return dataset;
-    }
-  };
+//#endregion
+//#region src/actions/check/check.ts
+/* @__NO_SIDE_EFFECTS__ */
+function check(requirement, message$1) {
+	return {
+		kind: "validation",
+		type: "check",
+		reference: check,
+		async: false,
+		expects: null,
+		requirement,
+		message: message$1,
+		"~run"(dataset, config$1) {
+			if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "input", dataset, config$1);
+			return dataset;
+		}
+	};
 }
 
-// src/actions/integer/integer.ts
-function integer(message) {
-  return {
-    kind: "validation",
-    type: "integer",
-    reference: integer,
-    async: false,
-    expects: null,
-    requirement: Number.isInteger,
-    message,
-    _run(dataset, config2) {
-      if (dataset.typed && !this.requirement(dataset.value)) {
-        _addIssue(this, "integer", dataset, config2);
-      }
-      return dataset;
-    }
-  };
+//#endregion
+//#region src/actions/integer/integer.ts
+/* @__NO_SIDE_EFFECTS__ */
+function integer(message$1) {
+	return {
+		kind: "validation",
+		type: "integer",
+		reference: integer,
+		async: false,
+		expects: null,
+		requirement: Number.isInteger,
+		message: message$1,
+		"~run"(dataset, config$1) {
+			if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "integer", dataset, config$1);
+			return dataset;
+		}
+	};
 }
 
-// src/actions/transform/transform.ts
+//#endregion
+//#region src/actions/transform/transform.ts
+/**
+* Creates a custom transformation action.
+*
+* @param operation The transformation operation.
+*
+* @returns A transform action.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function transform(operation) {
-  return {
-    kind: "transformation",
-    type: "transform",
-    reference: transform,
-    async: false,
-    operation,
-    _run(dataset) {
-      dataset.value = this.operation(dataset.value);
-      return dataset;
-    }
-  };
+	return {
+		kind: "transformation",
+		type: "transform",
+		reference: transform,
+		async: false,
+		operation,
+		"~run"(dataset) {
+			dataset.value = this.operation(dataset.value);
+			return dataset;
+		}
+	};
 }
 
-// src/methods/getDefault/getDefault.ts
-function getDefault(schema, dataset, config2) {
-  return typeof schema.default === "function" ? (
-    // @ts-expect-error
-    schema.default(dataset, config2)
-  ) : (
-    // @ts-expect-error
-    schema.default
-  );
+//#endregion
+//#region src/methods/getFallback/getFallback.ts
+/**
+* Returns the fallback value of the schema.
+*
+* @param schema The schema to get it from.
+* @param dataset The output dataset if available.
+* @param config The config if available.
+*
+* @returns The fallback value.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getFallback(schema, dataset, config$1) {
+	return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
 }
 
-// src/methods/is/is.ts
+//#endregion
+//#region src/methods/getDefault/getDefault.ts
+/**
+* Returns the default value of the schema.
+*
+* @param schema The schema to get it from.
+* @param dataset The input dataset if available.
+* @param config The config if available.
+*
+* @returns The default value.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getDefault(schema, dataset, config$1) {
+	return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
+}
+
+//#endregion
+//#region src/methods/is/is.ts
+/**
+* Checks if the input matches the schema. By using a type predicate, this
+* function can be used as a type guard.
+*
+* @param schema The schema to be used.
+* @param input The input to be tested.
+*
+* @returns Whether the input matches the schema.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function is(schema, input) {
-  return !schema._run({ typed: false, value: input }, { abortEarly: true }).issues;
+	return !schema["~run"]({ value: input }, { abortEarly: true }).issues;
 }
 
-// src/schemas/array/array.ts
-function array(item, message) {
-  return {
-    kind: "schema",
-    type: "array",
-    reference: array,
-    expects: "Array",
-    async: false,
-    item,
-    message,
-    _run(dataset, config2) {
-      const input = dataset.value;
-      if (Array.isArray(input)) {
-        dataset.typed = true;
-        dataset.value = [];
-        for (let key = 0; key < input.length; key++) {
-          const value2 = input[key];
-          const itemDataset = this.item._run({ typed: false, value: value2 }, config2);
-          if (itemDataset.issues) {
-            const pathItem = {
-              type: "array",
-              origin: "value",
-              input,
-              key,
-              value: value2
-            };
-            for (const issue of itemDataset.issues) {
-              if (issue.path) {
-                issue.path.unshift(pathItem);
-              } else {
-                issue.path = [pathItem];
-              }
-              dataset.issues?.push(issue);
-            }
-            if (!dataset.issues) {
-              dataset.issues = itemDataset.issues;
-            }
-            if (config2.abortEarly) {
-              dataset.typed = false;
-              break;
-            }
-          }
-          if (!itemDataset.typed) {
-            dataset.typed = false;
-          }
-          dataset.value.push(itemDataset.value);
-        }
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
-      return dataset;
-    }
-  };
+//#endregion
+//#region src/schemas/array/array.ts
+/* @__NO_SIDE_EFFECTS__ */
+function array(item, message$1) {
+	return {
+		kind: "schema",
+		type: "array",
+		reference: array,
+		expects: "Array",
+		async: false,
+		item,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			const input = dataset.value;
+			if (Array.isArray(input)) {
+				dataset.typed = true;
+				dataset.value = [];
+				for (let key = 0; key < input.length; key++) {
+					const value$1 = input[key];
+					const itemDataset = this.item["~run"]({ value: value$1 }, config$1);
+					if (itemDataset.issues) {
+						const pathItem = {
+							type: "array",
+							origin: "value",
+							input,
+							key,
+							value: value$1
+						};
+						for (const issue of itemDataset.issues) {
+							if (issue.path) issue.path.unshift(pathItem);
+							else issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = itemDataset.issues;
+						if (config$1.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					if (!itemDataset.typed) dataset.typed = false;
+					dataset.value.push(itemDataset.value);
+				}
+			} else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
 }
 
-// src/schemas/bigint/bigint.ts
-function bigint(message) {
-  return {
-    kind: "schema",
-    type: "bigint",
-    reference: bigint,
-    expects: "bigint",
-    async: false,
-    message,
-    _run(dataset, config2) {
-      if (typeof dataset.value === "bigint") {
-        dataset.typed = true;
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
-      return dataset;
-    }
-  };
+//#endregion
+//#region src/schemas/bigint/bigint.ts
+/* @__NO_SIDE_EFFECTS__ */
+function bigint(message$1) {
+	return {
+		kind: "schema",
+		type: "bigint",
+		reference: bigint,
+		expects: "bigint",
+		async: false,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (typeof dataset.value === "bigint") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
 }
 
-// src/schemas/boolean/boolean.ts
-function boolean(message) {
-  return {
-    kind: "schema",
-    type: "boolean",
-    reference: boolean,
-    expects: "boolean",
-    async: false,
-    message,
-    _run(dataset, config2) {
-      if (typeof dataset.value === "boolean") {
-        dataset.typed = true;
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
-      return dataset;
-    }
-  };
+//#endregion
+//#region src/schemas/boolean/boolean.ts
+/* @__NO_SIDE_EFFECTS__ */
+function boolean(message$1) {
+	return {
+		kind: "schema",
+		type: "boolean",
+		reference: boolean,
+		expects: "boolean",
+		async: false,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (typeof dataset.value === "boolean") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
 }
 
-// src/schemas/lazy/lazy.ts
+//#endregion
+//#region src/schemas/lazy/lazy.ts
+/**
+* Creates a lazy schema.
+*
+* @param getter The schema getter.
+*
+* @returns A lazy schema.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function lazy(getter) {
-  return {
-    kind: "schema",
-    type: "lazy",
-    reference: lazy,
-    expects: "unknown",
-    async: false,
-    getter,
-    _run(dataset, config2) {
-      return this.getter(dataset.value)._run(dataset, config2);
-    }
-  };
+	return {
+		kind: "schema",
+		type: "lazy",
+		reference: lazy,
+		expects: "unknown",
+		async: false,
+		getter,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			return this.getter(dataset.value)["~run"](dataset, config$1);
+		}
+	};
 }
 
-// src/schemas/literal/literal.ts
-function literal(literal_, message) {
-  return {
-    kind: "schema",
-    type: "literal",
-    reference: literal,
-    expects: _stringify(literal_),
-    async: false,
-    literal: literal_,
-    message,
-    _run(dataset, config2) {
-      if (dataset.value === this.literal) {
-        dataset.typed = true;
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
-      return dataset;
-    }
-  };
+//#endregion
+//#region src/schemas/literal/literal.ts
+/* @__NO_SIDE_EFFECTS__ */
+function literal(literal_, message$1) {
+	return {
+		kind: "schema",
+		type: "literal",
+		reference: literal,
+		expects: /* @__PURE__ */ _stringify(literal_),
+		async: false,
+		literal: literal_,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (dataset.value === this.literal) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
 }
 
-// src/schemas/nullable/nullable.ts
-function nullable(wrapped, ...args) {
-  const schema = {
-    kind: "schema",
-    type: "nullable",
-    reference: nullable,
-    expects: `${wrapped.expects} | null`,
-    async: false,
-    wrapped,
-    _run(dataset, config2) {
-      if (dataset.value === null) {
-        if ("default" in this) {
-          dataset.value = getDefault(
-            this,
-            dataset,
-            config2
-          );
-        }
-        if (dataset.value === null) {
-          dataset.typed = true;
-          return dataset;
-        }
-      }
-      return this.wrapped._run(dataset, config2);
-    }
-  };
-  if (0 in args) {
-    schema.default = args[0];
-  }
-  return schema;
+//#endregion
+//#region src/schemas/nullable/nullable.ts
+/* @__NO_SIDE_EFFECTS__ */
+function nullable(wrapped, default_) {
+	return {
+		kind: "schema",
+		type: "nullable",
+		reference: nullable,
+		expects: `(${wrapped.expects} | null)`,
+		async: false,
+		wrapped,
+		default: default_,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (dataset.value === null) {
+				if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+				if (dataset.value === null) {
+					dataset.typed = true;
+					return dataset;
+				}
+			}
+			return this.wrapped["~run"](dataset, config$1);
+		}
+	};
 }
 
-// src/schemas/nullish/nullish.ts
-function nullish(wrapped, ...args) {
-  const schema = {
-    kind: "schema",
-    type: "nullish",
-    reference: nullish,
-    expects: `${wrapped.expects} | null | undefined`,
-    async: false,
-    wrapped,
-    _run(dataset, config2) {
-      if (dataset.value === null || dataset.value === void 0) {
-        if ("default" in this) {
-          dataset.value = getDefault(
-            this,
-            dataset,
-            config2
-          );
-        }
-        if (dataset.value === null || dataset.value === void 0) {
-          dataset.typed = true;
-          return dataset;
-        }
-      }
-      return this.wrapped._run(dataset, config2);
-    }
-  };
-  if (0 in args) {
-    schema.default = args[0];
-  }
-  return schema;
+//#endregion
+//#region src/schemas/nullish/nullish.ts
+/* @__NO_SIDE_EFFECTS__ */
+function nullish(wrapped, default_) {
+	return {
+		kind: "schema",
+		type: "nullish",
+		reference: nullish,
+		expects: `(${wrapped.expects} | null | undefined)`,
+		async: false,
+		wrapped,
+		default: default_,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (dataset.value === null || dataset.value === void 0) {
+				if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+				if (dataset.value === null || dataset.value === void 0) {
+					dataset.typed = true;
+					return dataset;
+				}
+			}
+			return this.wrapped["~run"](dataset, config$1);
+		}
+	};
 }
 
-// src/schemas/number/number.ts
-function number(message) {
-  return {
-    kind: "schema",
-    type: "number",
-    reference: number,
-    expects: "number",
-    async: false,
-    message,
-    _run(dataset, config2) {
-      if (typeof dataset.value === "number" && !isNaN(dataset.value)) {
-        dataset.typed = true;
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
-      return dataset;
-    }
-  };
+//#endregion
+//#region src/schemas/number/number.ts
+/* @__NO_SIDE_EFFECTS__ */
+function number(message$1) {
+	return {
+		kind: "schema",
+		type: "number",
+		reference: number,
+		expects: "number",
+		async: false,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
 }
 
-// src/schemas/object/object.ts
-function object(entries, message) {
-  return {
-    kind: "schema",
-    type: "object",
-    reference: object,
-    expects: "Object",
-    async: false,
-    entries,
-    message,
-    _run(dataset, config2) {
-      const input = dataset.value;
-      if (input && typeof input === "object") {
-        dataset.typed = true;
-        dataset.value = {};
-        for (const key in this.entries) {
-          const value2 = input[key];
-          const valueDataset = this.entries[key]._run(
-            { typed: false, value: value2 },
-            config2
-          );
-          if (valueDataset.issues) {
-            const pathItem = {
-              type: "object",
-              origin: "value",
-              input,
-              key,
-              value: value2
-            };
-            for (const issue of valueDataset.issues) {
-              if (issue.path) {
-                issue.path.unshift(pathItem);
-              } else {
-                issue.path = [pathItem];
-              }
-              dataset.issues?.push(issue);
-            }
-            if (!dataset.issues) {
-              dataset.issues = valueDataset.issues;
-            }
-            if (config2.abortEarly) {
-              dataset.typed = false;
-              break;
-            }
-          }
-          if (!valueDataset.typed) {
-            dataset.typed = false;
-          }
-          if (valueDataset.value !== void 0 || key in input) {
-            dataset.value[key] = valueDataset.value;
-          }
-        }
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
-      return dataset;
-    }
-  };
+//#endregion
+//#region src/schemas/object/object.ts
+/* @__NO_SIDE_EFFECTS__ */
+function object(entries$1, message$1) {
+	return {
+		kind: "schema",
+		type: "object",
+		reference: object,
+		expects: "Object",
+		async: false,
+		entries: entries$1,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			const input = dataset.value;
+			if (input && typeof input === "object") {
+				dataset.typed = true;
+				dataset.value = {};
+				for (const key in this.entries) {
+					const valueSchema = this.entries[key];
+					if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+						const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+						const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+						if (valueDataset.issues) {
+							const pathItem = {
+								type: "object",
+								origin: "value",
+								input,
+								key,
+								value: value$1
+							};
+							for (const issue of valueDataset.issues) {
+								if (issue.path) issue.path.unshift(pathItem);
+								else issue.path = [pathItem];
+								dataset.issues?.push(issue);
+							}
+							if (!dataset.issues) dataset.issues = valueDataset.issues;
+							if (config$1.abortEarly) {
+								dataset.typed = false;
+								break;
+							}
+						}
+						if (!valueDataset.typed) dataset.typed = false;
+						dataset.value[key] = valueDataset.value;
+					} else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+					else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+						_addIssue(this, "key", dataset, config$1, {
+							input: void 0,
+							expected: `"${key}"`,
+							path: [{
+								type: "object",
+								origin: "key",
+								input,
+								key,
+								value: input[key]
+							}]
+						});
+						if (config$1.abortEarly) break;
+					}
+				}
+			} else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
 }
 
-// src/schemas/optional/optional.ts
-function optional(wrapped, ...args) {
-  const schema = {
-    kind: "schema",
-    type: "optional",
-    reference: optional,
-    expects: `${wrapped.expects} | undefined`,
-    async: false,
-    wrapped,
-    _run(dataset, config2) {
-      if (dataset.value === void 0) {
-        if ("default" in this) {
-          dataset.value = getDefault(
-            this,
-            dataset,
-            config2
-          );
-        }
-        if (dataset.value === void 0) {
-          dataset.typed = true;
-          return dataset;
-        }
-      }
-      return this.wrapped._run(dataset, config2);
-    }
-  };
-  if (0 in args) {
-    schema.default = args[0];
-  }
-  return schema;
+//#endregion
+//#region src/schemas/optional/optional.ts
+/* @__NO_SIDE_EFFECTS__ */
+function optional(wrapped, default_) {
+	return {
+		kind: "schema",
+		type: "optional",
+		reference: optional,
+		expects: `(${wrapped.expects} | undefined)`,
+		async: false,
+		wrapped,
+		default: default_,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (dataset.value === void 0) {
+				if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+				if (dataset.value === void 0) {
+					dataset.typed = true;
+					return dataset;
+				}
+			}
+			return this.wrapped["~run"](dataset, config$1);
+		}
+	};
 }
 
-// src/schemas/record/record.ts
-function record(key, value2, message) {
-  return {
-    kind: "schema",
-    type: "record",
-    reference: record,
-    expects: "Object",
-    async: false,
-    key,
-    value: value2,
-    message,
-    _run(dataset, config2) {
-      const input = dataset.value;
-      if (input && typeof input === "object") {
-        dataset.typed = true;
-        dataset.value = {};
-        for (const entryKey in input) {
-          if (_isValidObjectKey(input, entryKey)) {
-            const entryValue = input[entryKey];
-            const keyDataset = this.key._run(
-              { typed: false, value: entryKey },
-              config2
-            );
-            if (keyDataset.issues) {
-              const pathItem = {
-                type: "object",
-                origin: "key",
-                input,
-                key: entryKey,
-                value: entryValue
-              };
-              for (const issue of keyDataset.issues) {
-                issue.path = [pathItem];
-                dataset.issues?.push(issue);
-              }
-              if (!dataset.issues) {
-                dataset.issues = keyDataset.issues;
-              }
-              if (config2.abortEarly) {
-                dataset.typed = false;
-                break;
-              }
-            }
-            const valueDataset = this.value._run(
-              { typed: false, value: entryValue },
-              config2
-            );
-            if (valueDataset.issues) {
-              const pathItem = {
-                type: "object",
-                origin: "value",
-                input,
-                key: entryKey,
-                value: entryValue
-              };
-              for (const issue of valueDataset.issues) {
-                if (issue.path) {
-                  issue.path.unshift(pathItem);
-                } else {
-                  issue.path = [pathItem];
-                }
-                dataset.issues?.push(issue);
-              }
-              if (!dataset.issues) {
-                dataset.issues = valueDataset.issues;
-              }
-              if (config2.abortEarly) {
-                dataset.typed = false;
-                break;
-              }
-            }
-            if (!keyDataset.typed || !valueDataset.typed) {
-              dataset.typed = false;
-            }
-            if (keyDataset.typed) {
-              dataset.value[keyDataset.value] = valueDataset.value;
-            }
-          }
-        }
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
-      return dataset;
-    }
-  };
+//#endregion
+//#region src/schemas/record/record.ts
+/* @__NO_SIDE_EFFECTS__ */
+function record(key, value$1, message$1) {
+	return {
+		kind: "schema",
+		type: "record",
+		reference: record,
+		expects: "Object",
+		async: false,
+		key,
+		value: value$1,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			const input = dataset.value;
+			if (input && typeof input === "object") {
+				dataset.typed = true;
+				dataset.value = {};
+				for (const entryKey in input) if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
+					const entryValue = input[entryKey];
+					const keyDataset = this.key["~run"]({ value: entryKey }, config$1);
+					if (keyDataset.issues) {
+						const pathItem = {
+							type: "object",
+							origin: "key",
+							input,
+							key: entryKey,
+							value: entryValue
+						};
+						for (const issue of keyDataset.issues) {
+							issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = keyDataset.issues;
+						if (config$1.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					const valueDataset = this.value["~run"]({ value: entryValue }, config$1);
+					if (valueDataset.issues) {
+						const pathItem = {
+							type: "object",
+							origin: "value",
+							input,
+							key: entryKey,
+							value: entryValue
+						};
+						for (const issue of valueDataset.issues) {
+							if (issue.path) issue.path.unshift(pathItem);
+							else issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = valueDataset.issues;
+						if (config$1.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					if (!keyDataset.typed || !valueDataset.typed) dataset.typed = false;
+					if (keyDataset.typed) dataset.value[keyDataset.value] = valueDataset.value;
+				}
+			} else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
 }
 
-// src/schemas/string/string.ts
-function string(message) {
-  return {
-    kind: "schema",
-    type: "string",
-    reference: string,
-    expects: "string",
-    async: false,
-    message,
-    _run(dataset, config2) {
-      if (typeof dataset.value === "string") {
-        dataset.typed = true;
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
-      return dataset;
-    }
-  };
+//#endregion
+//#region src/schemas/string/string.ts
+/* @__NO_SIDE_EFFECTS__ */
+function string(message$1) {
+	return {
+		kind: "schema",
+		type: "string",
+		reference: string,
+		expects: "string",
+		async: false,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (typeof dataset.value === "string") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
 }
 
-// src/schemas/tuple/tuple.ts
-function tuple(items, message) {
-  return {
-    kind: "schema",
-    type: "tuple",
-    reference: tuple,
-    expects: "Array",
-    async: false,
-    items,
-    message,
-    _run(dataset, config2) {
-      const input = dataset.value;
-      if (Array.isArray(input)) {
-        dataset.typed = true;
-        dataset.value = [];
-        for (let key = 0; key < this.items.length; key++) {
-          const value2 = input[key];
-          const itemDataset = this.items[key]._run(
-            { typed: false, value: value2 },
-            config2
-          );
-          if (itemDataset.issues) {
-            const pathItem = {
-              type: "array",
-              origin: "value",
-              input,
-              key,
-              value: value2
-            };
-            for (const issue of itemDataset.issues) {
-              if (issue.path) {
-                issue.path.unshift(pathItem);
-              } else {
-                issue.path = [pathItem];
-              }
-              dataset.issues?.push(issue);
-            }
-            if (!dataset.issues) {
-              dataset.issues = itemDataset.issues;
-            }
-            if (config2.abortEarly) {
-              dataset.typed = false;
-              break;
-            }
-          }
-          if (!itemDataset.typed) {
-            dataset.typed = false;
-          }
-          dataset.value.push(itemDataset.value);
-        }
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
-      return dataset;
-    }
-  };
+//#endregion
+//#region src/schemas/tuple/tuple.ts
+/* @__NO_SIDE_EFFECTS__ */
+function tuple(items, message$1) {
+	return {
+		kind: "schema",
+		type: "tuple",
+		reference: tuple,
+		expects: "Array",
+		async: false,
+		items,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			const input = dataset.value;
+			if (Array.isArray(input)) {
+				dataset.typed = true;
+				dataset.value = [];
+				for (let key = 0; key < this.items.length; key++) {
+					const value$1 = input[key];
+					const itemDataset = this.items[key]["~run"]({ value: value$1 }, config$1);
+					if (itemDataset.issues) {
+						const pathItem = {
+							type: "array",
+							origin: "value",
+							input,
+							key,
+							value: value$1
+						};
+						for (const issue of itemDataset.issues) {
+							if (issue.path) issue.path.unshift(pathItem);
+							else issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = itemDataset.issues;
+						if (config$1.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					if (!itemDataset.typed) dataset.typed = false;
+					dataset.value.push(itemDataset.value);
+				}
+			} else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
 }
 
-// src/schemas/union/utils/_subIssues/_subIssues.ts
+//#endregion
+//#region src/schemas/union/utils/_subIssues/_subIssues.ts
+/**
+* Returns the sub issues of the provided datasets for the union issue.
+*
+* @param datasets The datasets.
+*
+* @returns The sub issues.
+*
+* @internal
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function _subIssues(datasets) {
-  let issues;
-  if (datasets) {
-    for (const dataset of datasets) {
-      if (issues) {
-        issues.push(...dataset.issues);
-      } else {
-        issues = dataset.issues;
-      }
-    }
-  }
-  return issues;
+	let issues;
+	if (datasets) for (const dataset of datasets) if (issues) issues.push(...dataset.issues);
+	else issues = dataset.issues;
+	return issues;
 }
 
-// src/schemas/union/union.ts
-function union(options, message) {
-  return {
-    kind: "schema",
-    type: "union",
-    reference: union,
-    expects: [...new Set(options.map((option) => option.expects))].join(" | ") || "never",
-    async: false,
-    options,
-    message,
-    _run(dataset, config2) {
-      let validDataset;
-      let typedDatasets;
-      let untypedDatasets;
-      for (const schema of this.options) {
-        const optionDataset = schema._run(
-          { typed: false, value: dataset.value },
-          config2
-        );
-        if (optionDataset.typed) {
-          if (optionDataset.issues) {
-            if (typedDatasets) {
-              typedDatasets.push(optionDataset);
-            } else {
-              typedDatasets = [optionDataset];
-            }
-          } else {
-            validDataset = optionDataset;
-            break;
-          }
-        } else {
-          if (untypedDatasets) {
-            untypedDatasets.push(optionDataset);
-          } else {
-            untypedDatasets = [optionDataset];
-          }
-        }
-      }
-      if (validDataset) {
-        return validDataset;
-      }
-      if (typedDatasets) {
-        if (typedDatasets.length === 1) {
-          return typedDatasets[0];
-        }
-        _addIssue(this, "type", dataset, config2, {
-          issues: _subIssues(typedDatasets)
-        });
-        dataset.typed = true;
-      } else if (untypedDatasets?.length === 1) {
-        return untypedDatasets[0];
-      } else {
-        _addIssue(this, "type", dataset, config2, {
-          issues: _subIssues(untypedDatasets)
-        });
-      }
-      return dataset;
-    }
-  };
+//#endregion
+//#region src/schemas/union/union.ts
+/* @__NO_SIDE_EFFECTS__ */
+function union(options, message$1) {
+	return {
+		kind: "schema",
+		type: "union",
+		reference: union,
+		expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "|"),
+		async: false,
+		options,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			let validDataset;
+			let typedDatasets;
+			let untypedDatasets;
+			for (const schema of this.options) {
+				const optionDataset = schema["~run"]({ value: dataset.value }, config$1);
+				if (optionDataset.typed) if (optionDataset.issues) if (typedDatasets) typedDatasets.push(optionDataset);
+				else typedDatasets = [optionDataset];
+				else {
+					validDataset = optionDataset;
+					break;
+				}
+				else if (untypedDatasets) untypedDatasets.push(optionDataset);
+				else untypedDatasets = [optionDataset];
+			}
+			if (validDataset) return validDataset;
+			if (typedDatasets) {
+				if (typedDatasets.length === 1) return typedDatasets[0];
+				_addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
+				dataset.typed = true;
+			} else if (untypedDatasets?.length === 1) return untypedDatasets[0];
+			else _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
+			return dataset;
+		}
+	};
 }
 
-// src/schemas/unknown/unknown.ts
+//#endregion
+//#region src/schemas/unknown/unknown.ts
+/**
+* Creates a unknown schema.
+*
+* @returns A unknown schema.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function unknown() {
-  return {
-    kind: "schema",
-    type: "unknown",
-    reference: unknown,
-    expects: "unknown",
-    async: false,
-    _run(dataset) {
-      dataset.typed = true;
-      return dataset;
-    }
-  };
+	return {
+		kind: "schema",
+		type: "unknown",
+		reference: unknown,
+		expects: "unknown",
+		async: false,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset) {
+			dataset.typed = true;
+			return dataset;
+		}
+	};
 }
 
-// src/methods/parse/parse.ts
-function parse(schema, input, config2) {
-  const dataset = schema._run(
-    { typed: false, value: input },
-    getGlobalConfig(config2)
-  );
-  if (dataset.issues) {
-    throw new ValiError(dataset.issues);
-  }
-  return dataset.value;
+//#endregion
+//#region src/methods/parse/parse.ts
+/**
+* Parses an unknown input based on a schema.
+*
+* @param schema The schema to be used.
+* @param input The input to be parsed.
+* @param config The parse configuration.
+*
+* @returns The parsed input.
+*/
+function parse(schema, input, config$1) {
+	const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+	if (dataset.issues) throw new ValiError(dataset.issues);
+	return dataset.value;
 }
 
-// src/methods/pipe/pipe.ts
-function pipe(...pipe2) {
-  return {
-    ...pipe2[0],
-    pipe: pipe2,
-    _run(dataset, config2) {
-      for (let index = 0; index < pipe2.length; index++) {
-        if (dataset.issues && (pipe2[index].kind === "schema" || pipe2[index].kind === "transformation")) {
-          dataset.typed = false;
-          break;
-        }
-        if (!dataset.issues || !config2.abortEarly && !config2.abortPipeEarly) {
-          dataset = pipe2[index]._run(dataset, config2);
-        }
-      }
-      return dataset;
-    }
-  };
+//#endregion
+//#region src/methods/pipe/pipe.ts
+/* @__NO_SIDE_EFFECTS__ */
+function pipe(...pipe$1) {
+	return {
+		...pipe$1[0],
+		pipe: pipe$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			for (const item of pipe$1) if (item.kind !== "metadata") {
+				if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+					dataset.typed = false;
+					break;
+				}
+				if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly) dataset = item["~run"](dataset, config$1);
+			}
+			return dataset;
+		}
+	};
 }
 
 function safeEnum(options) {
   const unionOptions = Object.entries(options).map(([key, value]) => object({ [key]: value }));
   return pipe(
     union(unionOptions),
-    transform((value) => ({
-      ...value,
-      $kind: Object.keys(value)[0]
-    }))
+    transform(
+      (value) => ({
+        ...value,
+        $kind: Object.keys(value)[0]
+      })
+    )
   );
 }
 const SuiAddress = pipe(
@@ -4746,14 +4877,14 @@ const NormalizedCallArg$1 = safeEnum({
     bytes: BCSBytes
   })
 });
-const TransactionExpiration$2 = safeEnum({
+const TransactionExpiration$1 = safeEnum({
   None: literal(true),
   Epoch: JsonU64
 });
 const TransactionDataSchema = object({
   version: literal(2),
   sender: nullish(SuiAddress),
-  expiration: nullish(TransactionExpiration$2),
+  expiration: nullish(TransactionExpiration$1),
   gasData: GasDataSchema,
   inputs: array(CallArgSchema),
   commands: array(CommandSchema)
@@ -4883,131 +5014,6 @@ const NormalizedCallArg = safeEnum({
   Object: ObjectArg$1,
   Pure: array(pipe(number(), integer()))
 });
-const TransactionInput = union([
-  object({
-    kind: literal("Input"),
-    index: pipe(number(), integer()),
-    value: unknown(),
-    type: optional(literal("object"))
-  }),
-  object({
-    kind: literal("Input"),
-    index: pipe(number(), integer()),
-    value: unknown(),
-    type: literal("pure")
-  })
-]);
-const TransactionExpiration$1 = union([
-  object({ Epoch: pipe(number(), integer()) }),
-  object({ None: nullable(literal(true)) })
-]);
-const StringEncodedBigint = pipe(
-  union([number(), string(), bigint()]),
-  check((val) => {
-    if (!["string", "number", "bigint"].includes(typeof val)) return false;
-    try {
-      BigInt(val);
-      return true;
-    } catch {
-      return false;
-    }
-  })
-);
-const TypeTag = union([
-  object({ bool: nullable(literal(true)) }),
-  object({ u8: nullable(literal(true)) }),
-  object({ u64: nullable(literal(true)) }),
-  object({ u128: nullable(literal(true)) }),
-  object({ address: nullable(literal(true)) }),
-  object({ signer: nullable(literal(true)) }),
-  object({ vector: lazy(() => TypeTag) }),
-  object({ struct: lazy(() => StructTag) }),
-  object({ u16: nullable(literal(true)) }),
-  object({ u32: nullable(literal(true)) }),
-  object({ u256: nullable(literal(true)) })
-]);
-const StructTag = object({
-  address: string(),
-  module: string(),
-  name: string(),
-  typeParams: array(TypeTag)
-});
-const GasConfig = object({
-  budget: optional(StringEncodedBigint),
-  price: optional(StringEncodedBigint),
-  payment: optional(array(ObjectRef)),
-  owner: optional(string())
-});
-const TransactionArgumentTypes = [
-  TransactionInput,
-  object({ kind: literal("GasCoin") }),
-  object({ kind: literal("Result"), index: pipe(number(), integer()) }),
-  object({
-    kind: literal("NestedResult"),
-    index: pipe(number(), integer()),
-    resultIndex: pipe(number(), integer())
-  })
-];
-const TransactionArgument = union([...TransactionArgumentTypes]);
-const MoveCallTransaction = object({
-  kind: literal("MoveCall"),
-  target: pipe(
-    string(),
-    check((target) => target.split("::").length === 3)
-  ),
-  typeArguments: array(string()),
-  arguments: array(TransactionArgument)
-});
-const TransferObjectsTransaction = object({
-  kind: literal("TransferObjects"),
-  objects: array(TransactionArgument),
-  address: TransactionArgument
-});
-const SplitCoinsTransaction = object({
-  kind: literal("SplitCoins"),
-  coin: TransactionArgument,
-  amounts: array(TransactionArgument)
-});
-const MergeCoinsTransaction = object({
-  kind: literal("MergeCoins"),
-  destination: TransactionArgument,
-  sources: array(TransactionArgument)
-});
-const MakeMoveVecTransaction = object({
-  kind: literal("MakeMoveVec"),
-  type: union([object({ Some: TypeTag }), object({ None: nullable(literal(true)) })]),
-  objects: array(TransactionArgument)
-});
-const PublishTransaction = object({
-  kind: literal("Publish"),
-  modules: array(array(pipe(number(), integer()))),
-  dependencies: array(string())
-});
-const UpgradeTransaction = object({
-  kind: literal("Upgrade"),
-  modules: array(array(pipe(number(), integer()))),
-  dependencies: array(string()),
-  packageId: string(),
-  ticket: TransactionArgument
-});
-const TransactionTypes = [
-  MoveCallTransaction,
-  TransferObjectsTransaction,
-  SplitCoinsTransaction,
-  MergeCoinsTransaction,
-  PublishTransaction,
-  UpgradeTransaction,
-  MakeMoveVecTransaction
-];
-const TransactionType = union([...TransactionTypes]);
-object({
-  version: literal(1),
-  sender: optional(string()),
-  expiration: nullish(TransactionExpiration$1),
-  gasConfig: GasConfig,
-  inputs: array(TransactionInput),
-  transactions: array(TransactionType)
-});
 function serializeV1TransactionData(transactionData) {
   const inputs = transactionData.inputs.map(
     (input, index) => {
@@ -6038,6 +6044,85 @@ function hashTypedData(typeTag, data) {
   return blake2b$1(dataWithTag, { dkLen: 32 });
 }
 
+function getIdFromCallArg(arg) {
+  if (typeof arg === "string") {
+    return normalizeSuiAddress(arg);
+  }
+  if (arg.Object) {
+    if (arg.Object.ImmOrOwnedObject) {
+      return normalizeSuiAddress(arg.Object.ImmOrOwnedObject.objectId);
+    }
+    if (arg.Object.Receiving) {
+      return normalizeSuiAddress(arg.Object.Receiving.objectId);
+    }
+    return normalizeSuiAddress(arg.Object.SharedObject.objectId);
+  }
+  if (arg.UnresolvedObject) {
+    return normalizeSuiAddress(arg.UnresolvedObject.objectId);
+  }
+  return void 0;
+}
+function remapCommandArguments(command, inputMapping, commandMapping) {
+  const remapArg = (arg) => {
+    switch (arg.$kind) {
+      case "Input": {
+        const newInputIndex = inputMapping.get(arg.Input);
+        if (newInputIndex === void 0) {
+          throw new Error(`Input ${arg.Input} not found in input mapping`);
+        }
+        return { ...arg, Input: newInputIndex };
+      }
+      case "Result": {
+        const newCommandIndex = commandMapping.get(arg.Result);
+        if (newCommandIndex !== void 0) {
+          return { ...arg, Result: newCommandIndex };
+        }
+        return arg;
+      }
+      case "NestedResult": {
+        const newCommandIndex = commandMapping.get(arg.NestedResult[0]);
+        if (newCommandIndex !== void 0) {
+          return { ...arg, NestedResult: [newCommandIndex, arg.NestedResult[1]] };
+        }
+        return arg;
+      }
+      default:
+        return arg;
+    }
+  };
+  switch (command.$kind) {
+    case "MoveCall":
+      command.MoveCall.arguments = command.MoveCall.arguments.map(remapArg);
+      break;
+    case "TransferObjects":
+      command.TransferObjects.objects = command.TransferObjects.objects.map(remapArg);
+      command.TransferObjects.address = remapArg(command.TransferObjects.address);
+      break;
+    case "SplitCoins":
+      command.SplitCoins.coin = remapArg(command.SplitCoins.coin);
+      command.SplitCoins.amounts = command.SplitCoins.amounts.map(remapArg);
+      break;
+    case "MergeCoins":
+      command.MergeCoins.destination = remapArg(command.MergeCoins.destination);
+      command.MergeCoins.sources = command.MergeCoins.sources.map(remapArg);
+      break;
+    case "MakeMoveVec":
+      command.MakeMoveVec.elements = command.MakeMoveVec.elements.map(remapArg);
+      break;
+    case "Upgrade":
+      command.Upgrade.ticket = remapArg(command.Upgrade.ticket);
+      break;
+    case "$Intent": {
+      const inputs = command.$Intent.inputs;
+      command.$Intent.inputs = {};
+      for (const [key, value] of Object.entries(inputs)) {
+        command.$Intent.inputs[key] = Array.isArray(value) ? value.map(remapArg) : remapArg(value);
+      }
+      break;
+    }
+  }
+}
+
 function prepareSuiAddress(address) {
   return normalizeSuiAddress(address).replace("0x", "");
 }
@@ -6239,26 +6324,107 @@ class TransactionDataBuilder {
       return;
     }
     const sizeDiff = replacement.length - 1;
-    this.commands.splice(index, 1, ...replacement);
-    if (sizeDiff !== 0) {
+    this.commands.splice(index, 1, ...structuredClone(replacement));
+    this.mapArguments((arg, _command, commandIndex) => {
+      if (commandIndex < index + replacement.length) {
+        return arg;
+      }
+      if (typeof resultIndex !== "number") {
+        if (arg.$kind === "Result" && arg.Result === index || arg.$kind === "NestedResult" && arg.NestedResult[0] === index) {
+          if (!("NestedResult" in arg) || arg.NestedResult[1] === 0) {
+            return parse(ArgumentSchema, structuredClone(resultIndex));
+          } else {
+            throw new Error(
+              `Cannot replace command ${index} with a specific result type: NestedResult[${index}, ${arg.NestedResult[1]}] references a nested element that cannot be mapped to the replacement result`
+            );
+          }
+        }
+      }
+      switch (arg.$kind) {
+        case "Result":
+          if (arg.Result === index && typeof resultIndex === "number") {
+            arg.Result = resultIndex;
+          }
+          if (arg.Result > index) {
+            arg.Result += sizeDiff;
+          }
+          break;
+        case "NestedResult":
+          if (arg.NestedResult[0] === index && typeof resultIndex === "number") {
+            return {
+              $kind: "NestedResult",
+              NestedResult: [resultIndex, arg.NestedResult[1]]
+            };
+          }
+          if (arg.NestedResult[0] > index) {
+            arg.NestedResult[0] += sizeDiff;
+          }
+          break;
+      }
+      return arg;
+    });
+  }
+  replaceCommandWithTransaction(index, otherTransaction, result) {
+    if (result.$kind !== "Result" && result.$kind !== "NestedResult") {
+      throw new Error("Result must be of kind Result or NestedResult");
+    }
+    this.insertTransaction(index, otherTransaction);
+    this.replaceCommand(
+      index + otherTransaction.commands.length,
+      [],
+      "Result" in result ? { NestedResult: [result.Result + index, 0] } : {
+        NestedResult: [
+          result.NestedResult[0] + index,
+          result.NestedResult[1]
+        ]
+      }
+    );
+  }
+  insertTransaction(atCommandIndex, otherTransaction) {
+    const inputMapping = /* @__PURE__ */ new Map();
+    const commandMapping = /* @__PURE__ */ new Map();
+    for (let i = 0; i < otherTransaction.inputs.length; i++) {
+      const otherInput = otherTransaction.inputs[i];
+      const id = getIdFromCallArg(otherInput);
+      let existingIndex = -1;
+      if (id !== void 0) {
+        existingIndex = this.inputs.findIndex((input) => getIdFromCallArg(input) === id);
+        if (existingIndex !== -1 && this.inputs[existingIndex].Object?.SharedObject && otherInput.Object?.SharedObject) {
+          this.inputs[existingIndex].Object.SharedObject.mutable = this.inputs[existingIndex].Object.SharedObject.mutable || otherInput.Object.SharedObject.mutable;
+        }
+      }
+      if (existingIndex !== -1) {
+        inputMapping.set(i, existingIndex);
+      } else {
+        const newIndex = this.inputs.length;
+        this.inputs.push(otherInput);
+        inputMapping.set(i, newIndex);
+      }
+    }
+    for (let i = 0; i < otherTransaction.commands.length; i++) {
+      commandMapping.set(i, atCommandIndex + i);
+    }
+    const remappedCommands = [];
+    for (let i = 0; i < otherTransaction.commands.length; i++) {
+      const command = structuredClone(otherTransaction.commands[i]);
+      remapCommandArguments(command, inputMapping, commandMapping);
+      remappedCommands.push(command);
+    }
+    this.commands.splice(atCommandIndex, 0, ...remappedCommands);
+    const sizeDiff = remappedCommands.length;
+    if (sizeDiff > 0) {
       this.mapArguments((arg, _command, commandIndex) => {
-        if (commandIndex < index + replacement.length) {
+        if (commandIndex >= atCommandIndex && commandIndex < atCommandIndex + remappedCommands.length) {
           return arg;
         }
         switch (arg.$kind) {
           case "Result":
-            if (arg.Result === index) {
-              arg.Result = resultIndex;
-            }
-            if (arg.Result > index) {
+            if (arg.Result >= atCommandIndex) {
               arg.Result += sizeDiff;
             }
             break;
           case "NestedResult":
-            if (arg.NestedResult[0] === index) {
-              arg.NestedResult[0] = resultIndex;
-            }
-            if (arg.NestedResult[0] > index) {
+            if (arg.NestedResult[0] >= atCommandIndex) {
               arg.NestedResult[0] += sizeDiff;
             }
             break;
@@ -6359,25 +6525,6 @@ class TransactionDataBuilder {
   }
 }
 
-function getIdFromCallArg(arg) {
-  if (typeof arg === "string") {
-    return normalizeSuiAddress(arg);
-  }
-  if (arg.Object) {
-    if (arg.Object.ImmOrOwnedObject) {
-      return normalizeSuiAddress(arg.Object.ImmOrOwnedObject.objectId);
-    }
-    if (arg.Object.Receiving) {
-      return normalizeSuiAddress(arg.Object.Receiving.objectId);
-    }
-    return normalizeSuiAddress(arg.Object.SharedObject.objectId);
-  }
-  if (arg.UnresolvedObject) {
-    return normalizeSuiAddress(arg.UnresolvedObject.objectId);
-  }
-  return void 0;
-}
-
 var __typeError$2 = (msg) => {
   throw TypeError(msg);
 };
@@ -6925,7 +7072,7 @@ const _Transaction = class _Transaction {
     }
   }
   setExpiration(expiration) {
-    __privateGet$1(this, _data).expiration = expiration ? parse(TransactionExpiration$2, expiration) : null;
+    __privateGet$1(this, _data).expiration = expiration ? parse(TransactionExpiration$1, expiration) : null;
   }
   setGasPrice(price) {
     __privateGet$1(this, _data).gasConfig.price = String(price);
@@ -7305,6 +7452,7 @@ runPlugins_fn = async function(plugins, options) {
   } finally {
     __privateSet$1(this, _inputSection, __privateGet$1(this, _data).inputs.slice());
     __privateSet$1(this, _commandSection, __privateGet$1(this, _data).commands.slice());
+    __privateSet$1(this, _availableResults, new Set(__privateGet$1(this, _commandSection).map((_, i) => i)));
   }
 };
 waitForPendingTasks_fn = async function() {
@@ -7800,8 +7948,13 @@ class JSONRpcCoreClient extends Experimental_CoreClient {
       errors: result.errors
     };
   }
-  resolveNameServiceNames(options) {
-    return __privateGet(this, _jsonRpcClient).resolveNameServiceNames(options);
+  async defaultNameServiceName(options) {
+    const name = (await __privateGet(this, _jsonRpcClient).resolveNameServiceNames(options)).data[0];
+    return {
+      data: {
+        name
+      }
+    };
   }
   resolveTransactionPlugin() {
     return jsonRpcClientResolveTransactionPlugin(__privateGet(this, _jsonRpcClient));
@@ -39656,7 +39809,11 @@ class VortexAPI {
         let page = 1;
         let hasNext = true;
         while (hasNext) {
-            const response = await this.getCommitments({ ...args, page, apiKey: args.apiKey });
+            const response = await this.getCommitments({
+                ...args,
+                page,
+                apiKey: args.apiKey,
+            });
             allCommitments.push(...response.data.items);
             hasNext = response.data.pagination.hasNext;
             page++;