@tonappchain/sdk 0.7.0-rc9 → 0.7.0

package/dist/artifacts/mainnet/ton/internal/wrappers/NFTCollection.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NFTCollection = exports.NFTCollectionErrors = exports.NFTCollectionOpCodes = void 0;
+exports.nftCollectionConfigToCell = nftCollectionConfigToCell;
+const core_1 = require("@ton/core");
+const Constants_1 = require("./Constants");
+exports.NFTCollectionOpCodes = {
+    admin_deployNFTItem: 0xfdba5d5f,
+    admin_batchDeployNFTItems: 0x909d579b,
+    admin_changeAdmin: 0x581879bc,
+    admin_cancelChangingAdmin: 0x60094a1b,
+    newAdmin_confirmChangingAdmin: 0x6a4fbe34,
+    admin_withdrawExtraTon: 0x1754ab63,
+    collection_init: 0xbd6ea770,
+};
+exports.NFTCollectionErrors = {
+    notFromAdmin: 73,
+    notFromNewAdmin: 75,
+    newAdminAddressIsNone: 80,
+};
+function nftCollectionConfigToCell(config) {
+    return (0, core_1.beginCell)()
+        .storeAddress(config.adminAddress)
+        .storeAddress(config.newAdminAddress)
+        .storeRef((0, core_1.beginCell)().storeRef(config.collectionContent).storeRef(config.commonContent).endCell())
+        .storeRef(config.nftItemCode)
+        .storeStringTail(config.originalAddress)
+        .endCell();
+}
+class NFTCollection {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new NFTCollection(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = nftCollectionConfigToCell(config);
+        const init = { code, data };
+        return new NFTCollection((0, core_1.contractAddress)(workchain, init), init);
+    }
+    async sendDeploy(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().endCell(),
+        });
+    }
+    static deployNFTItemMessage(queryId, itemIndex, itemOwner, nftContent, maybeNewContent) {
+        return (0, core_1.beginCell)()
+            .storeUint(exports.NFTCollectionOpCodes.admin_deployNFTItem, 32)
+            .storeUint(queryId, 64)
+            .storeUint(itemIndex, 256)
+            .storeAddress(itemOwner)
+            .storeRef(nftContent)
+            .storeMaybeRef(maybeNewContent)
+            .endCell();
+    }
+    async sendDeployNFTItem(provider, via, value, params) {
+        await provider.internal(via, {
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: NFTCollection.deployNFTItemMessage(params.queryId ?? 0, params.itemIndex, params.itemOwner, params.nftContent, params.maybeNewContent),
+            value,
+        });
+    }
+    static changeAdminMessage(newAdmin, queryId) {
+        return (0, core_1.beginCell)()
+            .storeUint(exports.NFTCollectionOpCodes.admin_changeAdmin, 32)
+            .storeUint(queryId, 64)
+            .storeAddress(newAdmin)
+            .endCell();
+    }
+    async sendChangeAdmin(provider, via, value, params) {
+        await provider.internal(via, {
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: NFTCollection.changeAdminMessage(params.newAdminAddress, params.queryId ?? 0),
+            value,
+        });
+    }
+    async sendCancelChangingAdmin(provider, via, value, params) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.NFTCollectionOpCodes.admin_cancelChangingAdmin, Constants_1.Params.bitsize.op)
+                .storeUint(params?.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .endCell(),
+        });
+    }
+    async sendConfirmNewAdmin(provider, via, value, params) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.NFTCollectionOpCodes.newAdmin_confirmChangingAdmin, Constants_1.Params.bitsize.op)
+                .storeUint(params?.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .endCell(),
+        });
+    }
+    async sendWithdrawExtraTon(provider, via, value, params) {
+        await provider.internal(via, {
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.NFTCollectionOpCodes.admin_withdrawExtraTon, 32)
+                .storeUint(params?.queryId || 0, 64)
+                .endCell(),
+            value,
+        });
+    }
+    async getCollectionData(provider) {
+        const res = await provider.get('get_collection_data', []);
+        const nextIndex = res.stack.readBigNumber();
+        const content = res.stack.readCell();
+        const adminAddress = res.stack.readAddress();
+        return {
+            nextIndex,
+            content,
+            adminAddress,
+        };
+    }
+    async getFullData(provider) {
+        const res = await provider.get('get_full_data', []);
+        const nextIndex = res.stack.readNumber();
+        const content = res.stack.readCell();
+        const adminAddress = res.stack.readAddress();
+        const newAdminAddress = res.stack.readAddressOpt();
+        return {
+            nextIndex,
+            content,
+            adminAddress,
+            newAdminAddress,
+        };
+    }
+    async getNFTAddressByIndex(provider, index) {
+        const res = await provider.get('get_nft_address_by_index', [{ type: 'int', value: BigInt(index) }]);
+        return res.stack.readAddress();
+    }
+    async getNFTContent(provider, index, individualNFTContent) {
+        const res = await provider.get('get_nft_content', [
+            { type: 'int', value: BigInt(index) },
+            { type: 'cell', cell: individualNFTContent },
+        ]);
+        return res.stack.readCell();
+    }
+    async getOriginalAddress(provider) {
+        const res = await provider.get('get_original_address', []);
+        return res.stack.readString();
+    }
+}
+exports.NFTCollection = NFTCollection;

