@pizzaton/ton 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,66 @@
+import { ContractWrapper } from "./base.mjs";
+import { Address, Cell, ContractProvider, Sender, TupleReader } from "@ton/core";
+//#region src/contracts/wrappers/pizzabox.d.ts
+export declare const PIZZABOX_OPCODES: {
+  readonly quickUnlock: 0;
+  readonly vestingUnlock: 2808733223;
+  readonly jettonTransfer: 260734629;
+};
+export declare const PIZZABOX_GAS: {
+  readonly quickLock: {
+    readonly messageValue: 250000000n;
+    readonly forwardAmount: 150000000n;
+  };
+  readonly vestingLock: {
+    readonly messageValue: 750000000n;
+    readonly forwardAmount: 645000000n;
+  };
+  readonly unlock: 50000000n;
+  readonly ptjBurn: 50000000n;
+};
+export interface PizzaBoxVestingMetadata {
+  readonly purpose: string;
+  readonly decimals: number;
+  readonly symbol: string;
+  readonly image: string;
+  readonly uri: string;
+}
+export interface PizzaBoxVestingPayloadInput extends PizzaBoxVestingMetadata {
+  readonly jettonMaster: Address;
+  readonly owner: Address;
+  readonly firstUnlockTime: number;
+  readonly firstUnlockPercent: number;
+  readonly cycleLengthSeconds: number;
+  readonly cycleNumber: number;
+  readonly referralAddress?: Address | null | undefined;
+}
+export declare function buildPizzaBoxQuickLockPayload(lockUntil: number): Cell;
+export declare function buildPizzaBoxVestingPayload(input: PizzaBoxVestingPayloadInput): Cell;
+export declare function buildPizzaBoxQuickUnlockBody(queryId?: bigint): Cell;
+export declare function buildPizzaBoxVestingUnlockBody(queryId?: bigint): Cell;
+export interface PizzaBoxLockStorage {
+  readonly initialized: boolean;
+  readonly factoryAddress: Address;
+  readonly index: bigint;
+  readonly ownerAddress: Address | null;
+  readonly jettonMinterAddress: Address | null;
+  readonly jettonWalletAddress: Address | null;
+  readonly lockedJettons: bigint;
+  readonly jettonsLocked: boolean;
+  readonly claimedTimes: number;
+  readonly claimedJettons: bigint;
+  readonly firstUnlockTime: number;
+  readonly firstUnlockSize: number;
+  readonly cycleLength: number;
+  readonly cyclesNumber: number;
+  readonly content: Cell | null;
+  readonly factoryJettonWallet?: Address;
+}
+export declare function readPizzaBoxVestingStorage(stack: TupleReader): PizzaBoxLockStorage;
+export declare class PizzaBoxLockBill extends ContractWrapper {
+  static createFromAddress(address: Address): PizzaBoxLockBill;
+  sendQuickUnlock(provider: ContractProvider, via: Sender, value?: 50000000n): Promise<void>;
+  sendVestingUnlock(provider: ContractProvider, via: Sender, value?: 50000000n): Promise<void>;
+  getStorageData(provider: ContractProvider): Promise<PizzaBoxLockStorage>;
+}
+//#endregion

package/dist/contracts/wrappers/pizzabox.mjs

