@mysten/pas 0.0.1

package/src/contracts/pas/namespace.ts

@@ -0,0 +1,207 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * The Namespace module.
+ *
+ * Namespace is responsible for creating objects that are easy to query & find:
+ *
+ * 1.  Accounts
+ * 2.  Policies ... any other module we might add in the future
+ */
+
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction } from '@mysten/sui/transactions';
+import * as versioning from './versioning.js';
+const $moduleName = '@mysten/pas::namespace';
+export const Namespace = new MoveStruct({
+	name: `${$moduleName}::Namespace`,
+	fields: {
+		id: bcs.Address,
+		/**
+		 * The UpgradeCap of the package, used as the "ownership" capability, mainly to
+		 * block versions of the package in case of emergency.
+		 */
+		upgrade_cap_id: bcs.option(bcs.Address),
+		/** Enables "blocking" versions of the package */
+		versioning: versioning.Versioning,
+	},
+});
+export interface SetupArguments {
+	namespace: RawTransactionArgument<string>;
+	cap: RawTransactionArgument<string>;
+}
+export interface SetupOptions {
+	package?: string;
+	arguments:
+		| SetupArguments
+		| [namespace: RawTransactionArgument<string>, cap: RawTransactionArgument<string>];
+}
+/**
+ * Setup the namespace (links the `UpgradeCap`) once after publishing. This makes
+ * the UpgradeCap the "admin" capability (which can set the blocked versions of a
+ * package).
+ */
+export function setup(options: SetupOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['namespace', 'cap'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'namespace',
+			function: 'setup',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface BlockVersionArguments {
+	namespace: RawTransactionArgument<string>;
+	cap: RawTransactionArgument<string>;
+	version: RawTransactionArgument<number | bigint>;
+}
+export interface BlockVersionOptions {
+	package?: string;
+	arguments:
+		| BlockVersionArguments
+		| [
+				namespace: RawTransactionArgument<string>,
+				cap: RawTransactionArgument<string>,
+				version: RawTransactionArgument<number | bigint>,
+		  ];
+}
+/**
+ * Allows the package admin to block a version of the package.
+ *
+ * This is only used in case of emergency (e.g. security consideration), or if
+ * there is a breaking change
+ */
+export function blockVersion(options: BlockVersionOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null, null, 'u64'] satisfies (string | null)[];
+	const parameterNames = ['namespace', 'cap', 'version'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'namespace',
+			function: 'block_version',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface UnblockVersionArguments {
+	namespace: RawTransactionArgument<string>;
+	cap: RawTransactionArgument<string>;
+	version: RawTransactionArgument<number | bigint>;
+}
+export interface UnblockVersionOptions {
+	package?: string;
+	arguments:
+		| UnblockVersionArguments
+		| [
+				namespace: RawTransactionArgument<string>,
+				cap: RawTransactionArgument<string>,
+				version: RawTransactionArgument<number | bigint>,
+		  ];
+}
+/** Allows the package admin to unblock a version of the package. */
+export function unblockVersion(options: UnblockVersionOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null, null, 'u64'] satisfies (string | null)[];
+	const parameterNames = ['namespace', 'cap', 'version'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'namespace',
+			function: 'unblock_version',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface PolicyExistsArguments {
+	namespace: RawTransactionArgument<string>;
+}
+export interface PolicyExistsOptions {
+	package?: string;
+	arguments: PolicyExistsArguments | [namespace: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/** Check if `Policy<T>` exists in the namespace */
+export function policyExists(options: PolicyExistsOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['namespace'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'namespace',
+			function: 'policy_exists',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface PolicyAddressArguments {
+	namespace: RawTransactionArgument<string>;
+}
+export interface PolicyAddressOptions {
+	package?: string;
+	arguments: PolicyAddressArguments | [namespace: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/** The derived address for `Policy<T>` */
+export function policyAddress(options: PolicyAddressOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['namespace'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'namespace',
+			function: 'policy_address',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface AccountExistsArguments {
+	namespace: RawTransactionArgument<string>;
+	owner: RawTransactionArgument<string>;
+}
+export interface AccountExistsOptions {
+	package?: string;
+	arguments:
+		| AccountExistsArguments
+		| [namespace: RawTransactionArgument<string>, owner: RawTransactionArgument<string>];
+}
+export function accountExists(options: AccountExistsOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null, 'address'] satisfies (string | null)[];
+	const parameterNames = ['namespace', 'owner'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'namespace',
+			function: 'account_exists',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface AccountAddressArguments {
+	namespace: RawTransactionArgument<string>;
+	owner: RawTransactionArgument<string>;
+}
+export interface AccountAddressOptions {
+	package?: string;
+	arguments:
+		| AccountAddressArguments
+		| [namespace: RawTransactionArgument<string>, owner: RawTransactionArgument<string>];
+}
+export function accountAddress(options: AccountAddressOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null, 'address'] satisfies (string | null)[];
+	const parameterNames = ['namespace', 'owner'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'namespace',
+			function: 'account_address',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}

package/src/contracts/pas/policy.ts

@@ -0,0 +1,212 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import {
+	MoveStruct,
+	MoveTuple,
+	normalizeMoveArguments,
+	type RawTransactionArgument,
+} from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction } from '@mysten/sui/transactions';
+import * as vec_map from './deps/sui/vec_map.js';
+import * as vec_set from './deps/sui/vec_set.js';
+import * as type_name from './deps/std/type_name.js';
+import * as versioning from './versioning.js';
+const $moduleName = '@mysten/pas::policy';
+export const Policy = new MoveStruct({
+	name: `${$moduleName}::Policy<phantom T>`,
+	fields: {
+		id: bcs.Address,
+		/**
+		 * The required approvals per request type. The key must be one of the request
+		 * types (e.g. `send_funds`, `unlock_funds` or `clawback_funds`).
+		 *
+		 * The value is a vector of approvals that need to be gather to resolve the
+		 * request.
+		 */
+		required_approvals: vec_map.VecMap(bcs.string(), vec_set.VecSet(type_name.TypeName)),
+		/**
+		 * Block versions to break backwards compatibility -- only used in case of
+		 * emergency.
+		 */
+		versioning: versioning.Versioning,
+		/** Whether clawback is allowed for this policy. */
+		clawback_allowed: bcs.bool(),
+	},
+});
+export const PolicyCap = new MoveStruct({
+	name: `${$moduleName}::PolicyCap<phantom T>`,
+	fields: {
+		id: bcs.Address,
+	},
+});
+export const PolicyCapKey = new MoveTuple({
+	name: `${$moduleName}::PolicyCapKey`,
+	fields: [bcs.bool()],
+});
+export interface NewForCurrencyArguments {
+	namespace: RawTransactionArgument<string>;
+	Cap: RawTransactionArgument<string>;
+	clawbackAllowed: RawTransactionArgument<boolean>;
+}
+export interface NewForCurrencyOptions {
+	package?: string;
+	arguments:
+		| NewForCurrencyArguments
+		| [
+				namespace: RawTransactionArgument<string>,
+				Cap: RawTransactionArgument<string>,
+				clawbackAllowed: RawTransactionArgument<boolean>,
+		  ];
+	typeArguments: [string];
+}
+export function newForCurrency(options: NewForCurrencyOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null, null, 'bool'] satisfies (string | null)[];
+	const parameterNames = ['namespace', 'Cap', 'clawbackAllowed'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'policy',
+			function: 'new_for_currency',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface ShareArguments {
+	policy: RawTransactionArgument<string>;
+}
+export interface ShareOptions {
+	package?: string;
+	arguments: ShareArguments | [policy: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+export function share(options: ShareOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['policy'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'policy',
+			function: 'share',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface RequiredApprovalsArguments {
+	policy: RawTransactionArgument<string>;
+	actionType: RawTransactionArgument<string>;
+}
+export interface RequiredApprovalsOptions {
+	package?: string;
+	arguments:
+		| RequiredApprovalsArguments
+		| [policy: RawTransactionArgument<string>, actionType: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/** Get the set of required approvals for a given action. */
+export function requiredApprovals(options: RequiredApprovalsOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null, '0x1::string::String'] satisfies (string | null)[];
+	const parameterNames = ['policy', 'actionType'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'policy',
+			function: 'required_approvals',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface SetRequiredApprovalArguments {
+	policy: RawTransactionArgument<string>;
+	cap: RawTransactionArgument<string>;
+	action: RawTransactionArgument<string>;
+}
+export interface SetRequiredApprovalOptions {
+	package?: string;
+	arguments:
+		| SetRequiredApprovalArguments
+		| [
+				policy: RawTransactionArgument<string>,
+				cap: RawTransactionArgument<string>,
+				action: RawTransactionArgument<string>,
+		  ];
+	typeArguments: [string, string];
+}
+export function setRequiredApproval(options: SetRequiredApprovalOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null, null, '0x1::string::String'] satisfies (string | null)[];
+	const parameterNames = ['policy', 'cap', 'action'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'policy',
+			function: 'set_required_approval',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface RemoveActionApprovalArguments {
+	policy: RawTransactionArgument<string>;
+	_: RawTransactionArgument<string>;
+	action: RawTransactionArgument<string>;
+}
+export interface RemoveActionApprovalOptions {
+	package?: string;
+	arguments:
+		| RemoveActionApprovalArguments
+		| [
+				policy: RawTransactionArgument<string>,
+				_: RawTransactionArgument<string>,
+				action: RawTransactionArgument<string>,
+		  ];
+	typeArguments: [string];
+}
+/**
+ * Remove the action approval for a given action (this will make all requests not
+ * resolve).
+ */
+export function removeActionApproval(options: RemoveActionApprovalOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null, null, '0x1::string::String'] satisfies (string | null)[];
+	const parameterNames = ['policy', '_', 'action'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'policy',
+			function: 'remove_action_approval',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface SyncVersioningArguments {
+	policy: RawTransactionArgument<string>;
+	namespace: RawTransactionArgument<string>;
+}
+export interface SyncVersioningOptions {
+	package?: string;
+	arguments:
+		| SyncVersioningArguments
+		| [policy: RawTransactionArgument<string>, namespace: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/**
+ * Allows syncing the versioning of a policy to the namespace's versioning. This is
+ * permission-less and can be done by anyone.
+ */
+export function syncVersioning(options: SyncVersioningOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['policy', 'namespace'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'policy',
+			function: 'sync_versioning',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}

package/src/contracts/pas/request.ts

@@ -0,0 +1,87 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType } from '@mysten/sui/bcs';
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { type Transaction } from '@mysten/sui/transactions';
+import * as vec_set from './deps/sui/vec_set.js';
+import * as type_name from './deps/std/type_name.js';
+const $moduleName = '@mysten/pas::request';
+/** A base request type. Examples: `Request<SendFunds<T>>` `Request<UnlockFunds<T>>` */
+export function Request<K extends BcsType<any>>(...typeParameters: [K]) {
+	return new MoveStruct({
+		name: `${$moduleName}::Request<${typeParameters[0].name as K['name']}>`,
+		fields: {
+			/** The collected approvals for this request */
+			approvals: vec_set.VecSet(type_name.TypeName),
+			data: typeParameters[0],
+		},
+	});
+}
+export interface ApproveArguments<U extends BcsType<any>> {
+	request: RawTransactionArgument<string>;
+	Approval: RawTransactionArgument<U>;
+}
+export interface ApproveOptions<U extends BcsType<any>> {
+	package?: string;
+	arguments:
+		| ApproveArguments<U>
+		| [request: RawTransactionArgument<string>, Approval: RawTransactionArgument<U>];
+	typeArguments: [string, string];
+}
+/** Adds an approval to a request. Can be called to resolve rules */
+export function approve<U extends BcsType<any>>(options: ApproveOptions<U>) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null, `${options.typeArguments[1]}`] satisfies (string | null)[];
+	const parameterNames = ['request', 'Approval'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'request',
+			function: 'approve',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface DataArguments {
+	request: RawTransactionArgument<string>;
+}
+export interface DataOptions {
+	package?: string;
+	arguments: DataArguments | [request: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+export function data(options: DataOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['request'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'request',
+			function: 'data',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface ApprovalsArguments {
+	request: RawTransactionArgument<string>;
+}
+export interface ApprovalsOptions {
+	package?: string;
+	arguments: ApprovalsArguments | [request: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+export function approvals(options: ApprovalsOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['request'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'request',
+			function: 'approvals',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}

package/src/contracts/pas/send_funds.ts

@@ -0,0 +1,174 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { type Transaction } from '@mysten/sui/transactions';
+const $moduleName = '@mysten/pas::send_funds';
+/**
+ * A transfer request that is generated once a send funds request is initialized.
+ *
+ * A hot potato that is issued when a transfer is initiated. It can only be
+ * resolved by presenting a witness `U` that is the witness of `Policy<T>`
+ *
+ * This enables the `resolve` function of each smart contract to be flexible and
+ * implement its own mechanisms for validation. The individual resolution module
+ * can:
+ *
+ * - Check whitelists/blacklists
+ * - Enforce holding periods
+ * - Collect fees
+ * - Emit regulatory events
+ * - Handle dividends/distributions
+ * - Implement any jurisdiction-specific rules
+ */
+export function SendFunds<T extends BcsType<any>>(...typeParameters: [T]) {
+	return new MoveStruct({
+		name: `${$moduleName}::SendFunds<${typeParameters[0].name as T['name']}>`,
+		fields: {
+			/** `sender` is the wallet OR object address, NOT the account address */
+			sender: bcs.Address,
+			/** `recipient` is the wallet OR object address, NOT the account address */
+			recipient: bcs.Address,
+			/** The ID of the account the funds are coming from */
+			sender_account_id: bcs.Address,
+			/** The ID of the account the funds are going to */
+			recipient_account_id: bcs.Address,
+			/** The balance being transferred */
+			funds: typeParameters[0],
+		},
+	});
+}
+export interface SenderArguments {
+	request: RawTransactionArgument<string>;
+}
+export interface SenderOptions {
+	package?: string;
+	arguments: SenderArguments | [request: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+export function sender(options: SenderOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['request'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'send_funds',
+			function: 'sender',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface RecipientArguments {
+	request: RawTransactionArgument<string>;
+}
+export interface RecipientOptions {
+	package?: string;
+	arguments: RecipientArguments | [request: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+export function recipient(options: RecipientOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['request'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'send_funds',
+			function: 'recipient',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface SenderAccountIdArguments {
+	request: RawTransactionArgument<string>;
+}
+export interface SenderAccountIdOptions {
+	package?: string;
+	arguments: SenderAccountIdArguments | [request: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+export function senderAccountId(options: SenderAccountIdOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['request'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'send_funds',
+			function: 'sender_account_id',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface RecipientAccountIdArguments {
+	request: RawTransactionArgument<string>;
+}
+export interface RecipientAccountIdOptions {
+	package?: string;
+	arguments: RecipientAccountIdArguments | [request: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+export function recipientAccountId(options: RecipientAccountIdOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['request'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'send_funds',
+			function: 'recipient_account_id',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface FundsArguments {
+	request: RawTransactionArgument<string>;
+}
+export interface FundsOptions {
+	package?: string;
+	arguments: FundsArguments | [request: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+export function funds(options: FundsOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['request'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'send_funds',
+			function: 'funds',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface ResolveBalanceArguments {
+	request: RawTransactionArgument<string>;
+	policy: RawTransactionArgument<string>;
+}
+export interface ResolveBalanceOptions {
+	package?: string;
+	arguments:
+		| ResolveBalanceArguments
+		| [request: RawTransactionArgument<string>, policy: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/**
+ * resolve a transfer request, if funds management is enabled & there are enough
+ * approvals.
+ */
+export function resolveBalance(options: ResolveBalanceOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['request', 'policy'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'send_funds',
+			function: 'resolve_balance',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}