@waterx/predict-sdk 0.1.0

package/dist/src/generated/bucket_v2_framework/liability.js

@@ -0,0 +1,205 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Module for managing Credit and Debt for DeFi protocol usage */
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = '@bucket/framework::liability';
+export const Credit = new MoveStruct({ name: `${$moduleName}::Credit<phantom T>`, fields: {
+        value: bcs.u64()
+    } });
+export const Debt = new MoveStruct({ name: `${$moduleName}::Debt<phantom T>`, fields: {
+        value: bcs.u64()
+    } });
+/** Public Funs */
+export function _new(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        'u64'
+    ];
+    const parameterNames = ["value"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'liability',
+        function: 'new',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function zeroCredit(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'liability',
+        function: 'zero_credit',
+        typeArguments: options.typeArguments
+    });
+}
+export function zeroDebt(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'liability',
+        function: 'zero_debt',
+        typeArguments: options.typeArguments
+    });
+}
+export function destroyZeroCredit(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["credit"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'liability',
+        function: 'destroy_zero_credit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function destroyZeroDebt(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["debt"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'liability',
+        function: 'destroy_zero_debt',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function addCredit(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["self", "credit"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'liability',
+        function: 'add_credit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function addDebt(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["self", "debt"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'liability',
+        function: 'add_debt',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function autoSettle(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["credit", "debt"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'liability',
+        function: 'auto_settle',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function settleDebt(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["credit", "debt"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'liability',
+        function: 'settle_debt',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function settleCredit(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["debt", "credit"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'liability',
+        function: 'settle_credit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function creditValue(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["credit"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'liability',
+        function: 'credit_value',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function debtValue(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["debt"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'liability',
+        function: 'debt_value',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function destroyCreditForTesting(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["credit"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'liability',
+        function: 'destroy_credit_for_testing',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function destroyDebtForTesting(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["debt"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'liability',
+        function: 'destroy_debt_for_testing',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

package/dist/src/generated/bucket_v2_framework/linked_table.d.ts

@@ -0,0 +1,384 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType } from '@mysten/sui/bcs';
+import { MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
+import { type Transaction } from '@mysten/sui/transactions';
+export declare function LinkedTable<K extends BcsType<any>>(...typeParameters: [
+    K
+]): MoveStruct<any, any>;
+export declare function Node<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]): MoveStruct<any, any>;
+export interface NewOptions {
+    package?: string;
+    arguments?: [
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Creates a new, empty table */
+export declare function _new(options: NewOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface FrontArguments {
+    table: RawTransactionArgument<string>;
+}
+export interface FrontOptions {
+    package?: string;
+    arguments: FrontArguments | [
+        table: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Returns the key for the first element in the table, or None if the table is
+ * empty
+ */
+export declare function front(options: FrontOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BackArguments {
+    table: RawTransactionArgument<string>;
+}
+export interface BackOptions {
+    package?: string;
+    arguments: BackArguments | [
+        table: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Returns the key for the last element in the table, or None if the table is empty */
+export declare function back(options: BackOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PushFrontArguments<K extends BcsType<any>, V extends BcsType<any>> {
+    table: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+    value: RawTransactionArgument<V>;
+}
+export interface PushFrontOptions<K extends BcsType<any>, V extends BcsType<any>> {
+    package?: string;
+    arguments: PushFrontArguments<K, V> | [
+        table: RawTransactionArgument<string>,
+        k: RawTransactionArgument<K>,
+        value: RawTransactionArgument<V>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Inserts a key-value pair at the front of the table, i.e. the newly inserted pair
+ * will be the first element in the table Aborts with
+ * `sui::dynamic_df::EFieldAlreadyExists` if the table already has an entry with
+ * that key `k: K`.
+ */
+export declare function pushFront<K extends BcsType<any>, V extends BcsType<any>>(options: PushFrontOptions<K, V>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PushBackArguments<K extends BcsType<any>, V extends BcsType<any>> {
+    table: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+    value: RawTransactionArgument<V>;
+}
+export interface PushBackOptions<K extends BcsType<any>, V extends BcsType<any>> {
+    package?: string;
+    arguments: PushBackArguments<K, V> | [
+        table: RawTransactionArgument<string>,
+        k: RawTransactionArgument<K>,
+        value: RawTransactionArgument<V>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Inserts a key-value pair at the back of the table, i.e. the newly inserted pair
+ * will be the last element in the table Aborts with
+ * `sui::dynamic_df::EFieldAlreadyExists` if the table already has an entry with
+ * that key `k: K`.
+ */
+export declare function pushBack<K extends BcsType<any>, V extends BcsType<any>>(options: PushBackOptions<K, V>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowArguments<K extends BcsType<any>> {
+    table: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+}
+export interface BorrowOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: BorrowArguments<K> | [
+        table: RawTransactionArgument<string>,
+        k: RawTransactionArgument<K>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Immutable borrows the value associated with the key in the table
+ * `table: &LinkedTable<K, V>`. Aborts with `sui::dynamic_df::EFieldDoesNotExist`
+ * if the table does not have an entry with that key `k: K`.
+ */
+export declare function borrow<K extends BcsType<any>>(options: BorrowOptions<K>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowMutArguments<K extends BcsType<any>> {
+    table: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+}
+export interface BorrowMutOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: BorrowMutArguments<K> | [
+        table: RawTransactionArgument<string>,
+        k: RawTransactionArgument<K>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Mutably borrows the value associated with the key in the table
+ * `table: &mut LinkedTable<K, V>`. Aborts with
+ * `sui::dynamic_df::EFieldDoesNotExist` if the table does not have an entry with
+ * that key `k: K`.
+ */
+export declare function borrowMut<K extends BcsType<any>>(options: BorrowMutOptions<K>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PrevArguments<K extends BcsType<any>> {
+    table: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+}
+export interface PrevOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: PrevArguments<K> | [
+        table: RawTransactionArgument<string>,
+        k: RawTransactionArgument<K>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Borrows the key for the previous entry of the specified key `k: K` in the table
+ * `table: &LinkedTable<K, V>`. Returns None if the entry does not have a
+ * predecessor. Aborts with `sui::dynamic_df::EFieldDoesNotExist` if the table does
+ * not have an entry with that key `k: K`
+ */
+export declare function prev<K extends BcsType<any>>(options: PrevOptions<K>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NextArguments<K extends BcsType<any>> {
+    table: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+}
+export interface NextOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: NextArguments<K> | [
+        table: RawTransactionArgument<string>,
+        k: RawTransactionArgument<K>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Borrows the key for the next entry of the specified key `k: K` in the table
+ * `table: &LinkedTable<K, V>`. Returns None if the entry does not have a
+ * predecessor. Aborts with `sui::dynamic_df::EFieldDoesNotExist` if the table does
+ * not have an entry with that key `k: K`
+ */
+export declare function next<K extends BcsType<any>>(options: NextOptions<K>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveArguments<K extends BcsType<any>> {
+    table: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+}
+export interface RemoveOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: RemoveArguments<K> | [
+        table: RawTransactionArgument<string>,
+        k: RawTransactionArgument<K>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Removes the key-value pair in the table `table: &mut LinkedTable<K, V>` and
+ * returns the value. This splices the element out of the ordering. Aborts with
+ * `sui::dynamic_df::EFieldDoesNotExist` if the table does not have an entry with
+ * that key `k: K`. Note: this is also what happens when the table is empty.
+ */
+export declare function remove<K extends BcsType<any>>(options: RemoveOptions<K>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PopFrontArguments {
+    table: RawTransactionArgument<string>;
+}
+export interface PopFrontOptions {
+    package?: string;
+    arguments: PopFrontArguments | [
+        table: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Removes the front of the table `table: &mut LinkedTable<K, V>` and returns the
+ * value. Aborts with `ETableIsEmpty` if the table is empty
+ */
+export declare function popFront(options: PopFrontOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PopBackArguments {
+    table: RawTransactionArgument<string>;
+}
+export interface PopBackOptions {
+    package?: string;
+    arguments: PopBackArguments | [
+        table: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Removes the back of the table `table: &mut LinkedTable<K, V>` and returns the
+ * value. Aborts with `ETableIsEmpty` if the table is empty
+ */
+export declare function popBack(options: PopBackOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ContainsArguments<K extends BcsType<any>> {
+    table: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+}
+export interface ContainsOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: ContainsArguments<K> | [
+        table: RawTransactionArgument<string>,
+        k: RawTransactionArgument<K>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Returns true iff there is a value associated with the key `k: K` in table
+ * `table: &LinkedTable<K, V>`
+ */
+export declare function contains<K extends BcsType<any>>(options: ContainsOptions<K>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface LengthArguments {
+    table: RawTransactionArgument<string>;
+}
+export interface LengthOptions {
+    package?: string;
+    arguments: LengthArguments | [
+        table: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Returns the size of the table, the number of key-value pairs */
+export declare function length(options: LengthOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsEmptyArguments {
+    table: RawTransactionArgument<string>;
+}
+export interface IsEmptyOptions {
+    package?: string;
+    arguments: IsEmptyArguments | [
+        table: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Returns true iff the table is empty (if `length` returns `0`) */
+export declare function isEmpty(options: IsEmptyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DestroyEmptyArguments {
+    table: RawTransactionArgument<string>;
+}
+export interface DestroyEmptyOptions {
+    package?: string;
+    arguments: DestroyEmptyArguments | [
+        table: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Destroys an empty table Aborts with `ETableNotEmpty` if the table still contains
+ * values
+ */
+export declare function destroyEmpty(options: DestroyEmptyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DropArguments {
+    table: RawTransactionArgument<string>;
+}
+export interface DropOptions {
+    package?: string;
+    arguments: DropArguments | [
+        table: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Drop a possibly non-empty table. Usable only if the value type `V` has the
+ * `drop` ability
+ */
+export declare function drop(options: DropOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InsertFrontArguments<K extends BcsType<any>, V extends BcsType<any>> {
+    table: RawTransactionArgument<string>;
+    nextK: RawTransactionArgument<K | null>;
+    k: RawTransactionArgument<K>;
+    value: RawTransactionArgument<V>;
+}
+export interface InsertFrontOptions<K extends BcsType<any>, V extends BcsType<any>> {
+    package?: string;
+    arguments: InsertFrontArguments<K, V> | [
+        table: RawTransactionArgument<string>,
+        nextK: RawTransactionArgument<K | null>,
+        k: RawTransactionArgument<K>,
+        value: RawTransactionArgument<V>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Insert a key-value pair in front of the given key If the given key is none, then
+ * set the key-value pair as back
+ */
+export declare function insertFront<K extends BcsType<any>, V extends BcsType<any>>(options: InsertFrontOptions<K, V>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InsertBackArguments<K extends BcsType<any>, V extends BcsType<any>> {
+    table: RawTransactionArgument<string>;
+    prevK: RawTransactionArgument<K | null>;
+    k: RawTransactionArgument<K>;
+    value: RawTransactionArgument<V>;
+}
+export interface InsertBackOptions<K extends BcsType<any>, V extends BcsType<any>> {
+    package?: string;
+    arguments: InsertBackArguments<K, V> | [
+        table: RawTransactionArgument<string>,
+        prevK: RawTransactionArgument<K | null>,
+        k: RawTransactionArgument<K>,
+        value: RawTransactionArgument<V>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Insert a key-value pair behind the given key If the given key is none, then set
+ * the key-value pair as front
+ */
+export declare function insertBack<K extends BcsType<any>, V extends BcsType<any>>(options: InsertBackOptions<K, V>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;