@pizzaton/ton 0.0.0-stage → 0.1.0

package/dist/contracts/wrappers/memeland.mjs

@@ -0,0 +1,396 @@
+import { crc32 } from "../codecs.mjs";
+import { buildJettonBurnBody, buildJettonTransferBody } from "../../jetton/index.mjs";
+import { buildOnchainMetadata } from "../../nft/content.mjs";
+import { ContractWrapper } from "./base.mjs";
+import { Cell, beginCell, contractAddress } from "@ton/core";
+//#region src/contracts/wrappers/memeland.ts
+/** Memeland BCL source revision: https://github.com/PizzaTon/memeland-contracts */
+const MEMELAND_CONTRACTS_COMMIT = "a7e132be091585b80cb6ffc6b7b50c8f0bdc53a2";
+const MEMELAND_OPCODES = {
+	deployCoin: crc32("op::deploy_coin"),
+	buy: crc32("op::buy"),
+	sell: crc32("op::sell"),
+	unlockWallet: crc32("op::unlock_wallet"),
+	setAdmin: crc32("op::set_admin"),
+	setAuthor: crc32("op::set_author"),
+	setContent: crc32("op::set_content"),
+	setFees: crc32("op::set_fees"),
+	setCode: crc32("op::set_code"),
+	setData: crc32("op::set_data"),
+	setCodeData: crc32("op::set_code_data"),
+	collectFees: crc32("op::collect_fees"),
+	toggleDeployEnable: crc32("op::toggle_deploy_enable"),
+	feePayout: crc32("op::fee_payout"),
+	topUp: 3547469196,
+	transfer: 260734629,
+	burn: 1499400124,
+	burnNotification: 2078119902,
+	setStatus: 4006754003,
+	transferNotification: 1935855772,
+	internalTransfer: 395134233,
+	excesses: 3576854235,
+	provideWalletAddress: 745978227,
+	takeWalletAddress: 3513996288,
+	mint: 21
+};
+const MEMELAND_GAS = {
+	coinDeployment: 50000000n,
+	coinBuy: 50000000n,
+	coinSell: 60000000n,
+	walletUnlock: 50000000n
+};
+const header = (opcode, queryId = 0n) => beginCell().storeUint(opcode, 32).storeUint(queryId, 64);
+function uint(value, bits, field) {
+	if (value < 0n || value >= 1n << BigInt(bits)) throw new RangeError(`${field} must fit in uint${String(bits)}`);
+	return value;
+}
+function positive(value, field) {
+	if (value <= 0n) throw new RangeError(`${field} must be positive`);
+	return value;
+}
+function uint16(value, field) {
+	if (!Number.isSafeInteger(value) || value < 0 || value > 65535) throw new RangeError(`${field} must fit in uint16`);
+	return value;
+}
+function uint32(value, field) {
+	if (!Number.isSafeInteger(value) || value < 0 || value > 4294967295) throw new RangeError(`${field} must fit in uint32`);
+	return value;
+}
+function requiredText(value, field) {
+	if (value.trim().length === 0) throw new RangeError(`${field} is required`);
+	return value;
+}
+function buildMemelandFactoryData(config) {
+	uint32(config.coinTtl, "coinTtl");
+	uint(config.seed, 64, "seed");
+	uint16(config.fee.feeNumerator, "feeNumerator");
+	uint16(config.fee.feeDenominator, "feeDenominator");
+	if (config.fee.feeDenominator === 0) throw new RangeError("feeDenominator must be positive");
+	return beginCell().storeAddress(config.loggerAddress).storeAddress(config.admin).storeCoins(config.deploymentFee).storeCoins(config.maxTon).storeRef(beginCell().storeAddress(config.coinAdmin).storeUint(config.coinTtl, 32).storeCoins(config.bclSupply).storeCoins(config.liqSupply).storeCoins(config.tradingCloseFee).storeCoins(config.fullPriceTon).storeCoins(config.fullPriceTonFee).storeBit(config.isEnabled).storeUint(config.seed, 64).endCell()).storeRef(beginCell().storeAddress(config.fee.feeAddress).storeUint(config.fee.feeNumerator, 16).storeUint(config.fee.feeDenominator, 16).endCell()).storeRef(config.coinCode).storeRef(config.walletCode).endCell();
+}
+function memelandMetadata(input) {
+	const data = {
+		name: requiredText(input.name, "name"),
+		decimals: "9",
+		...input.description ? { description: input.description } : {},
+		...input.image ? { image: input.image } : {},
+		...input.symbol ? { symbol: input.symbol } : {},
+		...input.socialLinks ? { social_links: JSON.stringify(input.socialLinks) } : {},
+		...input.extraMetadata ?? {}
+	};
+	return buildOnchainMetadata(data);
+}
+/** Build the external wallet payload for a factory coin deployment. */
+function buildMemelandDeployCoinBody(input, options) {
+	positive(options.deploymentFee, "deploymentFee");
+	const message = header(MEMELAND_OPCODES.deployCoin, input.queryId).storeRef(memelandMetadata(input)).storeAddress(input.author).storeRef(input.referral ?? Cell.EMPTY);
+	if (!options.firstBuy) return message.storeBit(0).endCell();
+	positive(options.firstBuy.tons, "firstBuy.tons");
+	positive(options.firstBuy.minReceive, "firstBuy.minReceive");
+	const firstBuy = header(MEMELAND_OPCODES.buy, options.firstBuy.queryId).storeCoins(options.firstBuy.minReceive).storeMaybeRef(options.firstBuy.referral ?? null).storeAddress(options.firstBuy.buyer).endCell();
+	return message.storeBit(1).storeRef(firstBuy).endCell();
+}
+function buildMemelandBuyBody(input) {
+	positive(input.tons, "tons");
+	positive(input.minReceive, "minReceive");
+	const body = header(MEMELAND_OPCODES.buy, input.queryId).storeCoins(input.minReceive).storeMaybeRef(input.referral ?? null);
+	if (input.buyer) body.storeAddress(input.buyer);
+	return body.endCell();
+}
+function buildMemelandSellBody(input) {
+	positive(input.amount, "amount");
+	positive(input.minReceive, "minReceive");
+	return header(MEMELAND_OPCODES.sell, input.queryId).storeCoins(input.amount).storeCoins(input.minReceive).storeMaybeRef(input.referral ?? null).endCell();
+}
+function buildMemelandUnlockBody(queryId = 0n) {
+	return header(MEMELAND_OPCODES.unlockWallet, queryId).endCell();
+}
+var MemelandBclFactory = class MemelandBclFactory extends ContractWrapper {
+	static createFromAddress(address) {
+		return new MemelandBclFactory(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: buildMemelandFactoryData(config)
+		};
+		return new MemelandBclFactory(contractAddress(workchain, init), init);
+	}
+	async sendDeploy(provider, via, value) {
+		await this.send(provider, via, value);
+	}
+	async sendSetAdmin(provider, via, value, admin) {
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.setAdmin).storeAddress(admin).endCell());
+	}
+	async sendSetFees(provider, via, value, deploymentFee, config) {
+		uint16(config.feeNumerator, "feeNumerator");
+		uint16(config.feeDenominator, "feeDenominator");
+		if (config.feeDenominator === 0) throw new RangeError("feeDenominator must be positive");
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.setFees).storeCoins(positive(deploymentFee, "deploymentFee")).storeAddress(config.feeAddress).storeUint(config.feeNumerator, 16).storeUint(config.feeDenominator, 16).endCell());
+	}
+	async sendSetCode(provider, via, value, code) {
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.setCode).storeRef(code).endCell());
+	}
+	async sendSetData(provider, via, value, data) {
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.setData).storeRef(data).endCell());
+	}
+	async sendSetCodeData(provider, via, value, code, data) {
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.setCodeData).storeRef(code).storeRef(data).endCell());
+	}
+	async sendCollectFees(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.collectFees, queryId).endCell());
+	}
+	async sendToggleDeployEnable(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.toggleDeployEnable, queryId).endCell());
+	}
+	async sendTopUp(provider, via, value) {
+		await this.send(provider, via, value, beginCell().storeUint(MEMELAND_OPCODES.topUp, 32).endCell());
+	}
+	async sendDeployCoin(provider, via, value, input, options) {
+		positive(options.deploymentFee, "deploymentFee");
+		const deploymentGas = options.deploymentGas ?? MEMELAND_GAS.coinDeployment;
+		const buyGas = options.buyGas ?? MEMELAND_GAS.coinBuy;
+		positive(deploymentGas, "deploymentGas");
+		positive(buyGas, "buyGas");
+		const message = header(MEMELAND_OPCODES.deployCoin, input.queryId).storeRef(memelandMetadata(input)).storeAddress(input.author).storeRef(input.referral ?? Cell.EMPTY);
+		if (!options.firstBuy) {
+			if (value < options.deploymentFee + deploymentGas) throw new RangeError("value is below the deployment fee and gas budget");
+			await this.send(provider, via, value, message.storeBit(0).endCell());
+			return;
+		}
+		positive(options.firstBuy.tons, "firstBuy.tons");
+		positive(options.firstBuy.minReceive, "firstBuy.minReceive");
+		if (value < options.deploymentFee + deploymentGas + buyGas + options.firstBuy.tons) throw new RangeError("value is below the deployment, buy, and gas budgets");
+		const firstBuy = header(MEMELAND_OPCODES.buy, options.firstBuy.queryId).storeCoins(options.firstBuy.minReceive).storeMaybeRef(options.firstBuy.referral ?? null).storeAddress(options.firstBuy.buyer).endCell();
+		await this.send(provider, via, value, message.storeBit(1).storeRef(firstBuy).endCell());
+	}
+	async getCoinsForTons(provider, tons) {
+		const stack = await this.get(provider, "coins_for_tons", [{
+			type: "int",
+			value: tons
+		}]);
+		return {
+			fees: stack.readBigNumber(),
+			coins: stack.readBigNumber()
+		};
+	}
+	async getFactoryData(provider) {
+		const stack = await this.get(provider, "get_factory_data");
+		return {
+			admin: stack.readAddress(),
+			deploymentFee: stack.readBigNumber(),
+			coinAdmin: stack.readAddress(),
+			coinTtl: stack.readNumber(),
+			bclSupply: stack.readBigNumber(),
+			liqSupply: stack.readBigNumber(),
+			feeAddress: stack.readAddress(),
+			feeNumerator: stack.readNumber(),
+			feeDenominator: stack.readNumber(),
+			tradingCloseFee: stack.readBigNumber(),
+			fullPriceTon: stack.readBigNumber(),
+			fullPriceTonFee: stack.readBigNumber(),
+			isEnabled: stack.readBoolean(),
+			seed: stack.readBigNumber(),
+			coinCode: stack.readCell(),
+			walletCode: stack.readCell()
+		};
+	}
+};
+var MemelandBclJettonMinter = class MemelandBclJettonMinter extends ContractWrapper {
+	static createFromAddress(address) {
+		return new MemelandBclJettonMinter(address);
+	}
+	async sendBuy(provider, via, value, input) {
+		positive(input.tons, "tons");
+		positive(input.minReceive, "minReceive");
+		if (value < input.tons + MEMELAND_GAS.coinBuy) throw new RangeError("value is below the buy amount and gas budget");
+		const body = header(MEMELAND_OPCODES.buy, input.queryId).storeCoins(input.minReceive).storeMaybeRef(input.referral ?? null);
+		if (input.buyer) body.storeAddress(input.buyer);
+		await this.send(provider, via, value, body.endCell());
+	}
+	async sendSetAdmin(provider, via, value, admin) {
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.setAdmin).storeAddress(admin).endCell());
+	}
+	async sendSetAuthor(provider, via, value, author) {
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.setAuthor).storeAddress(author).endCell());
+	}
+	async sendSetContent(provider, via, value, content) {
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.setContent).storeRef(content).endCell());
+	}
+	async sendSetFees(provider, via, value, feeAddress, numerator, denominator) {
+		uint16(numerator, "numerator");
+		uint16(denominator, "denominator");
+		if (denominator === 0) throw new RangeError("denominator must be positive");
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.setFees).storeAddress(feeAddress).storeUint(numerator, 16).storeUint(denominator, 16).endCell());
+	}
+	async sendSetCode(provider, via, value, code) {
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.setCode).storeRef(code).endCell());
+	}
+	async sendSetData(provider, via, value, data) {
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.setData).storeRef(data).endCell());
+	}
+	async sendSetCodeData(provider, via, value, code, data) {
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.setCodeData).storeRef(code).storeRef(data).endCell());
+	}
+	async sendTopUp(provider, via, value) {
+		await this.send(provider, via, value, beginCell().storeUint(MEMELAND_OPCODES.topUp, 32).endCell());
+	}
+	async sendMint(provider, via, value, input) {
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.mint, input.queryId).storeAddress(input.recipient).storeCoins(input.amount).storeRef(input.masterMessage).endCell());
+	}
+	async sendProvideWalletAddress(provider, via, value, owner, includeOwnerAddress, queryId = 0n) {
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.provideWalletAddress, queryId).storeAddress(owner).storeBit(includeOwnerAddress).endCell());
+	}
+	async sendBurnNotification(provider, via, value, amount, from, responseAddress, queryId = 0n) {
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.burnNotification, queryId).storeCoins(amount).storeAddress(from).storeAddress(responseAddress).endCell());
+	}
+	async getJettonData(provider) {
+		const stack = await this.get(provider, "get_jetton_data");
+		return {
+			totalSupply: stack.readBigNumber(),
+			mintable: stack.readBoolean(),
+			admin: stack.readAddressOpt(),
+			content: stack.readCell(),
+			walletCode: stack.readCell()
+		};
+	}
+	async getWalletAddress(provider, owner) {
+		return (await this.get(provider, "get_wallet_address", [{
+			type: "slice",
+			cell: beginCell().storeAddress(owner).endCell()
+		}])).readAddress();
+	}
+	async getUserWallet(provider, owner) {
+		return MemelandBclJettonWallet.createFromAddress(await this.getWalletAddress(provider, owner));
+	}
+	async getCoinPrice(provider) {
+		return (await this.get(provider, "coin_price")).readBigNumber();
+	}
+	async getCoinsForTons(provider, tons) {
+		const stack = await this.get(provider, "coins_for_tons", [{
+			type: "int",
+			value: tons
+		}]);
+		return {
+			fees: stack.readBigNumber(),
+			coins: stack.readBigNumber()
+		};
+	}
+	async getTonsForCoins(provider, coins) {
+		const stack = await this.get(provider, "tons_for_coins", [{
+			type: "int",
+			value: coins
+		}]);
+		return {
+			fees: stack.readBigNumber(),
+			tons: stack.readBigNumber()
+		};
+	}
+	async getBclData(provider) {
+		const stack = await this.get(provider, "get_bcl_data");
+		return {
+			totalSupply: stack.readBigNumber(),
+			bclSupply: stack.readBigNumber(),
+			liqSupply: stack.readBigNumber(),
+			admin: stack.readAddress(),
+			author: stack.readAddress(),
+			content: stack.readCell(),
+			feeAddress: stack.readAddress(),
+			feeNumerator: stack.readNumber(),
+			feeDenominator: stack.readNumber(),
+			ttl: stack.readNumber(),
+			lastTradeDate: stack.readNumber(),
+			tradingEnabled: stack.readBoolean(),
+			tonLiquidityCollected: stack.readBigNumber(),
+			referral: stack.readCell(),
+			tradingCloseFee: stack.readBigNumber(),
+			fullPriceTon: stack.readBigNumber(),
+			fullPriceTonFee: stack.readBigNumber(),
+			routerAddress: stack.readAddress(),
+			routerPtonWalletAddress: stack.readAddress()
+		};
+	}
+};
+function buildMemelandWalletData(config) {
+	if (config.status < 0 || config.status > 15) throw new RangeError("status must fit in uint4");
+	return beginCell().storeUint(config.status, 4).storeCoins(config.balance).storeAddress(config.owner).storeAddress(config.master).endCell();
+}
+var MemelandBclJettonWallet = class MemelandBclJettonWallet extends ContractWrapper {
+	static createFromAddress(address) {
+		return new MemelandBclJettonWallet(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: buildMemelandWalletData(config)
+		};
+		return new MemelandBclJettonWallet(contractAddress(workchain, init), init);
+	}
+	async sendTransfer(provider, via, value, input) {
+		await this.send(provider, via, value, buildJettonTransferBody(input));
+	}
+	async sendBurn(provider, via, value, input) {
+		await this.send(provider, via, value, buildJettonBurnBody(input));
+	}
+	async sendSell(provider, via, value, amount, minReceive, referral, queryId = 0n) {
+		positive(amount, "amount");
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.sell, queryId).storeCoins(amount).storeCoins(minReceive).storeMaybeRef(referral ?? null).endCell());
+	}
+	async sendUnlock(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.unlockWallet, queryId).endCell());
+	}
+	async sendSetStatus(provider, via, value, status, queryId = 0n) {
+		if (!Number.isInteger(status) || status < 0 || status > 15) throw new RangeError("status must fit in uint4");
+		await this.send(provider, via, value, header(MEMELAND_OPCODES.setStatus, queryId).storeUint(status, 4).endCell());
+	}
+	async getWalletData(provider) {
+		const stack = await this.get(provider, "get_wallet_data");
+		return {
+			balance: stack.readBigNumber(),
+			owner: stack.readAddress(),
+			master: stack.readAddress(),
+			walletCode: stack.readCell()
+		};
+	}
+	async getStatus(provider) {
+		return (await this.get(provider, "get_status")).readNumber();
+	}
+};
+function buildMemelandFeeCollectorData(config) {
+	return beginCell().storeAddress(config.admin).endCell();
+}
+var MemelandFeeCollector = class MemelandFeeCollector extends ContractWrapper {
+	static createFromAddress(address) {
+		return new MemelandFeeCollector(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: buildMemelandFeeCollectorData(config)
+		};
+		return new MemelandFeeCollector(contractAddress(workchain, init), init);
+	}
+	async sendSetAdmin(provider, via, value, admin) {
+		await this.send(provider, via, value, beginCell().storeUint(MEMELAND_OPCODES.setAdmin, 32).storeAddress(admin).endCell());
+	}
+	async sendSetCode(provider, via, value, code) {
+		await this.send(provider, via, value, beginCell().storeUint(MEMELAND_OPCODES.setCode, 32).storeRef(code).endCell());
+	}
+	async sendSetData(provider, via, value, data) {
+		await this.send(provider, via, value, beginCell().storeUint(MEMELAND_OPCODES.setData, 32).storeRef(data).endCell());
+	}
+	async sendSetCodeData(provider, via, value, code, data) {
+		await this.send(provider, via, value, beginCell().storeUint(MEMELAND_OPCODES.setCodeData, 32).storeRef(code).storeRef(data).endCell());
+	}
+	async sendFeePayout(provider, via, value, referral) {
+		await this.send(provider, via, value, beginCell().storeUint(MEMELAND_OPCODES.feePayout, 32).storeRef(referral).endCell());
+	}
+	async sendTopUp(provider, via, value) {
+		await this.send(provider, via, value, beginCell().storeUint(MEMELAND_OPCODES.topUp, 32).endCell());
+	}
+};
+function buildMemelandReferralPayout(referral) {
+	return header(MEMELAND_OPCODES.feePayout).storeRef(referral).endCell();
+}
+//#endregion
+export { MEMELAND_CONTRACTS_COMMIT, MEMELAND_GAS, MEMELAND_OPCODES, MemelandBclFactory, MemelandBclJettonMinter, MemelandBclJettonWallet, MemelandFeeCollector, buildMemelandBuyBody, buildMemelandDeployCoinBody, buildMemelandFactoryData, buildMemelandFeeCollectorData, buildMemelandReferralPayout, buildMemelandSellBody, buildMemelandUnlockBody, buildMemelandWalletData };

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

