@mysten/kiosk 0.14.6 → 1.0.0

package/src/client/tp-transaction.ts

@@ -3,19 +3,12 @@
 
 import type { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions';
 
-import {
-	attachFloorPriceRuleTx,
-	attachKioskLockRuleTx,
-	attachPersonalKioskRuleTx,
-	attachRoyaltyRuleTx,
-} from '../tx/rules/attach.js';
-import {
-	createTransferPolicy,
-	createTransferPolicyWithoutSharing,
-	removeTransferPolicyRule,
-	shareTransferPolicy,
-	withdrawFromPolicy,
-} from '../tx/transfer-policy.js';
+import * as royaltyRule from '../contracts/kiosk/royalty_rule.js';
+import * as kioskLockRule from '../contracts/kiosk/kiosk_lock_rule.js';
+import * as personalKioskRule from '../contracts/kiosk/personal_kiosk_rule.js';
+import * as floorPriceRule from '../contracts/kiosk/floor_price_rule.js';
+import * as transferPolicyContract from '../contracts/0x2/transfer_policy.js';
+import { createTransferPolicy, withdrawFromPolicy } from '../tx/transfer-policy.js';
 import type { ObjectArgument, TransferPolicyCap } from '../types/index.js';
 import type { KioskClient } from './kiosk-client.js';
 
@@ -28,8 +21,6 @@ export type TransferPolicyBaseParams = {
 export type TransferPolicyTransactionParams = {
 	kioskClient: KioskClient;
 	transaction: Transaction;
-	/** @deprecated use transaction instead */
-	transactionBlock?: Transaction;
 	cap?: TransferPolicyCap;
 };
 
@@ -40,12 +31,7 @@ export class TransferPolicyTransaction {
 	policyCap?: ObjectArgument;
 	type?: string;
 
-	constructor({
-		kioskClient,
-		transactionBlock,
-		transaction = transactionBlock!,
-		cap,
-	}: TransferPolicyTransactionParams) {
+	constructor({ kioskClient, transaction, cap }: TransferPolicyTransactionParams) {
 		this.kioskClient = kioskClient;
 		this.transaction = transaction;
 		if (cap) this.setCap(cap);
@@ -76,7 +62,7 @@ export class TransferPolicyTransaction {
 			if (policies.length > 0) throw new Error("There's already transfer policy for this Type.");
 		}
 		const cap = createTransferPolicy(this.transaction, type, publisher);
-		this.transaction.transferObjects([cap], this.transaction.pure.address(address));
+		this.transaction.transferObjects([cap], address);
 	}
 
 	/**
@@ -96,10 +82,13 @@ export class TransferPolicyTransaction {
 			const policies = await this.kioskClient.getTransferPolicies({ type });
 			if (policies.length > 0) throw new Error("There's already transfer policy for this Type.");
 		}
-		const [policy, policyCap] = createTransferPolicyWithoutSharing(
-			this.transaction,
-			type,
-			publisher,
+		const publisherArg =
+			typeof publisher === 'string' ? this.transaction.object(publisher) : publisher;
+		const [policy, policyCap] = this.transaction.add(
+			transferPolicyContract._new({
+				arguments: [publisherArg],
+				typeArguments: [type],
+			}),
 		);
 
 		this.#setup(policy, policyCap, type); // sets the client's TP to the newly created one.
@@ -116,10 +105,20 @@ export class TransferPolicyTransaction {
 		if (!this.type || !this.policyCap || !this.policy)
 			throw new Error('This function can only be called after `transferPolicyManager.create`');
 
-		shareTransferPolicy(this.transaction, this.type, this.policy as TransactionObjectArgument);
+		this.transaction.moveCall({
+			target: '0x2::transfer::public_share_object',
+			arguments: [
+				typeof this.policy === 'string' ? this.transaction.object(this.policy) : this.policy,
+			],
+			typeArguments: [`0x2::transfer_policy::TransferPolicy<${this.type}>`],
+		});
 		this.transaction.transferObjects(
-			[this.policyCap as TransactionObjectArgument],
-			this.transaction.pure.address(address),
+			[
+				typeof this.policyCap === 'string'
+					? this.transaction.object(this.policyCap)
+					: this.policyCap,
+			],
+			address,
 		);
 	}
 
@@ -148,7 +147,7 @@ export class TransferPolicyTransaction {
 			amount,
 		);
 
-		this.transaction.transferObjects([coin], this.transaction.pure.address(address));
+		this.transaction.transferObjects([coin], address);
 
 		return this;
 	}
@@ -169,17 +168,28 @@ export class TransferPolicyTransaction {
 	) {
 		this.#validateInputs();
 
-		// Hard-coding package Ids as these don't change.
-		// Also, it's hard to keep versioning as with network wipes, mainnet
-		// and testnet will conflict.
-		attachRoyaltyRuleTx(
-			this.transaction,
-			this.type!,
-			this.policy!,
-			this.policyCap!,
-			percentageBps,
-			minAmount,
-			this.kioskClient.getRulePackageId('royaltyRulePackageId'),
+		const policyArg =
+			typeof this.policy === 'string'
+				? this.transaction.object(this.policy)
+				: (this.policy as TransactionObjectArgument);
+		const policyCapArg =
+			typeof this.policyCap === 'string'
+				? this.transaction.object(this.policyCap)
+				: (this.policyCap as TransactionObjectArgument);
+
+		const packageId = this.kioskClient.getRulePackageId('royaltyRulePackageId');
+
+		this.transaction.add(
+			royaltyRule.add({
+				package: packageId,
+				arguments: {
+					policy: policyArg,
+					cap: policyCapArg,
+					amountBp: Number(percentageBps),
+					minAmount: typeof minAmount === 'string' ? BigInt(minAmount) : BigInt(minAmount),
+				},
+				typeArguments: [this.type!],
+			}),
 		);
 		return this;
 	}
@@ -191,12 +201,26 @@ export class TransferPolicyTransaction {
 	addLockRule() {
 		this.#validateInputs();
 
-		attachKioskLockRuleTx(
-			this.transaction,
-			this.type!,
-			this.policy!,
-			this.policyCap!,
-			this.kioskClient.getRulePackageId('kioskLockRulePackageId'),
+		const policyArg =
+			typeof this.policy === 'string'
+				? this.transaction.object(this.policy)
+				: (this.policy as TransactionObjectArgument);
+		const policyCapArg =
+			typeof this.policyCap === 'string'
+				? this.transaction.object(this.policyCap)
+				: (this.policyCap as TransactionObjectArgument);
+
+		const packageId = this.kioskClient.getRulePackageId('kioskLockRulePackageId');
+
+		this.transaction.add(
+			kioskLockRule.add({
+				package: packageId,
+				arguments: {
+					policy: policyArg,
+					cap: policyCapArg,
+				},
+				typeArguments: [this.type!],
+			}),
 		);
 		return this;
 	}
@@ -207,12 +231,26 @@ export class TransferPolicyTransaction {
 	addPersonalKioskRule() {
 		this.#validateInputs();
 
-		attachPersonalKioskRuleTx(
-			this.transaction,
-			this.type!,
-			this.policy!,
-			this.policyCap!,
-			this.kioskClient.getRulePackageId('personalKioskRulePackageId'),
+		const policyArg =
+			typeof this.policy === 'string'
+				? this.transaction.object(this.policy)
+				: (this.policy as TransactionObjectArgument);
+		const policyCapArg =
+			typeof this.policyCap === 'string'
+				? this.transaction.object(this.policyCap)
+				: (this.policyCap as TransactionObjectArgument);
+
+		const packageId = this.kioskClient.getRulePackageId('personalKioskRulePackageId');
+
+		this.transaction.add(
+			personalKioskRule.add({
+				package: packageId,
+				arguments: {
+					policy: policyArg,
+					cap: policyCapArg,
+				},
+				typeArguments: [this.type!],
+			}),
 		);
 		return this;
 	}
@@ -224,13 +262,27 @@ export class TransferPolicyTransaction {
 	addFloorPriceRule(minPrice: string | bigint) {
 		this.#validateInputs();
 
-		attachFloorPriceRuleTx(
-			this.transaction,
-			this.type!,
-			this.policy!,
-			this.policyCap!,
-			minPrice,
-			this.kioskClient.getRulePackageId('floorPriceRulePackageId'),
+		const policyArg =
+			typeof this.policy === 'string'
+				? this.transaction.object(this.policy)
+				: (this.policy as TransactionObjectArgument);
+		const policyCapArg =
+			typeof this.policyCap === 'string'
+				? this.transaction.object(this.policyCap)
+				: (this.policyCap as TransactionObjectArgument);
+
+		const packageId = this.kioskClient.getRulePackageId('floorPriceRulePackageId');
+
+		this.transaction.add(
+			floorPriceRule.add({
+				package: packageId,
+				arguments: {
+					policy: policyArg,
+					cap: policyCapArg,
+					floorPrice: typeof minPrice === 'string' ? BigInt(minPrice) : minPrice,
+				},
+				typeArguments: [this.type!],
+			}),
 		);
 		return this;
 	}
@@ -243,13 +295,11 @@ export class TransferPolicyTransaction {
 	removeRule({ ruleType, configType }: { ruleType: string; configType: string }) {
 		this.#validateInputs();
 
-		removeTransferPolicyRule(
-			this.transaction,
-			this.type!,
-			ruleType,
-			configType,
-			this.policy!,
-			this.policyCap!,
+		this.transaction.add(
+			transferPolicyContract.removeRule({
+				arguments: [this.policy!, this.policyCap!],
+				typeArguments: [this.type!, ruleType, configType],
+			}),
 		);
 	}
 
@@ -261,13 +311,15 @@ export class TransferPolicyTransaction {
 
 		const packageId = this.kioskClient.getRulePackageId('kioskLockRulePackageId');
 
-		removeTransferPolicyRule(
-			this.transaction,
-			this.type!,
-			`${packageId}::kiosk_lock_rule::Rule`,
-			`${packageId}::kiosk_lock_rule::Config`,
-			this.policy!,
-			this.policyCap!,
+		this.transaction.add(
+			transferPolicyContract.removeRule({
+				arguments: [this.policy!, this.policyCap!],
+				typeArguments: [
+					this.type!,
+					`${packageId}::kiosk_lock_rule::Rule`,
+					`${packageId}::kiosk_lock_rule::Config`,
+				],
+			}),
 		);
 		return this;
 	}
@@ -280,13 +332,15 @@ export class TransferPolicyTransaction {
 
 		const packageId = this.kioskClient.getRulePackageId('royaltyRulePackageId');
 
-		removeTransferPolicyRule(
-			this.transaction,
-			this.type!,
-			`${packageId}::royalty_rule::Rule`,
-			`${packageId}::royalty_rule::Config`,
-			this.policy!,
-			this.policyCap!,
+		this.transaction.add(
+			transferPolicyContract.removeRule({
+				arguments: [this.policy!, this.policyCap!],
+				typeArguments: [
+					this.type!,
+					`${packageId}::royalty_rule::Rule`,
+					`${packageId}::royalty_rule::Config`,
+				],
+			}),
 		);
 		return this;
 	}
@@ -296,13 +350,11 @@ export class TransferPolicyTransaction {
 
 		const packageId = this.kioskClient.getRulePackageId('personalKioskRulePackageId');
 
-		removeTransferPolicyRule(
-			this.transaction,
-			this.type!,
-			`${packageId}::personal_kiosk_rule::Rule`,
-			`bool`,
-			this.policy!,
-			this.policyCap!,
+		this.transaction.add(
+			transferPolicyContract.removeRule({
+				arguments: [this.policy!, this.policyCap!],
+				typeArguments: [this.type!, `${packageId}::personal_kiosk_rule::Rule`, `bool`],
+			}),
 		);
 		return this;
 	}
@@ -312,13 +364,15 @@ export class TransferPolicyTransaction {
 
 		const packageId = this.kioskClient.getRulePackageId('floorPriceRulePackageId');
 
-		removeTransferPolicyRule(
-			this.transaction,
-			this.type!,
-			`${packageId}::floor_price_rule::Rule`,
-			`${packageId}::floor_price_rule::Config`,
-			this.policy!,
-			this.policyCap!,
+		this.transaction.add(
+			transferPolicyContract.removeRule({
+				arguments: [this.policy!, this.policyCap!],
+				typeArguments: [
+					this.type!,
+					`${packageId}::floor_price_rule::Rule`,
+					`${packageId}::floor_price_rule::Config`,
+				],
+			}),
 		);
 		return this;
 	}

package/src/constants.ts

@@ -1,14 +1,13 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-// eslint-disable-next-line import/no-cycle
+import { SuiClientTypes } from '@mysten/sui/client';
 import {
 	resolveFloorPriceRule,
 	resolveKioskLockRule,
 	resolvePersonalKioskRule,
 	resolveRoyaltyRule,
 } from './tx/rules/resolve.js';
-import { Network } from './types/index.js';
 import type { ObjectArgument, RuleResolvingParams } from './types/index.js';
 
 /**
@@ -33,28 +32,24 @@ export type TransferPolicyRule = {
 	hasLockingRule?: boolean;
 };
 
-export const ROYALTY_RULE_ADDRESS: Record<Network, string> = {
-	[Network.TESTNET]: 'bd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585',
-	[Network.MAINNET]: '0x434b5bd8f6a7b05fede0ff46c6e511d71ea326ed38056e3bcd681d2d7c2a7879',
-	[Network.CUSTOM]: '',
+export const ROYALTY_RULE_ADDRESS: Partial<Record<SuiClientTypes.Network, string>> = {
+	['testnet']: 'bd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585',
+	['mainnet']: '0x434b5bd8f6a7b05fede0ff46c6e511d71ea326ed38056e3bcd681d2d7c2a7879',
 };
 
-export const KIOSK_LOCK_RULE_ADDRESS: Record<Network, string> = {
-	[Network.TESTNET]: 'bd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585',
-	[Network.MAINNET]: '0x434b5bd8f6a7b05fede0ff46c6e511d71ea326ed38056e3bcd681d2d7c2a7879',
-	[Network.CUSTOM]: '',
+export const KIOSK_LOCK_RULE_ADDRESS: Partial<Record<SuiClientTypes.Network, string>> = {
+	['testnet']: 'bd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585',
+	['mainnet']: '0x434b5bd8f6a7b05fede0ff46c6e511d71ea326ed38056e3bcd681d2d7c2a7879',
 };
 
-export const FLOOR_PRICE_RULE_ADDRESS: Record<Network, string> = {
-	[Network.TESTNET]: '0x06f6bdd3f2e2e759d8a4b9c252f379f7a05e72dfe4c0b9311cdac27b8eb791b1',
-	[Network.MAINNET]: '0x34cc6762780f4f6f153c924c0680cfe2a1fb4601e7d33cc28a92297b62de1e0e',
-	[Network.CUSTOM]: '',
+export const FLOOR_PRICE_RULE_ADDRESS: Partial<Record<SuiClientTypes.Network, string>> = {
+	['testnet']: '0x06f6bdd3f2e2e759d8a4b9c252f379f7a05e72dfe4c0b9311cdac27b8eb791b1',
+	['mainnet']: '0x34cc6762780f4f6f153c924c0680cfe2a1fb4601e7d33cc28a92297b62de1e0e',
 };
 
-export const PERSONAL_KIOSK_RULE_ADDRESS: Record<Network, string> = {
-	[Network.TESTNET]: '0x06f6bdd3f2e2e759d8a4b9c252f379f7a05e72dfe4c0b9311cdac27b8eb791b1',
-	[Network.MAINNET]: '0x0cb4bcc0560340eb1a1b929cabe56b33fc6449820ec8c1980d69bb98b649b802',
-	[Network.CUSTOM]: '',
+export const PERSONAL_KIOSK_RULE_ADDRESS: Partial<Record<SuiClientTypes.Network, string>> = {
+	['testnet']: '0x06f6bdd3f2e2e759d8a4b9c252f379f7a05e72dfe4c0b9311cdac27b8eb791b1',
+	['mainnet']: '0x0cb4bcc0560340eb1a1b929cabe56b33fc6449820ec8c1980d69bb98b649b802',
 };
 
 /**
@@ -106,16 +101,16 @@ export function getBaseRules({
 
 // A list of testnet's base rules.
 export const testnetRules: TransferPolicyRule[] = getBaseRules({
-	royaltyRulePackageId: ROYALTY_RULE_ADDRESS[Network.TESTNET],
-	kioskLockRulePackageId: KIOSK_LOCK_RULE_ADDRESS[Network.TESTNET],
-	personalKioskRulePackageId: PERSONAL_KIOSK_RULE_ADDRESS[Network.TESTNET],
-	floorPriceRulePackageId: FLOOR_PRICE_RULE_ADDRESS[Network.TESTNET],
+	royaltyRulePackageId: ROYALTY_RULE_ADDRESS['testnet'],
+	kioskLockRulePackageId: KIOSK_LOCK_RULE_ADDRESS['testnet'],
+	personalKioskRulePackageId: PERSONAL_KIOSK_RULE_ADDRESS['testnet'],
+	floorPriceRulePackageId: FLOOR_PRICE_RULE_ADDRESS['testnet'],
 });
 
 // A list of mainnet's base rules.
 export const mainnetRules: TransferPolicyRule[] = getBaseRules({
-	royaltyRulePackageId: ROYALTY_RULE_ADDRESS[Network.MAINNET],
-	kioskLockRulePackageId: KIOSK_LOCK_RULE_ADDRESS[Network.MAINNET],
+	royaltyRulePackageId: ROYALTY_RULE_ADDRESS['mainnet'],
+	kioskLockRulePackageId: KIOSK_LOCK_RULE_ADDRESS['mainnet'],
 });
 
 export const rules: TransferPolicyRule[] = [...testnetRules, ...mainnetRules];

package/src/contracts/0x2/accumulator.ts

@@ -0,0 +1,24 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = '0x2::accumulator';
+export const AccumulatorRoot = new MoveStruct({
+	name: `${$moduleName}::AccumulatorRoot`,
+	fields: {
+		id: bcs.Address,
+	},
+});
+export const U128 = new MoveStruct({
+	name: `${$moduleName}::U128`,
+	fields: {
+		value: bcs.u128(),
+	},
+});
+export const Key = new MoveStruct({
+	name: `${$moduleName}::Key`,
+	fields: {
+		address: bcs.Address,
+	},
+});

package/src/contracts/0x2/accumulator_metadata.ts

@@ -0,0 +1,38 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import * as bag from './bag.js';
+const $moduleName = '0x2::accumulator_metadata';
+export const OwnerKey = new MoveStruct({
+	name: `${$moduleName}::OwnerKey`,
+	fields: {
+		owner: bcs.Address,
+	},
+});
+export const Owner = new MoveStruct({
+	name: `${$moduleName}::Owner`,
+	fields: {
+		balances: bag.Bag,
+		owner: bcs.Address,
+	},
+});
+export const MetadataKey = new MoveStruct({
+	name: `${$moduleName}::MetadataKey`,
+	fields: {
+		dummy_field: bcs.bool(),
+	},
+});
+export const Metadata = new MoveStruct({
+	name: `${$moduleName}::Metadata`,
+	fields: {
+		fields: bag.Bag,
+	},
+});
+export const AccumulatorObjectCountKey = new MoveStruct({
+	name: `${$moduleName}::AccumulatorObjectCountKey`,
+	fields: {
+		dummy_field: bcs.bool(),
+	},
+});

package/src/contracts/0x2/accumulator_settlement.ts

@@ -0,0 +1,14 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = '0x2::accumulator_settlement';
+export const EventStreamHead = new MoveStruct({
+	name: `${$moduleName}::EventStreamHead`,
+	fields: {
+		mmr: bcs.vector(bcs.u256()),
+		checkpoint_seq: bcs.u64(),
+		num_events: bcs.u64(),
+	},
+});

package/src/contracts/0x2/address.ts

@@ -0,0 +1,145 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type Transaction } from '@mysten/sui/transactions';
+import { normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+export interface ToU256Options {
+	package?: string;
+	arguments: [RawTransactionArgument<string>];
+}
+export function toU256(options: ToU256Options) {
+	const packageAddress =
+		options.package ?? '0x0000000000000000000000000000000000000000000000000000000000000002';
+	const argumentsTypes = ['address'] satisfies (string | null)[];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'address',
+			function: 'to_u256',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes),
+		});
+}
+export interface FromU256Options {
+	package?: string;
+	arguments: [RawTransactionArgument<number | bigint>];
+}
+export function fromU256(options: FromU256Options) {
+	const packageAddress =
+		options.package ?? '0x0000000000000000000000000000000000000000000000000000000000000002';
+	const argumentsTypes = ['u256'] satisfies (string | null)[];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'address',
+			function: 'from_u256',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes),
+		});
+}
+export interface FromBytesOptions {
+	package?: string;
+	arguments: [RawTransactionArgument<number[]>];
+}
+export function fromBytes(options: FromBytesOptions) {
+	const packageAddress =
+		options.package ?? '0x0000000000000000000000000000000000000000000000000000000000000002';
+	const argumentsTypes = ['vector<u8>'] satisfies (string | null)[];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'address',
+			function: 'from_bytes',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes),
+		});
+}
+export interface ToBytesOptions {
+	package?: string;
+	arguments: [RawTransactionArgument<string>];
+}
+export function toBytes(options: ToBytesOptions) {
+	const packageAddress =
+		options.package ?? '0x0000000000000000000000000000000000000000000000000000000000000002';
+	const argumentsTypes = ['address'] satisfies (string | null)[];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'address',
+			function: 'to_bytes',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes),
+		});
+}
+export interface ToAsciiStringOptions {
+	package?: string;
+	arguments: [RawTransactionArgument<string>];
+}
+export function toAsciiString(options: ToAsciiStringOptions) {
+	const packageAddress =
+		options.package ?? '0x0000000000000000000000000000000000000000000000000000000000000002';
+	const argumentsTypes = ['address'] satisfies (string | null)[];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'address',
+			function: 'to_ascii_string',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes),
+		});
+}
+export interface ToStringOptions {
+	package?: string;
+	arguments: [RawTransactionArgument<string>];
+}
+export function toString(options: ToStringOptions) {
+	const packageAddress =
+		options.package ?? '0x0000000000000000000000000000000000000000000000000000000000000002';
+	const argumentsTypes = ['address'] satisfies (string | null)[];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'address',
+			function: 'to_string',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes),
+		});
+}
+export interface FromAsciiBytesOptions {
+	package?: string;
+	arguments: [RawTransactionArgument<number[]>];
+}
+export function fromAsciiBytes(options: FromAsciiBytesOptions) {
+	const packageAddress =
+		options.package ?? '0x0000000000000000000000000000000000000000000000000000000000000002';
+	const argumentsTypes = ['vector<u8>'] satisfies (string | null)[];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'address',
+			function: 'from_ascii_bytes',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes),
+		});
+}
+export interface LengthOptions {
+	package?: string;
+	arguments?: [];
+}
+export function length(options: LengthOptions = {}) {
+	const packageAddress =
+		options.package ?? '0x0000000000000000000000000000000000000000000000000000000000000002';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'address',
+			function: 'length',
+		});
+}
+export interface MaxOptions {
+	package?: string;
+	arguments?: [];
+}
+export function max(options: MaxOptions = {}) {
+	const packageAddress =
+		options.package ?? '0x0000000000000000000000000000000000000000000000000000000000000002';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'address',
+			function: 'max',
+		});
+}