@transak/hedera-transak 1.0.5

package/README.md

@@ -0,0 +1,2 @@
+# hedera-transak
+This repository contains the Hedera Transak integration.

package/lib/config.d.ts

@@ -0,0 +1,2 @@
+import { Network } from './types';
+export declare const networks: Record<string, Network>;

package/lib/config.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.networks = void 0;
+exports.networks = {
+    main: {
+        transactionLink: hash => `https://hederaexplorer.io/search-details/transaction/${hash}`,
+        walletLink: address => `https://hederaexplorer.io/search-details/account/${address}`,
+        networkName: 'mainnet',
+    },
+    testnet: {
+        transactionLink: hash => `https://testnet.hederaexplorer.io/search-details/transaction/${hash}`,
+        walletLink: address => `https://testnet.hederaexplorer.io/search-details/account/${address}`,
+        networkName: 'testnet',
+    },
+};
+module.exports = { networks: exports.networks };

package/lib/index.d.ts

@@ -0,0 +1,44 @@
+import { GetTransactionResult, SendTransactionResult, SendTransactionParams } from './types';
+/**
+ * Get the tokenAssociate transaction details by token id
+ * @param network
+ * @param privateKey
+ * @param accountId
+ * @param tokenId // tokenId
+ * @returns
+ */
+declare function isTokenAssociated(network: string, privateKey: string, accountId: string, userAccountId: string, tokenId: string): Promise<boolean>;
+/**
+ * Get the balance of the transak wallet address
+ * @param network
+ * @param decimals
+ * @param privateKey
+ * @param accountId
+ * @param tokenId // tokenId
+ * @returns
+ */
+declare function getBalance(network: string, decimals: number, privateKey: string, accountId: string, tokenId?: string): Promise<number>;
+/**
+ * Get the transaction details by transaction id
+ * @param txId
+ * @param network
+ * @param decimals
+ * @returns
+ */
+declare function getTransaction(txnId: string, network: string, privateKey: string, accountId: string): Promise<GetTransactionResult | null>;
+/**
+ * Send the transaction to the Hedera network
+ * @param param0
+ * @returns
+ */
+declare function sendTransaction({ to, amount, network, accountId, privateKey, decimals, tokenId, }: SendTransactionParams): Promise<SendTransactionResult>;
+declare const _default: {
+    getTransactionLink: (txId: string, network: string) => string;
+    getWalletLink: (walletAddress: string, network: string) => string;
+    getTransaction: typeof getTransaction;
+    isValidWalletAddress: (address: string) => boolean;
+    sendTransaction: typeof sendTransaction;
+    getBalance: typeof getBalance;
+    isTokenAssociated: typeof isTokenAssociated;
+};
+export = _default;

package/lib/index.js