@@ -0,0 +1,92 @@
+import { ContractWrapper } from "./base.mjs";
+import { Address, Cell, ContractProvider, Sender } from "@ton/core";
+//#region src/contracts/wrappers/multix.d.ts
+/** Multix DAO / sale contract source: https://github.com/multixcrypto/dao-contract */
+export declare const MULTIX_DAO_COMMIT = "dd03da038d8eecb72141eda77e231d536e5e3cd7";
+export declare const MULTIX_STORAGE_COMMIT = "dd03da038d8eecb72141eda77e231d536e5e3cd7";
+export declare const MULTIX_OPCODES: {
+  readonly init: 3372800;
+  readonly transferNotification: 1935855772;
+  readonly excessesNotification: 3576854235;
+  readonly balanceReplenishment: 4471;
+  readonly lockContract: 13141;
+  readonly unlockContract: 13175;
+  readonly saleStart: 30071;
+  readonly saleEdit: 30085;
+  readonly saleStop: 30088;
+  readonly saleParticipate: 30105;
+  readonly saleClaim: 29969;
+  readonly salesComplete: 2457;
+  readonly daoHoldersAdd: 13569;
+  readonly daoHoldersDelete: 13573;
+  readonly daoHoldersClaim: 13575;
+  readonly daoVetoVote: 39169;
+};
+export declare const MULTIX_STORAGE_OPCODES: {
+  readonly buyRequest: 14197;
+  readonly claimRequestFull: 14465;
+  readonly claimRequestAsset: 14467;
+  readonly daoVetoVoteRequest: 14739;
+};
+export interface MultixDaoConfig {
+  readonly code: Cell;
+  readonly data: Cell;
+}
+/**
+ * The Tact source defines the nested sale/vesting/DAO records. They are
+ * accepted as cells here intentionally: callers can use the generated Tact
+ * ABI for those records without this package maintaining a second, divergent
+ * schema. The outer message layout is encoded by this adapter.
+ */
+export declare class MultixDaoContract extends ContractWrapper {
+  static createFromAddress(address: Address): MultixDaoContract;
+  static createFromConfig(config: MultixDaoConfig, workchain?: number): MultixDaoContract;
+  sendBalanceReplenishment(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendLockContract(provider: ContractProvider, via: Sender, lockDaoHolders: boolean, lockSales: boolean, value: bigint, queryId?: bigint): Promise<void>;
+  sendUnlockContract(provider: ContractProvider, via: Sender, unlockDaoHolders: boolean, unlockSales: boolean, value: bigint, queryId?: bigint): Promise<void>;
+  sendSaleStart(provider: ContractProvider, via: Sender, saleOptions: Cell, unlockOptions: Cell, daoHolder: Cell, earlyRoundSignature: Cell, value: bigint, queryId?: bigint): Promise<void>;
+  sendSaleEdit(provider: ContractProvider, via: Sender, saleIndex: number, saleOptions: Cell, unlockOptions: Cell, daoHolder: Cell, earlyRoundSignature: Cell, value: bigint, queryId?: bigint): Promise<void>;
+  sendSaleStop(provider: ContractProvider, via: Sender, saleIndex: number, value: bigint, queryId?: bigint): Promise<void>;
+  sendSaleParticipate(provider: ContractProvider, via: Sender, saleIndex: number, signature: Cell, comment: Cell, value: bigint, queryId?: bigint): Promise<void>;
+  sendSaleClaim(provider: ContractProvider, via: Sender, saleIndex: number, comment: Cell, value: bigint, queryId?: bigint): Promise<void>;
+  sendSalesComplete(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendDaoHoldersAdd(provider: ContractProvider, via: Sender, counter: bigint, holders: Cell, value: bigint, queryId?: bigint): Promise<void>;
+  sendDaoHoldersDelete(provider: ContractProvider, via: Sender, indexes: Cell, value: bigint, queryId?: bigint): Promise<void>;
+  sendDaoHolderClaim(provider: ContractProvider, via: Sender, index: number, commentPrefix: number, comment: Cell, value: bigint, queryId?: bigint): Promise<void>;
+  sendDaoVetoVote(provider: ContractProvider, via: Sender, signature: Cell, commentPrefix: number, comment: Cell, value: bigint, queryId?: bigint): Promise<void>;
+  getState(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+  getClientStorageAddress(provider: ContractProvider, client: Address, saleIndex: number): Promise<Address>;
+}
+export interface MultixStorageConfig {
+  readonly dexContract: Address;
+  readonly clientAddress: Address;
+  readonly saleIndex: bigint;
+}
+export declare function buildMultixStorageData(config: MultixStorageConfig): Cell;
+export interface MultixUnlockOptions {
+  readonly unlockStartTime: bigint;
+  readonly unlockPercentHecto: number;
+  readonly cycleDaysOffsetA: number;
+  readonly cyclePercentHectoA: number;
+  readonly cyclesDaysA: number;
+  readonly cycleDaysOffsetB: number;
+  readonly cyclePercentHectoB: number;
+  readonly cyclesDaysB: number;
+  readonly cycleDaysOffsetC: number;
+  readonly cyclePercentHectoC: number;
+  readonly cyclesDaysC: number;
+  readonly cycleDaysOffsetD: number;
+  readonly cyclePercentHectoD: number;
+  readonly cyclesDaysD: number;
+}
+export declare function buildMultixUnlockOptions(options: MultixUnlockOptions): Cell;
+export declare class MultixStorageContract extends ContractWrapper {
+  static createFromAddress(address: Address): MultixStorageContract;
+  static createFromConfig(config: MultixStorageConfig, code: Cell, workchain?: number): MultixStorageContract;
+  sendBuyRequest(provider: ContractProvider, via: Sender, value: bigint, buyRequestId: bigint, limitTotalAmount: bigint, comment?: Cell): Promise<void>;
+  sendClaimRequestFull(provider: ContractProvider, via: Sender, value: bigint, contractTonBalance: bigint, comment?: Cell, queryId?: bigint): Promise<void>;
+  sendClaimRequestAsset(provider: ContractProvider, via: Sender, value: bigint, salesFreeTokens: bigint, itemPriceMilli: bigint, unlockOptions: Cell, comment?: Cell, queryId?: bigint): Promise<void>;
+  sendDaoVetoVoteRequest(provider: ContractProvider, via: Sender, value: bigint, itemPriceMilli: bigint, comment?: Cell, queryId?: bigint): Promise<void>;
+  getState(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+//#endregion

package/dist/contracts/wrappers/multix.mjs

@@ -0,0 +1,156 @@
+import { ContractWrapper } from "./base.mjs";
+import { Cell, beginCell, contractAddress } from "@ton/core";
+//#region src/contracts/wrappers/multix.ts
+/** Multix DAO / sale contract source: https://github.com/multixcrypto/dao-contract */
+const MULTIX_DAO_COMMIT = "dd03da038d8eecb72141eda77e231d536e5e3cd7";
+const MULTIX_STORAGE_COMMIT = MULTIX_DAO_COMMIT;
+const MULTIX_OPCODES = {
+	init: 3372800,
+	transferNotification: 1935855772,
+	excessesNotification: 3576854235,
+	balanceReplenishment: 4471,
+	lockContract: 13141,
+	unlockContract: 13175,
+	saleStart: 30071,
+	saleEdit: 30085,
+	saleStop: 30088,
+	saleParticipate: 30105,
+	saleClaim: 29969,
+	salesComplete: 2457,
+	daoHoldersAdd: 13569,
+	daoHoldersDelete: 13573,
+	daoHoldersClaim: 13575,
+	daoVetoVote: 39169
+};
+const MULTIX_STORAGE_OPCODES = {
+	buyRequest: 14197,
+	claimRequestFull: 14465,
+	claimRequestAsset: 14467,
+	daoVetoVoteRequest: 14739
+};
+const header = (op, queryId = 0n) => beginCell().storeUint(op, 32).storeUint(queryId, 64);
+/**
+* The Tact source defines the nested sale/vesting/DAO records. They are
+* accepted as cells here intentionally: callers can use the generated Tact
+* ABI for those records without this package maintaining a second, divergent
+* schema. The outer message layout is encoded by this adapter.
+*/
+var MultixDaoContract = class MultixDaoContract extends ContractWrapper {
+	static createFromAddress(address) {
+		return new MultixDaoContract(address);
+	}
+	static createFromConfig(config, workchain = 0) {
+		const init = {
+			code: config.code,
+			data: config.data
+		};
+		return new MultixDaoContract(contractAddress(workchain, init), init);
+	}
+	async sendBalanceReplenishment(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(MULTIX_OPCODES.balanceReplenishment, queryId).endCell());
+	}
+	async sendLockContract(provider, via, lockDaoHolders, lockSales, value, queryId = 0n) {
+		await this.send(provider, via, value, header(MULTIX_OPCODES.lockContract, queryId).storeBit(lockDaoHolders).storeBit(lockSales).endCell());
+	}
+	async sendUnlockContract(provider, via, unlockDaoHolders, unlockSales, value, queryId = 0n) {
+		await this.send(provider, via, value, header(MULTIX_OPCODES.unlockContract, queryId).storeBit(unlockDaoHolders).storeBit(unlockSales).endCell());
+	}
+	async sendSaleStart(provider, via, saleOptions, unlockOptions, daoHolder, earlyRoundSignature, value, queryId = 0n) {
+		await this.send(provider, via, value, header(MULTIX_OPCODES.saleStart, queryId).storeRef(saleOptions).storeRef(unlockOptions).storeRef(daoHolder).storeSlice(earlyRoundSignature.asSlice()).endCell());
+	}
+	async sendSaleEdit(provider, via, saleIndex, saleOptions, unlockOptions, daoHolder, earlyRoundSignature, value, queryId = 0n) {
+		await this.send(provider, via, value, header(MULTIX_OPCODES.saleEdit, queryId).storeUint(saleIndex, 32).storeRef(saleOptions).storeRef(unlockOptions).storeRef(daoHolder).storeSlice(earlyRoundSignature.asSlice()).endCell());
+	}
+	async sendSaleStop(provider, via, saleIndex, value, queryId = 0n) {
+		await this.send(provider, via, value, header(MULTIX_OPCODES.saleStop, queryId).storeUint(saleIndex, 32).endCell());
+	}
+	async sendSaleParticipate(provider, via, saleIndex, signature, comment, value, queryId = 0n) {
+		await this.send(provider, via, value, header(MULTIX_OPCODES.saleParticipate, queryId).storeUint(saleIndex, 32).storeSlice(signature.asSlice()).storeSlice(comment.asSlice()).endCell());
+	}
+	async sendSaleClaim(provider, via, saleIndex, comment, value, queryId = 0n) {
+		await this.send(provider, via, value, header(MULTIX_OPCODES.saleClaim, queryId).storeUint(saleIndex, 32).storeSlice(comment.asSlice()).endCell());
+	}
+	async sendSalesComplete(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(MULTIX_OPCODES.salesComplete, queryId).endCell());
+	}
+	async sendDaoHoldersAdd(provider, via, counter, holders, value, queryId = 0n) {
+		await this.send(provider, via, value, header(MULTIX_OPCODES.daoHoldersAdd, queryId).storeUint(counter, 64).storeRef(holders).endCell());
+	}
+	async sendDaoHoldersDelete(provider, via, indexes, value, queryId = 0n) {
+		await this.send(provider, via, value, header(MULTIX_OPCODES.daoHoldersDelete, queryId).storeRef(indexes).endCell());
+	}
+	async sendDaoHolderClaim(provider, via, index, commentPrefix, comment, value, queryId = 0n) {
+		await this.send(provider, via, value, header(MULTIX_OPCODES.daoHoldersClaim, queryId).storeUint(index, 32).storeUint(commentPrefix, 32).storeSlice(comment.asSlice()).endCell());
+	}
+	async sendDaoVetoVote(provider, via, signature, commentPrefix, comment, value, queryId = 0n) {
+		await this.send(provider, via, value, header(MULTIX_OPCODES.daoVetoVote, queryId).storeSlice(signature.asSlice()).storeUint(commentPrefix, 32).storeSlice(comment.asSlice()).endCell());
+	}
+	async getState(provider) {
+		return this.get(provider, "state");
+	}
+	async getClientStorageAddress(provider, client, saleIndex) {
+		return (await this.get(provider, "getClientStorageAddress", [{
+			type: "slice",
+			cell: beginCell().storeAddress(client).endCell()
+		}, {
+			type: "int",
+			value: BigInt(saleIndex)
+		}])).readAddress();
+	}
+};
+function buildMultixStorageData(config) {
+	if (config.saleIndex < 0n || config.saleIndex >= 1n << 64n) throw new RangeError("saleIndex must fit in uint64");
+	return beginCell().storeAddress(config.dexContract).storeAddress(config.clientAddress).storeUint(config.saleIndex, 64).storeUint(0, 64).storeCoins(0).storeCoins(0).storeCoins(0).storeUint(0, 64).storeBit(0).endCell();
+}
+function buildMultixUnlockOptions(options) {
+	if (options.unlockStartTime < 0n || options.unlockStartTime >= 1n << 64n) throw new RangeError("unlockStartTime must fit in uint64");
+	const values = [
+		options.unlockPercentHecto,
+		options.cycleDaysOffsetA,
+		options.cyclePercentHectoA,
+		options.cyclesDaysA,
+		options.cycleDaysOffsetB,
+		options.cyclePercentHectoB,
+		options.cyclesDaysB,
+		options.cycleDaysOffsetC,
+		options.cyclePercentHectoC,
+		options.cyclesDaysC,
+		options.cycleDaysOffsetD,
+		options.cyclePercentHectoD,
+		options.cyclesDaysD
+	];
+	if (values.some((value) => !Number.isInteger(value) || value < 0 || value > 65535)) throw new RangeError("unlock option values must fit in uint16");
+	const builder = beginCell().storeUint(options.unlockStartTime, 64);
+	for (const value of values) builder.storeUint(value, 16);
+	return builder.endCell();
+}
+const storageHeader = (opcode, queryId = 0n) => beginCell().storeUint(opcode, 32).storeUint(queryId, 64);
+var MultixStorageContract = class MultixStorageContract extends ContractWrapper {
+	static createFromAddress(address) {
+		return new MultixStorageContract(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: buildMultixStorageData(config)
+		};
+		return new MultixStorageContract(contractAddress(workchain, init), init);
+	}
+	async sendBuyRequest(provider, via, value, buyRequestId, limitTotalAmount, comment = Cell.EMPTY) {
+		await this.send(provider, via, value, storageHeader(MULTIX_STORAGE_OPCODES.buyRequest).storeUint(buyRequestId, 64).storeCoins(limitTotalAmount).storeSlice(comment.beginParse()).endCell());
+	}
+	async sendClaimRequestFull(provider, via, value, contractTonBalance, comment = Cell.EMPTY, queryId = 0n) {
+		await this.send(provider, via, value, storageHeader(MULTIX_STORAGE_OPCODES.claimRequestFull, queryId).storeCoins(contractTonBalance).storeSlice(comment.beginParse()).endCell());
+	}
+	async sendClaimRequestAsset(provider, via, value, salesFreeTokens, itemPriceMilli, unlockOptions, comment = Cell.EMPTY, queryId = 0n) {
+		await this.send(provider, via, value, storageHeader(MULTIX_STORAGE_OPCODES.claimRequestAsset, queryId).storeCoins(salesFreeTokens).storeCoins(itemPriceMilli).storeSlice(unlockOptions.beginParse()).storeSlice(comment.beginParse()).endCell());
+	}
+	async sendDaoVetoVoteRequest(provider, via, value, itemPriceMilli, comment = Cell.EMPTY, queryId = 0n) {
+		await this.send(provider, via, value, storageHeader(MULTIX_STORAGE_OPCODES.daoVetoVoteRequest, queryId).storeCoins(itemPriceMilli).storeSlice(comment.beginParse()).endCell());
+	}
+	async getState(provider) {
+		return this.get(provider, "state");
+	}
+};
+//#endregion
+export { MULTIX_DAO_COMMIT, MULTIX_OPCODES, MULTIX_STORAGE_COMMIT, MULTIX_STORAGE_OPCODES, MultixDaoContract, MultixStorageContract, buildMultixStorageData, buildMultixUnlockOptions };