@pizzaton/ton 0.0.0-stage → 0.1.1

package/dist/contracts/wrappers/jvault-support.d.mts

@@ -0,0 +1,135 @@
+import { ContractWrapper } from "./base.mjs";
+import { Address, Cell, ContractProvider, Sender } from "@ton/core";
+//#region src/contracts/wrappers/jvault-support.d.ts
+/** Native wrappers for the auxiliary JVault staking contracts. */
+export declare const JVAULT_SUPPORT_SOURCE_REVISIONS: {
+  readonly fixedStaking: "63cbc8137a7dca0269bcdd9089a9dcc37acbb727";
+  readonly floatingStaking: "51c86b4469fd99b3e2ebdff6f8cdad9fee067b4c";
+  readonly decentralizedLaunchpad: "83f59e126e5e885f2d7da792998a5d569c0aa944";
+};
+export interface JVaultFixedPoolsAdminConfig {
+  readonly stakingPoolCode: Cell;
+  readonly nftItemCode: Cell;
+  readonly creationFee: bigint;
+  readonly ownerAddress: Address;
+  readonly distributionAddress: Address;
+}
+export declare function buildJVaultFixedPoolsAdminData(config: JVaultFixedPoolsAdminConfig): Cell;
+export interface JVaultPoolAdminCodeUpdate {
+  readonly stakingPoolCode: Cell;
+  readonly nftItemCode: Cell;
+  readonly sharecomsCode: Cell;
+  readonly jvtNftCode: Cell;
+}
+declare abstract class JVaultPoolsAdminBase extends ContractWrapper {
+  getSharecomsByPool(provider: ContractProvider, poolAddress: Address): Promise<Address>;
+  getCreationFee(provider: ContractProvider): Promise<bigint>;
+  getOwners(provider: ContractProvider): Promise<{
+    team: Address;
+    conversion: Address;
+  }>;
+  getCodes(provider: ContractProvider): Promise<{
+    stakingPool: Cell;
+    nftItem: Cell;
+    sharecoms: Cell;
+    jvtNft: Cell;
+  }>;
+  getVersion(provider: ContractProvider): Promise<number>;
+  sendDepositJettons(provider: ContractProvider, via: Sender, value: bigint, jettonAmount: bigint, queryId?: bigint, forwardPayload?: Cell): Promise<void>;
+  sendWithdrawJetton(provider: ContractProvider, via: Sender, value: bigint, jettonWallet: Address, amount: bigint, queryId?: bigint): Promise<void>;
+  sendWithdrawTon(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendAny(provider: ContractProvider, via: Sender, value: bigint, message: Cell, queryId?: bigint): Promise<void>;
+  sendChangeCreationFee(provider: ContractProvider, via: Sender, value: bigint, fee: bigint, queryId?: bigint): Promise<void>;
+  sendChangeCodes(provider: ContractProvider, via: Sender, value: bigint, codes: JVaultPoolAdminCodeUpdate, queryId?: bigint): Promise<void>;
+  sendChangeTeam(provider: ContractProvider, via: Sender, value: bigint, address: Address, queryId?: bigint): Promise<void>;
+  sendChangeConversion(provider: ContractProvider, via: Sender, value: bigint, address: Address, queryId?: bigint): Promise<void>;
+  sendChangeJettonWallet(provider: ContractProvider, via: Sender, value: bigint, address: Address, queryId?: bigint): Promise<void>;
+  sendChangeStaking(provider: ContractProvider, via: Sender, value: bigint, address: Address, queryId?: bigint): Promise<void>;
+  sendChangeContentFee(provider: ContractProvider, via: Sender, value: bigint, fee: bigint, queryId?: bigint): Promise<void>;
+  sendSetData(provider: ContractProvider, via: Sender, value: bigint, data: Cell, queryId?: bigint): Promise<void>;
+  sendSetCode(provider: ContractProvider, via: Sender, value: bigint, code: Cell, queryId?: bigint): Promise<void>;
+  sendChangeHost(provider: ContractProvider, via: Sender, value: bigint, host: Cell, queryId?: bigint): Promise<void>;
+}
+export interface JVaultFloatingPoolsAdminConfig {
+  readonly creationFee: bigint;
+  readonly changeFee: bigint;
+  readonly stakingAddress: Address;
+  readonly stakingWalletAddress: Address;
+  readonly sharecomsCode: Cell;
+  readonly stakingPoolCode: Cell;
+  readonly nftItemCode: Cell;
+  readonly teamAddress: Address;
+  readonly conversionAddress: Address;
+  readonly host: Cell;
+  readonly jvtNftCode: Cell;
+}
+export declare function buildJVaultFloatingPoolsAdminData(config: JVaultFloatingPoolsAdminConfig): Cell;
+export declare class JVaultFixedPoolsAdmin extends JVaultPoolsAdminBase {
+  static createFromAddress(address: Address): JVaultFixedPoolsAdmin;
+  static createFromConfig(config: JVaultFixedPoolsAdminConfig, code: Cell, workchain?: number): JVaultFixedPoolsAdmin;
+}
+export declare class JVaultFloatingPoolsAdmin extends JVaultPoolsAdminBase {
+  static createFromAddress(address: Address): JVaultFloatingPoolsAdmin;
+  static createFromConfig(config: JVaultFloatingPoolsAdminConfig, code: Cell, workchain?: number): JVaultFloatingPoolsAdmin;
+}
+export interface JVaultSharecomsConfig {
+  readonly poolAddress: Address;
+  readonly poolAdminAddress: Address;
+  readonly stakingAddress: Address;
+  readonly jettonWalletAddress: Address;
+  readonly nftItemCode: Cell;
+  readonly lastCommissionTime?: number;
+  readonly allCommissions?: bigint;
+}
+export declare function buildJVaultSharecomsData(config: JVaultSharecomsConfig): Cell;
+export declare class JVaultFloatingSharecoms extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultFloatingSharecoms;
+  static createFromConfig(config: JVaultSharecomsConfig, code: Cell, workchain?: number): JVaultFloatingSharecoms;
+  getJettonWalletAddress(provider: ContractProvider): Promise<Address>;
+  getCommissionsPerDivider(provider: ContractProvider): Promise<bigint>;
+  getLastClaimedCommissionTime(provider: ContractProvider, nftId: bigint): Promise<bigint>;
+  getClaimableCommissionsByTime(provider: ContractProvider, time: bigint, stakedJvt: bigint): Promise<bigint>;
+  getDicts(provider: ContractProvider): Promise<{
+    nfts: Cell;
+    commissions: Cell;
+  }>;
+  getStorageData(provider: ContractProvider): Promise<{
+    pool: Address;
+    poolAdmin: Address;
+    lastCommissionTime: bigint;
+    allCommissions: bigint;
+    staking: Address;
+    jettonWallet: Address;
+    jettonWalletSet: boolean;
+    nftItemCode: Cell;
+    nfts: Cell;
+    nftCount: number;
+    commissions: Cell;
+  }>;
+  getVersion(provider: ContractProvider): Promise<number>;
+  sendWithdrawJetton(provider: ContractProvider, via: Sender, value: bigint, jettonWallet: Address, amount: bigint, queryId?: bigint): Promise<void>;
+  sendWithdrawTon(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendSetJettonWallet(provider: ContractProvider, via: Sender, value: bigint, address: Address, queryId?: bigint): Promise<void>;
+}
+export interface JVaultSbtItemDataConfig {
+  readonly index: bigint;
+  readonly collection: Address;
+}
+export declare function buildJVaultSbtItemData(config: JVaultSbtItemDataConfig): Cell;
+export declare class JVaultSbtSingle extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultSbtSingle;
+  static createFromConfig(config: JVaultSbtItemDataConfig, code: Cell, workchain?: number): JVaultSbtSingle;
+  sendDeploy(provider: ContractProvider, via: Sender, value: bigint, owner: Address, content: Cell, authority?: Address | null): Promise<void>;
+  sendProveOwnership(provider: ContractProvider, via: Sender, value: bigint, destination: Address, forwardPayload: Cell, withContent: boolean, queryId?: bigint): Promise<void>;
+  sendBuyWhitelist(provider: ContractProvider, via: Sender, value: bigint, destination: Address, level: number, referral?: Address | null): Promise<void>;
+  getNftData(provider: ContractProvider): Promise<{
+    initialized: boolean;
+    index: bigint;
+    collection: Address;
+    owner: Address | null;
+    content: Cell;
+  }>;
+  getAuthorityAddress(provider: ContractProvider): Promise<Address>;
+  getRevokedTime(provider: ContractProvider): Promise<bigint>;
+}
+//#endregion

