@hiero-ledger/sdk 2.70.0

package/src/schedule/ScheduleInfo.js

@@ -0,0 +1,243 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import ScheduleId from "./ScheduleId.js";
+import AccountId from "../account/AccountId.js";
+import Timestamp from "../Timestamp.js";
+import Transaction from "../transaction/Transaction.js";
+import * as HieroProto from "@hashgraph/proto";
+import TransactionId from "../transaction/TransactionId.js";
+import Key from "../Key.js";
+import KeyList from "../KeyList.js";
+
+const { proto } = HieroProto;
+
+/**
+ * Response when the client sends the node ScheduleGetInfoQuery.
+ */
+export default class ScheduleInfo {
+    /**
+     * @private
+     * @param {object} props
+     * @param {ScheduleId} props.scheduleId;
+     * @param {?AccountId} props.creatorAccountID;
+     * @param {?AccountId} props.payerAccountID;
+     * @param {?HieroProto.proto.ISchedulableTransactionBody} props.schedulableTransactionBody;
+     * @param {?Key} props.adminKey
+     * @param {?KeyList} props.signers;
+     * @param {?string} props.scheduleMemo;
+     * @param {?Timestamp} props.expirationTime;
+     * @param {?Timestamp} props.executed;
+     * @param {?Timestamp} props.deleted;
+     * @param {?TransactionId} props.scheduledTransactionId;
+     * @param {boolean} props.waitForExpiry;
+     */
+    constructor(props) {
+        /**
+         * @readonly
+         */
+        this.scheduleId = props.scheduleId;
+
+        /**
+         * @readonly
+         */
+        this.creatorAccountId = props.creatorAccountID;
+
+        /**
+         * @readonly
+         */
+        this.payerAccountId = props.payerAccountID;
+
+        /**
+         * @readonly
+         */
+        this.schedulableTransactionBody = props.schedulableTransactionBody;
+
+        /**
+         * @readonly
+         */
+        this.signers = props.signers;
+
+        /**
+         * @readonly
+         */
+        this.scheduleMemo = props.scheduleMemo;
+
+        /**
+         * @readonly
+         */
+        this.adminKey = props.adminKey != null ? props.adminKey : null;
+
+        /**
+         * @readonly
+         */
+        this.expirationTime = props.expirationTime;
+
+        /**
+         * @readonly
+         */
+        this.executed = props.executed;
+
+        /**
+         * @readonly
+         */
+        this.deleted = props.deleted;
+
+        /**
+         * @readonly
+         */
+        this.scheduledTransactionId = props.scheduledTransactionId;
+
+        /**
+         *
+         * @readonly
+         */
+        this.waitForExpiry = props.waitForExpiry;
+
+        Object.freeze(this);
+    }
+
+    /**
+     * @internal
+     * @param {HieroProto.proto.IScheduleInfo} info
+     * @returns {ScheduleInfo}
+     */
+    static _fromProtobuf(info) {
+        return new ScheduleInfo({
+            scheduleId: ScheduleId._fromProtobuf(
+                /** @type {HieroProto.proto.IScheduleID} */ (info.scheduleID),
+            ),
+            creatorAccountID:
+                info.creatorAccountID != null
+                    ? AccountId._fromProtobuf(
+                          /** @type {HieroProto.proto.IAccountID} */ (
+                              info.creatorAccountID
+                          ),
+                      )
+                    : null,
+            payerAccountID:
+                info.payerAccountID != null
+                    ? AccountId._fromProtobuf(
+                          /** @type {HieroProto.proto.IAccountID} */ (
+                              info.payerAccountID
+                          ),
+                      )
+                    : null,
+            schedulableTransactionBody:
+                info.scheduledTransactionBody != null
+                    ? info.scheduledTransactionBody
+                    : null,
+            adminKey:
+                info.adminKey != null
+                    ? Key._fromProtobufKey(info.adminKey)
+                    : null,
+            signers:
+                info.signers != null
+                    ? KeyList.__fromProtobufKeyList(info.signers)
+                    : null,
+            scheduleMemo: info.memo != null ? info.memo : null,
+            expirationTime:
+                info.expirationTime != null
+                    ? Timestamp._fromProtobuf(
+                          /** @type {HieroProto.proto.ITimestamp} */ (
+                              info.expirationTime
+                          ),
+                      )
+                    : null,
+            executed:
+                info.executionTime != null
+                    ? Timestamp._fromProtobuf(
+                          /** @type {HieroProto.proto.ITimestamp} */ (
+                              info.executionTime
+                          ),
+                      )
+                    : null,
+            deleted:
+                info.deletionTime != null
+                    ? Timestamp._fromProtobuf(
+                          /** @type {HieroProto.proto.ITimestamp} */ (
+                              info.deletionTime
+                          ),
+                      )
+                    : null,
+            scheduledTransactionId:
+                info.scheduledTransactionID != null
+                    ? TransactionId._fromProtobuf(info.scheduledTransactionID)
+                    : null,
+            waitForExpiry:
+                info.waitForExpiry != null ? info.waitForExpiry : false,
+        });
+    }
+
+    /**
+     * @returns {HieroProto.proto.IScheduleInfo}
+     */
+    _toProtobuf() {
+        return {
+            scheduleID:
+                this.scheduleId != null ? this.scheduleId._toProtobuf() : null,
+            creatorAccountID:
+                this.creatorAccountId != null
+                    ? this.creatorAccountId._toProtobuf()
+                    : null,
+            payerAccountID:
+                this.payerAccountId != null
+                    ? this.payerAccountId._toProtobuf()
+                    : null,
+            scheduledTransactionBody:
+                this.schedulableTransactionBody != null
+                    ? this.schedulableTransactionBody
+                    : null,
+            adminKey:
+                this.adminKey != null ? this.adminKey._toProtobufKey() : null,
+            signers:
+                this.signers != null
+                    ? this.signers._toProtobufKey().keyList
+                    : null,
+            memo: this.scheduleMemo != null ? this.scheduleMemo : "",
+            expirationTime:
+                this.expirationTime != null
+                    ? this.expirationTime._toProtobuf()
+                    : null,
+            scheduledTransactionID:
+                this.scheduledTransactionId != null
+                    ? this.scheduledTransactionId._toProtobuf()
+                    : null,
+            waitForExpiry: this.waitForExpiry,
+        };
+    }
+
+    /**
+     * @returns {Transaction}
+     */
+    get scheduledTransaction() {
+        if (this.schedulableTransactionBody == null) {
+            throw new Error("Scheduled transaction body is empty");
+        }
+
+        const scheduled = new proto.SchedulableTransactionBody(
+            this.schedulableTransactionBody,
+        );
+        const data =
+            /** @type {NonNullable<HieroProto.proto.SchedulableTransactionBody["data"]>} */ (
+                scheduled.data
+            );
+
+        return Transaction.fromBytes(
+            proto.TransactionList.encode({
+                transactionList: [
+                    {
+                        signedTransactionBytes: proto.SignedTransaction.encode({
+                            bodyBytes: proto.TransactionBody.encode({
+                                transactionFee:
+                                    this.schedulableTransactionBody
+                                        .transactionFee,
+                                memo: this.schedulableTransactionBody.memo,
+                                [data]: scheduled[data],
+                            }).finish(),
+                        }).finish(),
+                    },
+                ],
+            }).finish(),
+        );
+    }
+}

