@hiero-ledger/sdk 2.70.0

package/src/transaction/SignableNodeTransactionBodyBytes.js

@@ -0,0 +1,40 @@
+/**
+ * @typedef {import("../account/AccountId").default} AccountId
+ * @typedef {import("../transaction/TransactionId").default} TransactionId
+ */
+
+/**
+ * Represents a transaction body that is ready for signing, associated with a specific node account and transaction identifier.
+ * @property {AccountId} nodeAccountId - The account ID of the node.
+ * @property {TransactionId} transactionId - The transactionId of the transaction, (when dealing with a chunked transaction, this is the transactionId of the chunk).
+ * @property {Uint8Array} signableTransactionBodyBytes - The transaction body bytes ready for signing.
+ */
+export default class SignableNodeTransactionBodyBytes {
+    /**
+     * Creates a new instance of NodeSignableTransaction.
+     *
+     * @param {AccountId} nodeAccountId - The account ID of the node.
+     * @param {TransactionId} transactionId - The transactionId of the transaction.
+     * @param {Uint8Array} signableTransactionBodyBytes - The transaction body bytes ready for signing.
+     */
+    constructor(nodeAccountId, transactionId, signableTransactionBodyBytes) {
+        /**
+         * The node account identifier associated with the transaction.
+         * @type {AccountId}
+         */
+        this.nodeAccountId = nodeAccountId;
+
+        /**
+         * The transactionId identifier.
+         * Note: When dealing with a chunked transaction, this is the transactionId of the chunk.
+         * @type {TransactionId}
+         */
+        this.transactionId = transactionId;
+
+        /**
+         * The bytes of the transaction body, ready to be signed.
+         * @type {Uint8Array}
+         */
+        this.signableTransactionBodyBytes = signableTransactionBodyBytes;
+    }
+}

package/src/transaction/SignatureMap.js

@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import NodeAccountIdSignatureMap from "./NodeAccountIdSignatureMap.js";
+import ObjectMap from "../ObjectMap.js";
+import AccountId from "../account/AccountId.js";
+import List from "./List.js";
+
+/**
+ * Represents a mapping of account IDs to their corresponding signatures for transactions.
+ *
+ * The `SignatureMap` class is used to manage and store signatures associated with
+ * different accounts in a transaction. It allows for adding signatures, retrieving
+ * them, and converting the signature map to and from various formats.
+ */
+
+/**
+ * @augments {ObjectMap<AccountId, NodeAccountIdSignatureMap>}
+ */
+export default class SignatureMap extends ObjectMap {
+    /**
+     * @typedef {import("../transaction/TransactionId.js").default} TransactionId
+     * @typedef {import("../transaction/SignaturePairMap.js").default} SignaturePairMap
+     */
+    constructor() {
+        super((s) => AccountId.fromString(s));
+    }
+
+    /**
+     * This function is used to create a SignatureMap from an already built transaction.
+     * @param {import("./Transaction.js").default} transaction
+     * @returns {SignatureMap}
+     */
+    static _fromTransaction(transaction) {
+        const signatures = new SignatureMap();
+
+        const rowLength = transaction._nodeAccountIds.length;
+        const columns = transaction._signedTransactions.length / rowLength;
+
+        /*
+        this setup implies that the signed transactions are stored sequentially
+        in the signed transactions list. This means that the first rowLength
+        signed transactions are for the first node account id, the next rowLength
+        signed transactions are for the second node account id and so on.
+        */
+        for (let row = 0; row < rowLength; row++) {
+            /** @type { List<import("@hashgraph/proto").proto.ISignedTransaction> } */
+            const signedTransactions = new List();
+
+            for (let col = 0; col < columns; col++) {
+                signedTransactions.push(
+                    transaction._signedTransactions.get(col * rowLength + row),
+                );
+            }
+
+            signatures._set(
+                transaction._nodeAccountIds.list[row],
+                NodeAccountIdSignatureMap._fromSignedTransactions(
+                    signedTransactions,
+                ),
+            );
+        }
+
+        return signatures;
+    }
+
+    /**
+     * Updates the signature map with the given signature.
+     * by generating a new node account id signature map if it does not exist
+     * or adding the signature to the existing node account id signature map.
+     *
+     * @param {AccountId} nodeId
+     * @param {TransactionId} txId
+     * @param {import("../SignerSignature.js").PublicKey} publicKey
+     * @param {Uint8Array} signature
+     * @returns {SignatureMap}
+     */
+    addSignature(nodeId, txId, publicKey, signature) {
+        let nodeAccountIdSigdMap = this.get(nodeId);
+
+        if (!nodeAccountIdSigdMap) {
+            nodeAccountIdSigdMap = new NodeAccountIdSignatureMap();
+            this._set(nodeId, nodeAccountIdSigdMap);
+        }
+
+        nodeAccountIdSigdMap.addSignature(txId, publicKey, signature);
+        this._set(nodeId, nodeAccountIdSigdMap);
+
+        return this;
+    }
+    /**
+     * @returns {SignaturePairMap[]}
+     */
+    getFlatSignatureList() {
+        const flatSignatureList = [];
+
+        for (const nodeAccountIdSignatureMap of this.values()) {
+            for (const tx of nodeAccountIdSignatureMap.values()) {
+                flatSignatureList.push(tx);
+            }
+        }
+
+        return flatSignatureList;
+    }
+}