package/dist/artifacts/mainnet/ton/internal/wrappers/NFTItem.d.ts

@@ -0,0 +1,82 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from '@ton/core';
+export declare const NFTItemOpCodes: {
+    owner_transfer: number;
+    owner_burn: number;
+    collection_init: number;
+    anyone_getStaticData: number;
+    nftItem_reportStaticData: number;
+    nftItem_ownershipAssigned: number;
+    nftItem_excesses: number;
+    ccl_tvmMsgToEVM: number;
+    ccl_errorNotification: number;
+};
+export declare const NFTItemErrors: {
+    notEnoughGas: number;
+    alreadyInitialized: number;
+    notInitialized: number;
+    destinationNotAllowed: number;
+    notFromCCL: number;
+    notFromOwner: number;
+    notFromCollection: number;
+};
+export type NFTItemConfig = {
+    init?: boolean;
+    index: bigint;
+    collectionAddress: Address;
+    ownerAddress?: Address;
+    content?: Cell;
+    cclAddress: Address;
+};
+export type NFTItemData = {
+    init?: boolean;
+    index: bigint;
+    collectionAddress: Address;
+    ownerAddress?: Address;
+    content?: Cell;
+};
+export declare function nftItemConfigToCell(config: NFTItemConfig): Cell;
+export declare class NFTItem implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static createFromAddress(address: Address): NFTItem;
+    static createFromConfig(config: NFTItemConfig, code: Cell, workchain?: number): NFTItem;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    static transferMessage(queryId: number | bigint, newOwner: Address, responseAddress: Address, forwardAmount: bigint | number, forwardPayload?: Cell): Cell;
+    sendTransfer(provider: ContractProvider, via: Sender, value: bigint, params: {
+        queryId?: number | bigint;
+        newOwner: Address;
+        responseAddress: Address;
+        forwardAmount: bigint | number;
+        forwardPayload?: Cell;
+    }): Promise<void>;
+    static burnMessage(queryId: number | bigint, responseAddress: Address, crosschainTonAmount: bigint | number, crosschainPayload?: Cell, feeData?: Cell): Cell;
+    sendBurn(provider: ContractProvider, via: Sender, value: bigint, params: {
+        queryId?: number | bigint;
+        responseAddress: Address;
+        crosschainTonAmount?: number | bigint;
+        crosschainPayload?: Cell;
+        feeData?: Cell;
+    }): Promise<void>;
+    static initMessage(queryId: number | bigint, ownerAddress: Address, content: Cell): Cell;
+    sendInit(provider: ContractProvider, via: Sender, value: bigint, params: {
+        queryId?: number | bigint;
+        ownerAddress: Address;
+        content: Cell;
+    }): Promise<void>;
+    static getStaticDataMessage(queryId: number | bigint): Cell;
+    sendGetStaticData(provider: ContractProvider, via: Sender, value: bigint, params: {
+        queryId?: number | bigint;
+    }): Promise<void>;
+    static errorNotificationMessage(queryId: number | bigint): Cell;
+    sendErrorNotification(provider: ContractProvider, via: Sender, value: bigint, params?: {
+        queryId?: number | bigint;
+    }): Promise<void>;
+    getNFTData(provider: ContractProvider): Promise<NFTItemData>;
+}

