@pizzaton/ton 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,206 @@
+import { uint256CoinsDictionary } from "../codecs.mjs";
+import { ContractWrapper } from "./base.mjs";
+import { Address, Cell, ContractProvider, Dictionary, Sender, Slice } from "@ton/core";
+//#region src/contracts/wrappers/jvault-protocols.d.ts
+/** Exact source revisions for the JVault repositories. */
+export declare const JVAULT_SOURCE_REVISIONS: {
+  readonly stakingV2: "f7e83860ba7138c88bf63da13884f54d04589191";
+  readonly vesting: "b6d80efdbbeeeda4113ebc9d08c942b543b6b6b6";
+  readonly airdrop: "54edd36d242295699278b5668514dd6f2b10260d";
+  readonly decentralizedLaunchpad: "83f59e126e5e885f2d7da792998a5d569c0aa944";
+  readonly floatingStaking: "51c86b4469fd99b3e2ebdff6f8cdad9fee067b4c";
+  readonly fixedStaking: "63cbc8137a7dca0269bcdd9089a9dcc37acbb727";
+};
+export interface JVaultVestingConfig {
+  readonly factoryAddress: Address;
+  readonly index: bigint;
+  readonly ownerAddress?: Address;
+  readonly jettonMinterAddress?: Address;
+  readonly jettonWalletAddress?: Address | null;
+  readonly content?: Cell | null;
+  readonly factoryJettonWallet?: Address;
+  readonly lockedJettons?: bigint;
+  readonly jettonsLocked?: boolean;
+  readonly claimedTimes?: number;
+  readonly claimedJettons?: bigint;
+  readonly firstUnlockTime?: number;
+  readonly firstUnlockSize?: number;
+  readonly cycleLength?: number;
+  readonly cyclesNumber?: number;
+}
+export declare function buildJVaultVestingData(config: JVaultVestingConfig): Cell;
+export declare class JVaultVesting extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultVesting;
+  static createFromConfig(config: JVaultVestingConfig, code: Cell, workchain?: number): JVaultVesting;
+  sendClaim(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendBurnLockedJettons(provider: ContractProvider, via: Sender, value: bigint, amount?: bigint, queryId?: bigint): Promise<void>;
+  sendWithdrawJetton(provider: ContractProvider, via: Sender, value: bigint, wallet: Address, amount: bigint, queryId?: bigint): Promise<void>;
+  sendProveOwnership(provider: ContractProvider, via: Sender, value: bigint, destination: Address, payload: Cell, withContent: boolean, queryId?: bigint): Promise<void>;
+  sendTakeExcess(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  getStorageData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+  getNftData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+export interface JVaultVestingFactoryConfig {
+  readonly adminAddress: Address;
+  readonly startIndex: bigint;
+  readonly creationFee: bigint;
+  readonly vestingCodes: Dictionary<bigint, Slice>;
+  readonly content?: Cell | null;
+  readonly version: number;
+}
+export declare function buildJVaultVestingFactoryData(config: JVaultVestingFactoryConfig): Cell;
+/** Builds the HashmapE(128, Slice) used by the vesting factory code registry. */
+export declare function buildJVaultVestingCodeDictionary(codes: ReadonlyMap<bigint, Cell>): Dictionary<bigint, Slice>;
+export declare class JVaultVestingFactory extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultVestingFactory;
+  static createFromConfig(config: JVaultVestingFactoryConfig, code: Cell, workchain?: number): JVaultVestingFactory;
+  sendDeployVesting(provider: ContractProvider, via: Sender, value: bigint, payload: Cell): Promise<void>;
+  sendUpdateVestingCode(provider: ContractProvider, via: Sender, code: Cell, value: bigint): Promise<void>;
+  sendChangeCreationFee(provider: ContractProvider, via: Sender, fee: bigint, value: bigint): Promise<void>;
+  sendChangeContent(provider: ContractProvider, via: Sender, content: Cell | null, value: bigint): Promise<void>;
+  sendWithdrawTon(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+  getStorageData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+  getVestingAddress(provider: ContractProvider, index: bigint): Promise<Address>;
+}
+export type JettonAmountDictionary = Dictionary<bigint, bigint>;
+export interface JVaultAirdropMainConfig {
+  readonly publicKey: bigint;
+  readonly userContractCode: Cell;
+  readonly adminAddress: Address;
+}
+export declare function buildJVaultAirdropMainData(config: JVaultAirdropMainConfig): Cell;
+export declare class JVaultAirdropMain extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultAirdropMain;
+  static createFromConfig(config: JVaultAirdropMainConfig, code: Cell, workchain?: number): JVaultAirdropMain;
+  sendClaim(provider: ContractProvider, via: Sender, owner: Address, campaignId: number, claims: JettonAmountDictionary, value: bigint, queryId?: bigint): Promise<void>;
+  sendWithdrawTon(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendWithdrawJettons(provider: ContractProvider, via: Sender, claims: JettonAmountDictionary, value: bigint, queryId?: bigint): Promise<void>;
+  getUserContractAddress(provider: ContractProvider, owner: Address, campaignId: number): Promise<Address>;
+}
+export interface JVaultAirdropUserConfig {
+  readonly ownerAddress: Address;
+  readonly parentAddress: Address;
+  readonly campaignId: number;
+  readonly publicKey: bigint;
+}
+export declare function buildJVaultAirdropUserData(config: JVaultAirdropUserConfig): Cell;
+export declare class JVaultAirdropUser extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultAirdropUser;
+  static createFromConfig(config: JVaultAirdropUserConfig, code: Cell, workchain?: number): JVaultAirdropUser;
+  sendClaim(provider: ContractProvider, via: Sender, signature: Cell, campaignId: number, owner: Address, previous: Dictionary<bigint, Cell>, next: Dictionary<bigint, Cell>, value: bigint, queryId?: bigint): Promise<void>;
+  sendWithdrawTon(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendWithdrawJettons(provider: ContractProvider, via: Sender, claims: JettonAmountDictionary, value: bigint, queryId?: bigint): Promise<void>;
+  getStorageData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+export interface JVaultFixedCollectionConfig {
+  readonly collectionContent: Cell;
+  readonly nftItemCode: Cell;
+  readonly lockWallet: Address;
+  readonly rewardsWallet: Address;
+  readonly stakingParams: Dictionary<number, bigint>;
+  readonly minimumDeposit: bigint;
+  readonly commissionFactor: number;
+  readonly admin: Address;
+  readonly creator: Address;
+}
+export declare function buildJVaultFixedCollectionData(config: JVaultFixedCollectionConfig): Cell;
+export declare class JVaultFixedStakingCollection extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultFixedStakingCollection;
+  static createFromConfig(config: JVaultFixedCollectionConfig, code: Cell, workchain?: number): JVaultFixedStakingCollection;
+  sendMint(provider: ContractProvider, via: Sender, itemIndex: bigint, owner: Address, content: Cell, value: bigint, queryId?: bigint, itemValue?: bigint): Promise<void>;
+  sendBatchMint(provider: ContractProvider, via: Sender, nfts: Dictionary<bigint, Cell>, value: bigint, queryId?: bigint): Promise<void>;
+  getStorageData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+export declare class JVaultFixedStakingNftItem extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultFixedStakingNftItem;
+  sendTransfer(provider: ContractProvider, via: Sender, newOwner: Address, value: bigint, queryId?: bigint, responseDestination?: Address | null, forwardAmount?: bigint): Promise<void>;
+}
+export declare class JVaultFloatingStakingCollection extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultFloatingStakingCollection;
+  sendSetWalletAddress(provider: ContractProvider, via: Sender, walletAddress: Address, value: bigint, queryId?: bigint): Promise<void>;
+  sendGetStorageData(provider: ContractProvider, via: Sender, toAddress: Address, value: bigint, queryId?: bigint): Promise<void>;
+  sendChangeStartTime(provider: ContractProvider, via: Sender, startTime: number, value: bigint, queryId?: bigint): Promise<void>;
+  sendClosePremint(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendWithdrawRewards(provider: ContractProvider, via: Sender, amount: bigint, value: bigint, queryId?: bigint): Promise<void>;
+  sendWithdrawAccidentJettons(provider: ContractProvider, via: Sender, wallet: Address, amount: bigint, value: bigint, queryId?: bigint): Promise<void>;
+  sendWithdrawTon(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  getCollectionData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+  getNftContent(provider: ContractProvider, index: bigint): Promise<string>;
+  getVersion(provider: ContractProvider): Promise<bigint>;
+  getStorageData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+  getNftAddressByIndex(provider: ContractProvider, index: bigint): Promise<Address>;
+  getNftRewards(provider: ContractProvider, locked: bigint, distributed: bigint): Promise<bigint>;
+}
+export declare class JVaultFloatingStakingNftItem extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultFloatingStakingNftItem;
+  sendClaim(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendWithdraw(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendTransfer(provider: ContractProvider, via: Sender, owner: Address, value: bigint, queryId?: bigint, forwardPayload?: Cell): Promise<void>;
+}
+export declare class JVaultIcoSale extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultIcoSale;
+  sendBuy(provider: ContractProvider, via: Sender, value: bigint, referrer?: Address): Promise<void>;
+  sendEndSale(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendChangeOwner(provider: ContractProvider, via: Sender, owner: Address, value: bigint, queryId?: bigint): Promise<void>;
+  sendChangePurchaseInfo(provider: ContractProvider, via: Sender, purchaseConditions: Cell, value: bigint, queryId?: bigint): Promise<void>;
+  sendAddRefAddresses(provider: ContractProvider, via: Sender, refs: Dictionary<bigint, JVaultReferenceTerms>, value: bigint, queryId?: bigint): Promise<void>;
+  sendDeployRefs(provider: ContractProvider, via: Sender, startAddress: Address | null, value: bigint, queryId?: bigint): Promise<void>;
+  getJettonData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+  getWalletAddress(provider: ContractProvider, owner: Address): Promise<Address>;
+  getRefAddress(provider: ContractProvider, owner: Address): Promise<Address>;
+  getStorageData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+export interface JVaultReferenceTerms {
+  readonly discountFactor: number;
+  readonly cashbackFactor: number;
+}
+/** The decentralized-launchpad contracts key referrer maps by address hash. */
+export declare function buildJVaultReferenceDictionary(refs: ReadonlyMap<Address, JVaultReferenceTerms>): Dictionary<bigint, JVaultReferenceTerms>;
+export interface JVaultRefWalletConfig {
+  readonly ownerAddress: Address;
+  readonly collectionAddress: Address;
+  readonly saleEndTime: number;
+}
+export declare function buildJVaultRefWalletData(config: JVaultRefWalletConfig): Cell;
+export declare class JVaultRefWallet extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultRefWallet;
+  static createFromConfig(config: JVaultRefWalletConfig, code: Cell, workchain?: number): JVaultRefWallet;
+  sendClaimRef(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  getStorageData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+export interface JVaultSftItemConfig {
+  readonly index: bigint;
+  readonly collectionAddress: Address;
+}
+export declare function buildJVaultSftItemData(config: JVaultSftItemConfig): Cell;
+export interface JVaultSftItemUpdate {
+  readonly jettonsToPurchase: bigint;
+  readonly collectedTon: bigint;
+  readonly maxCollectedTon: bigint;
+  readonly buyerAddress: Address;
+  readonly firstUnlockTime: number;
+  readonly firstUnlockSize: number;
+  readonly cycleLength: number;
+  readonly cyclesNumber: number;
+  readonly refData?: Cell | null;
+  readonly changeInvitee: boolean;
+}
+export declare function buildJVaultSftItemUpdateBody(update: JVaultSftItemUpdate, queryId?: bigint): Cell;
+export declare class JVaultLaunchpadSftItem extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultLaunchpadSftItem;
+  static createFromConfig(config: JVaultSftItemConfig, code: Cell, workchain?: number): JVaultLaunchpadSftItem;
+  sendUpdate(provider: ContractProvider, via: Sender, update: JVaultSftItemUpdate, value: bigint, queryId?: bigint): Promise<void>;
+  sendClaim(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendRequestRefund(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  getStorageData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+export declare class JVaultSaleAdmin extends ContractWrapper {
+  static createFromAddress(address: Address): JVaultSaleAdmin;
+  sendDeploySale(provider: ContractProvider, via: Sender, saleConfig: Cell, value: bigint): Promise<void>;
+  sendChangeJettonWallet(provider: ContractProvider, via: Sender, jettonWallet: Address, value: bigint, queryId?: bigint): Promise<void>;
+  sendChangeCodes(provider: ContractProvider, via: Sender, icoSaleCode: Cell, sftItemCode: Cell, refWalletCode: Cell, value: bigint, queryId?: bigint): Promise<void>;
+  sendSetCode(provider: ContractProvider, via: Sender, saleAdminCode: Cell, value: bigint, queryId?: bigint): Promise<void>;
+  getStorageData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+//#endregion
+export { uint256CoinsDictionary };

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

@@ -0,0 +1,432 @@
+import { uint256CoinsDictionary } from "../codecs.mjs";
+import { NFT_OPCODES } from "../../nft/index.mjs";
+import { ContractWrapper } from "./base.mjs";
+import { Cell, Dictionary, beginCell, contractAddress } from "@ton/core";
+//#region src/contracts/wrappers/jvault-protocols.ts
+/** Exact source revisions for the JVault repositories. */
+const JVAULT_SOURCE_REVISIONS = {
+	stakingV2: "f7e83860ba7138c88bf63da13884f54d04589191",
+	vesting: "b6d80efdbbeeeda4113ebc9d08c942b543b6b6b6",
+	airdrop: "54edd36d242295699278b5668514dd6f2b10260d",
+	decentralizedLaunchpad: "83f59e126e5e885f2d7da792998a5d569c0aa944",
+	floatingStaking: "51c86b4469fd99b3e2ebdff6f8cdad9fee067b4c",
+	fixedStaking: "63cbc8137a7dca0269bcdd9089a9dcc37acbb727"
+};
+const OP = {
+	claim: 2808733223,
+	withdrawTon: 930245595,
+	withdrawJetton: 297834114,
+	proveOwnership: 81711432,
+	takeExcess: 3510031283,
+	burnLockedJettons: 1814361107,
+	updateVestingCode: 3746502603,
+	changeCreationFee: 1627537649,
+	changeContent: 247632384,
+	changeFactoryCode: 3805467153,
+	initialize: 3624791682,
+	transferNft: 1607220500,
+	claimNft: 2808733223,
+	withdrawNft: 3051249566,
+	changeStartTime: 2228344912,
+	closePremint: 213450974,
+	withdrawRewards: 7,
+	withdrawAccidentJettons: 9,
+	changeStateNft: 3701725772,
+	deployIcoSale: 382519873,
+	changeOwner: 2477808433,
+	changePurchaseInfo: 2816294541,
+	addRefAddresses: 2061877706,
+	endSale: 3414277128,
+	deployRefs: 3590818427,
+	claimRef: 528174657,
+	requestRefund: 276158371,
+	updateSbtData: 3701725772,
+	changeJettonWallet: 2015065302,
+	changeCodes: 3112008704,
+	setCode: 65535
+};
+const header = (op, queryId = 0n) => beginCell().storeUint(op, 32).storeUint(queryId, 64);
+function buildJVaultVestingData(config) {
+	const root = beginCell().storeAddress(config.factoryAddress).storeUint(config.index, 128);
+	if (!config.ownerAddress || !config.jettonMinterAddress) return root.endCell();
+	return root.storeAddress(config.ownerAddress).storeAddress(config.jettonMinterAddress).storeMaybeRef(config.content ?? null).storeRef(beginCell().storeAddress(config.jettonWalletAddress ?? null).storeAddress(config.factoryJettonWallet ?? null).storeCoins(config.lockedJettons ?? 0n).storeBit(config.jettonsLocked ?? false).storeUint(config.claimedTimes ?? 0, 32).storeCoins(config.claimedJettons ?? 0n).storeUint(config.firstUnlockTime ?? 0, 32).storeUint(config.firstUnlockSize ?? 0, 32).storeUint(config.cycleLength ?? 0, 32).storeUint(config.cyclesNumber ?? 0, 32).endCell()).endCell();
+}
+var JVaultVesting = class JVaultVesting extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultVesting(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: buildJVaultVestingData(config)
+		};
+		return new JVaultVesting(contractAddress(workchain, init), init);
+	}
+	async sendClaim(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.claim, queryId).endCell());
+	}
+	async sendBurnLockedJettons(provider, via, value, amount, queryId = 0n) {
+		const body = header(OP.burnLockedJettons, queryId);
+		await this.send(provider, via, value, (amount === void 0 ? body : body.storeCoins(amount)).endCell());
+	}
+	async sendWithdrawJetton(provider, via, value, wallet, amount, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.withdrawJetton, queryId).storeAddress(wallet).storeCoins(amount).endCell());
+	}
+	async sendProveOwnership(provider, via, value, destination, payload, withContent, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.proveOwnership, queryId).storeAddress(destination).storeRef(payload).storeBit(withContent).endCell());
+	}
+	async sendTakeExcess(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.takeExcess, queryId).endCell());
+	}
+	async getStorageData(provider) {
+		return this.get(provider, "get_storage_data");
+	}
+	async getNftData(provider) {
+		return this.get(provider, "get_nft_data");
+	}
+};
+function buildJVaultVestingFactoryData(config) {
+	return beginCell().storeAddress(config.adminAddress).storeUint(config.startIndex, 128).storeCoins(config.creationFee).storeDict(config.vestingCodes).storeMaybeRef(config.content ?? null).storeUint(config.version, 8).endCell();
+}
+/** Builds the HashmapE(128, Slice) used by the vesting factory code registry. */
+function buildJVaultVestingCodeDictionary(codes) {
+	const dictionary = Dictionary.empty(Dictionary.Keys.BigUint(128), {
+		serialize: (slice, builder) => builder.storeSlice(slice),
+		parse: (slice) => slice
+	});
+	for (const [index, code] of codes) dictionary.set(index, code.beginParse());
+	return dictionary;
+}
+var JVaultVestingFactory = class JVaultVestingFactory extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultVestingFactory(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: buildJVaultVestingFactoryData(config)
+		};
+		return new JVaultVestingFactory(contractAddress(workchain, init), init);
+	}
+	async sendDeployVesting(provider, via, value, payload) {
+		await this.send(provider, via, value, payload);
+	}
+	async sendUpdateVestingCode(provider, via, code, value) {
+		await this.send(provider, via, value, header(OP.updateVestingCode).storeMaybeRef(code).endCell());
+	}
+	async sendChangeCreationFee(provider, via, fee, value) {
+		await this.send(provider, via, value, header(OP.changeCreationFee).storeCoins(fee).endCell());
+	}
+	async sendChangeContent(provider, via, content, value) {
+		await this.send(provider, via, value, header(OP.changeContent).storeMaybeRef(content).endCell());
+	}
+	async sendWithdrawTon(provider, via, value) {
+		await this.send(provider, via, value, header(OP.withdrawTon).endCell());
+	}
+	async getStorageData(provider) {
+		return this.get(provider, "get_storage_data");
+	}
+	async getVestingAddress(provider, index) {
+		return (await this.get(provider, "get_nft_address_by_index", [{
+			type: "int",
+			value: index
+		}])).readAddress();
+	}
+};
+function buildJVaultAirdropMainData(config) {
+	return beginCell().storeUint(config.publicKey, 256).storeRef(config.userContractCode).storeAddress(config.adminAddress).endCell();
+}
+var JVaultAirdropMain = class JVaultAirdropMain extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultAirdropMain(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: buildJVaultAirdropMainData(config)
+		};
+		return new JVaultAirdropMain(contractAddress(workchain, init), init);
+	}
+	async sendClaim(provider, via, owner, campaignId, claims, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.claim, queryId).storeAddress(owner).storeUint(campaignId, 32).storeDict(claims).endCell());
+	}
+	async sendWithdrawTon(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.withdrawTon, queryId).endCell());
+	}
+	async sendWithdrawJettons(provider, via, claims, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.withdrawJetton, queryId).storeDict(claims).endCell());
+	}
+	async getUserContractAddress(provider, owner, campaignId) {
+		return (await this.get(provider, "get_user_contract_address", [{
+			type: "slice",
+			cell: beginCell().storeAddress(owner).endCell()
+		}, {
+			type: "int",
+			value: BigInt(campaignId)
+		}])).readAddress();
+	}
+};
+function buildJVaultAirdropUserData(config) {
+	return beginCell().storeBit(0).storeAddress(config.ownerAddress).storeAddress(config.parentAddress).storeUint(config.campaignId, 32).storeUint(config.publicKey, 256).storeBit(0).endCell();
+}
+var JVaultAirdropUser = class JVaultAirdropUser extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultAirdropUser(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: buildJVaultAirdropUserData(config)
+		};
+		return new JVaultAirdropUser(contractAddress(workchain, init), init);
+	}
+	async sendClaim(provider, via, signature, campaignId, owner, previous, next, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.claim, queryId).storeRef(signature).storeUint(campaignId, 32).storeAddress(owner).storeDict(previous).storeDict(next).endCell());
+	}
+	async sendWithdrawTon(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.withdrawTon, queryId).endCell());
+	}
+	async sendWithdrawJettons(provider, via, claims, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.withdrawJetton, queryId).storeDict(claims).endCell());
+	}
+	async getStorageData(provider) {
+		return this.get(provider, "get_storage_data");
+	}
+};
+function buildJVaultFixedCollectionData(config) {
+	return beginCell().storeUint(0, 33).storeRef(config.nftItemCode).storeRef(config.collectionContent).storeAddress(config.lockWallet).storeAddress(config.rewardsWallet).storeDict(config.stakingParams).storeCoins(config.minimumDeposit).storeUint(config.commissionFactor, 16).storeCoins(0).storeCoins(0).storeRef(beginCell().storeAddress(config.admin).storeAddress(config.creator).endCell()).endCell();
+}
+var JVaultFixedStakingCollection = class JVaultFixedStakingCollection extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultFixedStakingCollection(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: buildJVaultFixedCollectionData(config)
+		};
+		return new JVaultFixedStakingCollection(contractAddress(workchain, init), init);
+	}
+	async sendMint(provider, via, itemIndex, owner, content, value, queryId = 0n, itemValue = 0n) {
+		await this.send(provider, via, value, beginCell().storeUint(1, 32).storeUint(queryId, 64).storeUint(itemIndex, 64).storeCoins(itemValue).storeRef(beginCell().storeAddress(owner).storeRef(content).endCell()).endCell());
+	}
+	async sendBatchMint(provider, via, nfts, value, queryId = 0n) {
+		await this.send(provider, via, value, beginCell().storeUint(2, 32).storeUint(queryId, 64).storeDict(nfts).endCell());
+	}
+	async getStorageData(provider) {
+		return this.get(provider, "get_storage_data");
+	}
+};
+var JVaultFixedStakingNftItem = class JVaultFixedStakingNftItem extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultFixedStakingNftItem(address);
+	}
+	async sendTransfer(provider, via, newOwner, value, queryId = 0n, responseDestination = null, forwardAmount = 0n) {
+		await this.send(provider, via, value, beginCell().storeUint(NFT_OPCODES.transfer, 32).storeUint(queryId, 64).storeAddress(newOwner).storeAddress(responseDestination).storeBit(0).storeCoins(forwardAmount).storeBit(0).endCell());
+	}
+};
+var JVaultFloatingStakingCollection = class JVaultFloatingStakingCollection extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultFloatingStakingCollection(address);
+	}
+	async sendSetWalletAddress(provider, via, walletAddress, value, queryId = 0n) {
+		await this.send(provider, via, value, header(3513996288, queryId).storeAddress(walletAddress).endCell());
+	}
+	async sendGetStorageData(provider, via, toAddress, value, queryId = 0n) {
+		await this.send(provider, via, value, header(1535698380, queryId).storeAddress(toAddress).endCell());
+	}
+	async sendChangeStartTime(provider, via, startTime, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.changeStartTime, queryId).storeUint(startTime, 32).endCell());
+	}
+	async sendClosePremint(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.closePremint, queryId).endCell());
+	}
+	async sendWithdrawRewards(provider, via, amount, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.withdrawRewards, queryId).storeCoins(amount).endCell());
+	}
+	async sendWithdrawAccidentJettons(provider, via, wallet, amount, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.withdrawAccidentJettons, queryId).storeAddress(wallet).storeCoins(amount).endCell());
+	}
+	async sendWithdrawTon(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(4, queryId).endCell());
+	}
+	async getCollectionData(provider) {
+		return this.get(provider, "get_collection_data");
+	}
+	async getNftContent(provider, index) {
+		return (await this.get(provider, "get_nft_content", [{
+			type: "int",
+			value: index
+		}, {
+			type: "cell",
+			cell: beginCell().storeBit(1).endCell()
+		}])).readCell().beginParse().skip(8).loadStringTail();
+	}
+	async getVersion(provider) {
+		return (await this.get(provider, "get_version")).readBigNumber();
+	}
+	async getStorageData(provider) {
+		return this.get(provider, "get_storage_data");
+	}
+	async getNftAddressByIndex(provider, index) {
+		return (await this.get(provider, "get_nft_address_by_index", [{
+			type: "int",
+			value: index
+		}])).readAddress();
+	}
+	async getNftRewards(provider, locked, distributed) {
+		return (await this.get(provider, "get_nft_rewards", [{
+			type: "int",
+			value: locked
+		}, {
+			type: "int",
+			value: distributed
+		}])).readBigNumber();
+	}
+};
+var JVaultFloatingStakingNftItem = class JVaultFloatingStakingNftItem extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultFloatingStakingNftItem(address);
+	}
+	async sendClaim(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.claimNft, queryId).endCell());
+	}
+	async sendWithdraw(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.withdrawNft, queryId).endCell());
+	}
+	async sendTransfer(provider, via, owner, value, queryId = 0n, forwardPayload) {
+		await this.send(provider, via, value, beginCell().storeUint(NFT_OPCODES.transfer, 32).storeUint(queryId, 64).storeAddress(owner).storeAddress(via.address).storeBit(0).storeCoins(0).storeMaybeRef(forwardPayload).endCell());
+	}
+};
+var JVaultIcoSale = class JVaultIcoSale extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultIcoSale(address);
+	}
+	async sendBuy(provider, via, value, referrer) {
+		await this.send(provider, via, value, referrer ? beginCell().storeBit(1).storeRef(beginCell().storeAddress(referrer).endCell()).endCell() : Cell.EMPTY);
+	}
+	async sendEndSale(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.endSale, queryId).endCell());
+	}
+	async sendChangeOwner(provider, via, owner, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.changeOwner, queryId).storeAddress(owner).endCell());
+	}
+	async sendChangePurchaseInfo(provider, via, purchaseConditions, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.changePurchaseInfo, queryId).storeRef(purchaseConditions).endCell());
+	}
+	async sendAddRefAddresses(provider, via, refs, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.addRefAddresses, queryId).storeDict(refs).endCell());
+	}
+	async sendDeployRefs(provider, via, startAddress, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.deployRefs, queryId).storeAddress(startAddress).endCell());
+	}
+	async getJettonData(provider) {
+		return this.get(provider, "get_jetton_data");
+	}
+	async getWalletAddress(provider, owner) {
+		return (await this.get(provider, "get_wallet_address", [{
+			type: "slice",
+			cell: beginCell().storeAddress(owner).endCell()
+		}])).readAddress();
+	}
+	async getRefAddress(provider, owner) {
+		return (await this.get(provider, "get_ref_address", [{
+			type: "slice",
+			cell: beginCell().storeAddress(owner).endCell()
+		}])).readAddress();
+	}
+	async getStorageData(provider) {
+		return this.get(provider, "get_storage_data");
+	}
+};
+const JVAULT_REFERENCE_VALUE = {
+	serialize: (terms, builder) => {
+		builder.storeUint(terms.discountFactor, 32).storeUint(terms.cashbackFactor, 32);
+	},
+	parse: (slice) => ({
+		discountFactor: slice.loadUint(32),
+		cashbackFactor: slice.loadUint(32)
+	})
+};
+/** The decentralized-launchpad contracts key referrer maps by address hash. */
+function buildJVaultReferenceDictionary(refs) {
+	const dictionary = Dictionary.empty(Dictionary.Keys.BigUint(256), JVAULT_REFERENCE_VALUE);
+	for (const [address, terms] of refs) {
+		if (terms.discountFactor < 0 || terms.discountFactor > 4294967295 || terms.cashbackFactor < 0 || terms.cashbackFactor > 4294967295) throw new RangeError("reference factors must fit in uint32");
+		dictionary.set(BigInt(`0x${address.hash.toString("hex")}`), terms);
+	}
+	return dictionary;
+}
+function buildJVaultRefWalletData(config) {
+	return beginCell().storeAddress(config.ownerAddress).storeAddress(config.collectionAddress).storeUint(config.saleEndTime, 32).storeBit(0).endCell();
+}
+var JVaultRefWallet = class JVaultRefWallet extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultRefWallet(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: buildJVaultRefWalletData(config)
+		};
+		return new JVaultRefWallet(contractAddress(workchain, init), init);
+	}
+	async sendClaimRef(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.claimRef, queryId).endCell());
+	}
+	async getStorageData(provider) {
+		return this.get(provider, "get_storage_data");
+	}
+};
+function buildJVaultSftItemData(config) {
+	return beginCell().storeUint(config.index, 256).storeAddress(config.collectionAddress).endCell();
+}
+function buildJVaultSftItemUpdateBody(update, queryId = 0n) {
+	return header(OP.updateSbtData, queryId).storeCoins(update.jettonsToPurchase).storeCoins(update.collectedTon).storeCoins(update.maxCollectedTon).storeAddress(update.buyerAddress).storeUint(update.firstUnlockTime, 32).storeUint(update.firstUnlockSize, 32).storeUint(update.cycleLength, 32).storeUint(update.cyclesNumber, 16).storeBit(update.changeInvitee).storeMaybeRef(update.refData ?? null).endCell();
+}
+var JVaultLaunchpadSftItem = class JVaultLaunchpadSftItem extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultLaunchpadSftItem(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: buildJVaultSftItemData(config)
+		};
+		return new JVaultLaunchpadSftItem(contractAddress(workchain, init), init);
+	}
+	async sendUpdate(provider, via, update, value, queryId = 0n) {
+		await this.send(provider, via, value, buildJVaultSftItemUpdateBody(update, queryId));
+	}
+	async sendClaim(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.claimNft, queryId).endCell());
+	}
+	async sendRequestRefund(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.requestRefund, queryId).endCell());
+	}
+	async getStorageData(provider) {
+		return this.get(provider, "get_storage_data");
+	}
+};
+var JVaultSaleAdmin = class JVaultSaleAdmin extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultSaleAdmin(address);
+	}
+	async sendDeploySale(provider, via, saleConfig, value) {
+		await this.send(provider, via, value, header(OP.deployIcoSale).storeRef(saleConfig).endCell());
+	}
+	async sendChangeJettonWallet(provider, via, jettonWallet, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.changeJettonWallet, queryId).storeAddress(jettonWallet).endCell());
+	}
+	async sendChangeCodes(provider, via, icoSaleCode, sftItemCode, refWalletCode, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.changeCodes, queryId).storeRef(icoSaleCode).storeRef(sftItemCode).storeRef(refWalletCode).endCell());
+	}
+	async sendSetCode(provider, via, saleAdminCode, value, queryId = 0n) {
+		await this.send(provider, via, value, header(OP.setCode, queryId).storeRef(saleAdminCode).endCell());
+	}
+	async getStorageData(provider) {
+		return this.get(provider, "get_storage_data");
+	}
+};
+//#endregion
+export { JVAULT_SOURCE_REVISIONS, JVaultAirdropMain, JVaultAirdropUser, JVaultFixedStakingCollection, JVaultFixedStakingNftItem, JVaultFloatingStakingCollection, JVaultFloatingStakingNftItem, JVaultIcoSale, JVaultLaunchpadSftItem, JVaultRefWallet, JVaultSaleAdmin, JVaultVesting, JVaultVestingFactory, buildJVaultAirdropMainData, buildJVaultAirdropUserData, buildJVaultFixedCollectionData, buildJVaultRefWalletData, buildJVaultReferenceDictionary, buildJVaultSftItemData, buildJVaultSftItemUpdateBody, buildJVaultVestingCodeDictionary, buildJVaultVestingData, buildJVaultVestingFactoryData, uint256CoinsDictionary };