dipcoin-cli 0.6.0 → 0.8.1

package/dist/cli.cjs

@@ -9,7 +9,6 @@ var path = require('path');
 var os = require('os');
 var fs = require('fs');
 var ed25519 = require('@mysten/sui/keypairs/ed25519');
-var perpTsLibrary = require('@dipcoinlab/perp-ts-library');
 var transactions = require('@mysten/sui/transactions');
 var BigNumber = require('bignumber.js');
 var pythSuiJs = require('@pythnetwork/pyth-sui-js');
@@ -49,8 +48,8 @@ function initSDKOptions(options) {
     };
 }
 
-const PACKAGE_VERSION = "1.45.0";
-const TARGETED_RPC_VERSION = "1.61.0";
+const PACKAGE_VERSION = "1.45.2";
+const TARGETED_RPC_VERSION = "1.62.0";
 
 const CODE_TO_ERROR_TYPE = {
   "-32700": "ParseError",
@@ -2504,773 +2503,902 @@ 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];
+}
+
+//#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());
+		}
+	};
+}
+
+//#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";
 }
 
-// src/utils/_isValidObjectKey/_isValidObjectKey.ts
-function _isValidObjectKey(object2, key) {
-  return Object.hasOwn(object2, 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";
 }
 
-// src/utils/ValiError/ValiError.ts
+//#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;
+}
+
+//#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;
 }
 
-// src/methods/is/is.ts
+//#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;
+		}
+	};
 }
 
 const SUI_NS_NAME_REGEX = /^(?!.*(^(?!@)|[-.@])($|[-.@]))(?:[a-z0-9-]{0,63}(?:\.[a-z0-9-]{0,63})*)?@[a-z0-9-]{0,63}$/i;
