@zing-protocol/zing-sdk 0.0.1

package/README.md

@@ -0,0 +1,12 @@
+# Shared Package
+
+This package contains code shared with other packages.
+To use the code in the package, you need to add the following to the package.json file.
+
+```json
+{
+  "dependencies": {
+    "@extension/shared": "workspace:*"
+  }
+}
+```

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@zing-protocol/zing-sdk",
+  "sideEffects": false,
+  "type": "module",
+  "version": "0.0.1",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./src/*": "./src/*"
+  },
+  "scripts": {
+    "build": "tsc",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@mysten/seal": "catalog:",
+    "@mysten/sui": "catalog:",
+    "@mysten/walrus": "catalog:",
+    "@tanstack/react-query": "catalog:",
+    "@reclaimprotocol/js-sdk": "^4.5.1",
+    "js-sha3": "^0.9.3",
+    "zustand": "^5.0.8"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@package/tsconfig": "workspace:*",
+    "type-fest": "^4.41.0",
+    "typescript": "^5.8.3",
+    "@types/react": "catalog:",
+    "@types/react-dom": "catalog:",
+    "@types/node": "catalog:"
+  }
+}

package/src/_generated/index.js

@@ -0,0 +1,6 @@
+export * as Reclaim from "./zing_identity/reclaim.js";
+export * as Identity from "./zing_identity/identity.js";
+export * as StudioApp from "./zing_studio/app.js";
+export * as Studio from "./zing_studio/studio.js";
+export * as Article from "./zing_studio/article.js";
+export * as Storage from "./zing_studio/storage.js";

package/src/_generated/utils/index.ts

@@ -0,0 +1,181 @@
+import {
+  bcs,
+  TypeTagSerializer,
+  BcsStruct,
+  BcsEnum,
+  BcsTuple,
+} from "@mysten/sui/bcs";
+import { isArgument } from "@mysten/sui/transactions";
+import { normalizeSuiAddress } from "@mysten/sui/utils";
+import type { BcsType, TypeTag } from "@mysten/sui/bcs";
+import type { TransactionArgument } from "@mysten/sui/transactions";
+
+const MOVE_STDLIB_ADDRESS = normalizeSuiAddress("0x1");
+const SUI_FRAMEWORK_ADDRESS = normalizeSuiAddress("0x2");
+const SUI_SYSTEM_ADDRESS = normalizeSuiAddress("0x3");
+
+function stringify(val: unknown) {
+  if (typeof val === "object") {
+    return JSON.stringify(val, (val: unknown) => val);
+  }
+  if (typeof val === "bigint") {
+    return val.toString();
+  }
+
+  return val;
+}
+
+export type RawTransactionArgument<T> = T | TransactionArgument;
+
+export function getPureBcsSchema(
+  typeTag: string | TypeTag,
+): BcsType<any> | null {
+  const parsedTag =
+    typeof typeTag === "string"
+      ? TypeTagSerializer.parseFromStr(typeTag)
+      : typeTag;
+
+  if ("u8" in parsedTag) {
+    return bcs.U8;
+  } else if ("u16" in parsedTag) {
+    return bcs.U16;
+  } else if ("u32" in parsedTag) {
+    return bcs.U32;
+  } else if ("u64" in parsedTag) {
+    return bcs.U64;
+  } else if ("u128" in parsedTag) {
+    return bcs.U128;
+  } else if ("u256" in parsedTag) {
+    return bcs.U256;
+  } else if ("address" in parsedTag) {
+    return bcs.Address;
+  } else if ("bool" in parsedTag) {
+    return bcs.Bool;
+  } else if ("vector" in parsedTag) {
+    const type = getPureBcsSchema(parsedTag.vector);
+    return type ? bcs.vector(type) : null;
+  } else if ("struct" in parsedTag) {
+    const structTag = parsedTag.struct;
+    const pkg = normalizeSuiAddress(parsedTag.struct.address);
+
+    if (pkg === MOVE_STDLIB_ADDRESS) {
+      if (
+        (structTag.module === "ascii" || structTag.module === "string") &&
+        structTag.name === "String"
+      ) {
+        return bcs.String;
+      }
+
+      if (structTag.module === "option" && structTag.name === "Option") {
+        const type = getPureBcsSchema(structTag.typeParams[0]!);
+        return type ? bcs.option(type) : null;
+      }
+    }
+
+    if (
+      pkg === SUI_FRAMEWORK_ADDRESS &&
+      structTag.module === "Object" &&
+      structTag.name === "ID"
+    ) {
+      return bcs.Address;
+    }
+  }
+
+  return null;
+}
+
+export function normalizeMoveArguments(
+  args: unknown[] | object,
+  argTypes: string[],
+  parameterNames?: string[],
+) {
+  const argLen = Array.isArray(args) ? args.length : Object.keys(args).length;
+  if (parameterNames && argLen !== parameterNames.length) {
+    throw new Error(
+      `Invalid number of arguments, expected ${parameterNames.length}, got ${argLen}`,
+    );
+  }
+
+  const normalizedArgs: TransactionArgument[] = [];
+
+  let index = 0;
+  for (const [i, argType] of argTypes.entries()) {
+    if (argType === `${SUI_FRAMEWORK_ADDRESS}::deny_list::DenyList`) {
+      normalizedArgs.push((tx) => tx.object.denyList());
+      continue;
+    }
+
+    if (argType === `${SUI_FRAMEWORK_ADDRESS}::random::Random`) {
+      normalizedArgs.push((tx) => tx.object.random());
+      continue;
+    }
+
+    if (argType === `${SUI_FRAMEWORK_ADDRESS}::clock::Clock`) {
+      normalizedArgs.push((tx) => tx.object.clock());
+      continue;
+    }
+
+    if (argType === `${SUI_SYSTEM_ADDRESS}::sui_system::SuiSystemState`) {
+      normalizedArgs.push((tx) => tx.object.system());
+      continue;
+    }
+
+    let arg;
+    if (Array.isArray(args)) {
+      if (index >= args.length) {
+        throw new Error(
+          `Invalid number of arguments, expected at least ${index + 1}, got ${args.length}`,
+        );
+      }
+      arg = args[index];
+    } else {
+      if (!parameterNames) {
+        throw new Error(`Expected arguments to be passed as an array`);
+      }
+      const name = parameterNames[index];
+      arg = args[name as keyof typeof args];
+
+      if (arg === undefined) {
+        throw new Error(`Parameter ${name} is required`);
+      }
+    }
+
+    index += 1;
+
+    if (typeof arg === "function" || isArgument(arg)) {
+      normalizedArgs.push(arg as TransactionArgument);
+      continue;
+    }
+
+    const type = argTypes[i]!;
+    const bcsType = getPureBcsSchema(type);
+
+    if (bcsType) {
+      const bytes = bcsType.serialize(arg as never);
+      normalizedArgs.push((tx) => tx.pure(bytes));
+      continue;
+    } else if (typeof arg === "string") {
+      normalizedArgs.push((tx) => tx.object(arg));
+      continue;
+    }
+
+    throw new Error(`Invalid argument ${stringify(arg)} for type ${type}`);
+  }
+
+  return normalizedArgs;
+}
+
+export class MoveStruct<
+  T extends Record<string, BcsType<any>>,
+  const Name extends string = string,
+> extends BcsStruct<T, Name> {}
+
+export class MoveEnum<
+  T extends Record<string, BcsType<any> | null>,
+  const Name extends string,
+> extends BcsEnum<T, Name> {}
+
+export class MoveTuple<
+  T extends readonly BcsType<any>[],
+  const Name extends string,
+> extends BcsTuple<T, Name> {}

package/src/_generated/zing_framework/coin_utils.ts

@@ -0,0 +1,41 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { normalizeMoveArguments } from "../utils/index.js";
+import type { RawTransactionArgument } from "../utils/index.js";
+import type { Transaction } from "@mysten/sui/transactions";
+
+export interface BurnOrSendPositiveCoinArguments {
+  coin: RawTransactionArgument<string>;
+  recipient: RawTransactionArgument<string>;
+}
+export interface BurnOrSendPositiveCoinOptions {
+  package?: string;
+  arguments:
+    | BurnOrSendPositiveCoinArguments
+    | [
+        coin: RawTransactionArgument<string>,
+        recipient: RawTransactionArgument<string>,
+      ];
+  typeArguments: [string];
+}
+export function burnOrSendPositiveCoin(options: BurnOrSendPositiveCoinOptions) {
+  const packageAddress = options.package ?? "@local-pkg/zing_framework";
+  const argumentsTypes = [
+    `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`,
+    "address",
+  ] satisfies string[];
+  const parameterNames = ["coin", "recipient"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "coin_utils",
+      function: "burn_or_send_positive_coin",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+      typeArguments: options.typeArguments,
+    });
+}

package/src/_generated/zing_framework/deps/sui/object.ts

@@ -0,0 +1,16 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/** Sui object identifiers */
+
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+
+const $moduleName = "0x2::object";
+export const UID = new MoveStruct({
+  name: `${$moduleName}::UID`,
+  fields: {
+    id: bcs.Address,
+  },
+});