package/dist/contracts/wrappers/jvault-support.mjs

@@ -0,0 +1,269 @@
+import { buildJettonTransferBody } from "../../jetton/index.mjs";
+import { ContractWrapper } from "./base.mjs";
+import { JVAULT_SOURCE_REVISIONS } from "./jvault-protocols.mjs";
+import { Cell, Dictionary, beginCell, contractAddress } from "@ton/core";
+//#region src/contracts/wrappers/jvault-support.ts
+/** Native wrappers for the auxiliary JVault staking contracts. */
+const JVAULT_SUPPORT_SOURCE_REVISIONS = {
+	fixedStaking: JVAULT_SOURCE_REVISIONS.fixedStaking,
+	floatingStaking: JVAULT_SOURCE_REVISIONS.floatingStaking,
+	decentralizedLaunchpad: JVAULT_SOURCE_REVISIONS.decentralizedLaunchpad
+};
+const OP = {
+	transferNotification: 1935855772,
+	takeWalletAddress: 3513996288,
+	excesses: 3576854235,
+	withdrawJetton: 3,
+	withdrawTon: 4,
+	sendAny: 5,
+	changeCreationFee: 10,
+	changeCodes: 11,
+	changeTeam: 12,
+	changeConversion: 13,
+	changeJettonWallet: 14,
+	changeStaking: 15,
+	changeContentFee: 16,
+	setData: 65534,
+	setCode: 65535,
+	changeHost: 1399416858,
+	proveOwnership: 81711432,
+	buyWhitelist: 81711432
+};
+const header = (opcode, queryId = 0n) => beginCell().storeUint(opcode, 32).storeUint(queryId, 64);
+function buildJVaultFixedPoolsAdminData(config) {
+	return beginCell().storeRef(Cell.EMPTY).storeRef(config.stakingPoolCode).storeRef(config.nftItemCode).storeCoins(config.creationFee).storeAddress(config.ownerAddress).storeAddress(config.distributionAddress).endCell();
+}
+var JVaultPoolsAdminBase = class extends ContractWrapper {
+	async getSharecomsByPool(provider, poolAddress) {
+		return (await this.get(provider, "get_sharecoms_by_pool", [{
+			type: "slice",
+			cell: beginCell().storeAddress(poolAddress).endCell()
+		}])).readAddress();
+	}
+	async getCreationFee(provider) {
+		return (await this.get(provider, "get_creation_fee")).readBigNumber();
+	}
+	async getOwners(provider) {
+		const stack = await this.get(provider, "get_owners");
+		return {
+			team: stack.readAddress(),
+			conversion: stack.readAddress()
+		};
+	}
+	async getCodes(provider) {
+		const stack = await this.get(provider, "get_codes");
+		return {
+			stakingPool: stack.readCell(),
+			nftItem: stack.readCell(),
+			sharecoms: stack.readCell(),
+			jvtNft: stack.readCell()
+		};
+	}
+	async getVersion(provider) {
+		return (await this.get(provider, "get_version")).readNumber();
+	}
+	async sendDepositJettons(provider, via, value, jettonAmount, queryId = 0n, forwardPayload) {
+		const transfer = {
+			amount: jettonAmount,
+			destination: this.address,
+			responseDestination: via.address ?? this.address,
+			forwardAmount: 0n,
+			queryId
+		};
+		await this.send(provider, via, value, buildJettonTransferBody(forwardPayload ? {
+			...transfer,
+			forwardPayload
+		} : transfer));
+	}
+	async sendWithdrawJetton(provider, via, value, jettonWallet, amount, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.withdrawJetton, queryId).storeAddress(jettonWallet).storeCoins(amount).endCell());
+	}
+	async sendWithdrawTon(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.withdrawTon, queryId).endCell());
+	}
+	async sendAny(provider, via, value, message, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.sendAny, queryId).storeRef(message).endCell());
+	}
+	async sendChangeCreationFee(provider, via, value, fee, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.changeCreationFee, queryId).storeCoins(fee).endCell());
+	}
+	async sendChangeCodes(provider, via, value, codes, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.changeCodes, queryId).storeRef(codes.stakingPoolCode).storeRef(codes.nftItemCode).storeRef(codes.sharecomsCode).storeRef(codes.jvtNftCode).endCell());
+	}
+	async sendChangeTeam(provider, via, value, address, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.changeTeam, queryId).storeAddress(address).endCell());
+	}
+	async sendChangeConversion(provider, via, value, address, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.changeConversion, queryId).storeAddress(address).endCell());
+	}
+	async sendChangeJettonWallet(provider, via, value, address, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.changeJettonWallet, queryId).storeAddress(address).endCell());
+	}
+	async sendChangeStaking(provider, via, value, address, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.changeStaking, queryId).storeAddress(address).endCell());
+	}
+	async sendChangeContentFee(provider, via, value, fee, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.changeContentFee, queryId).storeCoins(fee).endCell());
+	}
+	async sendSetData(provider, via, value, data, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.setData, queryId).storeRef(data).endCell());
+	}
+	async sendSetCode(provider, via, value, code, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.setCode, queryId).storeRef(code).endCell());
+	}
+	async sendChangeHost(provider, via, value, host, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.changeHost, queryId).storeRef(host).endCell());
+	}
+};
+function buildJVaultFloatingPoolsAdminData(config) {
+	return beginCell().storeCoins(config.creationFee).storeCoins(config.changeFee).storeAddress(config.stakingAddress).storeAddress(config.stakingWalletAddress).storeRef(config.sharecomsCode).storeRef(config.stakingPoolCode).storeRef(config.nftItemCode).storeRef(beginCell().storeAddress(config.teamAddress).storeAddress(config.conversionAddress).storeRef(config.host).storeRef(config.jvtNftCode).endCell()).endCell();
+}
+var JVaultFixedPoolsAdmin = class JVaultFixedPoolsAdmin extends JVaultPoolsAdminBase {
+	static createFromAddress(address) {
+		return new JVaultFixedPoolsAdmin(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: buildJVaultFixedPoolsAdminData(config)
+		};
+		return new JVaultFixedPoolsAdmin(contractAddress(workchain, init), init);
+	}
+};
+var JVaultFloatingPoolsAdmin = class JVaultFloatingPoolsAdmin extends JVaultPoolsAdminBase {
+	static createFromAddress(address) {
+		return new JVaultFloatingPoolsAdmin(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: buildJVaultFloatingPoolsAdminData(config)
+		};
+		return new JVaultFloatingPoolsAdmin(contractAddress(workchain, init), init);
+	}
+};
+function buildJVaultSharecomsData(config) {
+	const nfts = Dictionary.empty(Dictionary.Keys.BigUint(256), {
+		serialize: (value, builder) => builder.storeUint(value, 32),
+		parse: (slice) => slice.loadUint(32)
+	});
+	const commissions = Dictionary.empty(Dictionary.Keys.Uint(32), {
+		serialize: (value, builder) => builder.storeUint(value, 256),
+		parse: (slice) => slice.loadUintBig(256)
+	});
+	return beginCell().storeAddress(config.poolAddress).storeAddress(config.poolAdminAddress).storeUint(config.lastCommissionTime ?? 0, 32).storeCoins(config.allCommissions ?? 0n).storeRef(beginCell().storeAddress(config.stakingAddress).storeAddress(config.jettonWalletAddress).storeBit(0).endCell()).storeRef(config.nftItemCode).storeDict(nfts).storeUint(0, 16).storeDict(commissions).endCell();
+}
+var JVaultFloatingSharecoms = class JVaultFloatingSharecoms extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultFloatingSharecoms(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: buildJVaultSharecomsData(config)
+		};
+		return new JVaultFloatingSharecoms(contractAddress(workchain, init), init);
+	}
+	async getJettonWalletAddress(provider) {
+		return (await this.get(provider, "get_jetton_wallet_adress")).readAddress();
+	}
+	async getCommissionsPerDivider(provider) {
+		return (await this.get(provider, "get_commissions_per_devider")).readBigNumber();
+	}
+	async getLastClaimedCommissionTime(provider, nftId) {
+		return (await this.get(provider, "get_last_claimed_commission_time", [{
+			type: "int",
+			value: nftId
+		}])).readBigNumber();
+	}
+	async getClaimableCommissionsByTime(provider, time, stakedJvt) {
+		return (await this.get(provider, "get_claimable_commissions_by_time", [{
+			type: "int",
+			value: time
+		}, {
+			type: "int",
+			value: stakedJvt
+		}])).readBigNumber();
+	}
+	async getDicts(provider) {
+		const stack = await this.get(provider, "get_dicts");
+		return {
+			nfts: stack.readCell(),
+			commissions: stack.readCell()
+		};
+	}
+	async getStorageData(provider) {
+		const stack = await this.get(provider, "get_storage_data");
+		return {
+			pool: stack.readAddress(),
+			poolAdmin: stack.readAddress(),
+			lastCommissionTime: stack.readBigNumber(),
+			allCommissions: stack.readBigNumber(),
+			staking: stack.readAddress(),
+			jettonWallet: stack.readAddress(),
+			jettonWalletSet: stack.readBoolean(),
+			nftItemCode: stack.readCell(),
+			nfts: stack.readCell(),
+			nftCount: stack.readNumber(),
+			commissions: stack.readCell()
+		};
+	}
+	async getVersion(provider) {
+		return (await this.get(provider, "get_version")).readNumber();
+	}
+	async sendWithdrawJetton(provider, via, value, jettonWallet, amount, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.withdrawJetton, queryId).storeAddress(jettonWallet).storeCoins(amount).endCell());
+	}
+	async sendWithdrawTon(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.withdrawTon, queryId).endCell());
+	}
+	async sendSetJettonWallet(provider, via, value, address, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.takeWalletAddress, queryId).storeAddress(address).endCell());
+	}
+};
+function buildJVaultSbtItemData(config) {
+	return beginCell().storeUint(config.index, 64).storeAddress(config.collection).endCell();
+}
+var JVaultSbtSingle = class JVaultSbtSingle extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultSbtSingle(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: buildJVaultSbtItemData(config)
+		};
+		return new JVaultSbtSingle(contractAddress(workchain, init), init);
+	}
+	async sendDeploy(provider, via, value, owner, content, authority) {
+		await this.send(provider, via, value, beginCell().storeAddress(owner).storeRef(content).storeAddress(authority ?? null).endCell());
+	}
+	async sendProveOwnership(provider, via, value, destination, forwardPayload, withContent, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.proveOwnership, queryId).storeAddress(destination).storeRef(forwardPayload).storeBit(withContent).endCell());
+	}
+	async sendBuyWhitelist(provider, via, value, destination, level, referral) {
+		if (!Number.isInteger(level) || level < 0 || level > 3) throw new RangeError("level must fit in uint2");
+		const payloadBuilder = beginCell().storeUint(level, 2);
+		if (referral) payloadBuilder.storeRef(beginCell().storeAddress(referral).endCell());
+		const payload = payloadBuilder.endCell();
+		await this.sendProveOwnership(provider, via, value, destination, payload, false);
+	}
+	async getNftData(provider) {
+		const stack = await this.get(provider, "get_nft_data");
+		return {
+			initialized: stack.readBoolean(),
+			index: stack.readBigNumber(),
+			collection: stack.readAddress(),
+			owner: stack.readAddressOpt(),
+			content: stack.readCell()
+		};
+	}
+	async getAuthorityAddress(provider) {
+		return (await this.get(provider, "get_authority_address")).readAddress();
+	}
+	async getRevokedTime(provider) {
+		return (await this.get(provider, "get_revoked_time")).readBigNumber();
+	}
+};
+//#endregion
+export { JVAULT_SUPPORT_SOURCE_REVISIONS, JVaultFixedPoolsAdmin, JVaultFloatingPoolsAdmin, JVaultFloatingSharecoms, JVaultSbtSingle, buildJVaultFixedPoolsAdminData, buildJVaultFloatingPoolsAdminData, buildJVaultSbtItemData, buildJVaultSharecomsData };