@@ -3389,10 +3517,12 @@ 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(
@@ -5017,7 +5147,7 @@ function asciiToBase16(ch) {
  * Convert hex string to byte array. Uses built-in function, when available.
  * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
  */
-function hexToBytes(hex) {
+function hexToBytes$1(hex) {
     if (typeof hex !== 'string')
         throw new Error('hex string expected, got ' + typeof hex);
     // @ts-ignore
@@ -7678,6 +7808,7 @@ runPlugins_fn = async function(plugins, options) {
   } finally {
     __privateSet$4(this, _inputSection, __privateGet$4(this, _data$1).inputs.slice());
     __privateSet$4(this, _commandSection, __privateGet$4(this, _data$1).commands.slice());
+    __privateSet$4(this, _availableResults, new Set(__privateGet$4(this, _commandSection).map((_, i) => i)));
   }
 };
 waitForPendingTasks_fn = async function() {
@@ -9498,6 +9629,322 @@ class HttpClient {
     }
 }
 
+// Copyright (c) 2025 Dipcoin LLC
+// SPDX-License-Identifier: Apache-2.0
+function computeOrderFlag(order) {
+    let flag = 0;
+    if (order.ioc)
+        flag += 1;
+    if (order.postOnly)
+        flag += 2;
+    if (order.reduceOnly)
+        flag += 4;
+    if (order.isLong)
+        flag += 8;
+    if (order.orderbookOnly)
+        flag += 16;
+    return flag;
+}
+function packPayload(fields) {
+    let result = "{\n";
+    for (const [key, value] of fields) {
+        result += `"${key}":"${value}",\n`;
+    }
+    result += '"domain":"dipcoin.io"\n';
+    result += "}";
+    return result;
+}
+function getOrderMessageForUIWallet(order) {
+    const flag = computeOrderFlag(order);
+    const fields = [
+        ["market", `${order.market}`],
+        ["creator", `${order.creator}`],
+        ["isLong", `${order.isLong}`],
+        ["reduceOnly", `${order.reduceOnly}`],
+        ["postOnly", `${order.postOnly}`],
+        ["orderbookOnly", `${order.orderbookOnly}`],
+        ["ioc", `${order.ioc || false}`],
+        ["quantity", `${order.quantity.toFixed(0)}`],
+        ["price", `${order.price.toFixed(0)}`],
+        ["leverage", `${order.leverage.toFixed(0)}`],
+        ["expiration", `${order.expiration.toFixed(0)}`],
+        ["salt", `${order.salt.toFixed(0)}`],
+        ["orderFlag", `${flag}`],
+    ];
+    return packPayload(fields);
+}
+
+// Copyright (c) 2025 Dipcoin LLC
+const CLOCK_OBJECT_ID = "0x6";
+// ---------------------------------------------------------------------------
+// Deployment config helpers
+// ---------------------------------------------------------------------------
+function getPackageId(deployment) {
+    const pkgs = deployment?.packages;
+    if (!pkgs || !pkgs.length)
+        throw new Error("Deployment config missing packages array");
+    return pkgs[pkgs.length - 1];
+}
+function getProtocolConfigId(deployment) {
+    const id = deployment?.objects?.ProtocolConfig?.id;
+    if (!id)
+        throw new Error("Deployment config missing ProtocolConfig id");
+    return id;
+}
+function getBankId(deployment) {
+    const id = deployment?.objects?.Bank?.id;
+    if (!id)
+        throw new Error("Deployment config missing Bank id");
+    return id;
+}
+function getSubAccountsId(deployment) {
+    const id = deployment?.objects?.SubAccounts?.id;
+    if (!id)
+        throw new Error("Deployment config missing SubAccounts id");
+    return id;
+}
+function getTxIndexerId(deployment) {
+    const id = deployment?.objects?.TxIndexer?.id;
+    if (!id)
+        throw new Error("Deployment config missing TxIndexer id");
+    return id;
+}
+function getCurrencyType(deployment) {
+    const dt = deployment?.objects?.Currency?.dataType;
+    if (!dt)
+        throw new Error("Deployment config missing Currency dataType");
+    return dt;
+}
+function getPerpetualId(deployment, market) {
+    const m = market?.toUpperCase();
+    const id = deployment?.markets?.[m]?.Objects?.Perpetual?.id;
+    if (!id)
+        throw new Error(`Deployment config missing Perpetual id for ${m}`);
+    return id;
+}
+function getPriceOracleObjectId(deployment, market) {
+    const m = market?.toUpperCase() || "ETH-PERP";
+    const id = deployment?.markets?.[m]?.Objects?.PriceInfoObject?.id;
+    if (!id)
+        throw new Error(`Deployment config missing PriceInfoObject id for ${m}`);
+    return id;
+}
+function getPriceOracleFeedId(deployment, market) {
+    const m = market?.toUpperCase() || "ETH-PERP";
+    const feedId = deployment?.markets?.[m]?.Config?.priceInfoFeedId;
+    if (!feedId)
+        throw new Error(`Deployment config missing priceInfoFeedId for ${m}`);
+    return feedId;
+}
+function getPythPkgId(deployment, market) {
+    const m = market?.toUpperCase() || "ETH-PERP";
+    const dataType = deployment?.markets?.[m]?.Objects?.PriceInfoObject?.dataType;
+    if (!dataType)
+        throw new Error(`Deployment config missing PriceInfoObject dataType for ${m}`);
+    return dataType.split("::")[0];
+}
+function hexToBytes(hex) {
+    const h = hex.startsWith("0x") ? hex.slice(2) : hex;
+    const bytes = [];
+    for (let i = 0; i < h.length; i += 2) {
+        bytes.push(parseInt(h.substr(i, 2), 16));
+    }
+    return bytes;
+}
+function toBigIntStr(value, decimals) {
+    // Equivalent to library's J(value, decimals) → multiply by 10^decimals and return integer string
+    const factor = Math.pow(10, decimals);
+    return Math.round(value * factor).toString();
+}
+// ---------------------------------------------------------------------------
+// Transaction builders
+// ---------------------------------------------------------------------------
+function buildAddMarginTx(deployment, args, tx, gasBudget, sender) {
+    const t = tx || new transactions.Transaction();
+    if (gasBudget)
+        t.setGasBudget(gasBudget);
+    if (sender)
+        t.setSender(sender);
+    const packageId = getPackageId(deployment);
+    t.moveCall({
+        target: `${packageId}::exchange::add_margin_v2`,
+        arguments: [
+            t.object(getProtocolConfigId(deployment)),
+            t.object(CLOCK_OBJECT_ID),
+            t.object(args.perpID || getPerpetualId(deployment, args.market)),
+            t.object(getBankId(deployment)),
+            t.object(args.subAccountsMapID || getSubAccountsId(deployment)),
+            t.object(getTxIndexerId(deployment)),
+            t.object(getPriceOracleObjectId(deployment, args.market)),
+            t.pure.address(args.account || sender || ""),
+            t.pure.u128(args.amount.toString()),
+        ],
+        typeArguments: [getCurrencyType(deployment)],
+    });
+    return t;
+}
+function buildRemoveMarginTx(deployment, args, tx, gasBudget, sender) {
+    const t = tx || new transactions.Transaction();
+    if (gasBudget)
+        t.setGasBudget(gasBudget);
+    if (sender)
+        t.setSender(sender);
+    const packageId = getPackageId(deployment);
+    t.moveCall({
+        target: `${packageId}::exchange::remove_margin_v2`,
+        arguments: [
+            t.object(getProtocolConfigId(deployment)),
+            t.object(CLOCK_OBJECT_ID),
+            t.object(args.perpID || getPerpetualId(deployment, args.market)),
+            t.object(getBankId(deployment)),
+            t.object(args.subAccountsMapID || getSubAccountsId(deployment)),
+            t.object(getTxIndexerId(deployment)),
+            t.object(getPriceOracleObjectId(deployment, args.market)),
+            t.pure.address(args.account || sender || ""),
+            t.pure.u128(args.amount.toString()),
+        ],
+        typeArguments: [getCurrencyType(deployment)],
+    });
+    return t;
+}
+function buildDepositTx(deployment, args, tx, gasBudget, sender) {
+    const t = tx || new transactions.Transaction();
+    if (gasBudget)
+        t.setGasBudget(gasBudget);
+    if (sender)
+        t.setSender(sender);
+    // The library uses a coin-splitting intent for deposit.
+    // We replicate the same Move call structure: bank::deposit_v2
+    // with a SplitCoins + the amount.
+    const coinType = getCurrencyType(deployment);
+    const coin = t.splitCoins(t.gas, [BigInt(args.amount)]);
+    const packageId = getPackageId(deployment);
+    t.moveCall({
+        target: `${packageId}::bank::deposit_v2`,
+        arguments: [
+            t.object(getProtocolConfigId(deployment)),
+            t.object(args.bankID || getBankId(deployment)),
+            t.object(getTxIndexerId(deployment)),
+            t.pure.address(args.accountAddress || sender || ""),
+            t.pure.u64(args.amount),
+            coin,
+        ],
+        typeArguments: [coinType],
+    });
+    return t;
+}
+function buildWithdrawTx(deployment, args, tx, gasBudget, sender) {
+    const t = tx || new transactions.Transaction();
+    if (gasBudget)
+        t.setGasBudget(gasBudget);
+    if (sender)
+        t.setSender(sender);
+    const packageId = getPackageId(deployment);
+    t.moveCall({
+        target: `${packageId}::bank::withdraw_v2`,
+        arguments: [
+            t.object(getProtocolConfigId(deployment)),
+            t.object(args.bankID || getBankId(deployment)),
+            t.object(getTxIndexerId(deployment)),
+            t.pure.address(args.accountAddress || sender || ""),
+            t.pure.u128(args.amount),
+        ],
+        typeArguments: [getCurrencyType(deployment)],
+    });
+    return t;
+}
+function buildSetSubAccountTx(deployment, args, tx, gasBudget, sender) {
+    const t = tx || new transactions.Transaction();
+    if (gasBudget)
+        t.setGasBudget(gasBudget);
+    if (sender)
+        t.setSender(sender);
+    const packageId = getPackageId(deployment);
+    t.moveCall({
+        target: `${packageId}::sub_accounts::set_sub_account`,
+        arguments: [
+            t.object(getProtocolConfigId(deployment)),
+            t.object(args.subAccountsMapID || getSubAccountsId(deployment)),
+            t.pure.address(args.account),
+            t.pure.bool(args.status),
+        ],
+        typeArguments: [],
+    });
+    return t;
+}
+function buildSetOraclePriceTx(deployment, args, tx, gasBudget, sender) {
+    const t = tx || new transactions.Transaction();
+    if (gasBudget)
+        t.setGasBudget(gasBudget);
+    if (sender)
+        t.setSender(sender);
+    const pythPkgId = getPythPkgId(deployment, args.market);
+    const oracleObjId = getPriceOracleObjectId(deployment, args.market);
+    const feedIdHex = getPriceOracleFeedId(deployment, args.market);
+    const feedIdBytes = hexToBytes(feedIdHex);
+    const priceU64 = toBigIntStr(args.price, 6);
+    t.moveCall({
+        target: `${pythPkgId}::price_info::update_price_info_object_for_test`,
+        arguments: [
+            t.object(oracleObjId),
+            t.object(CLOCK_OBJECT_ID),
+            t.pure.u64(priceU64),
+            t.pure.u64(args.confidence || "10"),
+            t.pure(suiBcs.vector(suiBcs.u8()).serialize(new Uint8Array(feedIdBytes))),
+        ],
+        typeArguments: [],
+    });
+    return t;
+}
+function buildBatchSetOraclePriceTx(deployment, args, tx, gasBudget, sender) {
+    let t = tx || new transactions.Transaction();
+    for (const priceArgs of args.prices) {
+        t = buildSetOraclePriceTx(deployment, priceArgs, t, undefined, undefined);
+    }
+    if (gasBudget)
+        t.setGasBudget(gasBudget);
+    if (sender)
+        t.setSender(sender);
+    return t;
+}
+
+// Copyright (c) 2025 Dipcoin LLC
+async function executeTxBlock(suiClient, tx, signer) {
+    return suiClient.signAndExecuteTransaction({
+        signer,
+        transaction: tx,
+        options: {
+            showObjectChanges: true,
+            showEffects: true,
+            showEvents: true,
+            showInput: true,
+        },
+    });
+}
+function getDeploymentPerpetualID(deployment, market) {
+    return getPerpetualId(deployment, market);
+}
+async function getOraclePrice(suiClient, deployment, market) {
+    const objId = getPriceOracleObjectId(deployment, market);
+    const obj = await suiClient.getObject({ id: objId, options: { showContent: true } });
+    const fields = obj.data?.content?.fields?.price_info?.fields?.price_feed?.fields?.price?.fields;
+    if (!fields)
+        throw new Error(`Failed to read oracle price for ${market}`);
+    return Number(fields.price.fields.magnitude) / Math.pow(10, Number(fields.expo.fields.magnitude));
+}
+async function depositToBank(suiClient, deployment, args, signer) {
+    const tx = buildDepositTx(deployment, args, undefined, args.gasBudget, signer.getPublicKey().toSuiAddress());
+    return executeTxBlock(suiClient, tx, signer);
+}
+async function withdrawFromBank(suiClient, deployment, args, signer) {
+    const tx = buildWithdrawTx(deployment, args, undefined, args.gasBudget, signer.getPublicKey().toSuiAddress());
+    return executeTxBlock(suiClient, tx, signer);
+}
+async function setSubAccount(suiClient, deployment, args, signer) {
+    const tx = buildSetSubAccountTx(deployment, args, undefined, args.gasBudget, signer.getPublicKey().toSuiAddress());
+    return executeTxBlock(suiClient, tx, signer);
+}
+
 // Copyright (c) 2025 Dipcoin LLC
 // SPDX-License-Identifier: Apache-2.0
 /**
@@ -9935,7 +10382,7 @@ function bytesToNumberLE(bytes) {
     return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
 }
 function numberToBytesBE(n, len) {
-    return hexToBytes(n.toString(16).padStart(len * 2, '0'));
+    return hexToBytes$1(n.toString(16).padStart(len * 2, '0'));
 }
 function numberToBytesLE(n, len) {
     return numberToBytesBE(n, len).reverse();
@@ -9953,7 +10400,7 @@ function ensureBytes(title, hex, expectedLength) {
     let res;
     if (typeof hex === 'string') {
         try {
-            res = hexToBytes(hex);
+            res = hexToBytes$1(hex);
         }
         catch (e) {
             throw new Error(title + ' must be hex string or Uint8Array, cause: ' + e);
@@ -11699,7 +12146,7 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
             throw new Error('invalid format');
         }
         static fromHex(hex, format) {
-            return this.fromBytes(hexToBytes(hex), format);
+            return this.fromBytes(hexToBytes$1(hex), format);
         }
         addRecoveryBit(recovery) {
             return new Signature(this.r, this.s, recovery);
@@ -11748,7 +12195,7 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
             if (format === 'compact')
                 return concatBytes(Fn.toBytes(this.r), Fn.toBytes(this.s));
             if (format === 'der')
-                return hexToBytes(DER.hexFromSig(this));
+                return hexToBytes$1(DER.hexFromSig(this));
             throw new Error('invalid format');
         }
         toHex(format) {
@@ -12381,7 +12828,7 @@ function bytesToNumber(bytes) {
 function numberToBytes(num) {
     if (typeof num !== 'bigint')
         throw new Error('bigint expected');
-    return hexToBytes(num.toString(16).padStart(64, '0'));
+    return hexToBytes$1(num.toString(16).padStart(64, '0'));
 }
 const MASTER_SECRET = utf8ToBytes('Bitcoin seed');
 // Bitcoin hardcoded by default
@@ -15324,7 +15771,7 @@ function findFirstNonZeroIndex(bytes) {
 }
 function toPaddedBigEndianBytes(num, width) {
   const hex = num.toString(16);
-  return hexToBytes(hex.padStart(width * 2, "0").slice(-width * 2));
+  return hexToBytes$1(hex.padStart(width * 2, "0").slice(-width * 2));
 }
 function toBigEndianBytes(num, width) {
   const bytes = toPaddedBigEndianBytes(num, width);
@@ -16607,10 +17054,8 @@ class DipCoinPerpSDK {
     subJwtToken;
     isAuthenticating = false;
     isSubAuthenticating = false;
-    exchangeOnChain;
     deploymentConfig;
     suiClient;
-    transactionBuilder;
     priceServiceConnection;
     pythClient;
     tradingPairsCache;
@@ -16646,10 +17091,6 @@ class DipCoinPerpSDK {
         this.deploymentConfig = readFile(`config/deployed/${options.network}/main_contract.json`);
         const rpcUrl = options.customRpc || getFullnodeUrl(options.network);
         this.suiClient = new SuiJsonRpcClient({ url: rpcUrl });
-        this.exchangeOnChain = new perpTsLibrary.ExchangeOnChain(this.deploymentConfig, this.suiClient, this.keypair);
-        const packageId = this.getDeploymentPackageId();
-        const protocolConfigId = this.getDeploymentProtocolConfigId();
-        this.transactionBuilder = new perpTsLibrary.TransactionBuilder(packageId, protocolConfigId, this.deploymentConfig, this.suiClient);
     }
     /**
      * Get wallet address
@@ -16923,21 +17364,21 @@ class DipCoinPerpSDK {
                 };
             }
             // Generate order message for signing
-            const orderMsg = perpTsLibrary.OrderSigner.getOrderMessageForUIWallet(order);
+            const orderMsg = getOrderMessageForUIWallet(order);
             const orderHashBytes = new TextEncoder().encode(orderMsg);
             // Sign main order
             const orderSignature = await signMessage(signingKeypair, orderHashBytes);
             // Sign TP order if exists
             let tpOrderSignature;
             if (tpOrder) {
-                const tpOrderMsg = perpTsLibrary.OrderSigner.getOrderMessageForUIWallet(tpOrder);
+                const tpOrderMsg = getOrderMessageForUIWallet(tpOrder);
                 const tpOrderHashBytes = new TextEncoder().encode(tpOrderMsg);
                 tpOrderSignature = await signMessage(signingKeypair, tpOrderHashBytes);
             }
             // Sign SL order if exists
             let slOrderSignature;
             if (slOrder) {
-                const slOrderMsg = perpTsLibrary.OrderSigner.getOrderMessageForUIWallet(slOrder);
+                const slOrderMsg = getOrderMessageForUIWallet(slOrder);
                 const slOrderHashBytes = new TextEncoder().encode(slOrderMsg);
                 slOrderSignature = await signMessage(signingKeypair, slOrderHashBytes);
             }
@@ -17325,7 +17766,7 @@ class DipCoinPerpSDK {
                     expiration: expirationBN,
                     salt: tpSaltValue,
                 };
-                const tpOrderMsg = perpTsLibrary.OrderSigner.getOrderMessageForUIWallet(tpOrder);
+                const tpOrderMsg = getOrderMessageForUIWallet(tpOrder);
                 const tpOrderSignature = await signMessage(signingKeypair, new TextEncoder().encode(tpOrderMsg));
                 tpPayload = {
                     ...planPayloadBase,
@@ -17370,7 +17811,7 @@ class DipCoinPerpSDK {
                     expiration: expirationBN,
                     salt: slSaltValue,
                 };
-                const slOrderMsg = perpTsLibrary.OrderSigner.getOrderMessageForUIWallet(slOrder);
+                const slOrderMsg = getOrderMessageForUIWallet(slOrder);
                 const slOrderSignature = await signMessage(signingKeypair, new TextEncoder().encode(slOrderMsg));
                 slPayload = {
                     ...planPayloadBase,
@@ -18251,10 +18692,11 @@ class DipCoinPerpSDK {
     async addMargin(params) {
         const transaction = await this.buildMarginTransaction(params, "add");
         if (transaction) {
-            return this.exchangeOnChain.executeTxBlock(transaction, this.keypair);
+            return executeTxBlock(this.suiClient, transaction, this.keypair);
         }
         const fallbackPayload = this.buildMarginCallArgs(params, "add");
-        return this.exchangeOnChain.addMargin(fallbackPayload);
+        const tx = buildAddMarginTx(this.deploymentConfig, fallbackPayload, undefined, fallbackPayload.gasBudget, this.keypair.getPublicKey().toSuiAddress());
+        return executeTxBlock(this.suiClient, tx, this.keypair);
     }
     /**
      * Remove isolated margin from an existing position (on-chain)
@@ -18263,10 +18705,11 @@ class DipCoinPerpSDK {
     async removeMargin(params) {
         const transaction = await this.buildMarginTransaction(params, "remove");
         if (transaction) {
-            return this.exchangeOnChain.executeTxBlock(transaction, this.keypair);
+            return executeTxBlock(this.suiClient, transaction, this.keypair);
         }
         const fallbackPayload = this.buildMarginCallArgs(params, "remove");
-        return this.exchangeOnChain.removeMargin(fallbackPayload);
+        const tx = buildRemoveMarginTx(this.deploymentConfig, fallbackPayload, undefined, fallbackPayload.gasBudget, this.keypair.getPublicKey().toSuiAddress());
+        return executeTxBlock(this.suiClient, tx, this.keypair);
     }
     /**
      * Build ExchangeOnChain call args for margin adjustments
@@ -18296,13 +18739,6 @@ class DipCoinPerpSDK {
             txHash,
         };
     }
-    getDeploymentPackageId() {
-        const packages = this.deploymentConfig?.packages;
-        if (!packages || !packages.length) {
-            throw new Error("Deployment config missing packages array");
-        }
-        return packages[packages.length - 1];
-    }
     getDeploymentProtocolConfigId() {
         const protocolId = this.deploymentConfig?.objects?.ProtocolConfig?.id;
         if (!protocolId) {
@@ -18311,18 +18747,15 @@ class DipCoinPerpSDK {
         return protocolId;
     }
     async buildMarginTransaction(params, action) {
-        if (!this.transactionBuilder) {
-            return undefined;
-        }
         const payload = this.buildMarginCallArgs(params, action);
         const updatePriceTx = payload.market
             ? await this.buildUpdatePriceTransaction(payload.market)
             : undefined;
         const baseTx = updatePriceTx || new transactions.Transaction();
         if (action === "add") {
-            return this.transactionBuilder.exchange_addMarginTx(payload, baseTx, params.gasBudget);
+            return buildAddMarginTx(this.deploymentConfig, payload, baseTx, params.gasBudget);
         }
-        return this.transactionBuilder.exchange_removeMarginTx(payload, baseTx, params.gasBudget);
+        return buildRemoveMarginTx(this.deploymentConfig, payload, baseTx, params.gasBudget);
     }
     async buildUpdatePriceTransaction(symbol) {
         if (!symbol) {
@@ -18365,11 +18798,11 @@ class DipCoinPerpSDK {
     }
     async buildTestnetPriceUpdateTransaction(symbol) {
         try {
-            const oraclePrice = await this.exchangeOnChain.getOraclePrice(symbol);
+            const oraclePrice = await getOraclePrice(this.suiClient, this.deploymentConfig, symbol);
             if (oraclePrice === undefined || oraclePrice === null) {
                 return undefined;
             }
-            return this.transactionBuilder.price_info_setOraclePriceTx({
+            return buildSetOraclePriceTx(this.deploymentConfig, {
                 price: Number(oraclePrice),
                 market: symbol,
             });
@@ -18464,7 +18897,7 @@ class DipCoinPerpSDK {
      */
     resolvePerpIdFromDeployment(market) {
         try {
-            const perpId = this.exchangeOnChain.getPerpetualID(market);
+            const perpId = getDeploymentPerpetualID(this.deploymentConfig, market);
             return perpId || undefined;
         }
         catch (error) {
@@ -18478,7 +18911,7 @@ class DipCoinPerpSDK {
      * @returns On-chain transaction result
      */
     async setSubAccount(subAddress) {
-        return await this.exchangeOnChain.setSubAccount({
+        return await setSubAccount(this.suiClient, this.deploymentConfig, {
             account: subAddress,
             status: true,
         }, this.keypair);
@@ -18494,7 +18927,7 @@ class DipCoinPerpSDK {
      * ```
      */
     async depositToBank(amount) {
-        return await this.exchangeOnChain.depositToBank({
+        return await depositToBank(this.suiClient, this.deploymentConfig, {
             amount: formatNormalToWei(amount, DECIMALS.USDC),
             accountAddress: this.address,
         }, this.keypair);
@@ -18510,7 +18943,7 @@ class DipCoinPerpSDK {
      * ```
      */
     async withdrawFromBank(amount) {
-        return await this.exchangeOnChain.withdrawFromBank({
+        return await withdrawFromBank(this.suiClient, this.deploymentConfig, {
             amount: formatNormalToWei(amount, DECIMALS.USDC),
             accountAddress: this.address,
         }, this.keypair);
@@ -18610,11 +19043,11 @@ class DipCoinPerpSDK {
         const currencyType = this.getCurrencyType();
         const symbols = markets && markets.length > 0 ? markets : this.getMarketSymbols();
         // On testnet, prepend price oracle updates so PriceInfoObjects are fresh
-        if (this.options.network === "testnet" && this.transactionBuilder) {
+        if (this.options.network === "testnet") {
             const prices = [];
             for (const sym of symbols) {
                 try {
-                    const oraclePrice = await this.exchangeOnChain.getOraclePrice(sym);
+                    const oraclePrice = await getOraclePrice(this.suiClient, this.deploymentConfig, sym);
                     if (oraclePrice !== undefined && oraclePrice !== null) {
                         prices.push({ price: Number(oraclePrice), market: sym });
                     }
@@ -18624,7 +19057,7 @@ class DipCoinPerpSDK {
                 }
             }
             if (prices.length > 0) {
-                this.transactionBuilder.price_info_batchSetOraclePriceTx({ prices }, t);
+                buildBatchSetOraclePriceTx(this.deploymentConfig, { prices }, t);
             }
         }
         const [nav] = t.moveCall({
@@ -20189,11 +20622,27 @@ function registerBalanceCommand(program) {
     });
 }
 
+function getPackageVersion() {
+    try {
+        // Works in both ESM and CJS after bundling
+        const pkgPath = path.resolve(path.dirname(url.fileURLToPath((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT' && document.currentScript.src || new URL('cli.cjs', document.baseURI).href)))), "../package.json");
+        return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
+    }
+    catch {
+        try {
+            // Fallback: resolve from cwd
+            return JSON.parse(fs.readFileSync(path.resolve(process.cwd(), "package.json"), "utf-8")).version;
+        }
+        catch {
+            return "0.0.0";
+        }
+    }
+}
 const program = new commander.Command();
 program
     .name("dipcoin-cli")
     .description("DipCoin Perpetual Trading CLI")
-    .version("0.5.0")
+    .version(getPackageVersion())
     .option("--json", "Output in JSON format")
     .option("--vault-index <n>", "Vault index (1+ for HD-derived sub-accounts)");
 registerAccountCommands(program);