@mysten/pas 0.0.1

package/src/contracts/pas/account.ts

@@ -0,0 +1,343 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/** Account logic */
+
+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 versioning from './versioning.js';
+const $moduleName = '@mysten/pas::account';
+export const Account = new MoveStruct({
+	name: `${$moduleName}::Account`,
+	fields: {
+		id: bcs.Address,
+		/** The owner of the account (address or object) */
+		owner: bcs.Address,
+		/**
+		 * The ID of the namespace that created this account. There's ONLY ONE namespace in
+		 * the system, but this helps us avoid having `&Namespace` inputs in all functions
+		 * that need to derive the IDs.
+		 */
+		namespace_id: bcs.Address,
+		/**
+		 * Block versions to break backwards compatibility -- only used in case of
+		 * emergency.
+		 */
+		versioning: versioning.Versioning,
+	},
+});
+export const Auth = new MoveTuple({ name: `${$moduleName}::Auth`, fields: [bcs.Address] });
+export interface CreateArguments {
+	namespace: RawTransactionArgument<string>;
+	owner: RawTransactionArgument<string>;
+}
+export interface CreateOptions {
+	package?: string;
+	arguments:
+		| CreateArguments
+		| [namespace: RawTransactionArgument<string>, owner: RawTransactionArgument<string>];
+}
+/** Create a new account for `owner`. This is a permission-less action. */
+export function create(options: CreateOptions) {
+	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: 'account',
+			function: 'create',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface ShareArguments {
+	account: RawTransactionArgument<string>;
+}
+export interface ShareOptions {
+	package?: string;
+	arguments: ShareArguments | [account: RawTransactionArgument<string>];
+}
+/**
+ * The only way to finalize the TX is by sharing the account. All accounts are
+ * shared by default.
+ */
+export function share(options: ShareOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['account'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account',
+			function: 'share',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface CreateAndShareArguments {
+	namespace: RawTransactionArgument<string>;
+	owner: RawTransactionArgument<string>;
+}
+export interface CreateAndShareOptions {
+	package?: string;
+	arguments:
+		| CreateAndShareArguments
+		| [namespace: RawTransactionArgument<string>, owner: RawTransactionArgument<string>];
+}
+/** Create and share a account in a single step. */
+export function createAndShare(options: CreateAndShareOptions) {
+	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: 'account',
+			function: 'create_and_share',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface UnlockBalanceArguments {
+	account: RawTransactionArgument<string>;
+	auth: RawTransactionArgument<string>;
+	amount: RawTransactionArgument<number | bigint>;
+}
+export interface UnlockBalanceOptions {
+	package?: string;
+	arguments:
+		| UnlockBalanceArguments
+		| [
+				account: RawTransactionArgument<string>,
+				auth: RawTransactionArgument<string>,
+				amount: RawTransactionArgument<number | bigint>,
+		  ];
+	typeArguments: [string];
+}
+/**
+ * Enables a fund unlock flow. This is useful for assets that are not managed by a
+ * Policy within the system, or if there's a special case where an issuer allows
+ * balances to flow out of the system.
+ */
+export function unlockBalance(options: UnlockBalanceOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null, null, 'u64'] satisfies (string | null)[];
+	const parameterNames = ['account', 'auth', 'amount'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account',
+			function: 'unlock_balance',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface SendBalanceArguments {
+	from: RawTransactionArgument<string>;
+	auth: RawTransactionArgument<string>;
+	to: RawTransactionArgument<string>;
+	amount: RawTransactionArgument<number | bigint>;
+}
+export interface SendBalanceOptions {
+	package?: string;
+	arguments:
+		| SendBalanceArguments
+		| [
+				from: RawTransactionArgument<string>,
+				auth: RawTransactionArgument<string>,
+				to: RawTransactionArgument<string>,
+				amount: RawTransactionArgument<number | bigint>,
+		  ];
+	typeArguments: [string];
+}
+/** Initiate a transfer from account A to account B. */
+export function sendBalance(options: SendBalanceOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null, null, null, 'u64'] satisfies (string | null)[];
+	const parameterNames = ['from', 'auth', 'to', 'amount'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account',
+			function: 'send_balance',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface ClawbackBalanceArguments {
+	from: RawTransactionArgument<string>;
+	amount: RawTransactionArgument<number | bigint>;
+}
+export interface ClawbackBalanceOptions {
+	package?: string;
+	arguments:
+		| ClawbackBalanceArguments
+		| [from: RawTransactionArgument<string>, amount: RawTransactionArgument<number | bigint>];
+	typeArguments: [string];
+}
+/**
+ * Initiate a clawback request for an amount of funds. This takes no `Auth`, as
+ * it's an admin action.
+ *
+ * This can only ever finalize if clawback is enabled in the policy.
+ */
+export function clawbackBalance(options: ClawbackBalanceOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null, 'u64'] satisfies (string | null)[];
+	const parameterNames = ['from', 'amount'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account',
+			function: 'clawback_balance',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface UnsafeSendBalanceArguments {
+	from: RawTransactionArgument<string>;
+	auth: RawTransactionArgument<string>;
+	recipientAddress: RawTransactionArgument<string>;
+	amount: RawTransactionArgument<number | bigint>;
+}
+export interface UnsafeSendBalanceOptions {
+	package?: string;
+	arguments:
+		| UnsafeSendBalanceArguments
+		| [
+				from: RawTransactionArgument<string>,
+				auth: RawTransactionArgument<string>,
+				recipientAddress: RawTransactionArgument<string>,
+				amount: RawTransactionArgument<number | bigint>,
+		  ];
+	typeArguments: [string];
+}
+/**
+ * Transfer `amount` from account to an address. This unlocks transfers to a
+ * account before it has been created.
+ *
+ * It's marked as `unsafe_` as it's easy to accidentally pick the wrong recipient
+ * address.
+ */
+export function unsafeSendBalance(options: UnsafeSendBalanceOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null, null, 'address', 'u64'] satisfies (string | null)[];
+	const parameterNames = ['from', 'auth', 'recipientAddress', 'amount'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account',
+			function: 'unsafe_send_balance',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface NewAuthOptions {
+	package?: string;
+	arguments?: [];
+}
+/** Generate an ownership proof from the sender of the transaction. */
+export function newAuth(options: NewAuthOptions = {}) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account',
+			function: 'new_auth',
+		});
+}
+export interface NewAuthAsObjectArguments {
+	uid: RawTransactionArgument<string>;
+}
+export interface NewAuthAsObjectOptions {
+	package?: string;
+	arguments: NewAuthAsObjectArguments | [uid: RawTransactionArgument<string>];
+}
+/**
+ * Generate an ownership proof from a `UID` object, to allow objects to own
+ * accounts. `&mut UID` is intentional — it serves as proof of ownership over the
+ * object.
+ */
+export function newAuthAsObject(options: NewAuthAsObjectOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = ['0x2::object::ID'] satisfies (string | null)[];
+	const parameterNames = ['uid'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account',
+			function: 'new_auth_as_object',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface OwnerArguments {
+	account: RawTransactionArgument<string>;
+}
+export interface OwnerOptions {
+	package?: string;
+	arguments: OwnerArguments | [account: RawTransactionArgument<string>];
+}
+export function owner(options: OwnerOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['account'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account',
+			function: 'owner',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface DepositBalanceArguments {
+	account: RawTransactionArgument<string>;
+	balance: RawTransactionArgument<string>;
+}
+export interface DepositBalanceOptions {
+	package?: string;
+	arguments:
+		| DepositBalanceArguments
+		| [account: RawTransactionArgument<string>, balance: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+export function depositBalance(options: DepositBalanceOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['account', 'balance'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account',
+			function: 'deposit_balance',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface SyncVersioningArguments {
+	account: RawTransactionArgument<string>;
+	namespace: RawTransactionArgument<string>;
+}
+export interface SyncVersioningOptions {
+	package?: string;
+	arguments:
+		| SyncVersioningArguments
+		| [account: RawTransactionArgument<string>, namespace: RawTransactionArgument<string>];
+}
+/** Permission-less operation to bring versioning up-to-date with the namespace. */
+export function syncVersioning(options: SyncVersioningOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['account', 'namespace'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account',
+			function: 'sync_versioning',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}

package/src/contracts/pas/clawback_funds.ts

@@ -0,0 +1,114 @@
+/**************************************************************
+ * 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::clawback_funds';
+export function ClawbackFunds<T extends BcsType<any>>(...typeParameters: [T]) {
+	return new MoveStruct({
+		name: `${$moduleName}::ClawbackFunds<${typeParameters[0].name as T['name']}>`,
+		fields: {
+			/** `owner` is the wallet OR object address, NOT the account address */
+			owner: bcs.Address,
+			/** The ID of the account the funds are coming from */
+			account_id: bcs.Address,
+			/** The balance that is being clawed back. */
+			funds: typeParameters[0],
+		},
+	});
+}
+export interface OwnerArguments {
+	request: RawTransactionArgument<string>;
+}
+export interface OwnerOptions {
+	package?: string;
+	arguments: OwnerArguments | [request: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+export function owner(options: OwnerOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['request'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'clawback_funds',
+			function: 'owner',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface AccountIdArguments {
+	request: RawTransactionArgument<string>;
+}
+export interface AccountIdOptions {
+	package?: string;
+	arguments: AccountIdArguments | [request: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+export function accountId(options: AccountIdOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['request'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'clawback_funds',
+			function: '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: 'clawback_funds',
+			function: 'funds',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface ResolveArguments {
+	request: RawTransactionArgument<string>;
+	policy: RawTransactionArgument<string>;
+}
+export interface ResolveOptions {
+	package?: string;
+	arguments:
+		| ResolveArguments
+		| [request: RawTransactionArgument<string>, policy: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/**
+ * Resolve a clawback funds request by:
+ *
+ * 1.  Verify policy is valid
+ * 2.  Verify policy has clawback enabled
+ * 3.  Make sure policy has enabled clawback resolution
+ */
+export function resolve(options: ResolveOptions) {
+	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: 'clawback_funds',
+			function: 'resolve',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}

package/src/contracts/pas/deps/std/type_name.ts

@@ -0,0 +1,24 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/** Functionality for converting Move types into values. Use with care! */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = 'std::type_name';
+export const TypeName = new MoveStruct({
+	name: `${$moduleName}::TypeName`,
+	fields: {
+		/**
+		 * String representation of the type. All types are represented using their source
+		 * syntax: "u8", "u64", "bool", "address", "vector", and so on for primitive types.
+		 * Struct types are represented as fully qualified type names; e.g.
+		 * `00000000000000000000000000000001::string::String` or
+		 * `0000000000000000000000000000000a::module_name1::type_name1<0000000000000000000000000000000a::module_name2::type_name2<u64>>`
+		 * Addresses are hex-encoded lowercase values of length ADDRESS_LENGTH (16, 20, or
+		 * 32 depending on the Move platform)
+		 */
+		name: bcs.string(),
+	},
+});

package/src/contracts/pas/deps/sui/vec_map.ts

@@ -0,0 +1,33 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+const $moduleName = '0x2::vec_map';
+/** An entry in the map */
+export function Entry<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [K, V]) {
+	return new MoveStruct({
+		name: `${$moduleName}::Entry<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`,
+		fields: {
+			key: typeParameters[0],
+			value: typeParameters[1],
+		},
+	});
+}
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export function VecMap<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [K, V]) {
+	return new MoveStruct({
+		name: `${$moduleName}::VecMap<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`,
+		fields: {
+			contents: bcs.vector(Entry(typeParameters[0], typeParameters[1])),
+		},
+	});
+}

package/src/contracts/pas/deps/sui/vec_set.ts

@@ -0,0 +1,22 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+const $moduleName = '0x2::vec_set';
+/**
+ * A set data structure backed by a vector. The set is guaranteed not to contain
+ * duplicate keys. All operations are O(N) in the size of the set
+ *
+ * - the intention of this data structure is only to provide the convenience of
+ *   programming against a set API. Sets that need sorted iteration rather than
+ *   insertion order iteration should be handwritten.
+ */
+export function VecSet<K extends BcsType<any>>(...typeParameters: [K]) {
+	return new MoveStruct({
+		name: `${$moduleName}::VecSet<${typeParameters[0].name as K['name']}>`,
+		fields: {
+			contents: bcs.vector(typeParameters[0]),
+		},
+	});
+}

package/src/contracts/pas/keys.ts

@@ -0,0 +1,90 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction } from '@mysten/sui/transactions';
+const $moduleName = '@mysten/pas::keys';
+export const PolicyKey = new MoveTuple({
+	name: `${$moduleName}::PolicyKey<phantom T>`,
+	fields: [bcs.bool()],
+});
+export const AccountKey = new MoveTuple({
+	name: `${$moduleName}::AccountKey`,
+	fields: [bcs.Address],
+});
+export const TemplateKey = new MoveTuple({
+	name: `${$moduleName}::TemplateKey`,
+	fields: [bcs.bool()],
+});
+export interface SendFundsActionOptions {
+	package?: string;
+	arguments?: [];
+}
+export function sendFundsAction(options: SendFundsActionOptions = {}) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'keys',
+			function: 'send_funds_action',
+		});
+}
+export interface UnlockFundsActionOptions {
+	package?: string;
+	arguments?: [];
+}
+export function unlockFundsAction(options: UnlockFundsActionOptions = {}) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'keys',
+			function: 'unlock_funds_action',
+		});
+}
+export interface ClawbackFundsActionOptions {
+	package?: string;
+	arguments?: [];
+}
+export function clawbackFundsAction(options: ClawbackFundsActionOptions = {}) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'keys',
+			function: 'clawback_funds_action',
+		});
+}
+export interface ActionsOptions {
+	package?: string;
+	arguments?: [];
+}
+export function actions(options: ActionsOptions = {}) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'keys',
+			function: 'actions',
+		});
+}
+export interface IsValidActionArguments {
+	action: RawTransactionArgument<string>;
+}
+export interface IsValidActionOptions {
+	package?: string;
+	arguments: IsValidActionArguments | [action: RawTransactionArgument<string>];
+}
+export function isValidAction(options: IsValidActionOptions) {
+	const packageAddress = options.package ?? '@mysten/pas';
+	const argumentsTypes = ['0x1::string::String'] satisfies (string | null)[];
+	const parameterNames = ['action'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'keys',
+			function: 'is_valid_action',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}