@hiero-ledger/sdk 2.70.0

package/src/token/TokenNftInfoQuery.js

@@ -0,0 +1,369 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import Query, { QUERY_REGISTRY } from "../query/Query.js";
+import NftId from "./NftId.js";
+import AccountId from "../account/AccountId.js";
+import TokenId from "../token/TokenId.js";
+import TokenNftInfo from "./TokenNftInfo.js";
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import Hbar from "../Hbar.js";
+import Long from "long";
+
+/**
+ * @namespace proto
+ * @typedef {import("@hashgraph/proto").proto.IQuery} HieroProto.proto.IQuery
+ * @typedef {import("@hashgraph/proto").proto.IQueryHeader} HieroProto.proto.IQueryHeader
+ * @typedef {import("@hashgraph/proto").proto.IResponse} HieroProto.proto.IResponse
+ * @typedef {import("@hashgraph/proto").proto.ITokenNftInfo} HieroProto.proto.ITokenNftInfo
+ * @typedef {import("@hashgraph/proto").proto.IResponseHeader} HieroProto.proto.IResponseHeader
+ * @typedef {import("@hashgraph/proto").proto.ITokenGetNftInfoQuery} HieroProto.proto.ITokenGetNftInfoQuery
+ * @typedef {import("@hashgraph/proto").proto.ITokenGetNftInfosQuery} HieroProto.proto.ITokenGetNftInfosQuery
+ * @typedef {import("@hashgraph/proto").proto.ITokenGetAccountNftInfosQuery} HieroProto.proto.ITokenGetAccountNftInfosQuery
+ * @typedef {import("@hashgraph/proto").proto.ITokenGetNftInfoResponse} HieroProto.proto.ITokenGetNftInfoResponse
+ * @typedef {import("@hashgraph/proto").proto.ITokenGetNftInfosResponse} HieroProto.proto.ITokenGetNftInfosResponse
+ * @typedef {import("@hashgraph/proto").proto.ITokenGetAccountNftInfosResponse} HieroProto.proto.ITokenGetAccountNftInfosResponse
+ */
+
+/**
+ * @typedef {import("../channel/Channel.js").default} Channel
+ */
+
+/**
+ * @augments {Query<TokenNftInfo[]>}
+ */
+export default class TokenNftInfoQuery extends Query {
+    /**
+     * @param {object} properties
+     * @param {NftId | string} [properties.nftId]
+     * @param {AccountId | string} [properties.accountId]
+     * @param {TokenId | string} [properties.tokenId]
+     * @param {Long | number} [properties.start]
+     * @param {Long | number} [properties.end]
+     */
+    constructor(properties = {}) {
+        super();
+
+        /**
+         * @private
+         * @type {?NftId}
+         */
+        this._nftId = null;
+        if (properties.nftId != null) {
+            this.setNftId(properties.nftId);
+        }
+
+        /**
+         * @private
+         * @type {?AccountId}
+         */
+        this._accountId = null;
+        if (properties.accountId != null) {
+            // eslint-disable-next-line deprecation/deprecation
+            this.setAccountId(properties.accountId);
+        }
+
+        /**
+         * @private
+         * @type {?TokenId}
+         */
+        this._tokenId = null;
+        if (properties.tokenId != null) {
+            // eslint-disable-next-line deprecation/deprecation
+            this.setTokenId(properties.tokenId);
+        }
+
+        /**
+         * @private
+         * @type {?Long}
+         */
+        this._start = null;
+        if (properties.start != null) {
+            // eslint-disable-next-line deprecation/deprecation
+            this.setStart(properties.start);
+        }
+
+        /**
+         * @private
+         * @type {?Long}
+         */
+        this._end = null;
+        if (properties.end != null) {
+            // eslint-disable-next-line deprecation/deprecation
+            this.setEnd(properties.end);
+        }
+    }
+
+    /**
+     * @internal
+     * @param {HieroProto.proto.IQuery} query
+     * @returns {TokenNftInfoQuery}
+     */
+    static _fromProtobuf(query) {
+        if (query.tokenGetNftInfo != null) {
+            const info = /** @type {HieroProto.proto.ITokenGetNftInfoQuery} */ (
+                query.tokenGetNftInfo
+            );
+
+            return new TokenNftInfoQuery({
+                nftId:
+                    info.nftID != null
+                        ? NftId._fromProtobuf(info.nftID)
+                        : undefined,
+            });
+        } else if (query.tokenGetAccountNftInfos != null) {
+            const info =
+                /** @type {HieroProto.proto.ITokenGetAccountNftInfosQuery} */ (
+                    query.tokenGetAccountNftInfos
+                );
+
+            return new TokenNftInfoQuery({
+                accountId:
+                    info.accountID != null
+                        ? AccountId._fromProtobuf(info.accountID)
+                        : undefined,
+                start: info.start != null ? info.start : undefined,
+                end: info.end != null ? info.end : undefined,
+            });
+        } else {
+            const info =
+                /** @type {HieroProto.proto.ITokenGetNftInfosQuery} */ (
+                    query.tokenGetNftInfos
+                );
+
+            return new TokenNftInfoQuery({
+                tokenId:
+                    info.tokenID != null
+                        ? TokenId._fromProtobuf(info.tokenID)
+                        : undefined,
+                start: info.start != null ? info.start : undefined,
+                end: info.end != null ? info.end : undefined,
+            });
+        }
+    }
+
+    /**
+     * @returns {?NftId}
+     */
+    get nftId() {
+        return this._nftId;
+    }
+
+    /**
+     * Set the token ID for which the info is being requested.
+     *
+     * @param {NftId | string} nftId
+     * @returns {TokenNftInfoQuery}
+     */
+    setNftId(nftId) {
+        this._nftId =
+            typeof nftId === "string"
+                ? NftId.fromString(nftId)
+                : NftId._fromProtobuf(nftId._toProtobuf());
+
+        return this;
+    }
+
+    /**
+     * @deprecated with no replacement
+     * @returns {?AccountId}
+     */
+    get accountId() {
+        console.warn(
+            "`TokenNftInfoQuery.accountId` is deprecated with no replacement",
+        );
+        return this._accountId;
+    }
+
+    /**
+     * @deprecated with no replacement
+     * Set the token ID for which the info is being requested.
+     * @param {AccountId | string} accountId
+     * @returns {TokenNftInfoQuery}
+     */
+    setAccountId(accountId) {
+        console.warn(
+            "`TokenNftInfoQuery.setAccountId()` is deprecated with no replacement",
+        );
+        this._accountId =
+            typeof accountId === "string"
+                ? AccountId.fromString(accountId)
+                : AccountId._fromProtobuf(accountId._toProtobuf());
+
+        return this;
+    }
+
+    /**
+     * @deprecated with no replacement
+     * @returns {?TokenId}
+     */
+    get tokenId() {
+        console.warn(
+            "`TokenNftInfoQuery.tokenId` is deprecated with no replacement",
+        );
+        return this._tokenId;
+    }
+
+    /**
+     * @deprecated with no replacement
+     * Set the token ID for which the info is being requested.
+     * @param {TokenId | string} tokenId
+     * @returns {TokenNftInfoQuery}
+     */
+    setTokenId(tokenId) {
+        console.warn(
+            "`TokenNftInfoQuery.setTokenId()` is deprecated with no replacement",
+        );
+        this._tokenId =
+            typeof tokenId === "string"
+                ? TokenId.fromString(tokenId)
+                : TokenId._fromProtobuf(tokenId._toProtobuf());
+
+        return this;
+    }
+
+    /**
+     * @deprecated with no replacement
+     * @returns {?Long}
+     */
+    get start() {
+        console.warn(
+            "`TokenNftInfoQuery.start` is deprecated with no replacement",
+        );
+        return this._start;
+    }
+
+    /**
+     * @deprecated with no replacement
+     * Set the token ID for which the info is being requested.
+     * @param {Long | number} start
+     * @returns {TokenNftInfoQuery}
+     */
+    setStart(start) {
+        console.warn(
+            "`TokenNftInfoQuery.setStart()` is deprecated with no replacement",
+        );
+        this._start =
+            typeof start === "number" ? Long.fromNumber(start) : start;
+
+        return this;
+    }
+
+    /**
+     * @deprecated with no replacement
+     * @returns {?Long}
+     */
+    get end() {
+        console.warn(
+            "`TokenNftInfoQuery.end` is deprecated with no replacement",
+        );
+        return this._end;
+    }
+
+    /**
+     * @deprecated with no replacement
+     * Set the token ID for which the info is being requested.
+     * @param {Long | number} end
+     * @returns {TokenNftInfoQuery}
+     */
+    setEnd(end) {
+        console.warn(
+            "`TokenNftInfoQuery.setEnd()` is deprecated with no replacement",
+        );
+        this._end = typeof end === "number" ? Long.fromNumber(end) : end;
+
+        return this;
+    }
+
+    /**
+     * @override
+     * @param {import("../client/Client.js").default<Channel, *>} client
+     * @returns {Promise<Hbar>}
+     */
+    async getCost(client) {
+        return super.getCost(client);
+    }
+
+    /**
+     * @override
+     * @internal
+     * @param {Channel} channel
+     * @param {HieroProto.proto.IQuery} request
+     * @returns {Promise<HieroProto.proto.IResponse>}
+     */
+    _execute(channel, request) {
+        return channel.token.getTokenNftInfo(request);
+    }
+
+    /**
+     * @override
+     * @internal
+     * @param {HieroProto.proto.IResponse} response
+     * @returns {HieroProto.proto.IResponseHeader}
+     */
+    _mapResponseHeader(response) {
+        const infos = /** @type {HieroProto.proto.ITokenGetNftInfoResponse} */ (
+            response.tokenGetNftInfo
+        );
+
+        return /** @type {HieroProto.proto.IResponseHeader} */ (infos.header);
+    }
+
+    /**
+     * @override
+     * @internal
+     * @param {HieroProto.proto.IResponse} response
+     * @param {AccountId} nodeAccountId
+     * @param {HieroProto.proto.IQuery} request
+     * @returns {Promise<TokenNftInfo[]>}
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _mapResponse(response, nodeAccountId, request) {
+        const nfts = [
+            /** @type {HieroProto.proto.ITokenNftInfo} */
+            (
+                /** @type {HieroProto.proto.ITokenGetNftInfoResponse} */ (
+                    response.tokenGetNftInfo
+                ).nft
+            ),
+        ];
+
+        return Promise.resolve(
+            nfts.map((nft) =>
+                TokenNftInfo._fromProtobuf(
+                    /** @type {HieroProto.proto.ITokenNftInfo} */ (nft),
+                ),
+            ),
+        );
+    }
+
+    /**
+     * @override
+     * @internal
+     * @param {HieroProto.proto.IQueryHeader} header
+     * @returns {HieroProto.proto.IQuery}
+     */
+    _onMakeRequest(header) {
+        return {
+            tokenGetNftInfo: {
+                header,
+                nftID: this._nftId != null ? this._nftId._toProtobuf() : null,
+            },
+        };
+    }
+
+    /**
+     * @returns {string}
+     */
+    _getLogId() {
+        const timestamp =
+            this._paymentTransactionId != null &&
+            this._paymentTransactionId.validStart != null
+                ? this._paymentTransactionId.validStart
+                : this._timestamp;
+
+        return `TokenNftInfoQuery:${timestamp.toString()}`;
+    }
+}
+
+// eslint-disable-next-line @typescript-eslint/unbound-method
+QUERY_REGISTRY.set("tokenGetNftInfo", TokenNftInfoQuery._fromProtobuf);