@@ -0,0 +1,105 @@
+import { buildOnchainMetadata } from "../../nft/content.mjs";
+import { ContractWrapper } from "./base.mjs";
+import { beginCell } from "@ton/core";
+//#region src/contracts/wrappers/pizzabox.ts
+const PIZZABOX_OPCODES = {
+	quickUnlock: 0,
+	vestingUnlock: 2808733223,
+	jettonTransfer: 260734629
+};
+const PIZZABOX_GAS = {
+	quickLock: {
+		messageValue: 250000000n,
+		forwardAmount: 150000000n
+	},
+	vestingLock: {
+		messageValue: 750000000n,
+		forwardAmount: 645000000n
+	},
+	unlock: 50000000n,
+	ptjBurn: 50000000n
+};
+function buildPizzaBoxQuickLockPayload(lockUntil) {
+	assertUint(lockUntil, 32, "lockUntil");
+	return beginCell().storeUint(lockUntil, 32).endCell();
+}
+function buildPizzaBoxVestingPayload(input) {
+	assertUint(input.firstUnlockTime, 32, "firstUnlockTime");
+	assertUint(input.cycleLengthSeconds, 32, "cycleLengthSeconds");
+	assertUint(input.cycleNumber, 32, "cycleNumber");
+	if (!Number.isFinite(input.firstUnlockPercent) || input.firstUnlockPercent < 0 || input.firstUnlockPercent > 100) throw new RangeError("firstUnlockPercent must be between 0 and 100");
+	return beginCell().storeAddress(input.jettonMaster).storeAddress(input.owner).storeUint(input.firstUnlockTime, 32).storeUint(Math.floor(input.firstUnlockPercent * 1e6), 32).storeUint(input.cycleLengthSeconds, 32).storeUint(input.cycleNumber, 32).storeMaybeRef(buildOnchainMetadata({
+		purpose: input.purpose,
+		decimals: String(input.decimals),
+		symbol: input.symbol,
+		image: input.image,
+		uri: input.uri
+	})).storeAddress(input.referralAddress ?? null).endCell();
+}
+function buildPizzaBoxQuickUnlockBody(queryId = 0n) {
+	if (queryId < 0n || queryId >= 2n ** 64n) throw new RangeError("queryId out of range");
+	return beginCell().storeUint(PIZZABOX_OPCODES.quickUnlock, 32).storeUint(queryId, 64).storeStringTail("#unlock").endCell();
+}
+function buildPizzaBoxVestingUnlockBody(queryId = 0n) {
+	if (queryId < 0n || queryId >= 2n ** 64n) throw new RangeError("queryId out of range");
+	return beginCell().storeUint(PIZZABOX_OPCODES.vestingUnlock, 32).storeUint(queryId, 64).endCell();
+}
+function readPizzaBoxVestingStorage(stack) {
+	const initialized = stack.readBoolean();
+	const factoryAddress = stack.readAddress();
+	const index = stack.readBigNumber();
+	if (!initialized) return {
+		initialized,
+		factoryAddress,
+		index,
+		ownerAddress: null,
+		jettonMinterAddress: null,
+		jettonWalletAddress: null,
+		lockedJettons: 0n,
+		jettonsLocked: false,
+		claimedTimes: 0,
+		claimedJettons: 0n,
+		firstUnlockTime: 0,
+		firstUnlockSize: 0,
+		cycleLength: 0,
+		cyclesNumber: 0,
+		content: null
+	};
+	return {
+		initialized,
+		factoryAddress,
+		index,
+		ownerAddress: stack.readAddress(),
+		jettonMinterAddress: stack.readAddress(),
+		jettonWalletAddress: stack.readAddressOpt(),
+		content: stack.readCellOpt(),
+		factoryJettonWallet: stack.readAddress(),
+		lockedJettons: stack.readBigNumber(),
+		jettonsLocked: stack.readBoolean(),
+		claimedTimes: stack.readNumber(),
+		claimedJettons: stack.readBigNumber(),
+		firstUnlockTime: stack.readNumber(),
+		firstUnlockSize: stack.readNumber(),
+		cycleLength: stack.readNumber(),
+		cyclesNumber: stack.readNumber()
+	};
+}
+var PizzaBoxLockBill = class PizzaBoxLockBill extends ContractWrapper {
+	static createFromAddress(address) {
+		return new PizzaBoxLockBill(address);
+	}
+	async sendQuickUnlock(provider, via, value = PIZZABOX_GAS.unlock) {
+		await this.send(provider, via, value, buildPizzaBoxQuickUnlockBody());
+	}
+	async sendVestingUnlock(provider, via, value = PIZZABOX_GAS.unlock) {
+		await this.send(provider, via, value, buildPizzaBoxVestingUnlockBody());
+	}
+	async getStorageData(provider) {
+		return readPizzaBoxVestingStorage(await this.get(provider, "get_storage_data"));
+	}
+};
+function assertUint(value, bits, name) {
+	if (!Number.isSafeInteger(value) || value < 0 || value >= 2 ** bits) throw new RangeError(`${name} must fit in uint${bits}`);
+}
+//#endregion
+export { PIZZABOX_GAS, PIZZABOX_OPCODES, PizzaBoxLockBill, buildPizzaBoxQuickLockPayload, buildPizzaBoxQuickUnlockBody, buildPizzaBoxVestingPayload, buildPizzaBoxVestingUnlockBody, readPizzaBoxVestingStorage };

