@pizzaton/ton 0.0.0-stage → 0.1.1

package/dist/contracts/wrappers/jvault.mjs

@@ -0,0 +1,258 @@
+import { addressFlagDictionary, uint32FlagDictionary } from "../codecs.mjs";
+import { JETTON_OPCODES, buildJettonTransferBody } from "../../jetton/index.mjs";
+import { buildOnchainMetadata } from "../../nft/content.mjs";
+import { ContractWrapper } from "./base.mjs";
+import { Dictionary, TupleBuilder, beginCell, contractAddress } from "@ton/core";
+//#region src/contracts/wrappers/jvault.ts
+/** JVault staking-v2 source: https://github.com/JVault-app/staking-v2 */
+const JVAULT_STAKING_V2_COMMIT = "f7e83860ba7138c88bf63da13884f54d04589191";
+const JVAULT_OPCODES = {
+	transferJetton: JETTON_OPCODES.transfer,
+	claimRewards: 2027548937,
+	unstakeJettons: 1234866786,
+	unstakeRequest: 23647415,
+	cancelUnstakeRequest: 2760970010,
+	addRewardJettons: 275213031,
+	addRewards: 3675696277,
+	claimCommissions: 3165188199,
+	claimReferralRewards: 2027548937,
+	deployNewPool: 3666222871,
+	setLockWallet: 3513996288,
+	deployReferrerWallets: 3736195191,
+	changeCreationFee: 1725256331,
+	changeContent: 247632384,
+	updatePoolsCode: 3736195208,
+	updateCodes: 2244551631,
+	sendWithdrawTon: 3854050959,
+	requestUpdateReferrer: 1438866240,
+	sendReferrerRewards: 3087954386,
+	updateReferrer: 124708064,
+	upgradeReferrerWallet: 2529429272,
+	setData: 942936554
+};
+const MAX_UINT32 = 4294967295;
+const MAX_UINT64 = 18446744073709551615n;
+const SECONDS_PER_DAY = 86400;
+const MAX_COINS = (1n << 120n) - 1n;
+function queryId(value) {
+	const result = value ?? 0n;
+	if (result < 0n || result > MAX_UINT64) throw new RangeError("queryId must be a uint64");
+	return result;
+}
+function uint(value, max, field) {
+	if (!Number.isSafeInteger(value) || value < 0 || value > max) throw new RangeError(`${field} must be an unsigned integer <= ${String(max)}`);
+	return value;
+}
+function positive(value, field) {
+	if (value <= 0n) throw new RangeError(`${field} must be positive`);
+	return value;
+}
+function bodyWithHeader(op, id) {
+	return beginCell().storeUint(op, 32).storeUint(queryId(id), 64);
+}
+function buildJVaultStakeForwardPayload(input) {
+	const seconds = uint(input.lockPeriodDays * SECONDS_PER_DAY, MAX_UINT32, "lockPeriodDays");
+	const builder = bodyWithHeader(3818940809).storeUint(seconds, 32);
+	return (input.referrer ? builder.storeMaybeRef(beginCell().storeAddress(input.referrer).endCell()) : builder.storeBit(0)).endCell();
+}
+function buildJVaultStakeBody(input) {
+	positive(input.jettonAmount, "jettonAmount");
+	const transfer = {
+		amount: input.jettonAmount,
+		destination: input.pool,
+		responseDestination: input.owner,
+		forwardAmount: 390000000n,
+		forwardPayload: buildJVaultStakeForwardPayload(input)
+	};
+	return input.queryId === void 0 ? buildJettonTransferBody(transfer) : buildJettonTransferBody({
+		...transfer,
+		queryId: input.queryId
+	});
+}
+function buildJVaultAddRewardsBody(input) {
+	positive(input.jettonAmount, "jettonAmount");
+	uint(input.startTime, MAX_UINT32, "startTime");
+	uint(input.endTime, MAX_UINT32, "endTime");
+	if (input.endTime <= input.startTime) throw new RangeError("endTime must be after startTime");
+	const transfer = {
+		amount: input.jettonAmount,
+		destination: input.pool,
+		responseDestination: input.owner,
+		forwardAmount: 100000000n,
+		forwardPayload: beginCell().storeUint(JVAULT_OPCODES.addRewards, 32).storeUint(input.startTime, 32).storeUint(input.endTime, 32).endCell()
+	};
+	return input.queryId === void 0 ? buildJettonTransferBody(transfer) : buildJettonTransferBody({
+		...transfer,
+		queryId: input.queryId
+	});
+}
+/** Encodes PoolFactory::deploy_new_pool from staking-v2/functions.fc. */
+function buildJVaultDeployPoolBody(input) {
+	if (input.periods.length === 0) throw new RangeError("periods must not be empty");
+	if (input.poolName.length === 0 || input.poolName.length > 127) throw new RangeError("poolName must contain between 1 and 127 characters");
+	if (input.jettonSymbol.length === 0 || input.jettonSymbol.length > 127) throw new RangeError("jettonSymbol must contain between 1 and 127 characters");
+	if (input.jettonFullName.length === 0 || input.jettonFullName.length > 127) throw new RangeError("jettonFullName must contain between 1 and 127 characters");
+	if (!input.imageUrl.startsWith("https://")) throw new RangeError("imageUrl must use https://");
+	uint(input.jettonDecimals, 255, "jettonDecimals");
+	if (input.minDeposit < 0n || input.minDeposit >= 1n << 120n) throw new RangeError("minDeposit must fit in TON coins");
+	if (input.maxDeposit !== null && input.maxDeposit < input.minDeposit) throw new RangeError("maxDeposit must be at least minDeposit");
+	if (input.maxDeposit !== null && input.maxDeposit >= 1n << 120n) throw new RangeError("maxDeposit must fit in TON coins");
+	const periods = Dictionary.empty(Dictionary.Keys.Uint(32), {
+		serialize: (value, builder) => builder.storeSlice(value.beginParse()).endCell(),
+		parse: (slice) => slice.asCell()
+	});
+	for (const period of input.periods) {
+		if (period.days <= 0) throw new RangeError("period.days must be positive");
+		const seconds = uint(period.days * SECONDS_PER_DAY, MAX_UINT32, "period.days");
+		periods.set(seconds, beginCell().storeCoins(period.tvlLimit ?? MAX_COINS).storeUint(uint(period.rewardMultiplierPerMille, 65535, "rewardMultiplierPerMille"), 16).storeUint(uint(period.depositCommissionBps, 1e4, "depositCommissionBps"), 16).storeUint(uint(period.unstakeCommissionBps, 1e4, "unstakeCommissionBps"), 16).storeMaybeRef(buildOnchainMetadata({
+			name: `${input.jettonSymbol} staked on JVault.xyz`,
+			symbol: `st-${input.jettonSymbol}-${String(period.days)}D`,
+			decimals: String(input.jettonDecimals),
+			image: input.imageUrl,
+			description: `These jettons confirm ownership of ${input.jettonFullName} staked on JVault.xyz.`
+		})).endCell());
+	}
+	const payload = beginCell().storeUint(JVAULT_OPCODES.deployNewPool, 32).storeAddress(input.lockJettonMaster).storeCoins(input.minDeposit).storeCoins(input.maxDeposit ?? MAX_COINS).storeDict(periods).storeDict(addressFlagDictionary(input.whitelist ?? [])).storeUint(uint(input.rewardsCommissionBps, 1e4, "rewardsCommissionBps"), 16).storeMaybeRef(buildOnchainMetadata({
+		name: input.poolName,
+		description: "This staking pool was created on JVault.xyz",
+		image: input.imageUrl,
+		lock_jetton_address: input.lockJettonMaster.toString()
+	})).endCell();
+	const transfer = {
+		amount: positive(input.creationFee, "creationFee"),
+		destination: input.factory,
+		responseDestination: input.sender,
+		forwardAmount: 150000000n,
+		forwardPayload: payload
+	};
+	return input.queryId === void 0 ? buildJettonTransferBody(transfer) : buildJettonTransferBody({
+		...transfer,
+		queryId: input.queryId
+	});
+}
+var JVaultStakingPool = class JVaultStakingPool extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultStakingPool(address);
+	}
+	static createFromConfig(config, workchain = 0) {
+		const init = {
+			code: config.code,
+			data: config.data
+		};
+		return new JVaultStakingPool(contractAddress(workchain, init), init);
+	}
+	async sendAddRewardJettons(provider, via, wallets, value, queryIdValue) {
+		await this.send(provider, via, value, bodyWithHeader(JVAULT_OPCODES.addRewardJettons, queryIdValue).storeDict(addressFlagDictionary(wallets)).endCell());
+	}
+	async sendAddRewards(provider, via, input, value) {
+		await this.send(provider, via, value, buildJVaultAddRewardsBody(input));
+	}
+	async sendClaimCommissions(provider, via, value, queryIdValue) {
+		await this.send(provider, via, value, bodyWithHeader(JVAULT_OPCODES.claimCommissions, queryIdValue).endCell());
+	}
+	async sendSetLockWallet(provider, via, wallet, value, queryIdValue) {
+		await this.send(provider, via, value, bodyWithHeader(JVAULT_OPCODES.setLockWallet, queryIdValue).storeAddress(wallet).endCell());
+	}
+	async getStorageData(provider) {
+		return this.get(provider, "get_storage_data");
+	}
+	async getStakeWalletAddress(provider, owner, lockPeriodSeconds) {
+		const tupleBuilder = new TupleBuilder();
+		tupleBuilder.writeAddress(owner);
+		tupleBuilder.writeNumber(uint(lockPeriodSeconds, MAX_UINT32, "lockPeriodSeconds"));
+		const tuple = tupleBuilder.build();
+		return (await this.get(provider, "get_stake_wallet_address", tuple)).readAddress();
+	}
+};
+var JVaultStakeWallet = class JVaultStakeWallet extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultStakeWallet(address);
+	}
+	async sendUnstakeRequest(provider, via, amount, value, queryIdValue) {
+		await this.send(provider, via, value, bodyWithHeader(JVAULT_OPCODES.unstakeRequest, queryIdValue).storeCoins(positive(amount, "amount")).endCell());
+	}
+	async sendUnstake(provider, via, amount, force, value, queryIdValue) {
+		await this.send(provider, via, value, bodyWithHeader(JVAULT_OPCODES.unstakeJettons, queryIdValue).storeCoins(positive(amount, "amount")).storeBit(force).endCell());
+	}
+	async sendCancelUnstake(provider, via, requestTimes, value, queryIdValue) {
+		if (requestTimes.length === 0) throw new RangeError("requestTimes must not be empty");
+		await this.send(provider, via, value, bodyWithHeader(JVAULT_OPCODES.cancelUnstakeRequest, queryIdValue).storeDict(uint32FlagDictionary(requestTimes)).endCell());
+	}
+	async sendClaimRewards(provider, via, poolJettonWallets, value, queryIdValue) {
+		if (poolJettonWallets.length === 0) throw new RangeError("poolJettonWallets must not be empty");
+		await this.send(provider, via, value, bodyWithHeader(JVAULT_OPCODES.claimRewards, queryIdValue).storeDict(addressFlagDictionary(poolJettonWallets)).endCell());
+	}
+	async getStorageData(provider) {
+		return this.get(provider, "get_storage_data");
+	}
+};
+var JVaultPoolFactory = class JVaultPoolFactory extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultPoolFactory(address);
+	}
+	async sendDeployPool(provider, via, payload, value) {
+		await this.send(provider, via, value, payload);
+	}
+	async sendDeployPoolBody(provider, via, input, value) {
+		await this.send(provider, via, value, buildJVaultDeployPoolBody(input));
+	}
+	async sendDeployReferrerWallets(provider, via, owners, value, queryIdValue) {
+		await this.send(provider, via, value, bodyWithHeader(JVAULT_OPCODES.deployReferrerWallets, queryIdValue).storeDict(addressFlagDictionary(owners)).endCell());
+	}
+	async getStorageData(provider) {
+		return this.get(provider, "get_storage_data");
+	}
+	async getPoolAddressByIndex(provider, index) {
+		const tuple = [{
+			type: "int",
+			value: BigInt(uint(index, MAX_UINT32, "index"))
+		}];
+		return (await this.get(provider, "get_nft_address_by_index", tuple)).readAddress();
+	}
+};
+var JVaultReferrerWallet = class JVaultReferrerWallet extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultReferrerWallet(address);
+	}
+	async sendClaimRewards(provider, via, entries, value, queryIdValue) {
+		await this.send(provider, via, value, buildJVaultReferralClaimBody(entries, queryIdValue));
+	}
+	async getStorageData(provider) {
+		return this.get(provider, "get_storage_data");
+	}
+};
+/** Encodes ReferrerWallet::claim_rewards' HashmapE(32, coins + wallet set). */
+function buildJVaultReferralClaimBody(entries, queryIdValue) {
+	return bodyWithHeader(JVAULT_OPCODES.claimReferralRewards, queryIdValue).storeDict(buildJVaultReferralClaimDictionary(entries)).endCell();
+}
+function buildJVaultReferralClaimDictionary(entries) {
+	if (entries.length === 0) throw new RangeError("entries must not be empty");
+	const dictionary = Dictionary.empty(Dictionary.Keys.Uint(32), {
+		serialize: (entry, builder) => {
+			if (entry.poolJettonWallets.length === 0) throw new RangeError("poolJettonWallets must not be empty");
+			builder.storeCoins(300000000n + 55000000n * BigInt(entry.poolJettonWallets.length)).storeDict(addressFlagDictionary(entry.poolJettonWallets));
+		},
+		parse: () => {
+			throw new Error("JVaultReferralClaimEntry is write-only");
+		}
+	});
+	const poolIds = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		uint(entry.poolId, MAX_UINT32, "poolId");
+		if (entry.poolJettonWallets.length === 0) throw new RangeError("poolJettonWallets must not be empty");
+		if (poolIds.has(entry.poolId)) throw new RangeError(`duplicate poolId: ${String(entry.poolId)}`);
+		poolIds.add(entry.poolId);
+		dictionary.set(entry.poolId, entry);
+	}
+	return dictionary;
+}
+var JVaultInviteeWallet = class JVaultInviteeWallet extends ContractWrapper {
+	static createFromAddress(address) {
+		return new JVaultInviteeWallet(address);
+	}
+	async getStorageData(provider) {
+		return this.get(provider, "get_storage_data");
+	}
+};
+//#endregion
+export { JVAULT_OPCODES, JVAULT_STAKING_V2_COMMIT, JVaultInviteeWallet, JVaultPoolFactory, JVaultReferrerWallet, JVaultStakeWallet, JVaultStakingPool, buildJVaultAddRewardsBody, buildJVaultDeployPoolBody, buildJVaultReferralClaimBody, buildJVaultStakeBody, buildJVaultStakeForwardPayload };

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

