@zebec-network/admin-sdk 1.0.0

package/dist/services/suiCardService.d.ts

@@ -0,0 +1,91 @@
+import type { ClientWithCoreApi, SuiClientTypes } from "@mysten/sui/client";
+import type { Signer } from "@mysten/sui/cryptography";
+import { Transaction } from "@mysten/sui/transactions";
+import type { DecimalString, Percent, SuiAddress, SuiCardConfig, SuiFeeTierList, SuiNetwork, SuiSwapFeeList, WalletInterface } from "../types.js";
+export declare class SuiSilverCardPackageInfo {
+    readonly network: SuiNetwork;
+    readonly address: string;
+    readonly module: string;
+    constructor(network: SuiNetwork);
+}
+export declare class SuiTransactionPayload {
+    private readonly _suiClient;
+    readonly transaction: Transaction;
+    readonly wallet: WalletInterface;
+    constructor(_suiClient: ClientWithCoreApi, transaction: Transaction, wallet: WalletInterface);
+    execute(options?: {
+        signer?: Signer;
+        signal?: AbortSignal;
+    }): Promise<SuiClientTypes.TransactionResult<object>>;
+}
+export declare class SuiCardAdminService {
+    readonly packageInfo: SuiSilverCardPackageInfo;
+    readonly suiClient: ClientWithCoreApi;
+    readonly adminCapObjectId: SuiAddress;
+    readonly cardConfigObjectId: SuiAddress;
+    readonly feeTierListObjectId: SuiAddress;
+    readonly swapFeeListObjectId: SuiAddress;
+    readonly usdcCoinType: string;
+    readonly usdcCoinMetadata: SuiClientTypes.CoinMetadata;
+    readonly wallet: WalletInterface;
+    constructor(packageInfo: SuiSilverCardPackageInfo, suiClient: ClientWithCoreApi, adminCapObjectId: SuiAddress, cardConfigObjectId: SuiAddress, feeTierListObjectId: SuiAddress, swapFeeListObjectId: SuiAddress, usdcCoinType: string, usdcCoinMetadata: SuiClientTypes.CoinMetadata, wallet: WalletInterface);
+    static create(packageInfo: SuiSilverCardPackageInfo, suiClient: ClientWithCoreApi, wallet: WalletInterface): Promise<SuiCardAdminService>;
+    getCardConfig(): Promise<SuiCardConfig>;
+    getFeeTierList(): Promise<SuiFeeTierList>;
+    getSwapFeeList(): Promise<SuiSwapFeeList>;
+    setNativeFee(params: {
+        feePercent: number;
+    }): Promise<SuiTransactionPayload>;
+    setNonNativeFee(params: {
+        feePercent: number;
+    }): Promise<SuiTransactionPayload>;
+    setRevenueVault(params: {
+        vaultAddress: string;
+    }): Promise<SuiTransactionPayload>;
+    setUsdcAddress(params: {
+        usdcAddress: string;
+    }): Promise<SuiTransactionPayload>;
+    setCardVault(params: {
+        vaultAddress: string;
+    }): Promise<SuiTransactionPayload>;
+    setRevenueFee(params: {
+        feePercent: number;
+    }): Promise<SuiTransactionPayload>;
+    setMinCardAmount(params: {
+        minCardAmount: string;
+    }): Promise<SuiTransactionPayload>;
+    setMaxCardAmount(params: {
+        maxCardAmount: string;
+    }): Promise<SuiTransactionPayload>;
+    setDailyLimit(params: {
+        dailyLimit: string;
+    }): Promise<SuiTransactionPayload>;
+    addFeeTier(params: {
+        minAmount: DecimalString;
+        maxAmount: DecimalString;
+        fee: Percent;
+    }): Promise<SuiTransactionPayload>;
+    updateFeeTier(params: {
+        minAmount: DecimalString;
+        maxAmount: DecimalString;
+        fee: Percent;
+    }): Promise<SuiTransactionPayload>;
+    removeFeeTier(params: {
+        minAmount: DecimalString;
+        maxAmount: DecimalString;
+    }): Promise<SuiTransactionPayload>;
+    getFeeForAmount(params: {
+        amount: DecimalString;
+    }): Promise<SuiTransactionPayload>;
+    addSwapFee(params: {
+        tokenType: string;
+        fee: number;
+    }): Promise<SuiTransactionPayload>;
+    updateSwapFee(params: {
+        tokenType: string;
+        fee: number;
+    }): Promise<SuiTransactionPayload>;
+    removeSwapFee(params: {
+        tokenType: string;
+    }): Promise<SuiTransactionPayload>;
+}