package/src/_generated/zing_framework/derived_object_bag.ts

@@ -0,0 +1,400 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import * as object from "./deps/sui/object.js";
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+import type { RawTransactionArgument } from "../utils/index.js";
+import type { BcsType } from "@mysten/sui/bcs";
+import type { Transaction } from "@mysten/sui/transactions";
+
+const $moduleName = "@local-pkg/zing_framework::derived_object_bag";
+export const DerivedObjectBag = new MoveStruct({
+  name: `${$moduleName}::DerivedObjectBag`,
+  fields: {
+    /** the ID of this bag */
+    id: object.UID,
+    /** the number of key-value pairs in the bag */
+    size: bcs.u64(),
+  },
+});
+export interface NewArguments<K extends BcsType<any>> {
+  parent: RawTransactionArgument<string>;
+  key: RawTransactionArgument<K>;
+}
+export interface NewOptions<K extends BcsType<any>> {
+  package?: string;
+  arguments:
+    | NewArguments<K>
+    | [parent: RawTransactionArgument<string>, key: RawTransactionArgument<K>];
+  typeArguments: [string];
+}
+/** Creates a new, empty bag */
+export function _new<K extends BcsType<any>>(options: NewOptions<K>) {
+  const packageAddress = options.package ?? "@local-pkg/zing_framework";
+  const argumentsTypes = [
+    "0x0000000000000000000000000000000000000000000000000000000000000002::object::UID",
+    `${options.typeArguments[0]}`,
+  ] satisfies string[];
+  const parameterNames = ["parent", "key"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "derived_object_bag",
+      function: "new",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+      typeArguments: options.typeArguments,
+    });
+}
+export interface AddArguments<K extends BcsType<any>, V extends BcsType<any>> {
+  bag: RawTransactionArgument<string>;
+  k: RawTransactionArgument<K>;
+  v: RawTransactionArgument<V>;
+}
+export interface AddOptions<K extends BcsType<any>, V extends BcsType<any>> {
+  package?: string;
+  arguments:
+    | AddArguments<K, V>
+    | [
+        bag: RawTransactionArgument<string>,
+        k: RawTransactionArgument<K>,
+        v: RawTransactionArgument<V>,
+      ];
+  typeArguments: [string, string];
+}
+/**
+ * Adds a key-value pair to the bag `bag: &mut DerivedObjectBag` Aborts with
+ * `sui::dynamic_field::EFieldAlreadyExists` if the bag already has an entry with
+ * that key `k: K`.
+ */
+export function add<K extends BcsType<any>, V extends BcsType<any>>(
+  options: AddOptions<K, V>,
+) {
+  const packageAddress = options.package ?? "@local-pkg/zing_framework";
+  const argumentsTypes = [
+    `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+    `${options.typeArguments[0]}`,
+    `${options.typeArguments[1]}`,
+  ] satisfies string[];
+  const parameterNames = ["bag", "k", "v"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "derived_object_bag",
+      function: "add",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+      typeArguments: options.typeArguments,
+    });
+}
+export interface BorrowArguments<K extends BcsType<any>> {
+  bag: RawTransactionArgument<string>;
+  k: RawTransactionArgument<K>;
+}
+export interface BorrowOptions<K extends BcsType<any>> {
+  package?: string;
+  arguments:
+    | BorrowArguments<K>
+    | [bag: RawTransactionArgument<string>, k: RawTransactionArgument<K>];
+  typeArguments: [string, string];
+}
+/**
+ * Immutably borrows the value associated with the key in the bag
+ * `bag: &DerivedObjectBag`. Aborts with `sui::dynamic_field::EFieldDoesNotExist`
+ * if the bag does not have an entry with that key `k: K`. Aborts with
+ * `sui::dynamic_field::EFieldTypeMismatch` if the bag has an entry for the key,
+ * but the value does not have the specified type.
+ */
+export function borrow<K extends BcsType<any>>(options: BorrowOptions<K>) {
+  const packageAddress = options.package ?? "@local-pkg/zing_framework";
+  const argumentsTypes = [
+    `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+    `${options.typeArguments[0]}`,
+  ] satisfies string[];
+  const parameterNames = ["bag", "k"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "derived_object_bag",
+      function: "borrow",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+      typeArguments: options.typeArguments,
+    });
+}
+export interface BorrowMutArguments<K extends BcsType<any>> {
+  bag: RawTransactionArgument<string>;
+  k: RawTransactionArgument<K>;
+}
+export interface BorrowMutOptions<K extends BcsType<any>> {
+  package?: string;
+  arguments:
+    | BorrowMutArguments<K>
+    | [bag: RawTransactionArgument<string>, k: RawTransactionArgument<K>];
+  typeArguments: [string, string];
+}
+/**
+ * Mutably borrows the value associated with the key in the bag
+ * `bag: &mut DerivedObjectBag`. Aborts with
+ * `sui::dynamic_field::EFieldDoesNotExist` if the bag does not have an entry with
+ * that key `k: K`. Aborts with `sui::dynamic_field::EFieldTypeMismatch` if the bag
+ * has an entry for the key, but the value does not have the specified type.
+ */
+export function borrowMut<K extends BcsType<any>>(
+  options: BorrowMutOptions<K>,
+) {
+  const packageAddress = options.package ?? "@local-pkg/zing_framework";
+  const argumentsTypes = [
+    `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+    `${options.typeArguments[0]}`,
+  ] satisfies string[];
+  const parameterNames = ["bag", "k"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "derived_object_bag",
+      function: "borrow_mut",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+      typeArguments: options.typeArguments,
+    });
+}
+export interface RemoveArguments<K extends BcsType<any>> {
+  bag: RawTransactionArgument<string>;
+  k: RawTransactionArgument<K>;
+}
+export interface RemoveOptions<K extends BcsType<any>> {
+  package?: string;
+  arguments:
+    | RemoveArguments<K>
+    | [bag: RawTransactionArgument<string>, k: RawTransactionArgument<K>];
+  typeArguments: [string, string];
+}
+/**
+ * Mutably borrows the key-value pair in the bag `bag: &mut DerivedObjectBag` and
+ * returns the value. Aborts with `sui::dynamic_field::EFieldDoesNotExist` if the
+ * bag does not have an entry with that key `k: K`. Aborts with
+ * `sui::dynamic_field::EFieldTypeMismatch` if the bag has an entry for the key,
+ * but the value does not have the specified type.
+ */
+export function remove<K extends BcsType<any>>(options: RemoveOptions<K>) {
+  const packageAddress = options.package ?? "@local-pkg/zing_framework";
+  const argumentsTypes = [
+    `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+    `${options.typeArguments[0]}`,
+  ] satisfies string[];
+  const parameterNames = ["bag", "k"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "derived_object_bag",
+      function: "remove",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+      typeArguments: options.typeArguments,
+    });
+}
+export interface ContainsArguments<K extends BcsType<any>> {
+  bag: RawTransactionArgument<string>;
+  k: RawTransactionArgument<K>;
+}
+export interface ContainsOptions<K extends BcsType<any>> {
+  package?: string;
+  arguments:
+    | ContainsArguments<K>
+    | [bag: RawTransactionArgument<string>, k: RawTransactionArgument<K>];
+  typeArguments: [string];
+}
+/**
+ * Returns true iff there is an value associated with the key `k: K` in the bag
+ * `bag: &DerivedObjectBag`
+ */
+export function contains<K extends BcsType<any>>(options: ContainsOptions<K>) {
+  const packageAddress = options.package ?? "@local-pkg/zing_framework";
+  const argumentsTypes = [
+    `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+    `${options.typeArguments[0]}`,
+  ] satisfies string[];
+  const parameterNames = ["bag", "k"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "derived_object_bag",
+      function: "contains",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+      typeArguments: options.typeArguments,
+    });
+}
+export interface ContainsWithTypeArguments<K extends BcsType<any>> {
+  bag: RawTransactionArgument<string>;
+  k: RawTransactionArgument<K>;
+}
+export interface ContainsWithTypeOptions<K extends BcsType<any>> {
+  package?: string;
+  arguments:
+    | ContainsWithTypeArguments<K>
+    | [bag: RawTransactionArgument<string>, k: RawTransactionArgument<K>];
+  typeArguments: [string, string];
+}
+/**
+ * Returns true iff there is an value associated with the key `k: K` in the bag
+ * `bag: &DerivedObjectBag` with an assigned value of type `V`
+ */
+export function containsWithType<K extends BcsType<any>>(
+  options: ContainsWithTypeOptions<K>,
+) {
+  const packageAddress = options.package ?? "@local-pkg/zing_framework";
+  const argumentsTypes = [
+    `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+    `${options.typeArguments[0]}`,
+  ] satisfies string[];
+  const parameterNames = ["bag", "k"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "derived_object_bag",
+      function: "contains_with_type",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+      typeArguments: options.typeArguments,
+    });
+}
+export interface LengthArguments {
+  bag: RawTransactionArgument<string>;
+}
+export interface LengthOptions {
+  package?: string;
+  arguments: LengthArguments | [bag: RawTransactionArgument<string>];
+}
+/** Returns the size of the bag, the number of key-value pairs */
+export function length(options: LengthOptions) {
+  const packageAddress = options.package ?? "@local-pkg/zing_framework";
+  const argumentsTypes = [
+    `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+  ] satisfies string[];
+  const parameterNames = ["bag"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "derived_object_bag",
+      function: "length",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+    });
+}
+export interface IsEmptyArguments {
+  bag: RawTransactionArgument<string>;
+}
+export interface IsEmptyOptions {
+  package?: string;
+  arguments: IsEmptyArguments | [bag: RawTransactionArgument<string>];
+}
+/** Returns true iff the bag is empty (if `length` returns `0`) */
+export function isEmpty(options: IsEmptyOptions) {
+  const packageAddress = options.package ?? "@local-pkg/zing_framework";
+  const argumentsTypes = [
+    `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+  ] satisfies string[];
+  const parameterNames = ["bag"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "derived_object_bag",
+      function: "is_empty",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+    });
+}
+export interface DestroyEmptyArguments {
+  bag: RawTransactionArgument<string>;
+}
+export interface DestroyEmptyOptions {
+  package?: string;
+  arguments: DestroyEmptyArguments | [bag: RawTransactionArgument<string>];
+}
+/**
+ * Destroys an empty bag Aborts with `EBagNotEmpty` if the bag still contains
+ * values
+ */
+export function destroyEmpty(options: DestroyEmptyOptions) {
+  const packageAddress = options.package ?? "@local-pkg/zing_framework";
+  const argumentsTypes = [
+    `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+  ] satisfies string[];
+  const parameterNames = ["bag"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "derived_object_bag",
+      function: "destroy_empty",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+    });
+}
+export interface ValueIdArguments<K extends BcsType<any>> {
+  bag: RawTransactionArgument<string>;
+  k: RawTransactionArgument<K>;
+}
+export interface ValueIdOptions<K extends BcsType<any>> {
+  package?: string;
+  arguments:
+    | ValueIdArguments<K>
+    | [bag: RawTransactionArgument<string>, k: RawTransactionArgument<K>];
+  typeArguments: [string];
+}
+/**
+ * Returns the ID of the object associated with the key if the bag has an entry
+ * with key `k: K` Returns none otherwise
+ */
+export function valueId<K extends BcsType<any>>(options: ValueIdOptions<K>) {
+  const packageAddress = options.package ?? "@local-pkg/zing_framework";
+  const argumentsTypes = [
+    `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+    `${options.typeArguments[0]}`,
+  ] satisfies string[];
+  const parameterNames = ["bag", "k"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "derived_object_bag",
+      function: "value_id",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+      typeArguments: options.typeArguments,
+    });
+}