@@ -0,0 +1,197 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const config_1 = require("./config");
+const utils_1 = require("./utils");
+const sdk_1 = require("@hashgraph/sdk");
+const validWallet = /^(0|(?:[1-9]\d*))\.(0|(?:[1-9]\d*))\.(0|(?:[1-9]\d*))(?:-([a-z]{5}))?$/;
+/**
+ * Get the network config
+ * @param network
+ * @returns
+ */
+const getNetwork = (network) => (network === 'main' ? config_1.networks[network] : config_1.networks.testnet);
+/**
+ * Validate the wallet address
+ * @param address
+ * @returns
+ */
+const isValidWalletAddress = (address) => new RegExp(validWallet).test(address);
+/**
+ *
+ * @param txId
+ * @param network
+ * @returns
+ */
+const getTransactionLink = (txId, network) => getNetwork(network).transactionLink(txId);
+/**
+ * get wallet link for the given address
+ * @param walletAddress
+ * @param network
+ * @returns
+ */
+const getWalletLink = (walletAddress, network) => getNetwork(network).walletLink(walletAddress);
+/**
+ * create a client instance
+ * @param network
+ * @returns
+ */
+function getClient(network, privateKey, accountId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const config = getNetwork(network);
+        // If we weren't able to grab it, we should throw a new error
+        if (accountId == null || privateKey == null) {
+            throw new Error('variables privateKey and accountId must be present');
+        }
+        // Create our connection to the Hedera network
+        const client = sdk_1.Client.forName(config.networkName); // valid names mainnet, testnet ,previewnet
+        client.setOperator(accountId, privateKey);
+        return client;
+    });
+}
+/**
+ * Get the tokenAssociate transaction details by token id
+ * @param network
+ * @param privateKey
+ * @param accountId
+ * @param tokenId // tokenId
+ * @returns
+ */
+function isTokenAssociated(network, privateKey, accountId, userAccountId, tokenId) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const client = yield getClient(network, privateKey, accountId);
+        const balance = yield new sdk_1.AccountBalanceQuery()
+            .setAccountId(userAccountId) //  user's account id
+            .execute(client);
+        const token = (_a = balance.tokens) === null || _a === void 0 ? void 0 : _a.get(tokenId); // will return null if token is not associated
+        return !!token;
+    });
+}
+/**
+ * Get the balance of the transak wallet address
+ * @param network
+ * @param decimals
+ * @param privateKey
+ * @param accountId
+ * @param tokenId // tokenId
+ * @returns
+ */
+function getBalance(network, decimals, privateKey, accountId, tokenId) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const client = yield getClient(network, privateKey, accountId);
+        const balance = yield new sdk_1.AccountBalanceQuery()
+            .setAccountId(client.operatorAccountId.toString()) //  transak's account id
+            .execute(client);
+        // if token id is present then return the token balance
+        if (tokenId) {
+            return Number((0, utils_1._toDecimal)(((_b = (_a = balance.tokens) === null || _a === void 0 ? void 0 : _a.get(tokenId)) === null || _b === void 0 ? void 0 : _b.toString()) || '0', decimals));
+        }
+        // else return the hbar balance
+        return Number((0, utils_1._toDecimal)(balance.hbars.toTinybars().toString(), decimals));
+    });
+}
+/**
+ * Get the transaction details by transaction id
+ * @param txId
+ * @param network
+ * @param decimals
+ * @returns
+ */
+function getTransaction(txnId, network, privateKey, accountId) {
+    var _a, _b, _c;
+    return __awaiter(this, void 0, void 0, function* () {
+        const client = yield getClient(network, privateKey, accountId);
+        const TransactionRecord = yield new sdk_1.TransactionRecordQuery()
+            .setTransactionId(txnId)
+            .setIncludeDuplicates(true)
+            .execute(client);
+        const from = (_a = TransactionRecord.transactionId.accountId) === null || _a === void 0 ? void 0 : _a.toString();
+        return {
+            transactionData: TransactionRecord,
+            receipt: {
+                amount: Math.abs(((_b = TransactionRecord.transfers
+                    .find(d => d.accountId.toString() === from)) === null || _b === void 0 ? void 0 : _b.amount.toTinybars().toNumber()) || 0),
+                date: TransactionRecord.consensusTimestamp.toDate(),
+                from: from || '',
+                gasCostCryptoCurrency: 'HBAR',
+                gasCostInCrypto: TransactionRecord.transactionFee.toBigNumber().toNumber(),
+                gasLimit: 1,
+                isPending: false,
+                isExecuted: true,
+                isSuccessful: TransactionRecord.receipt.status.toString() === 'SUCCESS',
+                isFailed: TransactionRecord.receipt.status.toString() !== 'SUCCESS',
+                isInvalid: TransactionRecord.receipt.status.toString() !== 'SUCCESS',
+                network,
+                nonce: ((_c = TransactionRecord.transactionId.nonce) === null || _c === void 0 ? void 0 : _c.toNumber()) || 0,
+                transactionHash: TransactionRecord.transactionHash.toString(),
+                transactionId: TransactionRecord.transactionId.toString(),
+                transactionLink: getTransactionLink(TransactionRecord.transactionId.toString(), network),
+            },
+        };
+    });
+}
+/**
+ * Send the transaction to the Hedera network
+ * @param param0
+ * @returns
+ */
+function sendTransaction({ to, amount, network, accountId, privateKey, decimals, tokenId, }) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const client = yield getClient(network, privateKey, accountId);
+        // amount in lowest denomination - tinybars in this case
+        const amountInCrypto = (0, utils_1._toCrypto)(amount.toString(), decimals);
+        const from = client.operatorAccountId.toString(); // transak wallet address
+        // Create the transfer transaction
+        const transferTransaction = new sdk_1.TransferTransaction();
+        if (!tokenId) {
+            transferTransaction
+                .addHbarTransfer(from, sdk_1.Hbar.fromTinybars(-amountInCrypto.toNumber())) // Sending account
+                .addHbarTransfer(to, sdk_1.Hbar.fromTinybars(amountInCrypto.toNumber())); // Receiving account
+        }
+        if (tokenId) {
+            // user needs to associate the token with the account before sending the token
+            transferTransaction
+                .addTokenTransferWithDecimals(tokenId, from, -amountInCrypto.toNumber(), decimals) // Sending account
+                .addTokenTransferWithDecimals(tokenId, to, amountInCrypto.toNumber(), decimals) // Receiving account
+                .freezeWith(client)
+                .signWithOperator(client);
+        }
+        const sendTransactionResponse = yield transferTransaction.execute(client);
+        const transactionReceipt = yield sendTransactionResponse.getReceipt(client);
+        return {
+            transactionData: sendTransactionResponse,
+            receipt: {
+                amount,
+                date: ((_a = sendTransactionResponse.transactionId.validStart) === null || _a === void 0 ? void 0 : _a.toDate()) || null,
+                from,
+                gasCostCryptoCurrency: 'HBAR',
+                transactionReceipt,
+                network,
+                nonce: ((_b = sendTransactionResponse.transactionId.nonce) === null || _b === void 0 ? void 0 : _b.toNumber()) || 0,
+                to,
+                transactionHash: sendTransactionResponse.transactionHash,
+                transactionId: sendTransactionResponse.transactionId.toString(),
+                transactionLink: getTransactionLink(sendTransactionResponse.transactionId.toString(), network),
+            },
+        };
+    });
+}
+module.exports = {
+    getTransactionLink,
+    getWalletLink,
+    getTransaction,
+    isValidWalletAddress,
+    sendTransaction,
+    getBalance,
+    isTokenAssociated,
+};