package/dist/services/suiCardService.js

@@ -0,0 +1,487 @@
+import { BigNumber } from "bignumber.js";
+import { Transaction } from "@mysten/sui/transactions";
+import { fromBase64, isValidSuiAddress, toBase64 } from "@mysten/sui/utils";
+import { bpsToPercent, percentToBps } from "@zebec-network/core-utils";
+import { TEN_BIGNUM } from "@zebec-network/solana-common";
+import { SUI_SILVERCARD_ADMIN_CAP_STRUCT_TYPE, SUI_SILVERCARD_CARD_CONFIG_OBJECT_ID, SUI_SILVERCARD_FEE_TIER_LIST_OBJECT_ID, SUI_SILVERCARD_MODULE_NAME, SUI_SILVERCARD_PACKAGE_ADDRESS, SUI_SILVERCARD_SWAP_FEE_LIST_OBJECT_ID, SUI_USDC_COIN_TYPE, } from "../constants.js";
+import { createSuiSignTransactionMethodFromSigner } from "../utils.js";
+export class SuiSilverCardPackageInfo {
+    network;
+    address;
+    module;
+    constructor(network) {
+        this.network = network;
+        this.address = SUI_SILVERCARD_PACKAGE_ADDRESS[network];
+        this.module = SUI_SILVERCARD_MODULE_NAME;
+    }
+}
+export class SuiTransactionPayload {
+    _suiClient;
+    transaction;
+    wallet;
+    constructor(_suiClient, transaction, wallet) {
+        this._suiClient = _suiClient;
+        this.transaction = transaction;
+        this.wallet = wallet;
+    }
+    async execute(options) {
+        const transaction = await this.transaction.build({
+            client: this._suiClient,
+        });
+        const signTransaction = this.wallet.signTransaction
+            ? this.wallet.signTransaction
+            : options?.signer
+                ? createSuiSignTransactionMethodFromSigner(options.signer)
+                : undefined;
+        if (!signTransaction) {
+            throw new Error("Both signTransaction and signer is undefined.");
+        }
+        const { signature, bytes } = await signTransaction({
+            transaction: toBase64(transaction),
+        });
+        const result = await this._suiClient.core.executeTransaction({
+            transaction: fromBase64(bytes),
+            signatures: [signature],
+            signal: options?.signal,
+            include: {
+                effects: true,
+                transaction: true,
+                events: true,
+            },
+        });
+        const res = await this._suiClient.core.waitForTransaction({
+            signal: options?.signal,
+            result,
+        });
+        return res;
+    }
+}
+export class SuiCardAdminService {
+    packageInfo;
+    suiClient;
+    adminCapObjectId;
+    cardConfigObjectId;
+    feeTierListObjectId;
+    swapFeeListObjectId;
+    usdcCoinType;
+    usdcCoinMetadata;
+    wallet;
+    constructor(packageInfo, suiClient, adminCapObjectId, cardConfigObjectId, feeTierListObjectId, swapFeeListObjectId, usdcCoinType, usdcCoinMetadata, wallet) {
+        this.packageInfo = packageInfo;
+        this.suiClient = suiClient;
+        this.adminCapObjectId = adminCapObjectId;
+        this.cardConfigObjectId = cardConfigObjectId;
+        this.feeTierListObjectId = feeTierListObjectId;
+        this.swapFeeListObjectId = swapFeeListObjectId;
+        this.usdcCoinType = usdcCoinType;
+        this.usdcCoinMetadata = usdcCoinMetadata;
+        this.wallet = wallet;
+    }
+    static async create(packageInfo, suiClient, wallet) {
+        const admin = wallet.address;
+        const response = await suiClient.core.listOwnedObjects({
+            owner: admin,
+            type: SUI_SILVERCARD_ADMIN_CAP_STRUCT_TYPE[packageInfo.network],
+        });
+        const { objects } = response;
+        // console.log("admin cap objects:", objects);
+        const [adminCapObject] = objects;
+        if (!adminCapObject || objects.length !== 1) {
+            throw new Error("Given wallet address does not own any admin cap object.");
+        }
+        const adminCapObjectId = adminCapObject.objectId;
+        const coinType = SUI_USDC_COIN_TYPE[packageInfo.network];
+        const coinMetadataResponse = await suiClient.core.getCoinMetadata({
+            coinType,
+        });
+        if (!coinMetadataResponse.coinMetadata) {
+            throw new Error("Could not fetch usdc coin metadata");
+        }
+        const cardConfigObjectId = SUI_SILVERCARD_CARD_CONFIG_OBJECT_ID[packageInfo.network];
+        const feeTierListObjectId = SUI_SILVERCARD_FEE_TIER_LIST_OBJECT_ID[packageInfo.network];
+        const swapFeeListObjectId = SUI_SILVERCARD_SWAP_FEE_LIST_OBJECT_ID[packageInfo.network];
+        return new SuiCardAdminService(packageInfo, suiClient, adminCapObjectId, cardConfigObjectId, feeTierListObjectId, swapFeeListObjectId, coinType, coinMetadataResponse.coinMetadata, wallet);
+    }
+    async getCardConfig() {
+        const usdcDecimals = this.usdcCoinMetadata.decimals;
+        const UNITS_PER_USDC = TEN_BIGNUM.pow(usdcDecimals);
+        const { object } = await this.suiClient.core.getObject({
+            objectId: this.cardConfigObjectId,
+            include: { json: true },
+        });
+        const json = object.json;
+        if (typeof json.admin !== "string")
+            throw new Error('Invalid card config: missing or invalid "admin"');
+        if (typeof json.card_vault !== "string")
+            throw new Error('Invalid card config: missing or invalid "card_vault"');
+        if (typeof json.daily_card_buy_limit !== "string")
+            throw new Error('Invalid card config: missing or invalid "daily_card_buy_limit"');
+        if (typeof json.max_card_amount !== "string")
+            throw new Error('Invalid card config: missing or invalid "max_card_amount"');
+        if (typeof json.min_card_amount !== "string")
+            throw new Error('Invalid card config: missing or invalid "min_card_amount"');
+        if (typeof json.native_fee !== "string")
+            throw new Error('Invalid card config: missing or invalid "native_fee"');
+        if (typeof json.non_native_fee !== "string")
+            throw new Error('Invalid card config: missing or invalid "non_native_fee"');
+        if (typeof json.revenue_fee !== "string")
+            throw new Error('Invalid card config: missing or invalid "revenue_fee"');
+        if (typeof json.revenue_vault !== "string")
+            throw new Error('Invalid card config: missing or invalid "revenue_vault"');
+        if (typeof json.version !== "string")
+            throw new Error('Invalid card config: missing or invalid "version"');
+        if (typeof json.usdc_address !== "string")
+            throw new Error('Invalid card config: missing or invalid "usdc_address"');
+        return {
+            admin: json.admin,
+            cardVault: json.card_vault,
+            dailyCardBuyLimit: BigNumber(json.daily_card_buy_limit)
+                .div(UNITS_PER_USDC)
+                .toFixed(),
+            id: object.objectId,
+            maxCardAmount: BigNumber(json.max_card_amount)
+                .div(UNITS_PER_USDC)
+                .toFixed(),
+            minCardAmount: BigNumber(json.min_card_amount)
+                .div(UNITS_PER_USDC)
+                .toFixed(),
+            nativeFee: bpsToPercent(json.native_fee),
+            nonNativeFee: bpsToPercent(json.non_native_fee),
+            revenueFee: bpsToPercent(json.revenue_fee),
+            revenueVault: json.revenue_vault,
+            version: json.version,
+            usdcAddress: json.usdc_address,
+        };
+    }
+    async getFeeTierList() {
+        const usdcDecimals = this.usdcCoinMetadata.decimals;
+        const UNITS_PER_USDC = TEN_BIGNUM.pow(usdcDecimals);
+        const { object } = await this.suiClient.core.getObject({
+            objectId: this.feeTierListObjectId,
+            include: { json: true },
+        });
+        const json = object.json;
+        if (!Array.isArray(json.tiers))
+            throw new Error('Invalid fee tier list: missing or invalid "tiers"');
+        if (typeof json.version !== "string")
+            throw new Error('Invalid fee tier list: missing or invalid "version"');
+        const tiers = json.tiers.map((tier) => {
+            if (typeof tier !== "object" || tier === null)
+                throw new Error("Invalid fee tier: expected object");
+            const t = tier;
+            if (typeof t.minAmount !== "string")
+                throw new Error('Invalid fee tier: missing or invalid "minAmount"');
+            if (typeof t.maxAmount !== "string")
+                throw new Error('Invalid fee tier: missing or invalid "maxAmount"');
+            if (typeof t.fee !== "string")
+                throw new Error('Invalid fee tier: missing or invalid "fee"');
+            return {
+                minAmount: BigNumber(t.minAmount).div(UNITS_PER_USDC).toFixed(),
+                maxAmount: BigNumber(t.maxAmount).div(UNITS_PER_USDC).toFixed(),
+                fee: bpsToPercent(t.fee),
+            };
+        });
+        return {
+            id: object.objectId,
+            tiers,
+            version: json.version,
+        };
+    }
+    async getSwapFeeList() {
+        const { object } = await this.suiClient.core.getObject({
+            objectId: this.swapFeeListObjectId,
+            include: { json: true },
+        });
+        const json = object.json;
+        if (typeof json.version !== "string")
+            throw new Error('Invalid swap fee list: missing or invalid "version"');
+        if (!Array.isArray(json.swap_fees))
+            throw new Error('Invalid swap fee list: missing or invalid "swap_fees"');
+        const swapFees = json.swap_fees.map((swapFee) => {
+            if (typeof swapFee !== "object" || swapFee === null)
+                throw new Error("Invalid swap fee: expected object");
+            const sf = swapFee;
+            if (typeof sf.token_type !== "string")
+                throw new Error('Invalid swap fee: missing or invalid "token_type"');
+            if (typeof sf.fee !== "string")
+                throw new Error('Invalid swap fee: missing or invalid "fee"');
+            return {
+                tokenType: sf.token_type,
+                fee: bpsToPercent(sf.fee),
+            };
+        });
+        return {
+            id: object.objectId,
+            version: json.version,
+            swapFees,
+        };
+    }
+    async setNativeFee(params) {
+        const feeBps = BigInt(percentToBps(params.feePercent));
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.packageInfo.address}::${this.packageInfo.module}::set_native_fee`,
+            arguments: [
+                tx.object(this.adminCapObjectId),
+                tx.object(this.cardConfigObjectId),
+                tx.pure.u64(feeBps),
+            ],
+        });
+        tx.setSender(this.wallet.address);
+        return new SuiTransactionPayload(this.suiClient, tx, this.wallet);
+    }
+    async setNonNativeFee(params) {
+        const feeBps = BigInt(percentToBps(params.feePercent));
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.packageInfo.address}::${this.packageInfo.module}::set_non_native_fee`,
+            arguments: [
+                tx.object(this.adminCapObjectId),
+                tx.object(this.cardConfigObjectId),
+                tx.pure.u64(feeBps),
+            ],
+        });
+        tx.setSender(this.wallet.address);
+        return new SuiTransactionPayload(this.suiClient, tx, this.wallet);
+    }
+    async setRevenueVault(params) {
+        if (!isValidSuiAddress(params.vaultAddress)) {
+            throw new Error("Invalid Sui Address");
+        }
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.packageInfo.address}::${this.packageInfo.module}::set_revenue_vault`,
+            arguments: [
+                tx.object(this.adminCapObjectId),
+                tx.object(this.cardConfigObjectId),
+                tx.pure.address(params.vaultAddress),
+            ],
+        });
+        tx.setSender(this.wallet.address);
+        return new SuiTransactionPayload(this.suiClient, tx, this.wallet);
+    }
+    async setUsdcAddress(params) {
+        if (!isValidSuiAddress(params.usdcAddress)) {
+            throw new Error("Invalid Sui Address");
+        }
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.packageInfo.address}::${this.packageInfo.module}::set_usdc_address`,
+            arguments: [
+                tx.object(this.adminCapObjectId),
+                tx.object(this.cardConfigObjectId),
+                tx.pure.address(params.usdcAddress),
+            ],
+        });
+        tx.setSender(this.wallet.address);
+        return new SuiTransactionPayload(this.suiClient, tx, this.wallet);
+    }
+    async setCardVault(params) {
+        if (!isValidSuiAddress(params.vaultAddress)) {
+            throw new Error("Invalid Sui Address");
+        }
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.packageInfo.address}::${this.packageInfo.module}::set_card_vault`,
+            arguments: [
+                tx.object(this.adminCapObjectId),
+                tx.object(this.cardConfigObjectId),
+                tx.pure.address(params.vaultAddress),
+            ],
+        });
+        tx.setSender(this.wallet.address);
+        return new SuiTransactionPayload(this.suiClient, tx, this.wallet);
+    }
+    async setRevenueFee(params) {
+        const feeBps = BigInt(percentToBps(params.feePercent));
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.packageInfo.address}::${this.packageInfo.module}::set_revenue_fee`,
+            arguments: [
+                tx.object(this.adminCapObjectId),
+                tx.object(this.cardConfigObjectId),
+                tx.pure.u64(feeBps),
+            ],
+        });
+        tx.setSender(this.wallet.address);
+        return new SuiTransactionPayload(this.suiClient, tx, this.wallet);
+    }
+    async setMinCardAmount(params) {
+        const usdcDecimals = this.usdcCoinMetadata.decimals;
+        const minCardAmount = BigInt(BigNumber(params.minCardAmount)
+            .times(TEN_BIGNUM.pow(usdcDecimals))
+            .toFixed(0));
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.packageInfo.address}::${this.packageInfo.module}::set_min_card_amount`,
+            arguments: [
+                tx.object(this.adminCapObjectId),
+                tx.object(this.cardConfigObjectId),
+                tx.pure.u64(minCardAmount),
+            ],
+        });
+        tx.setSender(this.wallet.address);
+        return new SuiTransactionPayload(this.suiClient, tx, this.wallet);
+    }
+    async setMaxCardAmount(params) {
+        const usdcDecimals = this.usdcCoinMetadata.decimals;
+        const maxCardAmount = BigInt(BigNumber(params.maxCardAmount)
+            .times(TEN_BIGNUM.pow(usdcDecimals))
+            .toFixed(0));
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.packageInfo.address}::${this.packageInfo.module}::set_max_card_amount`,
+            arguments: [
+                tx.object(this.adminCapObjectId),
+                tx.object(this.cardConfigObjectId),
+                tx.pure.u64(maxCardAmount),
+            ],
+        });
+        tx.setSender(this.wallet.address);
+        return new SuiTransactionPayload(this.suiClient, tx, this.wallet);
+    }
+    async setDailyLimit(params) {
+        const usdcDecimals = this.usdcCoinMetadata.decimals;
+        const dailyLimit = BigInt(BigNumber(params.dailyLimit)
+            .times(TEN_BIGNUM.pow(usdcDecimals))
+            .toFixed(0));
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.packageInfo.address}::${this.packageInfo.module}::set_daily_limit`,
+            arguments: [
+                tx.object(this.adminCapObjectId),
+                tx.object(this.cardConfigObjectId),
+                tx.pure.u64(dailyLimit),
+            ],
+        });
+        tx.setSender(this.wallet.address);
+        return new SuiTransactionPayload(this.suiClient, tx, this.wallet);
+    }
+    async addFeeTier(params) {
+        const usdcDecimals = this.usdcCoinMetadata.decimals;
+        const feeTier = {
+            fee: BigInt(percentToBps(params.fee)),
+            minAmount: BigInt(BigNumber(params.minAmount)
+                .times(TEN_BIGNUM.pow(usdcDecimals))
+                .toFixed(0, BigNumber.ROUND_DOWN)),
+            maxAmount: BigInt(BigNumber(params.maxAmount)
+                .times(TEN_BIGNUM.pow(usdcDecimals))
+                .toFixed(0, BigNumber.ROUND_DOWN)),
+        };
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.packageInfo.address}::${this.packageInfo.module}::add_fee_tier`,
+            arguments: [
+                tx.object(this.adminCapObjectId),
+                tx.object(this.feeTierListObjectId),
+                tx.pure.u64(feeTier.minAmount),
+                tx.pure.u64(feeTier.maxAmount),
+                tx.pure.u64(feeTier.fee),
+            ],
+        });
+        tx.setSender(this.wallet.address);
+        return new SuiTransactionPayload(this.suiClient, tx, this.wallet);
+    }
+    async updateFeeTier(params) {
+        const usdcDecimals = this.usdcCoinMetadata.decimals;
+        const feeTier = {
+            fee: BigInt(percentToBps(params.fee)),
+            minAmount: BigInt(BigNumber(params.minAmount)
+                .times(TEN_BIGNUM.pow(usdcDecimals))
+                .toFixed(0, BigNumber.ROUND_DOWN)),
+            maxAmount: BigInt(BigNumber(params.maxAmount)
+                .times(TEN_BIGNUM.pow(usdcDecimals))
+                .toFixed(0, BigNumber.ROUND_DOWN)),
+        };
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.packageInfo.address}::${this.packageInfo.module}::update_fee_tier`,
+            arguments: [
+                tx.object(this.adminCapObjectId),
+                tx.object(this.feeTierListObjectId),
+                tx.pure.u64(feeTier.minAmount),
+                tx.pure.u64(feeTier.maxAmount),
+                tx.pure.u64(feeTier.fee),
+            ],
+        });
+        tx.setSender(this.wallet.address);
+        return new SuiTransactionPayload(this.suiClient, tx, this.wallet);
+    }
+    async removeFeeTier(params) {
+        const usdcDecimals = this.usdcCoinMetadata.decimals;
+        const minAmount = BigInt(BigNumber(params.minAmount)
+            .times(TEN_BIGNUM.pow(usdcDecimals))
+            .toFixed(0, BigNumber.ROUND_DOWN));
+        const maxAmount = BigInt(BigNumber(params.maxAmount)
+            .times(TEN_BIGNUM.pow(usdcDecimals))
+            .toFixed(0, BigNumber.ROUND_DOWN));
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.packageInfo.address}::${this.packageInfo.module}::remove_fee_tier`,
+            arguments: [
+                tx.object(this.adminCapObjectId),
+                tx.object(this.feeTierListObjectId),
+                tx.pure.u64(minAmount),
+                tx.pure.u64(maxAmount),
+            ],
+        });
+        tx.setSender(this.wallet.address);
+        return new SuiTransactionPayload(this.suiClient, tx, this.wallet);
+    }
+    async getFeeForAmount(params) {
+        const usdcDecimals = this.usdcCoinMetadata.decimals;
+        const amount = BigInt(BigNumber(params.amount)
+            .times(TEN_BIGNUM.pow(usdcDecimals))
+            .toFixed(0, BigNumber.ROUND_DOWN));
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.packageInfo.address}::${this.packageInfo.module}::get_fee_from_tiers`,
+            arguments: [tx.object(this.feeTierListObjectId), tx.pure.u64(amount)],
+        });
+        tx.setSender(this.wallet.address);
+        return new SuiTransactionPayload(this.suiClient, tx, this.wallet);
+    }
+    async addSwapFee(params) {
+        const fee = BigInt(percentToBps(params.fee));
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.packageInfo.address}::${this.packageInfo.module}::add_swap_fee`,
+            arguments: [
+                tx.object(this.adminCapObjectId),
+                tx.object(this.swapFeeListObjectId),
+                tx.pure.string(params.tokenType),
+                tx.pure.u64(fee),
+            ],
+        });
+        tx.setSender(this.wallet.address);
+        return new SuiTransactionPayload(this.suiClient, tx, this.wallet);
+    }
+    async updateSwapFee(params) {
+        const fee = BigInt(percentToBps(params.fee));
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.packageInfo.address}::${this.packageInfo.module}::update_swap_fee`,
+            arguments: [
+                tx.object(this.adminCapObjectId),
+                tx.object(this.swapFeeListObjectId),
+                tx.pure.string(params.tokenType),
+                tx.pure.u64(fee),
+            ],
+        });
+        tx.setSender(this.wallet.address);
+        return new SuiTransactionPayload(this.suiClient, tx, this.wallet);
+    }
+    async removeSwapFee(params) {
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.packageInfo.address}::${this.packageInfo.module}::remove_swap_fee`,
+            arguments: [
+                tx.object(this.adminCapObjectId),
+                tx.object(this.swapFeeListObjectId),
+                tx.pure.string(params.tokenType),
+            ],
+        });
+        tx.setSender(this.wallet.address);
+        return new SuiTransactionPayload(this.suiClient, tx, this.wallet);
+    }
+}