package/src/schedule/ScheduleInfoQuery.js

@@ -0,0 +1,189 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import Query, { QUERY_REGISTRY } from "../query/Query.js";
+import ScheduleId from "./ScheduleId.js";
+import ScheduleInfo from "./ScheduleInfo.js";
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import Hbar from "../Hbar.js";
+
+/**
+ * @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.IResponseHeader} HieroProto.proto.IResponseHeader
+ * @typedef {import("@hashgraph/proto").proto.IScheduleInfo} HieroProto.proto.IScheduleInfo
+ * @typedef {import("@hashgraph/proto").proto.IScheduleGetInfoQuery} HieroProto.proto.IScheduleGetInfoQuery
+ * @typedef {import("@hashgraph/proto").proto.IScheduleGetInfoResponse} HieroProto.proto.IScheduleGetInfoResponse
+ */
+
+/**
+ * @typedef {import("../channel/Channel.js").default} Channel
+ * @typedef {import("../client/Client.js").default<*, *>} Client
+ * @typedef {import("../account/AccountId.js").default} AccountId
+ */
+
+/**
+ * Retrieve the metadata for a schedule.
+ * @augments {Query<ScheduleInfo>}
+ */
+export default class ScheduleInfoQuery extends Query {
+    /**
+     * @param {object} properties
+     * @param {ScheduleId | string} [properties.scheduleId]
+     */
+    constructor(properties = {}) {
+        super();
+
+        /**
+         * @private
+         * @type {?ScheduleId}
+         */
+        this._scheduleId = null;
+
+        if (properties.scheduleId != null) {
+            this.setScheduleId(properties.scheduleId);
+        }
+    }
+
+    /**
+     * @internal
+     * @param {HieroProto.proto.IQuery} query
+     * @returns {ScheduleInfoQuery}
+     */
+    static _fromProtobuf(query) {
+        const info = /** @type {HieroProto.proto.IScheduleGetInfoQuery} */ (
+            query.scheduleGetInfo
+        );
+
+        return new ScheduleInfoQuery({
+            scheduleId:
+                info.scheduleID != null
+                    ? ScheduleId._fromProtobuf(info.scheduleID)
+                    : undefined,
+        });
+    }
+
+    /**
+     * @returns {?ScheduleId}
+     */
+    get scheduleId() {
+        return this._scheduleId;
+    }
+
+    /**
+     *
+     * @param {ScheduleId | string} scheduleId
+     * @returns {ScheduleInfoQuery}
+     */
+    setScheduleId(scheduleId) {
+        this._scheduleId =
+            typeof scheduleId === "string"
+                ? ScheduleId.fromString(scheduleId)
+                : scheduleId.clone();
+
+        return this;
+    }
+
+    /**
+     * @override
+     * @param {import("../client/Client.js").default<Channel, *>} client
+     * @returns {Promise<Hbar>}
+     */
+    async getCost(client) {
+        return super.getCost(client);
+    }
+
+    /**
+     * @param {Client} client
+     */
+    _validateChecksums(client) {
+        if (this._scheduleId != null) {
+            this._scheduleId.validateChecksum(client);
+        }
+    }
+
+    /**
+     * @override
+     * @internal
+     * @param {Channel} channel
+     * @param {HieroProto.proto.IQuery} request
+     * @returns {Promise<HieroProto.proto.IResponse>}
+     */
+    _execute(channel, request) {
+        return channel.schedule.getScheduleInfo(request);
+    }
+
+    /**
+     * @override
+     * @internal
+     * @param {HieroProto.proto.IResponse} response
+     * @returns {HieroProto.proto.IResponseHeader}
+     */
+    _mapResponseHeader(response) {
+        const scheduleGetInfo =
+            /** @type {HieroProto.proto.IScheduleGetInfoResponse} */ (
+                response.scheduleGetInfo
+            );
+        return /** @type {HieroProto.proto.IResponseHeader} */ (
+            scheduleGetInfo.header
+        );
+    }
+
+    /**
+     * @override
+     * @internal
+     * @param {HieroProto.proto.IResponse} response
+     * @param {AccountId} nodeAccountId
+     * @param {HieroProto.proto.IQuery} request
+     * @returns {Promise<ScheduleInfo>}
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _mapResponse(response, nodeAccountId, request) {
+        const info = /** @type {HieroProto.proto.IScheduleGetInfoResponse} */ (
+            response.scheduleGetInfo
+        );
+
+        return Promise.resolve(
+            ScheduleInfo._fromProtobuf(
+                /** @type {HieroProto.proto.IScheduleInfo} */ (
+                    info.scheduleInfo
+                ),
+            ),
+        );
+    }
+
+    /**
+     * @override
+     * @internal
+     * @param {HieroProto.proto.IQueryHeader} header
+     * @returns {HieroProto.proto.IQuery}
+     */
+    _onMakeRequest(header) {
+        return {
+            scheduleGetInfo: {
+                header,
+                scheduleID:
+                    this._scheduleId != null
+                        ? this._scheduleId._toProtobuf()
+                        : null,
+            },
+        };
+    }
+
+    /**
+     * @returns {string}
+     */
+    _getLogId() {
+        const timestamp =
+            this._paymentTransactionId != null &&
+            this._paymentTransactionId.validStart != null
+                ? this._paymentTransactionId.validStart
+                : this._timestamp;
+
+        return `ScheduleInfoQuery:${timestamp.toString()}`;
+    }
+}
+
+// eslint-disable-next-line @typescript-eslint/unbound-method
+QUERY_REGISTRY.set("scheduleGetInfo", ScheduleInfoQuery._fromProtobuf);