package/dist/artifacts/mainnet/ton/internal/wrappers/NFTItem.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NFTItem = exports.NFTItemErrors = exports.NFTItemOpCodes = void 0;
+exports.nftItemConfigToCell = nftItemConfigToCell;
+const core_1 = require("@ton/core");
+exports.NFTItemOpCodes = {
+    owner_transfer: 0x5fcc3d14,
+    owner_burn: 0x3b390ce,
+    collection_init: 0xbd6ea770,
+    anyone_getStaticData: 0x2fcb26a2,
+    nftItem_reportStaticData: 0x8b771735,
+    nftItem_ownershipAssigned: 0x05138d91,
+    nftItem_excesses: 0xd53276db,
+    ccl_tvmMsgToEVM: 0x6c582059,
+    ccl_errorNotification: 0xae7df95b,
+};
+exports.NFTItemErrors = {
+    notEnoughGas: 48,
+    alreadyInitialized: 200,
+    notInitialized: 201,
+    destinationNotAllowed: 202,
+    notFromCCL: 70,
+    notFromOwner: 71,
+    notFromCollection: 72,
+};
+function nftItemConfigToCell(config) {
+    return (0, core_1.beginCell)()
+        .storeBit(config.init ?? false)
+        .storeUint(config.index, 256)
+        .storeRef((0, core_1.beginCell)()
+        .storeAddress(config.collectionAddress)
+        .storeAddress(config.cclAddress)
+        .storeAddress(config.ownerAddress ?? null)
+        .endCell())
+        .storeMaybeRef(config.content ?? null)
+        .endCell();
+}
+class NFTItem {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new NFTItem(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = nftItemConfigToCell(config);
+        const init = { code, data };
+        return new NFTItem((0, core_1.contractAddress)(workchain, init), init);
+    }
+    async sendDeploy(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().endCell(),
+        });
+    }
+    static transferMessage(queryId, newOwner, responseAddress, forwardAmount, forwardPayload) {
+        let msg = (0, core_1.beginCell)()
+            .storeUint(exports.NFTItemOpCodes.owner_transfer, 32)
+            .storeUint(queryId, 64)
+            .storeAddress(newOwner)
+            .storeAddress(responseAddress)
+            .storeBit(false) // custom payload
+            .storeCoins((0, core_1.toNano)(forwardAmount));
+        if (forwardPayload) {
+            msg.storeMaybeRef(forwardPayload);
+        }
+        return msg.endCell();
+    }
+    async sendTransfer(provider, via, value, params) {
+        await provider.internal(via, {
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: NFTItem.transferMessage(params.queryId ?? 0, params.newOwner, params.responseAddress, params.forwardAmount, params.forwardPayload),
+            value,
+        });
+    }
+    static burnMessage(queryId, responseAddress, crosschainTonAmount, crosschainPayload, feeData) {
+        return (0, core_1.beginCell)()
+            .storeUint(exports.NFTItemOpCodes.owner_burn, 32)
+            .storeUint(queryId, 64)
+            .storeAddress(responseAddress)
+            .storeMaybeRef((0, core_1.beginCell)()
+            .storeCoins((0, core_1.toNano)(crosschainTonAmount))
+            .storeMaybeRef(feeData)
+            .storeMaybeRef(crosschainPayload ?? null)
+            .endCell())
+            .endCell();
+    }
+    async sendBurn(provider, via, value, params) {
+        await provider.internal(via, {
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: NFTItem.burnMessage(params.queryId ?? 0, params.responseAddress, params.crosschainTonAmount ?? 0n, params.crosschainPayload, params.feeData),
+            value,
+        });
+    }
+    static initMessage(queryId, ownerAddress, content) {
+        return (0, core_1.beginCell)()
+            .storeUint(exports.NFTItemOpCodes.collection_init, 32)
+            .storeUint(queryId, 64)
+            .storeAddress(ownerAddress)
+            .storeRef(content)
+            .endCell();
+    }
+    async sendInit(provider, via, value, params) {
+        await provider.internal(via, {
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: NFTItem.initMessage(params.queryId ?? 0, params.ownerAddress, params.content),
+            value,
+        });
+    }
+    static getStaticDataMessage(queryId) {
+        return (0, core_1.beginCell)().storeUint(exports.NFTItemOpCodes.anyone_getStaticData, 32).storeUint(queryId, 64).endCell();
+    }
+    async sendGetStaticData(provider, via, value, params) {
+        await provider.internal(via, {
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: NFTItem.getStaticDataMessage(params.queryId ?? 0),
+            value,
+        });
+    }
+    static errorNotificationMessage(queryId) {
+        return (0, core_1.beginCell)().storeUint(exports.NFTItemOpCodes.ccl_errorNotification, 32).storeUint(queryId, 64).endCell();
+    }
+    async sendErrorNotification(provider, via, value, params = {}) {
+        await provider.internal(via, {
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: NFTItem.errorNotificationMessage(params.queryId ?? 0),
+            value,
+        });
+    }
+    async getNFTData(provider) {
+        const res = await provider.get('get_nft_data', []);
+        const init = res.stack.readBoolean();
+        const index = res.stack.readBigNumber();
+        const collectionAddress = res.stack.readAddress();
+        const ownerAddress = res.stack.readAddressOpt() ?? undefined;
+        const content = res.stack.readCellOpt() ?? undefined;
+        return {
+            init,
+            index,
+            collectionAddress,
+            ownerAddress,
+            content,
+        };
+    }
+}
+exports.NFTItem = NFTItem;