package/lib/types.d.ts

@@ -0,0 +1,52 @@
+import { TransactionResponse, TransactionRecord, TransactionReceipt } from '@hashgraph/sdk';
+export declare type Network = {
+    networkName: string;
+    transactionLink: (arg0: string) => string;
+    walletLink: (arg0: string) => string;
+};
+export declare type GetTransactionResult = {
+    transactionData: TransactionRecord;
+    receipt: {
+        amount: number;
+        date: Date | null;
+        from: string;
+        gasCostCryptoCurrency: string;
+        gasCostInCrypto: number;
+        gasLimit: number;
+        isPending: boolean;
+        isExecuted: boolean;
+        isSuccessful: boolean;
+        isFailed: boolean;
+        isInvalid: boolean;
+        network: string;
+        nonce: number;
+        transactionHash: string;
+        transactionId: string;
+        transactionLink: string;
+    };
+};
+export declare type SendTransactionParams = {
+    to: string;
+    amount: number;
+    network: string;
+    decimals: number;
+    accountId: string;
+    privateKey: string;
+    tokenId?: string;
+};
+export declare type SendTransactionResult = {
+    transactionData: TransactionResponse;
+    receipt: {
+        amount: number;
+        date: Date | null;
+        from: string;
+        gasCostCryptoCurrency: string;
+        network: string;
+        nonce: number;
+        to: string;
+        transactionHash: Uint8Array;
+        transactionLink: string;
+        transactionId: string;
+        transactionReceipt: TransactionReceipt;
+    };
+};

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils.d.ts

@@ -0,0 +1,4 @@
+import { BigNumber } from '@hashgraph/hethers';
+export declare const _toDecimal: (amount: string, decimals: number) => string;
+export declare const _toCrypto: (amount: string, decimals: number) => BigNumber;
+export declare const _getAccountNumber: (txnId: string) => string;

package/lib/utils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._getAccountNumber = exports._toCrypto = exports._toDecimal = void 0;
+const hethers_1 = require("@hashgraph/hethers");
+// converts any units to Hbars
+const _toDecimal = (amount, decimals) => {
+    // sting to BigNumber
+    return hethers_1.hethers.utils.formatUnits(hethers_1.hethers.BigNumber.from(amount), decimals);
+};
+exports._toDecimal = _toDecimal;
+// converts Hbar to tinybar
+const _toCrypto = (amount, decimals) => hethers_1.hethers.utils.parseUnits(amount, decimals);
+exports._toCrypto = _toCrypto;
+const _getAccountNumber = (txnId) => {
+    const [accountId, rest] = txnId.split('@');
+    return accountId;
+};
+exports._getAccountNumber = _getAccountNumber;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@transak/hedera-transak",
+  "version": "1.0.5",
+  "description": "",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "directories": {
+    "test": "test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Transak/hedera-transak.git"
+  },
+  "scripts": {
+    "test": "jest -c jest.config.js",
+    "restricted-publish": "npm publish --access restricted",
+    "build": "npx tsc",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "lint": "tslint -p tsconfig.json",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run lint",
+    "preversion": "npm run lint",
+    "version": "npm run format && git add -A src"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@ethersproject/abi": "^5.7.0",
+    "@ethersproject/basex": "^5.7.0",
+    "@ethersproject/random": "^5.7.0",
+    "@ethersproject/wordlists": "^5.7.0",
+    "@hashgraph/hethers": "^1.2.1",
+    "@hashgraph/sdk": "^2.18.1",
+    "dotenv": "10.0.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.0.0",
+    "jest": "^28.0.0",
+    "prettier": "^2.7.1",
+    "ts-jest": "^28.0.8",
+    "ts-node": "^10.4.0",
+    "tslint": "^6.1.3",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^4.5.2"
+  },
+  "files": [
+    "/lib/**/*"
+  ]
+}