package/src/schedule/ScheduleSignTransaction.js

@@ -0,0 +1,189 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import ScheduleId from "./ScheduleId.js";
+import Hbar from "../Hbar.js";
+import Transaction, {
+    TRANSACTION_REGISTRY,
+} from "../transaction/Transaction.js";
+
+/**
+ * @typedef {object} ProtoSignaturePair
+ * @property {(Uint8Array | null)=} pubKeyPrefix
+ * @property {(Uint8Array | null)=} ed25519
+ */
+
+/**
+ * @typedef {object} ProtoSigMap
+ * @property {(ProtoSignaturePair[] | null)=} sigPair
+ */
+
+/**
+ * @typedef {object} ProtoSignedTransaction
+ * @property {(Uint8Array | null)=} bodyBytes
+ * @property {(ProtoSigMap | null)=} sigMap
+ */
+
+/**
+ * @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.IScheduleSignTransactionBody} HieroProto.proto.IScheduleSignTransactionBody
+ * @typedef {import("@hashgraph/proto").proto.IAccountID} HieroProto.proto.IAccountID
+ * @typedef {import("@hashgraph/proto").proto.ISignatureMap} HieroProto.proto.ISignatureMap
+ */
+
+/**
+ * @typedef {import("bignumber.js").default} BigNumber
+ * @typedef {import("@hashgraph/cryptography").Key} Key
+ * @typedef {import("../channel/Channel.js").default} Channel
+ * @typedef {import("../client/Client.js").default<*, *>} Client
+ * @typedef {import("../Timestamp.js").default} Timestamp
+ * @typedef {import("../transaction/TransactionId.js").default} TransactionId
+ * @typedef {import("../account/AccountId.js").default} AccountId
+ * @typedef {import("@hashgraph/cryptography").PublicKey} PublicKey
+ */
+
+/**
+ * Create a new Hedera™ crypto-currency account.
+ */
+export default class ScheduleSignTransaction extends Transaction {
+    /**
+     * @param {object} [props]
+     * @param {ScheduleId | string} [props.scheduleId]
+     */
+    constructor(props = {}) {
+        super();
+
+        /**
+         * @private
+         * @type {?ScheduleId}
+         */
+        this._scheduleId = null;
+
+        if (props.scheduleId != null) {
+            this.setScheduleId(props.scheduleId);
+        }
+
+        this._defaultMaxTransactionFee = new Hbar(5);
+    }
+
+    /**
+     * @internal
+     * @param {HieroProto.proto.ITransaction[]} transactions
+     * @param {HieroProto.proto.ISignedTransaction[]} signedTransactions
+     * @param {TransactionId[]} transactionIds
+     * @param {AccountId[]} nodeIds
+     * @param {HieroProto.proto.ITransactionBody[]} bodies
+     * @returns {ScheduleSignTransaction}
+     */
+    static _fromProtobuf(
+        transactions,
+        signedTransactions,
+        transactionIds,
+        nodeIds,
+        bodies,
+    ) {
+        const body = bodies[0];
+        const sign =
+            /** @type {HieroProto.proto.IScheduleSignTransactionBody} */ (
+                body.scheduleSign
+            );
+
+        return Transaction._fromProtobufTransactions(
+            new ScheduleSignTransaction({
+                scheduleId:
+                    sign.scheduleID != null
+                        ? ScheduleId._fromProtobuf(sign.scheduleID)
+                        : undefined,
+            }),
+            transactions,
+            signedTransactions,
+            transactionIds,
+            nodeIds,
+            bodies,
+        );
+    }
+
+    /**
+     * @returns {?ScheduleId}
+     */
+    get scheduleId() {
+        return this._scheduleId;
+    }
+
+    /**
+     * @param {ScheduleId | string} scheduleId
+     * @returns {this}
+     */
+    setScheduleId(scheduleId) {
+        this._requireNotFrozen();
+        this._scheduleId =
+            typeof scheduleId === "string"
+                ? ScheduleId.fromString(scheduleId)
+                : scheduleId.clone();
+
+        return this;
+    }
+
+    /**
+     * @param {Client} client
+     */
+    _validateChecksums(client) {
+        if (this._scheduleId != null) {
+            this._scheduleId.validateChecksum(client);
+        }
+    }
+
+    /**
+     * @override
+     * @internal
+     * @param {Channel} channel
+     * @param {HieroProto.proto.ITransaction} request
+     * @returns {Promise<HieroProto.proto.ITransactionResponse>}
+     */
+    _execute(channel, request) {
+        return channel.schedule.signSchedule(request);
+    }
+
+    /**
+     * @override
+     * @protected
+     * @returns {NonNullable<HieroProto.proto.TransactionBody["data"]>}
+     */
+    _getTransactionDataCase() {
+        return "scheduleSign";
+    }
+
+    /**
+     * @override
+     * @protected
+     * @returns {HieroProto.proto.IScheduleSignTransactionBody}
+     */
+    _makeTransactionData() {
+        return {
+            scheduleID:
+                this._scheduleId != null
+                    ? this._scheduleId._toProtobuf()
+                    : null,
+        };
+    }
+
+    /**
+     * @returns {string}
+     */
+    _getLogId() {
+        const timestamp = /** @type {import("../Timestamp.js").default} */ (
+            this._transactionIds.current.validStart
+        );
+        return `ScheduleSignTransaction:${timestamp.toString()}`;
+    }
+}
+
+TRANSACTION_REGISTRY.set(
+    "scheduleSign",
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    ScheduleSignTransaction._fromProtobuf,
+);