package/dist/contracts/wrappers/ton-raffles.d.mts

@@ -0,0 +1,215 @@
+import { ContractWrapper } from "./base.mjs";
+import { Address, Cell, ContractProvider, Dictionary, Sender } from "@ton/core";
+//#region src/contracts/wrappers/ton-raffles.d.ts
+/**
+ * Native adapters for the supplied Ton-Raffles/PizzaTon revisions. Each
+ * revision is intentionally a separate class: these contracts are not
+ * interchangeable even when their names and opcodes overlap.
+ */
+export declare const TON_RAFFLES_SOURCE_REVISIONS: {
+  readonly nftLaunchpad: "983a668dae2c5fd0b71a4c8c42c47392ecf5a9bd";
+  readonly nftAuctionV2: "b2bc3755c79d43f6cc2b361210362d4a1672b1dd";
+  readonly nftSwapV2: "8e262604c56f0be2753be254772df4a3fed03882";
+  readonly scalableAirdrop: "47b8fb00163af2755b413c16cd815672c5cdeae2";
+  readonly offchainProofsV2: "467815bdcbb58e604d6b82e22bfb1aa16ce6282a";
+  readonly shoppingCart: "78b9b18de1fda2fb2360e10e6dd54877defc906f";
+  readonly jettonLocker: "cd1574f52b413c2aea6255a08110c8fad3b5616e";
+  readonly nftSaleJettons: "d65f5348a748b0c3567fa59b7594ca0b7218f368";
+  readonly memeland: "a7e132be091585b80cb6ffc6b7b50c8f0bdc53a2";
+  readonly bondingCurve: "5dbb20575fde5144d00c63f9d3099c0ac71bab95";
+};
+export interface NftLaunchpadSaleConfig {
+  readonly adminPublicKey: Buffer;
+  readonly available: bigint;
+  readonly price: bigint;
+  readonly lastIndex: bigint;
+  readonly collection: Address;
+  readonly buyerLimit: bigint;
+  readonly startTime: bigint;
+  readonly endTime: bigint;
+  readonly adminAddress: Address;
+  readonly helperCode: Cell;
+  readonly affiliatePercentage?: bigint;
+}
+export declare function buildNftLaunchpadSaleData(config: NftLaunchpadSaleConfig): Cell;
+export declare class TonRafflesNftLaunchpadSale extends ContractWrapper {
+  static createFromAddress(address: Address): TonRafflesNftLaunchpadSale;
+  static createFromConfig(config: NftLaunchpadSaleConfig, code: Cell, workchain?: number): TonRafflesNftLaunchpadSale;
+  sendPurchase(provider: ContractProvider, via: Sender, value: bigint, quantity: bigint, time: bigint, signature: Buffer, queryId?: bigint, referrer?: Address): Promise<void>;
+  sendChangeCollectionOwner(provider: ContractProvider, via: Sender, value: bigint, owner: Address, collection?: Address): Promise<void>;
+  sendChangeAvailable(provider: ContractProvider, via: Sender, value: bigint, available: bigint): Promise<void>;
+  sendChangeStartTime(provider: ContractProvider, via: Sender, value: bigint, time: bigint): Promise<void>;
+  sendChangeEndTime(provider: ContractProvider, via: Sender, value: bigint, time: bigint): Promise<void>;
+  sendEnable(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+  sendDisable(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+  sendCollectRemainingBalance(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+  getContractData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+export interface TonRafflesModernSaleConfig {
+  readonly createdAt: bigint;
+  readonly marketplace: Address;
+  readonly nft: Address;
+  readonly nftOwner: Address;
+  readonly fullPrice: bigint;
+  readonly fees: Cell;
+  readonly publicKey: Buffer;
+}
+export declare function buildTonRafflesModernSaleData(config: TonRafflesModernSaleConfig): Cell;
+export declare class TonRafflesModernNftSale extends ContractWrapper {
+  static createFromAddress(address: Address): TonRafflesModernNftSale;
+  static createFromConfig(config: TonRafflesModernSaleConfig, code: Cell, workchain?: number): TonRafflesModernNftSale;
+  sendDeploy(provider: ContractProvider, via: Sender, value: bigint, signature: Buffer, queryId?: bigint): Promise<void>;
+  sendCancel(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendChangePrice(provider: ContractProvider, via: Sender, value: bigint, newPrice: bigint, fees: Cell, queryId?: bigint): Promise<void>;
+  getSaleData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+export interface TonRafflesJettonSalePrices {
+  readonly fullPrice: bigint;
+  readonly marketplaceFee: bigint;
+  readonly royaltyAmount: bigint;
+}
+export declare function buildTonRafflesJettonSalePrices(prices: ReadonlyMap<Address, TonRafflesJettonSalePrices>): Dictionary<bigint, TonRafflesJettonSalePrices>;
+export interface TonRafflesJettonSaleConfig {
+  readonly isComplete: boolean;
+  readonly createdAt: bigint;
+  readonly marketplace: Address;
+  readonly nft: Address;
+  readonly nftOwner: Address | null;
+  readonly fullPrice: bigint;
+  readonly marketplaceFeeAddress: Address;
+  readonly marketplaceFee: bigint;
+  readonly royaltyAddress: Address;
+  readonly royaltyAmount: bigint;
+  readonly jettonsConfigured: boolean;
+  readonly jettonPrices: ReadonlyMap<Address, TonRafflesJettonSalePrices> | null;
+  readonly publicKey: Buffer;
+}
+export declare function buildTonRafflesJettonSaleData(config: TonRafflesJettonSaleConfig): Cell;
+export declare class TonRafflesJettonPricedNftSale extends ContractWrapper {
+  static createFromAddress(address: Address): TonRafflesJettonPricedNftSale;
+  static createFromConfig(config: TonRafflesJettonSaleConfig, code: Cell, workchain?: number): TonRafflesJettonPricedNftSale;
+  sendBuy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+  sendBuyWithReferrer(provider: ContractProvider, via: Sender, referrer: Address | null, value: bigint): Promise<void>;
+  sendInitialize(provider: ContractProvider, via: Sender, value: bigint, signature: Buffer, queryId?: bigint): Promise<void>;
+  sendConfigureJettons(provider: ContractProvider, via: Sender, prices: Dictionary<bigint, TonRafflesJettonSalePrices>, value: bigint, queryId?: bigint): Promise<void>;
+  sendCancel(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  getSaleData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+export declare class TonRafflesNftAuctionV2 extends ContractWrapper {
+  static createFromAddress(address: Address): TonRafflesNftAuctionV2;
+  sendDeploy(provider: ContractProvider, via: Sender, value: bigint, signature: Buffer, wallet: Address, queryId?: bigint): Promise<void>;
+  sendBid(provider: ContractProvider, via: Sender, value: bigint, amount: bigint, queryId?: bigint): Promise<void>;
+  sendCancellation(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendCheck(provider: ContractProvider, queryId?: bigint): Promise<void>;
+  getContractData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+export type TonRafflesSwapAsset = {
+  readonly tokenType: 0n | 1n | 2n;
+  readonly received: boolean;
+  readonly sent: boolean;
+  readonly tonAmount?: bigint;
+  readonly jettonAmount?: bigint;
+  readonly gasAmount: bigint;
+};
+export declare class TonRafflesNftSwapV2 extends ContractWrapper {
+  static createFromAddress(address: Address): TonRafflesNftSwapV2;
+  sendDeploy(provider: ContractProvider, via: Sender, value: bigint, signature: Buffer, firstAssets: Dictionary<Address, TonRafflesSwapAsset>, secondAssets: Dictionary<Address, TonRafflesSwapAsset>, queryId?: bigint): Promise<void>;
+  sendReplenish(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendCancel(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  getContractData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+export interface TonRafflesAirdropHelperConfig {
+  readonly airdrop: Address;
+  readonly proofHash: Buffer;
+  readonly index: bigint;
+}
+export declare function buildTonRafflesAirdropHelperData(config: TonRafflesAirdropHelperConfig): Cell;
+export declare class TonRafflesAirdropHelper extends ContractWrapper {
+  static createFromAddress(address: Address): TonRafflesAirdropHelper;
+  static createFromConfig(config: TonRafflesAirdropHelperConfig, code: Cell, workchain?: number): TonRafflesAirdropHelper;
+  sendClaim(provider: ContractProvider, queryId: bigint, proof: Cell): Promise<void>;
+  getClaimed(provider: ContractProvider): Promise<boolean>;
+}
+export interface TonRafflesScalableAirdropConfig {
+  readonly merkleRoot: bigint;
+  readonly helperCode: Cell;
+  readonly startTime: bigint;
+  readonly admin: Address;
+  /** Explicit nonce keeps StateInit deterministic; the upstream sample used randomness. */
+  readonly nonce: bigint;
+}
+export interface TonRafflesAirdropEntry {
+  readonly address: Address;
+  readonly amount: bigint;
+}
+export declare function buildTonRafflesAirdropEntries(entries: readonly TonRafflesAirdropEntry[]): Dictionary<bigint, TonRafflesAirdropEntry>;
+export declare function buildTonRafflesScalableAirdropData(config: TonRafflesScalableAirdropConfig): Cell;
+export declare class TonRafflesScalableAirdrop extends ContractWrapper {
+  static createFromAddress(address: Address): TonRafflesScalableAirdrop;
+  static createFromConfig(config: TonRafflesScalableAirdropConfig, code: Cell, workchain?: number): TonRafflesScalableAirdrop;
+  sendDeploy(provider: ContractProvider, via: Sender, jettonWallet: Address, value: bigint, queryId?: bigint): Promise<void>;
+  sendWithdrawJettons(provider: ContractProvider, via: Sender, amount: bigint, value: bigint, queryId?: bigint): Promise<void>;
+}
+export interface TonRafflesStakingHelperConfig {
+  readonly master: Address;
+  readonly item: Address;
+}
+export declare function buildTonRafflesStakingHelperData(config: TonRafflesStakingHelperConfig): Cell;
+export declare class TonRafflesNftStakingHelper extends ContractWrapper {
+  static createFromAddress(address: Address): TonRafflesNftStakingHelper;
+  static createFromConfig(config: TonRafflesStakingHelperConfig, code: Cell, workchain?: number): TonRafflesNftStakingHelper;
+  sendClaim(provider: ContractProvider, via: Sender, value: bigint, returnItem: boolean, queryId?: bigint): Promise<void>;
+  getContractData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+export declare function buildOffchainProofDataToSign(task: Address, user: Address, referrer: Address | null, validUntil: bigint): Cell;
+export declare class TonRafflesOffchainProofTask extends ContractWrapper {
+  static createFromAddress(address: Address): TonRafflesOffchainProofTask;
+  sendClaim(provider: ContractProvider, via: Sender, value: bigint, signature: Buffer, signedData: Cell, queryId?: bigint): Promise<void>;
+  sendServiceMessage(provider: ContractProvider, via: Sender, value: bigint, message: Cell, mode: number, queryId?: bigint): Promise<void>;
+  sendWithdrawJettons(provider: ContractProvider, via: Sender, value: bigint, amount: bigint, queryId?: bigint): Promise<void>;
+  getHelperAddress(provider: ContractProvider, user: Address): Promise<Address>;
+  getContractData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+export declare class TonRafflesShoppingCart extends ContractWrapper {
+  static createFromAddress(address: Address): TonRafflesShoppingCart;
+  sendBuy(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+}
+export declare class PizzaTonJettonLockerBill extends ContractWrapper {
+  static createFromAddress(address: Address): PizzaTonJettonLockerBill;
+  sendUnlock(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+}
+export declare class PizzaTonJettonLockerCollection extends ContractWrapper {
+  static createFromAddress(address: Address): PizzaTonJettonLockerCollection;
+  sendDeployNewNft(provider: ContractProvider, via: Sender, value: bigint, passAmount: bigint, owner: Address, campaignId: bigint, queryId?: bigint, activeUntil?: bigint): Promise<void>;
+  sendChangeOwner(provider: ContractProvider, via: Sender, owner: Address, value: bigint, queryId?: bigint): Promise<void>;
+  sendAddJettonWallet(provider: ContractProvider, via: Sender, wallet: Address, master: Address, value: bigint, queryId?: bigint): Promise<void>;
+  sendWithdrawBalance(provider: ContractProvider, via: Sender, value: bigint, amount: bigint, queryId?: bigint): Promise<void>;
+  getWallets(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+export declare class TonRafflesNftItem extends ContractWrapper {
+  static createFromAddress(address: Address): TonRafflesNftItem;
+  sendTransfer(provider: ContractProvider, via: Sender, value: bigint, newOwner: Address, queryId?: bigint, forwardAmount?: bigint): Promise<void>;
+  getOwner(provider: ContractProvider): Promise<Address>;
+}
+export declare class TonRafflesNftStakingMaster extends ContractWrapper {
+  static createFromAddress(address: Address): TonRafflesNftStakingMaster;
+  sendAdminJettonsWithdrawal(provider: ContractProvider, via: Sender, value: bigint, amount: bigint, queryId?: bigint): Promise<void>;
+  sendAdminAddItems(provider: ContractProvider, via: Sender, value: bigint, items: Dictionary<Address, bigint>, queryId?: bigint): Promise<void>;
+  sendAdminRemoveItems(provider: ContractProvider, via: Sender, value: bigint, items: Dictionary<Address, bigint>, queryId?: bigint): Promise<void>;
+  getItems(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+  getStakedItems(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+  getEstimatedReward(provider: ContractProvider, item: Address, elapsedSeconds: bigint): Promise<bigint>;
+}
+export declare class TonRafflesNftLendingMaster extends ContractWrapper {
+  static createFromAddress(address: Address): TonRafflesNftLendingMaster;
+  sendCancel(provider: ContractProvider, via: Sender, value: bigint, queryId?: bigint): Promise<void>;
+  sendChangeData(provider: ContractProvider, via: Sender, value: bigint, options: {
+    readonly jettonWallet?: Address;
+    readonly amount?: bigint;
+    readonly loanDuration?: bigint;
+    readonly aprAmount?: bigint;
+  }, queryId?: bigint): Promise<void>;
+  sendMakeOffer(provider: ContractProvider, via: Sender, value: bigint, owner: Address, offerAmount: bigint, aprAmount: bigint, loanDuration: bigint, queryId?: bigint): Promise<void>;
+  getContractData(provider: ContractProvider): Promise<import("@ton/core").TupleReader>;
+}
+//#endregion