package/dist/artifacts/mainnet/ton/internal/wrappers/NFTProxy.d.ts

@@ -0,0 +1,84 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from '@ton/core';
+export declare const NFTItemTransferOperation = 2332633442;
+export declare const NFTProxyOpCodes: {
+    admin_changeAdmin: number;
+    admin_updateCode: number;
+    ccl_evmMsgToTVMProxy: number;
+    ccl_errorNotification: number;
+    ccl_tvmMsgToEVM: number;
+    nftItem_ownershipAssigned: number;
+    nftItem_burn: number;
+    nftItem_transfer: number;
+    admin_cancelChangingAdmin: number;
+    newAdmin_confirmChangingAdmin: number;
+};
+export declare const NFTProxyErrors: {
+    notFromCrossChainLayer: number;
+    notFromAdmin: number;
+    notFromNewAdmin: number;
+    newAdminAddressIsNone: number;
+    notEnoughTon: number;
+    invalidPayload: number;
+};
+export type NFTProxyConfig = {
+    cclAddress: Address;
+    adminAddress: Address;
+    newAdminAddress: Address | null;
+};
+export declare function nftProxyConfigToCell(config: NFTProxyConfig): Cell;
+export declare class NFTProxy implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static createFromAddress(address: Address): NFTProxy;
+    static createFromConfig(config: NFTProxyConfig, code: Cell, workchain?: number): NFTProxy;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    static errorNotificationMessage(queryId: number | bigint, operation: number | bigint, itemAddress: Address, owner: Address): Cell;
+    sendErrorNotification(provider: ContractProvider, via: Sender, value: bigint, params: {
+        queryId?: number | bigint;
+        operation: number | bigint;
+        itemAddress: Address;
+        owner: Address;
+    }): Promise<void>;
+    static evmMsgToTVMProxyMessage(queryId: number | bigint, itemAddress: Address, newOwner: Address, forwardAmount: bigint): Cell;
+    sendEVMMsgToTVMProxy(provider: ContractProvider, via: Sender, value: bigint, params: {
+        queryId?: number | bigint;
+        itemAddress: Address;
+        newOwner: Address;
+        forwardAmount: bigint;
+    }): Promise<void>;
+    static ownershipAssignedMessage(queryId: number | bigint, itemOwner: Address, crosschainTonAmount: bigint, evmData?: Cell, feeData?: Cell): Cell;
+    sendOwnershipAssigned(provider: ContractProvider, via: Sender, value: bigint, params: {
+        queryId?: number | bigint;
+        itemOwner: Address;
+        crosschainTonAmount: bigint;
+        evmData?: Cell;
+        feeData?: Cell;
+    }): Promise<void>;
+    sendUpdateCode(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryId?: number;
+        code: Cell;
+        data: Cell;
+    }): Promise<void>;
+    sendChangeAdmin(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryId?: number;
+        adminAddress: string;
+    }): Promise<void>;
+    sendCancelChangingAdmin(provider: ContractProvider, via: Sender, value: bigint, opts?: {
+        queryId?: number;
+    }): Promise<void>;
+    sendConfirmNewAdmin(provider: ContractProvider, via: Sender, value: bigint, opts?: {
+        queryId?: number;
+    }): Promise<void>;
+    getFullData(provider: ContractProvider): Promise<{
+        cclAddress: Address;
+        adminAddress: Address;
+        newAdminAddress: Address | null;
+    }>;
+}