@@ -0,0 +1,253 @@
+import { ContractWrapper } from "./base.mjs";
+import { Address, Cell, ContractProvider, Sender } from "@ton/core";
+//#region src/contracts/wrappers/memeland.d.ts
+/** Memeland BCL source revision: https://github.com/PizzaTon/memeland-contracts */
+export declare const MEMELAND_CONTRACTS_COMMIT = "a7e132be091585b80cb6ffc6b7b50c8f0bdc53a2";
+declare const MEMELAND_OPCODES: {
+  readonly deployCoin: number;
+  readonly buy: number;
+  readonly sell: number;
+  readonly unlockWallet: number;
+  readonly setAdmin: number;
+  readonly setAuthor: number;
+  readonly setContent: number;
+  readonly setFees: number;
+  readonly setCode: number;
+  readonly setData: number;
+  readonly setCodeData: number;
+  readonly collectFees: number;
+  readonly toggleDeployEnable: number;
+  readonly feePayout: number;
+  readonly topUp: 3547469196;
+  readonly transfer: 260734629;
+  readonly burn: 1499400124;
+  readonly burnNotification: 2078119902;
+  readonly setStatus: 4006754003;
+  readonly transferNotification: 1935855772;
+  readonly internalTransfer: 395134233;
+  readonly excesses: 3576854235;
+  readonly provideWalletAddress: 745978227;
+  readonly takeWalletAddress: 3513996288;
+  readonly mint: 21;
+};
+export declare const MEMELAND_GAS: {
+  readonly coinDeployment: 50000000n;
+  readonly coinBuy: 50000000n;
+  readonly coinSell: 60000000n;
+  readonly walletUnlock: 50000000n;
+};
+export interface MemelandFeeConfig {
+  readonly feeAddress: Address;
+  readonly feeNumerator: number;
+  readonly feeDenominator: number;
+}
+export interface MemelandFactoryConfig {
+  readonly loggerAddress: Address;
+  readonly admin: Address;
+  readonly deploymentFee: bigint;
+  readonly maxTon: bigint;
+  readonly coinAdmin: Address;
+  readonly coinTtl: number;
+  readonly bclSupply: bigint;
+  readonly liqSupply: bigint;
+  readonly tradingCloseFee: bigint;
+  readonly fullPriceTon: bigint;
+  readonly fullPriceTonFee: bigint;
+  readonly isEnabled: boolean;
+  readonly seed: bigint;
+  readonly fee: MemelandFeeConfig;
+  readonly coinCode: Cell;
+  readonly walletCode: Cell;
+}
+export declare function buildMemelandFactoryData(config: MemelandFactoryConfig): Cell;
+export interface MemelandDeployCoinInput {
+  readonly author: Address;
+  readonly name: string;
+  readonly description?: string;
+  readonly image?: string;
+  readonly symbol?: string;
+  readonly socialLinks?: readonly string[];
+  readonly extraMetadata?: Readonly<Record<string, string>>;
+  readonly referral?: Cell | null;
+  readonly queryId?: bigint;
+}
+export interface MemelandFirstBuyInput {
+  readonly tons: bigint;
+  readonly minReceive: bigint;
+  readonly buyer: Address;
+  readonly referral?: Cell | null;
+  readonly queryId?: bigint;
+}
+export interface MemelandDeployCoinOptions {
+  readonly deploymentFee: bigint;
+  readonly deploymentGas?: bigint;
+  readonly buyGas?: bigint;
+  readonly firstBuy?: MemelandFirstBuyInput;
+}
+/** Build the external wallet payload for a factory coin deployment. */
+export declare function buildMemelandDeployCoinBody(input: MemelandDeployCoinInput, options: MemelandDeployCoinOptions): Cell;
+export declare function buildMemelandBuyBody(input: MemelandBuyInput): Cell;
+export declare function buildMemelandSellBody(input: {
+  readonly amount: bigint;
+  readonly minReceive: bigint;
+  readonly referral?: Cell | null;
+  readonly queryId?: bigint;
+}): Cell;
+export declare function buildMemelandUnlockBody(queryId?: bigint): Cell;
+export declare class MemelandBclFactory extends ContractWrapper {
+  static createFromAddress(address: Address): MemelandBclFactory;
+  static createFromConfig(config: MemelandFactoryConfig, code: Cell, workchain?: number): MemelandBclFactory;
+  sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+  sendSetAdmin(provider: ContractProvider, via: Sender, value: bigint, admin: Address): Promise<void>;
+  sendSetFees(provider: ContractProvider, via: Sender, value: bigint, deploymentFee: bigint, config: MemelandFeeConfig): Promise<void>;
+  sendSetCode(provider: ContractProvider, via: Sender, value: bigint, code: Cell): Promise<void>;
+  sendSetData(provider: ContractProvider, via: Sender, value: bigint, data: Cell): Promise<void>;
+  sendSetCodeData(provider: ContractProvider, via: Sender, value: bigint, code: Cell, data: Cell): Promise<void>;
+  sendCollectFees(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendToggleDeployEnable(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendTopUp(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+  sendDeployCoin(provider: ContractProvider, via: Sender, value: bigint, input: MemelandDeployCoinInput, options: MemelandDeployCoinOptions): Promise<void>;
+  getCoinsForTons(provider: ContractProvider, tons: bigint): Promise<{
+    fees: bigint;
+    coins: bigint;
+  }>;
+  getFactoryData(provider: ContractProvider): Promise<MemelandFactoryData>;
+}
+export interface MemelandFactoryData {
+  readonly admin: Address;
+  readonly deploymentFee: bigint;
+  readonly coinAdmin: Address;
+  readonly coinTtl: number;
+  readonly bclSupply: bigint;
+  readonly liqSupply: bigint;
+  readonly feeAddress: Address;
+  readonly feeNumerator: number;
+  readonly feeDenominator: number;
+  readonly tradingCloseFee: bigint;
+  readonly fullPriceTon: bigint;
+  readonly fullPriceTonFee: bigint;
+  readonly isEnabled: boolean;
+  readonly seed: bigint;
+  readonly coinCode: Cell;
+  readonly walletCode: Cell;
+}
+export interface MemelandBclData {
+  readonly totalSupply: bigint;
+  readonly bclSupply: bigint;
+  readonly liqSupply: bigint;
+  readonly admin: Address;
+  readonly author: Address;
+  readonly content: Cell;
+  readonly feeAddress: Address;
+  readonly feeNumerator: number;
+  readonly feeDenominator: number;
+  readonly ttl: number;
+  readonly lastTradeDate: number;
+  readonly tradingEnabled: boolean;
+  readonly tonLiquidityCollected: bigint;
+  readonly referral: Cell;
+  readonly tradingCloseFee: bigint;
+  readonly fullPriceTon: bigint;
+  readonly fullPriceTonFee: bigint;
+  readonly routerAddress: Address;
+  readonly routerPtonWalletAddress: Address;
+}
+export interface MemelandBuyInput {
+  readonly tons: bigint;
+  readonly minReceive: bigint;
+  readonly buyer?: Address;
+  readonly referral?: Cell | null;
+  readonly queryId?: bigint;
+}
+export declare class MemelandBclJettonMinter extends ContractWrapper {
+  static createFromAddress(address: Address): MemelandBclJettonMinter;
+  sendBuy(provider: ContractProvider, via: Sender, value: bigint, input: MemelandBuyInput): Promise<void>;
+  sendSetAdmin(provider: ContractProvider, via: Sender, value: bigint, admin: Address): Promise<void>;
+  sendSetAuthor(provider: ContractProvider, via: Sender, value: bigint, author: Address): Promise<void>;
+  sendSetContent(provider: ContractProvider, via: Sender, value: bigint, content: Cell): Promise<void>;
+  sendSetFees(provider: ContractProvider, via: Sender, value: bigint, feeAddress: Address, numerator: number, denominator: number): Promise<void>;
+  sendSetCode(provider: ContractProvider, via: Sender, value: bigint, code: Cell): Promise<void>;
+  sendSetData(provider: ContractProvider, via: Sender, value: bigint, data: Cell): Promise<void>;
+  sendSetCodeData(provider: ContractProvider, via: Sender, value: bigint, code: Cell, data: Cell): Promise<void>;
+  sendTopUp(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+  sendMint(provider: ContractProvider, via: Sender, value: bigint, input: {
+    readonly recipient: Address;
+    readonly amount: bigint;
+    readonly masterMessage: Cell;
+    readonly queryId?: bigint;
+  }): Promise<void>;
+  sendProvideWalletAddress(provider: ContractProvider, via: Sender, value: bigint, owner: Address, includeOwnerAddress: boolean, queryId?: bigint): Promise<void>;
+  sendBurnNotification(provider: ContractProvider, via: Sender, value: bigint, amount: bigint, from: Address, responseAddress: Address, queryId?: bigint): Promise<void>;
+  getJettonData(provider: ContractProvider): Promise<{
+    totalSupply: bigint;
+    mintable: boolean;
+    admin: Address | null;
+    content: Cell;
+    walletCode: Cell;
+  }>;
+  getWalletAddress(provider: ContractProvider, owner: Address): Promise<Address>;
+  getUserWallet(provider: ContractProvider, owner: Address): Promise<MemelandBclJettonWallet>;
+  getCoinPrice(provider: ContractProvider): Promise<bigint>;
+  getCoinsForTons(provider: ContractProvider, tons: bigint): Promise<{
+    fees: bigint;
+    coins: bigint;
+  }>;
+  getTonsForCoins(provider: ContractProvider, coins: bigint): Promise<{
+    fees: bigint;
+    tons: bigint;
+  }>;
+  getBclData(provider: ContractProvider): Promise<MemelandBclData>;
+}
+export interface MemelandWalletConfig {
+  readonly status: number;
+  readonly balance: bigint;
+  readonly owner: Address;
+  readonly master: Address;
+}
+export declare function buildMemelandWalletData(config: MemelandWalletConfig): Cell;
+export declare class MemelandBclJettonWallet extends ContractWrapper {
+  static createFromAddress(address: Address): MemelandBclJettonWallet;
+  static createFromConfig(config: MemelandWalletConfig, code: Cell, workchain?: number): MemelandBclJettonWallet;
+  sendTransfer(provider: ContractProvider, via: Sender, value: bigint, input: {
+    amount: bigint;
+    destination: Address;
+    responseDestination: Address;
+    customPayload?: Cell;
+    forwardAmount?: bigint;
+    forwardPayload?: Cell;
+    queryId?: bigint;
+  }): Promise<void>;
+  sendBurn(provider: ContractProvider, via: Sender, value: bigint, input: {
+    amount: bigint;
+    responseDestination: Address;
+    customPayload?: Cell;
+    queryId?: bigint;
+  }): Promise<void>;
+  sendSell(provider: ContractProvider, via: Sender, value: bigint, amount: bigint, minReceive: bigint, referral?: Cell | null, queryId?: bigint): Promise<void>;
+  sendUnlock(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendSetStatus(provider: ContractProvider, via: Sender, value: bigint, status: number, queryId?: bigint): Promise<void>;
+  getWalletData(provider: ContractProvider): Promise<{
+    balance: bigint;
+    owner: Address;
+    master: Address;
+    walletCode: Cell;
+  }>;
+  getStatus(provider: ContractProvider): Promise<number>;
+}
+export interface MemelandFeeCollectorConfig {
+  readonly admin: Address;
+}
+export declare function buildMemelandFeeCollectorData(config: MemelandFeeCollectorConfig): Cell;
+export declare class MemelandFeeCollector extends ContractWrapper {
+  static createFromAddress(address: Address): MemelandFeeCollector;
+  static createFromConfig(config: MemelandFeeCollectorConfig, code: Cell, workchain?: number): MemelandFeeCollector;
+  sendSetAdmin(provider: ContractProvider, via: Sender, value: bigint, admin: Address): Promise<void>;
+  sendSetCode(provider: ContractProvider, via: Sender, value: bigint, code: Cell): Promise<void>;
+  sendSetData(provider: ContractProvider, via: Sender, value: bigint, data: Cell): Promise<void>;
+  sendSetCodeData(provider: ContractProvider, via: Sender, value: bigint, code: Cell, data: Cell): Promise<void>;
+  sendFeePayout(provider: ContractProvider, via: Sender, value: bigint, referral: Cell): Promise<void>;
+  sendTopUp(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+}
+export declare function buildMemelandReferralPayout(referral: Cell): Cell;
+//#endregion
+export { MEMELAND_OPCODES };