@dfns/lib-hedera 0.7.12

package/index.d.ts

@@ -0,0 +1,33 @@
+import { DfnsApiClient } from '@dfns/sdk';
+import { AccountId, PublicKey, Transaction, Signer, Provider, LedgerId, Executable, SignerSignature, AccountBalance, AccountInfo, TransactionRecord } from '@hashgraph/sdk';
+export declare const hexToBuffer: (hex: string) => Buffer;
+export type DfnsWalletOptions = {
+    walletId: string;
+    dfnsClient: DfnsApiClient;
+};
+export declare class DfnsWallet implements Signer {
+    private readonly provider;
+    private readonly publicKey;
+    private readonly accountId;
+    private readonly dfnsClient;
+    private readonly walletId;
+    private constructor();
+    static init(options: DfnsWalletOptions): Promise<DfnsWallet>;
+    signTransaction<T extends Transaction>(transaction: T): Promise<T>;
+    getProvider(): Provider;
+    getLedgerId(): LedgerId | null;
+    getAccountId(): AccountId;
+    getNetwork(): {
+        [key: string]: string | AccountId;
+    };
+    getMirrorNetwork(): string[];
+    getAccountKey(): PublicKey;
+    getAccountBalance(): Promise<AccountBalance>;
+    getAccountInfo(): Promise<AccountInfo>;
+    getAccountRecords(): Promise<TransactionRecord[]>;
+    sign(_messages: Uint8Array[]): Promise<SignerSignature[]>;
+    checkTransaction<T extends Transaction>(transaction: T): Promise<T>;
+    populateTransaction<T extends Transaction>(transaction: T): Promise<T>;
+    call<RequestT, ResponseT, OutputT>(request: Executable<RequestT, ResponseT, OutputT>): Promise<OutputT>;
+    close(): void;
+}