package/src/token/TokenNftTransfer.js

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import Long from "long";
+import AccountId from "../account/AccountId.js";
+import TokenId from "./TokenId.js";
+
+/**
+ * @namespace proto
+ * @typedef {import("@hashgraph/proto").proto.ITokenTransferList} HieroProto.proto.ITokenTransferList
+ * @typedef {import("@hashgraph/proto").proto.IAccountAmount} HieroProto.proto.IAccountAmount
+ * @typedef {import("@hashgraph/proto").proto.INftTransfer} HieroProto.proto.INftTransfer
+ * @typedef {import("@hashgraph/proto").proto.IAccountID} HieroProto.proto.IAccountID
+ * @typedef {import("@hashgraph/proto").proto.ITokenID} HieroProto.proto.ITokenID
+ */
+
+/**
+ * @typedef {import("bignumber.js").default} BigNumber
+ */
+
+/**
+ * An account, and the amount that it sends or receives during a cryptocurrency tokentransfer.
+ */
+export default class TokenNftTransfer {
+    /**
+     * @internal
+     * @param {object} props
+     * @param {TokenId | string} props.tokenId
+     * @param {AccountId | string} props.senderAccountId
+     * @param {AccountId | string} props.receiverAccountId
+     * @param {Long | number} props.serialNumber
+     * @param {boolean} props.isApproved
+     */
+    constructor(props) {
+        /**
+         * The Token ID that sends or receives cryptocurrency.
+         */
+        this.tokenId =
+            props.tokenId instanceof TokenId
+                ? props.tokenId
+                : TokenId.fromString(props.tokenId);
+
+        /**
+         * The Account ID that sends or receives cryptocurrency.
+         */
+        this.senderAccountId =
+            props.senderAccountId instanceof AccountId
+                ? props.senderAccountId
+                : AccountId.fromString(props.senderAccountId);
+
+        /**
+         * The Account ID that sends or receives cryptocurrency.
+         */
+        this.receiverAccountId =
+            props.receiverAccountId instanceof AccountId
+                ? props.receiverAccountId
+                : AccountId.fromString(props.receiverAccountId);
+
+        this.serialNumber = Long.fromValue(props.serialNumber);
+        this.isApproved = props.isApproved;
+    }
+
+    /**
+     * @internal
+     * @param {HieroProto.proto.ITokenTransferList[]} tokenTransfers
+     * @returns {TokenNftTransfer[]}
+     */
+    static _fromProtobuf(tokenTransfers) {
+        const transfers = [];
+
+        for (const tokenTransfer of tokenTransfers) {
+            const tokenId = TokenId._fromProtobuf(
+                /** @type {HieroProto.proto.ITokenID} */ (tokenTransfer.token),
+            );
+            for (const transfer of tokenTransfer.nftTransfers != null
+                ? tokenTransfer.nftTransfers
+                : []) {
+                transfers.push(
+                    new TokenNftTransfer({
+                        tokenId,
+                        senderAccountId: AccountId._fromProtobuf(
+                            /** @type {HieroProto.proto.IAccountID} */ (
+                                transfer.senderAccountID
+                            ),
+                        ),
+                        receiverAccountId: AccountId._fromProtobuf(
+                            /** @type {HieroProto.proto.IAccountID} */ (
+                                transfer.receiverAccountID
+                            ),
+                        ),
+                        serialNumber:
+                            transfer.serialNumber != null
+                                ? transfer.serialNumber
+                                : Long.ZERO,
+                        isApproved: transfer.isApproval == true,
+                    }),
+                );
+            }
+        }
+
+        return transfers;
+    }
+
+    /**
+     * @internal
+     * @returns {HieroProto.proto.INftTransfer}
+     */
+    _toProtobuf() {
+        return {
+            senderAccountID: this.senderAccountId._toProtobuf(),
+            receiverAccountID: this.receiverAccountId._toProtobuf(),
+            serialNumber: this.serialNumber,
+            isApproval: this.isApproved,
+        };
+    }
+}