package/dist/artifacts/mainnet/ton/internal/wrappers/NFTProxy.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NFTProxy = exports.NFTProxyErrors = exports.NFTProxyOpCodes = exports.NFTItemTransferOperation = void 0;
+exports.nftProxyConfigToCell = nftProxyConfigToCell;
+const core_1 = require("@ton/core");
+const Constants_1 = require("./Constants");
+exports.NFTItemTransferOperation = 0x8b092962;
+exports.NFTProxyOpCodes = {
+    admin_changeAdmin: 0x581879bc,
+    admin_updateCode: 0x20faec53,
+    ccl_evmMsgToTVMProxy: 0x7817b330,
+    ccl_errorNotification: 0xae7df95b,
+    ccl_tvmMsgToEVM: 0x6c582059,
+    nftItem_ownershipAssigned: 0x05138d91,
+    nftItem_burn: 0x6656d267,
+    nftItem_transfer: 0x5fcc3d14,
+    admin_cancelChangingAdmin: 0x60094a1b,
+    newAdmin_confirmChangingAdmin: 0x6a4fbe34,
+};
+exports.NFTProxyErrors = {
+    notFromCrossChainLayer: 70,
+    notFromAdmin: 71,
+    notFromNewAdmin: 72,
+    newAdminAddressIsNone: 80,
+    notEnoughTon: 100,
+    invalidPayload: 200,
+};
+function nftProxyConfigToCell(config) {
+    return (0, core_1.beginCell)()
+        .storeAddress(config.cclAddress)
+        .storeAddress(config.adminAddress)
+        .storeAddress(config.newAdminAddress)
+        .endCell();
+}
+class NFTProxy {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new NFTProxy(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = nftProxyConfigToCell(config);
+        const init = { code, data };
+        return new NFTProxy((0, core_1.contractAddress)(workchain, init), init);
+    }
+    async sendDeploy(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().endCell(),
+        });
+    }
+    static errorNotificationMessage(queryId, operation, itemAddress, owner) {
+        return (0, core_1.beginCell)()
+            .storeUint(exports.NFTProxyOpCodes.ccl_errorNotification, Constants_1.Params.bitsize.op)
+            .storeUint(queryId, Constants_1.Params.bitsize.queryId)
+            .storeUint(operation, 32)
+            .storeAddress(itemAddress)
+            .storeAddress(owner)
+            .endCell();
+    }
+    async sendErrorNotification(provider, via, value, params) {
+        await provider.internal(via, {
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: NFTProxy.errorNotificationMessage(params.queryId ?? 0, params.operation, params.itemAddress, params.owner),
+            value,
+        });
+    }
+    static evmMsgToTVMProxyMessage(queryId, itemAddress, newOwner, forwardAmount) {
+        return (0, core_1.beginCell)()
+            .storeUint(exports.NFTProxyOpCodes.ccl_evmMsgToTVMProxy, Constants_1.Params.bitsize.op)
+            .storeUint(queryId, Constants_1.Params.bitsize.queryId)
+            .storeAddress(itemAddress)
+            .storeAddress(newOwner)
+            .storeCoins(forwardAmount)
+            .endCell();
+    }
+    async sendEVMMsgToTVMProxy(provider, via, value, params) {
+        await provider.internal(via, {
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: NFTProxy.evmMsgToTVMProxyMessage(params.queryId ?? 0, params.itemAddress, params.newOwner, params.forwardAmount),
+            value,
+        });
+    }
+    static ownershipAssignedMessage(queryId, itemOwner, crosschainTonAmount, evmData, feeData) {
+        return (0, core_1.beginCell)()
+            .storeUint(exports.NFTProxyOpCodes.nftItem_ownershipAssigned, Constants_1.Params.bitsize.op)
+            .storeUint(queryId, Constants_1.Params.bitsize.queryId)
+            .storeAddress(itemOwner)
+            .storeMaybeRef((0, core_1.beginCell)().storeCoins(crosschainTonAmount).storeMaybeRef(feeData).storeMaybeRef(evmData).endCell())
+            .endCell();
+    }
+    async sendOwnershipAssigned(provider, via, value, params) {
+        await provider.internal(via, {
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: NFTProxy.ownershipAssignedMessage(params.queryId ?? 0, params.itemOwner, params.crosschainTonAmount, params.evmData, params.feeData),
+            value,
+        });
+    }
+    async sendUpdateCode(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.NFTProxyOpCodes.admin_updateCode, Constants_1.Params.bitsize.op)
+                .storeUint(opts.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .storeRef(opts.code)
+                .storeRef(opts.data)
+                .endCell(),
+        });
+    }
+    async sendChangeAdmin(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.NFTProxyOpCodes.admin_changeAdmin, Constants_1.Params.bitsize.op)
+                .storeUint(opts.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .storeAddress(!!opts.adminAddress ? core_1.Address.parse(opts.adminAddress) : null)
+                .endCell(),
+        });
+    }
+    async sendCancelChangingAdmin(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.NFTProxyOpCodes.admin_cancelChangingAdmin, Constants_1.Params.bitsize.op)
+                .storeUint(opts?.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .endCell(),
+        });
+    }
+    async sendConfirmNewAdmin(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.NFTProxyOpCodes.newAdmin_confirmChangingAdmin, Constants_1.Params.bitsize.op)
+                .storeUint(opts?.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .endCell(),
+        });
+    }
+    async getFullData(provider) {
+        const res = await provider.get('get_full_data', []);
+        const cclAddress = res.stack.readAddress();
+        const adminAddress = res.stack.readAddress();
+        const newAdminAddress = res.stack.readAddressOpt();
+        return {
+            cclAddress,
+            adminAddress,
+            newAdminAddress,
+        };
+    }
+}
+exports.NFTProxy = NFTProxy;