package/dist/contracts/wrappers/jvault.d.mts

@@ -0,0 +1,123 @@
+import { ContractWrapper } from "./base.mjs";
+import { Address, Cell, ContractProvider, Sender } from "@ton/core";
+//#region src/contracts/wrappers/jvault.d.ts
+/** JVault staking-v2 source: https://github.com/JVault-app/staking-v2 */
+export declare const JVAULT_STAKING_V2_COMMIT = "f7e83860ba7138c88bf63da13884f54d04589191";
+export declare const JVAULT_OPCODES: {
+  readonly transferJetton: 260734629;
+  readonly claimRewards: 2027548937;
+  readonly unstakeJettons: 1234866786;
+  readonly unstakeRequest: 23647415;
+  readonly cancelUnstakeRequest: 2760970010;
+  readonly addRewardJettons: 275213031;
+  readonly addRewards: 3675696277;
+  readonly claimCommissions: 3165188199;
+  readonly claimReferralRewards: 2027548937;
+  readonly deployNewPool: 3666222871;
+  readonly setLockWallet: 3513996288;
+  readonly deployReferrerWallets: 3736195191;
+  readonly changeCreationFee: 1725256331;
+  readonly changeContent: 247632384;
+  readonly updatePoolsCode: 3736195208;
+  readonly updateCodes: 2244551631;
+  readonly sendWithdrawTon: 3854050959;
+  readonly requestUpdateReferrer: 1438866240;
+  readonly sendReferrerRewards: 3087954386;
+  readonly updateReferrer: 124708064;
+  readonly upgradeReferrerWallet: 2529429272;
+  readonly setData: 942936554;
+};
+export interface JVaultStakeForwardPayload {
+  readonly lockPeriodDays: number;
+  readonly referrer?: Address | null;
+}
+export declare function buildJVaultStakeForwardPayload(input: JVaultStakeForwardPayload): Cell;
+export interface JVaultStakeBody {
+  readonly jettonAmount: bigint;
+  readonly pool: Address;
+  readonly owner: Address;
+  readonly lockPeriodDays: number;
+  readonly referrer?: Address | null;
+  readonly queryId?: bigint;
+}
+export declare function buildJVaultStakeBody(input: JVaultStakeBody): Cell;
+export interface JVaultAddRewardsBody {
+  readonly jettonAmount: bigint;
+  readonly pool: Address;
+  readonly owner: Address;
+  readonly startTime: number;
+  readonly endTime: number;
+  readonly queryId?: bigint;
+}
+export declare function buildJVaultAddRewardsBody(input: JVaultAddRewardsBody): Cell;
+export interface JVaultDeployPoolPeriod {
+  readonly days: number;
+  readonly tvlLimit: bigint | null;
+  readonly rewardMultiplierPerMille: number;
+  readonly depositCommissionBps: number;
+  readonly unstakeCommissionBps: number;
+}
+export interface JVaultDeployPoolPayload {
+  readonly factory: Address;
+  readonly lockJettonMaster: Address;
+  readonly sender: Address;
+  readonly poolName: string;
+  readonly jettonSymbol: string;
+  readonly jettonFullName: string;
+  readonly jettonDecimals: number;
+  readonly minDeposit: bigint;
+  readonly maxDeposit: bigint | null;
+  readonly periods: readonly JVaultDeployPoolPeriod[];
+  readonly whitelist?: readonly Address[];
+  readonly rewardsCommissionBps: number;
+  readonly creationFee: bigint;
+  readonly imageUrl: string;
+  readonly queryId?: bigint;
+}
+/** Encodes PoolFactory::deploy_new_pool from staking-v2/functions.fc. */
+export declare function buildJVaultDeployPoolBody(input: JVaultDeployPoolPayload): Cell;
+export declare class JVaultStakingPool extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultStakingPool;
+  static createFromConfig(config: {
+    code: Cell;
+    data: Cell;
+  }, workchain?: number): JVaultStakingPool;
+  sendAddRewardJettons(provider: ContractProvider, via: Sender, wallets: readonly Address[], value: bigint, queryIdValue?: bigint): Promise<void>;
+  sendAddRewards(provider: ContractProvider, via: Sender, input: JVaultAddRewardsBody, value: bigint): Promise<void>;
+  sendClaimCommissions(provider: ContractProvider, via: Sender, value: bigint, queryIdValue?: bigint): Promise<void>;
+  sendSetLockWallet(provider: ContractProvider, via: Sender, wallet: Address, value: bigint, queryIdValue?: bigint): Promise<void>;
+  getStorageData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+  getStakeWalletAddress(provider: ContractProvider, owner: Address, lockPeriodSeconds: number): Promise<Address>;
+}
+export declare class JVaultStakeWallet extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultStakeWallet;
+  sendUnstakeRequest(provider: ContractProvider, via: Sender, amount: bigint, value: bigint, queryIdValue?: bigint): Promise<void>;
+  sendUnstake(provider: ContractProvider, via: Sender, amount: bigint, force: boolean, value: bigint, queryIdValue?: bigint): Promise<void>;
+  sendCancelUnstake(provider: ContractProvider, via: Sender, requestTimes: readonly number[], value: bigint, queryIdValue?: bigint): Promise<void>;
+  sendClaimRewards(provider: ContractProvider, via: Sender, poolJettonWallets: readonly Address[], value: bigint, queryIdValue?: bigint): Promise<void>;
+  getStorageData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+export declare class JVaultPoolFactory extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultPoolFactory;
+  sendDeployPool(provider: ContractProvider, via: Sender, payload: Cell, value: bigint): Promise<void>;
+  sendDeployPoolBody(provider: ContractProvider, via: Sender, input: JVaultDeployPoolPayload, value: bigint): Promise<void>;
+  sendDeployReferrerWallets(provider: ContractProvider, via: Sender, owners: readonly Address[], value: bigint, queryIdValue?: bigint): Promise<void>;
+  getStorageData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+  getPoolAddressByIndex(provider: ContractProvider, index: number): Promise<Address>;
+}
+export declare class JVaultReferrerWallet extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultReferrerWallet;
+  sendClaimRewards(provider: ContractProvider, via: Sender, entries: readonly JVaultReferralClaimEntry[], value: bigint, queryIdValue?: bigint): Promise<void>;
+  getStorageData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+export interface JVaultReferralClaimEntry {
+  readonly poolId: number;
+  readonly poolJettonWallets: readonly Address[];
+}
+/** Encodes ReferrerWallet::claim_rewards' HashmapE(32, coins + wallet set). */
+export declare function buildJVaultReferralClaimBody(entries: readonly JVaultReferralClaimEntry[], queryIdValue?: bigint): Cell;
+export declare class JVaultInviteeWallet extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultInviteeWallet;
+  getStorageData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+//#endregion