package/src/token/TokenNftsUpdateTransaction.js

@@ -0,0 +1,220 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import TokenId from "./TokenId.js";
+import Transaction, {
+    TRANSACTION_REGISTRY,
+} from "../transaction/Transaction.js";
+
+/**
+ * @namespace proto
+ * @typedef {import("@hashgraph/proto").proto.ITransaction} HieroProto.proto.ITransaction
+ * @typedef {import("@hashgraph/proto").proto.ISignedTransaction} HieroProto.proto.ISignedTransaction
+ * @typedef {import("@hashgraph/proto").proto.TransactionBody} HieroProto.proto.TransactionBody
+ * @typedef {import("@hashgraph/proto").proto.ITransactionBody} HieroProto.proto.ITransactionBody
+ * @typedef {import("@hashgraph/proto").proto.ITransactionResponse} HieroProto.proto.ITransactionResponse
+ * @typedef {import("@hashgraph/proto").proto.ITokenUpdateNftsTransactionBody} HieroProto.proto.ITokenUpdateNftsTransactionBody
+ * @typedef {import("@hashgraph/proto").proto.ITokenID} HieroProto.proto.ITokenID
+ */
+
+/**
+ * @typedef {import("../channel/Channel.js").default} Channel
+ * @typedef {import("../client/Client.js").default<*, *>} Client
+ * @typedef {import("../transaction/TransactionId.js").default} TransactionId
+ * @typedef {import("../account/AccountId.js").default} AccountId
+ */
+
+/**
+ * @deprecated - Use TokenUpdateNftsTransaction instead
+ */
+export default class TokenNftsUpdateTransaction extends Transaction {
+    /**
+     * @param {object} [props]
+     * @param {TokenId | string} [props.tokenId]
+     * @param {Long[]} [props.serialNumbers]
+     * @param {Uint8Array} [props.metadata]
+     */
+    constructor(props = {}) {
+        super();
+
+        /**
+         * @private
+         * @type {?TokenId}
+         */
+        this._tokenId = null;
+
+        /**
+         * @private
+         * @type {?Long[]}
+         */
+        this._serialNumbers = [];
+
+        /**
+         * @private
+         * @type {?Uint8Array}
+         */
+        this._metadata = null;
+
+        if (props.tokenId != null) {
+            this.setTokenId(props.tokenId);
+        }
+
+        if (props.serialNumbers != null) {
+            this.setSerialNumbers(props.serialNumbers);
+        }
+
+        if (props.metadata != null) {
+            this.setMetadata(props.metadata);
+        }
+    }
+
+    /**
+     * @internal
+     * @param {HieroProto.proto.ITransaction[]} transactions
+     * @param {HieroProto.proto.ISignedTransaction[]} signedTransactions
+     * @param {TransactionId[]} transactionIds
+     * @param {AccountId[]} nodeIds
+     * @param {HieroProto.proto.ITransactionBody[]} bodies
+     * @returns {TokenNftsUpdateTransaction}
+     */
+    static _fromProtobuf(
+        transactions,
+        signedTransactions,
+        transactionIds,
+        nodeIds,
+        bodies,
+    ) {
+        const body = bodies[0];
+        const tokenUpdate =
+            /** @type {HieroProto.proto.ITokenUpdateNftsTransactionBody} */ (
+                body.tokenUpdate
+            );
+
+        return Transaction._fromProtobufTransactions(
+            // eslint-disable-next-line deprecation/deprecation
+            new TokenNftsUpdateTransaction({
+                tokenId:
+                    tokenUpdate.token != null
+                        ? TokenId._fromProtobuf(tokenUpdate.token)
+                        : undefined,
+                serialNumbers:
+                    tokenUpdate.serialNumbers != null
+                        ? tokenUpdate.serialNumbers
+                        : [],
+                metadata:
+                    tokenUpdate.metadata != null
+                        ? tokenUpdate.metadata.value != null
+                            ? tokenUpdate.metadata.value
+                            : undefined
+                        : undefined,
+            }),
+            transactions,
+            signedTransactions,
+            transactionIds,
+            nodeIds,
+            bodies,
+        );
+    }
+
+    /**
+     * @description Assign the token id.
+     * @param {TokenId | string} tokenId
+     * @returns {this}
+     */
+    setTokenId(tokenId) {
+        this._requireNotFrozen();
+        this._tokenId =
+            typeof tokenId === "string"
+                ? TokenId.fromString(tokenId)
+                : tokenId.clone();
+
+        return this;
+    }
+
+    /**
+     * @description Assign the list of serial numbers.
+     * @param {Long[]} serialNumbers
+     * @returns {this}
+     */
+    setSerialNumbers(serialNumbers) {
+        this._requireNotFrozen();
+        this._serialNumbers = serialNumbers;
+
+        return this;
+    }
+
+    /**
+     * @param {Uint8Array} metadata
+     * @returns {this}
+     */
+    setMetadata(metadata) {
+        this._requireNotFrozen();
+        this._metadata = metadata;
+
+        return this;
+    }
+
+    /**
+     * @param {Client} client
+     */
+    _validateChecksums(client) {
+        if (this._tokenId != null) {
+            this._tokenId.validateChecksum(client);
+        }
+    }
+
+    /**
+     * @override
+     * @internal
+     * @param {Channel} channel
+     * @param {HieroProto.proto.ITransaction} request
+     * @returns {Promise<HieroProto.proto.ITransactionResponse>}
+     */
+    _execute(channel, request) {
+        return channel.token.pauseToken(request);
+    }
+
+    /**
+     * @override
+     * @protected
+     * @returns {NonNullable<HieroProto.proto.TransactionBody["data"]>}
+     */
+    _getTransactionDataCase() {
+        return "tokenUpdateNfts";
+    }
+
+    /**
+     * @override
+     * @protected
+     * @returns {HieroProto.proto.ITokenUpdateNftsTransactionBody}
+     */
+    _makeTransactionData() {
+        return {
+            token: this._tokenId != null ? this._tokenId._toProtobuf() : null,
+            serialNumbers:
+                this._serialNumbers != null ? this._serialNumbers : [],
+            ...(this._metadata != null
+                ? {
+                      metadata: {
+                          value: this._metadata,
+                      },
+                  }
+                : null),
+        };
+    }
+
+    /**
+     * @returns {string}
+     */
+    _getLogId() {
+        const timestamp = /** @type {import("../Timestamp.js").default} */ (
+            this._transactionIds.current.validStart
+        );
+        return `TokenNftsUpdateTransaction:${timestamp.toString()}`;
+    }
+}
+
+TRANSACTION_REGISTRY.set(
+    "tokenUpdateNfts",
+    // eslint-disable-next-line deprecation/deprecation, @typescript-eslint/unbound-method
+    TokenNftsUpdateTransaction._fromProtobuf,
+);