package/src/transaction/SignatureMapLegacy.js

@@ -0,0 +1,37 @@
+/* eslint-disable deprecation/deprecation */
+import NodeAccountIdSignatureMapLegacy from "./NodeAccountIdSignatureMapLegacy.js";
+import ObjectMap from "../ObjectMap.js";
+import AccountId from "../account/AccountId.js";
+
+/**
+ * @deprecated
+ * @augments {ObjectMap<AccountId, NodeAccountIdSignatureMapLegacy>}
+ */
+export default class SignatureMap extends ObjectMap {
+    constructor() {
+        super((s) => AccountId.fromString(s));
+    }
+
+    /**
+     * @param {import("./Transaction.js").default} transaction
+     * @returns {SignatureMap}
+     */
+    static _fromTransaction(transaction) {
+        const signatures = new SignatureMap();
+
+        for (let i = 0; i < transaction._nodeAccountIds.length; i++) {
+            const sigMap = transaction._signedTransactions.get(i).sigMap;
+
+            if (sigMap != null) {
+                signatures._set(
+                    transaction._nodeAccountIds.list[i],
+                    NodeAccountIdSignatureMapLegacy._fromTransactionSigMap(
+                        sigMap,
+                    ),
+                );
+            }
+        }
+
+        return signatures;
+    }
+}

package/src/transaction/SignaturePairMap.js

@@ -0,0 +1,53 @@
+import ObjectMap from "../ObjectMap.js";
+import PublicKey from "../PublicKey.js";
+
+/**
+ * @augments {ObjectMap<PublicKey, Uint8Array>}
+ */
+export default class SignaturePairMap extends ObjectMap {
+    constructor() {
+        super((s) => PublicKey.fromString(s));
+    }
+
+    /**
+     * This function is used to create a SignaturePairMap from an already built transaction.
+     * @param {import("@hashgraph/proto").proto.ISignatureMap} sigMap
+     * @returns {SignaturePairMap}
+     */
+    static _fromTransactionSigMap(sigMap) {
+        const signatures = new SignaturePairMap();
+
+        const sigPairs = sigMap.sigPair != null ? sigMap.sigPair : [];
+
+        for (const sigPair of sigPairs) {
+            if (sigPair.pubKeyPrefix == null) {
+                continue;
+            }
+
+            if (sigPair.ed25519 != null) {
+                signatures._set(
+                    PublicKey.fromBytesED25519(sigPair.pubKeyPrefix),
+                    sigPair.ed25519,
+                );
+            } else if (sigPair.ECDSASecp256k1 != null) {
+                signatures._set(
+                    PublicKey.fromBytesECDSA(sigPair.pubKeyPrefix),
+                    sigPair.ECDSASecp256k1,
+                );
+            }
+        }
+
+        return signatures;
+    }
+
+    /**
+     *
+     * @param {PublicKey} pubKey
+     * @param {Uint8Array} signature
+     * @returns {SignaturePairMap}
+     */
+    addSignature(pubKey, signature) {
+        this._set(pubKey, signature);
+        return this;
+    }
+}

package/src/transaction/TokenTransfer.js

@@ -0,0 +1 @@
+// SPDX-License-Identifier: Apache-2.0