@zing-protocol/zing-sdk 0.0.1 → 0.0.2

package/dist/_generated/zing_identity/identity.d.ts

@@ -0,0 +1,262 @@
+import { MoveStruct } from "../utils/index.js";
+import type { RawTransactionArgument } from "../utils/index.js";
+import type { BcsType } from "@mysten/sui/bcs";
+import type { Transaction } from "@mysten/sui/transactions";
+export declare const IdentityManager: MoveStruct<{
+    id: MoveStruct<{
+        id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    address_to_identifier: MoveStruct<{
+        id: MoveStruct<{
+            id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        }, "0x2::object::UID">;
+        size: BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::table::Table">;
+    identifier_info: MoveStruct<{
+        id: MoveStruct<{
+            id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        }, "0x2::object::UID">;
+        size: BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::table::Table">;
+    whitelist_modules: MoveStruct<{
+        contents: BcsType<{
+            name: string;
+        }[], Iterable<{
+            name: string;
+        }> & {
+            length: number;
+        }, "vector<std::type_name::TypeName>">;
+    }, string>;
+}, "@local-pkg/zing_identity::identity::IdentityManager">;
+export declare const IdentifierInfo: MoveStruct<{
+    owner: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    updated_at: BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_identity::identity::IdentifierInfo">;
+export declare const ReadAccess: MoveStruct<{
+    dummy_field: BcsType<boolean, boolean, "bool">;
+}, "@local-pkg/zing_identity::identity::ReadAccess">;
+export interface ModuleAddressToIdentifierBorrowArguments<T extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    Witness: RawTransactionArgument<T>;
+}
+export interface ModuleAddressToIdentifierBorrowOptions<T extends BcsType<any>> {
+    package?: string;
+    arguments: ModuleAddressToIdentifierBorrowArguments<T> | [
+        self: RawTransactionArgument<string>,
+        Witness: RawTransactionArgument<T>
+    ];
+    typeArguments: [string];
+}
+export declare function moduleAddressToIdentifierBorrow<T extends BcsType<any>>(options: ModuleAddressToIdentifierBorrowOptions<T>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ModuleAddressToIdentifierBorrowMutArguments<T extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    Witness: RawTransactionArgument<T>;
+}
+export interface ModuleAddressToIdentifierBorrowMutOptions<T extends BcsType<any>> {
+    package?: string;
+    arguments: ModuleAddressToIdentifierBorrowMutArguments<T> | [
+        self: RawTransactionArgument<string>,
+        Witness: RawTransactionArgument<T>
+    ];
+    typeArguments: [string];
+}
+export declare function moduleAddressToIdentifierBorrowMut<T extends BcsType<any>>(options: ModuleAddressToIdentifierBorrowMutOptions<T>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ModuleIdentifierInfoBorrowArguments<T extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    Witness: RawTransactionArgument<T>;
+}
+export interface ModuleIdentifierInfoBorrowOptions<T extends BcsType<any>> {
+    package?: string;
+    arguments: ModuleIdentifierInfoBorrowArguments<T> | [
+        self: RawTransactionArgument<string>,
+        Witness: RawTransactionArgument<T>
+    ];
+    typeArguments: [string];
+}
+export declare function moduleIdentifierInfoBorrow<T extends BcsType<any>>(options: ModuleIdentifierInfoBorrowOptions<T>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ModuleIdentifierInfoBorrowMutArguments<T extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    Witness: RawTransactionArgument<T>;
+}
+export interface ModuleIdentifierInfoBorrowMutOptions<T extends BcsType<any>> {
+    package?: string;
+    arguments: ModuleIdentifierInfoBorrowMutArguments<T> | [
+        self: RawTransactionArgument<string>,
+        Witness: RawTransactionArgument<T>
+    ];
+    typeArguments: [string];
+}
+export declare function moduleIdentifierInfoBorrowMut<T extends BcsType<any>>(options: ModuleIdentifierInfoBorrowMutOptions<T>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NewIdentifierInfoArguments {
+    owner: RawTransactionArgument<string>;
+    updatedAt: RawTransactionArgument<number | bigint>;
+}
+export interface NewIdentifierInfoOptions {
+    package?: string;
+    arguments: NewIdentifierInfoArguments | [
+        owner: RawTransactionArgument<string>,
+        updatedAt: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function newIdentifierInfo(options: NewIdentifierInfoOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DropIdentifierInfoArguments {
+    identifierInfo: RawTransactionArgument<string>;
+}
+export interface DropIdentifierInfoOptions {
+    package?: string;
+    arguments: DropIdentifierInfoArguments | [identifierInfo: RawTransactionArgument<string>];
+}
+export declare function dropIdentifierInfo(options: DropIdentifierInfoOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OwnerArguments {
+    info: RawTransactionArgument<string>;
+}
+export interface OwnerOptions {
+    package?: string;
+    arguments: OwnerArguments | [info: RawTransactionArgument<string>];
+}
+export declare function owner(options: OwnerOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdatedAtArguments {
+    info: RawTransactionArgument<string>;
+}
+export interface UpdatedAtOptions {
+    package?: string;
+    arguments: UpdatedAtArguments | [info: RawTransactionArgument<string>];
+}
+export declare function updatedAt(options: UpdatedAtOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateOwnerArguments {
+    info: RawTransactionArgument<string>;
+    owner: RawTransactionArgument<string>;
+}
+export interface UpdateOwnerOptions {
+    package?: string;
+    arguments: UpdateOwnerArguments | [
+        info: RawTransactionArgument<string>,
+        owner: RawTransactionArgument<string>
+    ];
+}
+export declare function updateOwner(options: UpdateOwnerOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateUpdatedAtArguments {
+    info: RawTransactionArgument<string>;
+    updatedAt: RawTransactionArgument<number | bigint>;
+}
+export interface UpdateUpdatedAtOptions {
+    package?: string;
+    arguments: UpdateUpdatedAtArguments | [
+        info: RawTransactionArgument<string>,
+        updatedAt: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function updateUpdatedAt(options: UpdateUpdatedAtOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetReadAccessArguments {
+    config: RawTransactionArgument<string>;
+    treasury: RawTransactionArgument<string>;
+    balance: RawTransactionArgument<string>;
+}
+export interface GetReadAccessOptions {
+    package?: string;
+    arguments: GetReadAccessArguments | [
+        config: RawTransactionArgument<string>,
+        treasury: RawTransactionArgument<string>,
+        balance: RawTransactionArgument<string>
+    ];
+}
+export declare function getReadAccess(options: GetReadAccessOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IdentifierByAddressWithReadAccessArguments {
+    self: RawTransactionArgument<string>;
+    Access: RawTransactionArgument<string>;
+    user: RawTransactionArgument<string>;
+}
+export interface IdentifierByAddressWithReadAccessOptions {
+    package?: string;
+    arguments: IdentifierByAddressWithReadAccessArguments | [
+        self: RawTransactionArgument<string>,
+        Access: RawTransactionArgument<string>,
+        user: RawTransactionArgument<string>
+    ];
+    typeArguments: [string];
+}
+export declare function identifierByAddressWithReadAccess(options: IdentifierByAddressWithReadAccessOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IdentifierInfoWithReadAccessArguments {
+    self: RawTransactionArgument<string>;
+    Access: RawTransactionArgument<string>;
+    identifier: RawTransactionArgument<string>;
+}
+export interface IdentifierInfoWithReadAccessOptions {
+    package?: string;
+    arguments: IdentifierInfoWithReadAccessArguments | [
+        self: RawTransactionArgument<string>,
+        Access: RawTransactionArgument<string>,
+        identifier: RawTransactionArgument<string>
+    ];
+    typeArguments: [string];
+}
+export declare function identifierInfoWithReadAccess(options: IdentifierInfoWithReadAccessOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NewArguments {
+    config: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+}
+export interface NewOptions {
+    package?: string;
+    arguments: NewArguments | [
+        config: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>
+    ];
+    typeArguments: [string];
+}
+export declare function _new(options: NewOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddWhiteslitArguments {
+    self: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+}
+export interface AddWhiteslitOptions {
+    package?: string;
+    arguments: AddWhiteslitArguments | [
+        self: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>
+    ];
+    typeArguments: [string, string];
+}
+export declare function addWhiteslit(options: AddWhiteslitOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveWhiteslitArguments {
+    self: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+}
+export interface RemoveWhiteslitOptions {
+    package?: string;
+    arguments: RemoveWhiteslitArguments | [
+        self: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>
+    ];
+    typeArguments: [string, string];
+}
+export declare function removeWhiteslit(options: RemoveWhiteslitOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IdentifierByAddressWithWhitelistArguments<Whitelist extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    _: RawTransactionArgument<Whitelist>;
+    user: RawTransactionArgument<string>;
+}
+export interface IdentifierByAddressWithWhitelistOptions<Whitelist extends BcsType<any>> {
+    package?: string;
+    arguments: IdentifierByAddressWithWhitelistArguments<Whitelist> | [
+        self: RawTransactionArgument<string>,
+        _: RawTransactionArgument<Whitelist>,
+        user: RawTransactionArgument<string>
+    ];
+    typeArguments: [string, string];
+}
+export declare function identifierByAddressWithWhitelist<Whitelist extends BcsType<any>>(options: IdentifierByAddressWithWhitelistOptions<Whitelist>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IdentifierInfoWithWhitelistArguments<Whitelist extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    _: RawTransactionArgument<Whitelist>;
+    identifier: RawTransactionArgument<string>;
+}
+export interface IdentifierInfoWithWhitelistOptions<Whitelist extends BcsType<any>> {
+    package?: string;
+    arguments: IdentifierInfoWithWhitelistArguments<Whitelist> | [
+        self: RawTransactionArgument<string>,
+        _: RawTransactionArgument<Whitelist>,
+        identifier: RawTransactionArgument<string>
+    ];
+    typeArguments: [string, string];
+}
+export declare function identifierInfoWithWhitelist<Whitelist extends BcsType<any>>(options: IdentifierInfoWithWhitelistOptions<Whitelist>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/_generated/zing_identity/identity.js

@@ -0,0 +1,294 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import * as type_name from "./deps/std/type_name.js";
+import * as object from "./deps/sui/object.js";
+import * as table from "./deps/sui/table.js";
+import * as vec_set from "./deps/sui/vec_set.js";
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+const $moduleName = "@local-pkg/zing_identity::identity";
+export const IdentityManager = new MoveStruct({
+    name: `${$moduleName}::IdentityManager`,
+    fields: {
+        id: object.UID,
+        address_to_identifier: table.Table,
+        identifier_info: table.Table,
+        whitelist_modules: vec_set.VecSet(type_name.TypeName),
+    },
+});
+export const IdentifierInfo = new MoveStruct({
+    name: `${$moduleName}::IdentifierInfo`,
+    fields: {
+        owner: bcs.Address,
+        updated_at: bcs.u64(),
+    },
+});
+export const ReadAccess = new MoveStruct({
+    name: `${$moduleName}::ReadAccess`,
+    fields: {
+        dummy_field: bcs.bool(),
+    },
+});
+export function moduleAddressToIdentifierBorrow(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_identity";
+    const argumentsTypes = [
+        `${packageAddress}::identity::IdentityManager<${options.typeArguments[0]}>`,
+        `${options.typeArguments[0]}`,
+    ];
+    const parameterNames = ["self", "Witness"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "identity",
+        function: "module_address_to_identifier_borrow",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+export function moduleAddressToIdentifierBorrowMut(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_identity";
+    const argumentsTypes = [
+        `${packageAddress}::identity::IdentityManager<${options.typeArguments[0]}>`,
+        `${options.typeArguments[0]}`,
+    ];
+    const parameterNames = ["self", "Witness"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "identity",
+        function: "module_address_to_identifier_borrow_mut",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+export function moduleIdentifierInfoBorrow(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_identity";
+    const argumentsTypes = [
+        `${packageAddress}::identity::IdentityManager<${options.typeArguments[0]}>`,
+        `${options.typeArguments[0]}`,
+    ];
+    const parameterNames = ["self", "Witness"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "identity",
+        function: "module_identifier_info_borrow",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+export function moduleIdentifierInfoBorrowMut(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_identity";
+    const argumentsTypes = [
+        `${packageAddress}::identity::IdentityManager<${options.typeArguments[0]}>`,
+        `${options.typeArguments[0]}`,
+    ];
+    const parameterNames = ["self", "Witness"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "identity",
+        function: "module_identifier_info_borrow_mut",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+export function newIdentifierInfo(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_identity";
+    const argumentsTypes = ["address", "u64"];
+    const parameterNames = ["owner", "updatedAt"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "identity",
+        function: "new_identifier_info",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function dropIdentifierInfo(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_identity";
+    const argumentsTypes = [
+        `${packageAddress}::identity::IdentifierInfo`,
+    ];
+    const parameterNames = ["identifierInfo"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "identity",
+        function: "drop_identifier_info",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function owner(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_identity";
+    const argumentsTypes = [
+        `${packageAddress}::identity::IdentifierInfo`,
+    ];
+    const parameterNames = ["info"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "identity",
+        function: "owner",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function updatedAt(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_identity";
+    const argumentsTypes = [
+        `${packageAddress}::identity::IdentifierInfo`,
+    ];
+    const parameterNames = ["info"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "identity",
+        function: "updated_at",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function updateOwner(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_identity";
+    const argumentsTypes = [
+        `${packageAddress}::identity::IdentifierInfo`,
+        "address",
+    ];
+    const parameterNames = ["info", "owner"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "identity",
+        function: "update_owner",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function updateUpdatedAt(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_identity";
+    const argumentsTypes = [
+        `${packageAddress}::identity::IdentifierInfo`,
+        "u64",
+    ];
+    const parameterNames = ["info", "updatedAt"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "identity",
+        function: "update_updated_at",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function getReadAccess(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_identity";
+    const argumentsTypes = [
+        `${packageAddress}::config::Config`,
+        `${packageAddress}::treasury::Treasury`,
+        "0x0000000000000000000000000000000000000000000000000000000000000002::balance::Balance<0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI>",
+    ];
+    const parameterNames = ["config", "treasury", "balance"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "identity",
+        function: "get_read_access",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function identifierByAddressWithReadAccess(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_identity";
+    const argumentsTypes = [
+        `${packageAddress}::identity::IdentityManager<${options.typeArguments[0]}>`,
+        `${packageAddress}::identity::ReadAccess`,
+        "address",
+    ];
+    const parameterNames = ["self", "Access", "user"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "identity",
+        function: "identifier_by_address_with_read_access",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+export function identifierInfoWithReadAccess(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_identity";
+    const argumentsTypes = [
+        `${packageAddress}::identity::IdentityManager<${options.typeArguments[0]}>`,
+        `${packageAddress}::identity::ReadAccess`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String",
+    ];
+    const parameterNames = ["self", "Access", "identifier"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "identity",
+        function: "identifier_info_with_read_access",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+export function _new(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_identity";
+    const argumentsTypes = [
+        `${packageAddress}::config::Config`,
+        `${packageAddress}::admin::AdminCap`,
+    ];
+    const parameterNames = ["config", "Cap"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "identity",
+        function: "new",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+export function addWhiteslit(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_identity";
+    const argumentsTypes = [
+        `${packageAddress}::identity::IdentityManager<${options.typeArguments[0]}>`,
+        `${packageAddress}::admin::AdminCap`,
+    ];
+    const parameterNames = ["self", "Cap"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "identity",
+        function: "add_whiteslit",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+export function removeWhiteslit(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_identity";
+    const argumentsTypes = [
+        `${packageAddress}::identity::IdentityManager<${options.typeArguments[0]}>`,
+        `${packageAddress}::admin::AdminCap`,
+    ];
+    const parameterNames = ["self", "Cap"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "identity",
+        function: "remove_whiteslit",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+export function identifierByAddressWithWhitelist(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_identity";
+    const argumentsTypes = [
+        `${packageAddress}::identity::IdentityManager<${options.typeArguments[0]}>`,
+        `${options.typeArguments[1]}`,
+        "address",
+    ];
+    const parameterNames = ["self", "_", "user"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "identity",
+        function: "identifier_by_address_with_whitelist",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+export function identifierInfoWithWhitelist(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_identity";
+    const argumentsTypes = [
+        `${packageAddress}::identity::IdentityManager<${options.typeArguments[0]}>`,
+        `${options.typeArguments[1]}`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String",
+    ];
+    const parameterNames = ["self", "_", "identifier"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "identity",
+        function: "identifier_info_with_whitelist",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}