package/index.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfnsWallet = exports.hexToBuffer = void 0;
+const sdk_1 = require("@dfns/sdk");
+const sdk_2 = require("@hashgraph/sdk");
+const hexToBuffer = (hex) => {
+    return Buffer.from(stripHexPrefix(hex), 'hex');
+};
+exports.hexToBuffer = hexToBuffer;
+const stripHexPrefix = (hex) => {
+    return hex.replace(/^0x/, '');
+};
+const assertSignResponseSuccessful = (response) => {
+    if (response.status === 'Failed') {
+        throw new sdk_1.DfnsError(-1, 'signing failed', response);
+    }
+    else if (response.status !== 'Signed') {
+        throw new sdk_1.DfnsError(-1, 'cannot complete signing synchronously because this wallet action requires policy approval', response);
+    }
+    else if (!response.signature || !response.signature.encoded) {
+        throw new sdk_1.DfnsError(-1, 'signature missing', response);
+    }
+};
+class DfnsWallet {
+    constructor(dfnsOptions, provider, publicKey, accountId) {
+        this.provider = provider;
+        this.publicKey = publicKey;
+        this.accountId = accountId;
+        this.dfnsClient = dfnsOptions.dfnsClient;
+        this.walletId = dfnsOptions.walletId;
+    }
+    static async init(options) {
+        const { walletId, dfnsClient } = options;
+        const res = await dfnsClient.wallets.getWallet({ walletId });
+        if (res.status !== 'Active') {
+            throw new sdk_1.DfnsError(-1, 'wallet not active', { walletId, status: res.status });
+        }
+        if (res.network !== 'Hedera' && res.network !== 'HederaTestnet') {
+            throw new sdk_1.DfnsError(-1, 'wallet is not bound to a Hedera network', {
+                walletId,
+                network: res.network,
+            });
+        }
+        const nativeAddressRegex = /^0\.0\.\d+$/;
+        if (!nativeAddressRegex.test(res.address)) {
+            throw new sdk_1.DfnsError(-1, 'account must be created. Address is not in native Hedera format (0.0.x)', {
+                walletId,
+                address: res.address
+            });
+        }
+        const accountId = sdk_2.AccountId.fromString(res.address);
+        if (!res.signingKey?.publicKey) {
+            throw new sdk_1.DfnsError(-1, 'wallet public key not found', { walletId });
+        }
+        const publicKey = sdk_2.PublicKey.fromString(res.signingKey.publicKey);
+        const client = res.network === 'HederaTestnet'
+            ? sdk_2.Client.forTestnet()
+            : sdk_2.Client.forMainnet();
+        return new DfnsWallet(options, new sdk_2.LocalProvider({ client }), publicKey, accountId);
+    }
+    async signTransaction(transaction) {
+        if (!transaction.isFrozen()) {
+            transaction.freeze();
+        }
+        const transactionBytes = transaction.toBytes();
+        const messageHex = '0x' + Buffer.from(transactionBytes).toString('hex');
+        const response = await this.dfnsClient.wallets.generateSignature({
+            walletId: this.walletId,
+            body: {
+                kind: 'Transaction',
+                transaction: messageHex,
+            },
+        });
+        assertSignResponseSuccessful(response);
+        const signature = response.signature;
+        if (!signature?.encoded) {
+            throw new sdk_1.DfnsError(-1, 'signature encoded value missing', response);
+        }
+        if (!response.signedData) {
+            throw new sdk_1.DfnsError(-1, 'signed data missing', response);
+        }
+        const signedTx = sdk_2.Transaction.fromBytes(new Uint8Array((0, exports.hexToBuffer)(response.signedData)));
+        transaction.addSignature(this.getAccountKey(), signedTx.getSignatures());
+        return transaction;
+    }
+    getProvider() {
+        return this.provider;
+    }
+    getLedgerId() {
+        return this.provider.getLedgerId();
+    }
+    getAccountId() {
+        return this.accountId;
+    }
+    getNetwork() {
+        return this.provider.getNetwork();
+    }
+    getMirrorNetwork() {
+        return this.provider.getMirrorNetwork();
+    }
+    getAccountKey() {
+        return this.publicKey;
+    }
+    getAccountBalance() {
+        return this.call(new sdk_2.AccountBalanceQuery().setAccountId(this.accountId));
+    }
+    getAccountInfo() {
+        return this.call(new sdk_2.AccountInfoQuery().setAccountId(this.accountId));
+    }
+    getAccountRecords() {
+        return this.call(new sdk_2.AccountRecordsQuery().setAccountId(this.accountId));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    sign(_messages) {
+        throw new sdk_1.DfnsError(-1, 'sign method not implemented', {});
+    }
+    async checkTransaction(transaction) {
+        const transactionId = transaction.transactionId;
+        if (transactionId?.accountId && transactionId.accountId.compare(this.accountId) !== 0) {
+            throw new sdk_1.DfnsError(-1, "transaction's ID constructed with a different account ID", {
+                transactionAccountId: transactionId.accountId.toString(),
+                walletAccountId: this.accountId.toString(),
+            });
+        }
+        if (!this.provider) {
+            return transaction;
+        }
+        const nodeAccountIds = (transaction.nodeAccountIds ?? []).map((nodeAccountId) => nodeAccountId.toString());
+        const network = Object.values(this.provider.getNetwork()).map((nodeAccountId) => nodeAccountId.toString());
+        const allNodeIdsInNetwork = nodeAccountIds.every((nodeId) => network.includes(nodeId));
+        if (!allNodeIdsInNetwork) {
+            throw new sdk_1.DfnsError(-1, 'Transaction already set node account IDs to values not within the current network', {
+                transactionNodeIds: nodeAccountIds,
+                networkNodeIds: network,
+            });
+        }
+        return transaction;
+    }
+    async populateTransaction(transaction) {
+        const accountId = this.getAccountId();
+        transaction._freezeWithAccountId(accountId);
+        if (transaction.transactionId == null) {
+            transaction.setTransactionId(sdk_2.TransactionId.generate(accountId));
+        }
+        if (transaction.nodeAccountIds != null &&
+            transaction.nodeAccountIds.length != 0) {
+            return Promise.resolve(transaction.freeze());
+        }
+        if (this.provider == null) {
+            return Promise.resolve(transaction);
+        }
+        const nodeAccountIds = Object.values(this.provider.getNetwork()).map((id) => (typeof id === "string" ? sdk_2.AccountId.fromString(id) : id));
+        transaction.setNodeAccountIds([nodeAccountIds[0]]);
+        return Promise.resolve(transaction.freeze());
+    }
+    call(request) {
+        return this.provider.call(request);
+    }
+    close() {
+        this.provider.close();
+    }
+}
+exports.DfnsWallet = DfnsWallet;

package/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@dfns/lib-hedera",
+  "version": "0.7.12",
+  "peerDependencies": {
+    "@hashgraph/sdk": "^2.70.0"
+  },
+  "main": "./index.js",
+  "type": "commonjs"
+}