@bitgo/sdk-coin-hbar 2.2.15 → 2.3.1

package/dist/src/hbar.js

@@ -0,0 +1,497 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hbar = void 0;
+/**
+ * @prettier
+ */
+const statics_1 = require("@bitgo/statics");
+const sdk_core_1 = require("@bitgo/sdk-core");
+const bignumber_js_1 = require("bignumber.js");
+const stellar = __importStar(require("stellar-sdk"));
+const seedValidator_1 = require("./seedValidator");
+const lib_1 = require("./lib");
+const Utils = __importStar(require("./lib/utils"));
+const _ = __importStar(require("lodash"));
+const sdk_1 = require("@hashgraph/sdk");
+const keyPair_1 = require("./lib/keyPair");
+class Hbar extends sdk_core_1.BaseCoin {
+    constructor(bitgo, staticsCoin) {
+        super(bitgo);
+        if (!staticsCoin) {
+            throw new Error('missing required constructor parameter staticsCoin');
+        }
+        this._staticsCoin = staticsCoin;
+    }
+    getChain() {
+        return this._staticsCoin.name;
+    }
+    getFamily() {
+        return this._staticsCoin.family;
+    }
+    getFullName() {
+        return this._staticsCoin.fullName;
+    }
+    getBaseFactor() {
+        return Math.pow(10, this._staticsCoin.decimalPlaces);
+    }
+    static createInstance(bitgo, staticsCoin) {
+        return new Hbar(bitgo, staticsCoin);
+    }
+    /**
+     * Flag for sending value of 0
+     * @returns {boolean} True if okay to send 0 value, false otherwise
+     */
+    valuelessTransferAllowed() {
+        return false;
+    }
+    /**
+     * Checks if this is a valid base58 or hex address
+     * @param address
+     */
+    isValidAddress(address) {
+        try {
+            return Utils.isValidAddressWithPaymentId(address);
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /** inheritdoc */
+    deriveKeyWithSeed() {
+        throw new sdk_core_1.NotSupported('method deriveKeyWithSeed not supported for eddsa curve');
+    }
+    /** inheritdoc */
+    generateKeyPair(seed) {
+        const keyPair = seed ? new lib_1.KeyPair({ seed }) : new lib_1.KeyPair();
+        const keys = keyPair.getKeys();
+        if (!keys.prv) {
+            throw new Error('Keypair generation failed to generate a prv');
+        }
+        return {
+            pub: keys.pub,
+            prv: keys.prv,
+        };
+    }
+    /** inheritdoc */
+    generateRootKeyPair(seed) {
+        const keyPair = seed ? new lib_1.KeyPair({ seed }) : new lib_1.KeyPair();
+        const keys = keyPair.getKeys(true);
+        if (!keys.prv) {
+            throw new Error('Missing prv in key generation.');
+        }
+        return { prv: keys.prv + keys.pub, pub: keys.pub };
+    }
+    async parseTransaction(params) {
+        return {};
+    }
+    /**
+     * Check if address is valid, then make sure it matches the base address.
+     *
+     * @param {VerifyAddressOptions} params
+     * @param {String} params.address - the address to verify
+     * @param {String} params.baseAddress - the base address from the wallet
+     */
+    async isWalletAddress(params) {
+        const { address, baseAddress } = params;
+        return Utils.isSameBaseAddress(address, baseAddress);
+    }
+    async verifyTransaction(params) {
+        // asset name to transfer amount map
+        const coinConfig = statics_1.coins.get(this.getChain());
+        const { txParams: txParams, txPrebuild: txPrebuild, memo: memo } = params;
+        const transaction = new lib_1.Transaction(coinConfig);
+        if (!txPrebuild.txHex) {
+            throw new Error('missing required tx prebuild property txHex');
+        }
+        transaction.fromRawTransaction(txPrebuild.txHex);
+        const explainTxParams = {
+            txHex: txPrebuild.txHex,
+            feeInfo: txPrebuild.feeInfo,
+            memo: memo,
+        };
+        const explainedTx = await this.explainTransaction(explainTxParams);
+        if (!txParams.recipients) {
+            throw new Error('missing required tx params property recipients');
+        }
+        // for enabletoken, recipient output amount is 0
+        const recipients = txParams.recipients.map((recipient) => ({
+            ...recipient,
+            amount: txParams.type === 'enabletoken' ? '0' : recipient.amount,
+            address: Utils.getAddressDetails(recipient.address).address,
+        }));
+        if (coinConfig.isToken) {
+            recipients.forEach((recipient) => {
+                if (recipient.tokenName !== undefined && recipient.tokenName !== coinConfig.name) {
+                    throw new Error('Incorrect token name specified in recipients');
+                }
+                recipient.tokenName = coinConfig.name;
+            });
+        }
+        // verify recipients from params and explainedTx
+        const filteredRecipients = recipients?.map((recipient) => _.pick(recipient, ['address', 'amount', 'tokenName']));
+        const filteredOutputs = explainedTx.outputs.map((output) => _.pick(output, ['address', 'amount', 'tokenName']));
+        if (!_.isEqual(filteredOutputs, filteredRecipients)) {
+            throw new Error('Tx outputs does not match with expected txParams recipients');
+        }
+        return true;
+    }
+    /**
+     * Assemble keychain and half-sign prebuilt transaction
+     *
+     * @param params
+     * @param params.txPrebuild {Object} prebuild object returned by platform
+     * @param params.prv {String} user prv
+     * @returns Promise<SignedTransaction>
+     */
+    async signTransaction(params) {
+        const factory = this.getBuilderFactory();
+        const txBuilder = factory.from(params.txPrebuild.txHex);
+        txBuilder.sign({ key: params.prv });
+        const transaction = await txBuilder.build();
+        if (!transaction) {
+            throw new Error('Invalid messaged passed to signMessage');
+        }
+        const response = {
+            txHex: transaction.toBroadcastFormat(),
+        };
+        return transaction.signature.length >= 2 ? response : { halfSigned: response };
+    }
+    /**
+     * Sign message with private key
+     *
+     * @param key
+     * @param message
+     * @return {Buffer} A signature over the given message using the given key
+     */
+    async signMessage(key, message) {
+        const msg = Buffer.isBuffer(message) ? message.toString('utf8') : message;
+        // reconstitute keys and sign
+        return Buffer.from(new lib_1.KeyPair({ prv: key.prv }).signMessage(msg));
+    }
+    /**
+     * Builds a funds recovery transaction without BitGo.
+     * We need to do three queries during this:
+     * 1) Node query - how much money is in the account
+     * 2) Build transaction - build our transaction for the amount
+     * 3) Send signed build - send our signed build to a public node
+     * @param params
+     */
+    async recover(params) {
+        const isUnsignedSweep = (params.backupKey.startsWith(keyPair_1.PUBLIC_KEY_PREFIX) && params.userKey.startsWith(keyPair_1.PUBLIC_KEY_PREFIX)) ||
+            (Utils.isValidPublicKey(params.userKey) && Utils.isValidPublicKey(params.backupKey));
+        // Validate the root address
+        if (!this.isValidAddress(params.rootAddress)) {
+            throw new Error('invalid rootAddress, got: ' + params.rootAddress);
+        }
+        // Validate the destination address
+        if (!this.isValidAddress(params.recoveryDestination)) {
+            throw new Error('invalid recoveryDestination, got: ' + params.recoveryDestination);
+        }
+        // Validate nodeId
+        if (params.nodeId && !Utils.isValidAddress(params.nodeId)) {
+            throw new Error('invalid nodeId, got: ' + params.nodeId);
+        }
+        // validate fee
+        if (params.maxFee && !Utils.isValidAmount(params.maxFee)) {
+            throw new Error('invalid maxFee, got: ' + params.maxFee);
+        }
+        // validate startTime
+        if (params.startTime) {
+            Utils.validateStartTime(params.startTime);
+        }
+        if (isUnsignedSweep && !params.startTime) {
+            throw new Error('start time is required for unsigned sweep');
+        }
+        if (!isUnsignedSweep && !params.walletPassphrase) {
+            throw new Error('walletPassphrase is required for non-bitgo recovery');
+        }
+        let userPrv;
+        let backUp;
+        if (!isUnsignedSweep) {
+            try {
+                userPrv = this.bitgo.decrypt({ input: params.userKey, password: params.walletPassphrase });
+                backUp = this.bitgo.decrypt({ input: params.backupKey, password: params.walletPassphrase });
+            }
+            catch (e) {
+                throw new Error('unable to decrypt userKey or backupKey with the walletPassphrase provided, got error: ' + e.message);
+            }
+        }
+        // validate userKey for unsigned sweep
+        if (isUnsignedSweep && !Utils.isValidPublicKey(params.userKey)) {
+            throw new Error('invalid userKey, got: ' + params.userKey);
+        }
+        // validate backupKey for unsigned sweep
+        if (isUnsignedSweep && !Utils.isValidPublicKey(params.backupKey)) {
+            throw new Error('invalid backupKey, got: ' + params.backupKey);
+        }
+        const { address: destinationAddress, memoId } = Utils.getAddressDetails(params.recoveryDestination);
+        const nodeId = params.nodeId ? params.nodeId : '0.0.3';
+        const client = this.getHbarClient();
+        const balance = await this.getAccountBalance(params.rootAddress, client);
+        const fee = params.maxFee ? params.maxFee : '10000000'; // default fee to 1 hbar
+        const nativeBalance = sdk_1.Hbar.fromString(balance.hbars).toTinybars().toString();
+        const spendableAmount = new bignumber_js_1.BigNumber(nativeBalance).minus(fee);
+        let txBuilder;
+        if (!params.tokenId) {
+            if (spendableAmount.isZero() || spendableAmount.isNegative()) {
+                throw new Error(`Insufficient balance to recover, got balance: ${nativeBalance} fee: ${fee}`);
+            }
+            txBuilder = this.getBuilderFactory().getTransferBuilder();
+            txBuilder.send({ address: destinationAddress, amount: spendableAmount.toString() });
+        }
+        else {
+            if (spendableAmount.isNegative()) {
+                throw new Error(`Insufficient native balance to recover tokens, got native balance: ${nativeBalance} fee: ${fee}`);
+            }
+            const tokenBalance = balance.tokens.find((token) => token.tokenId === params.tokenId);
+            const token = Utils.getHederaTokenNameFromId(params.tokenId);
+            if (!token) {
+                throw new Error(`Unsupported token: ${params.tokenId}`);
+            }
+            if (!tokenBalance || new bignumber_js_1.BigNumber(tokenBalance.balance).isZero()) {
+                throw new Error(`Insufficient balance to recover token: ${params.tokenId} for account: ${params.rootAddress}`);
+            }
+            txBuilder = this.getBuilderFactory().getTokenTransferBuilder();
+            txBuilder.send({ address: destinationAddress, amount: tokenBalance.balance, tokenName: token.name });
+        }
+        txBuilder.node({ nodeId });
+        txBuilder.fee({ fee });
+        txBuilder.source({ address: params.rootAddress });
+        txBuilder.validDuration(180);
+        if (memoId) {
+            txBuilder.memo(memoId);
+        }
+        if (params.startTime) {
+            txBuilder.startTime(Utils.normalizeStarttime(params.startTime));
+        }
+        if (isUnsignedSweep) {
+            const tx = await txBuilder.build();
+            const txJson = tx.toJson();
+            return {
+                txHex: tx.toBroadcastFormat(),
+                coin: this.getChain(),
+                id: txJson.id,
+                startTime: txJson.startTime,
+                validDuration: txJson.validDuration,
+                nodeId: txJson.node,
+                memo: txJson.memo,
+                userKey: params.userKey,
+                backupKey: params.backupKey,
+                bitgoKey: params.bitgoKey,
+                maxFee: fee,
+                address: params.rootAddress,
+                recipients: txJson.instructionsData.params.recipients,
+                amount: txJson.amount,
+                json: txJson,
+            };
+        }
+        txBuilder.sign({ key: userPrv });
+        txBuilder.sign({ key: backUp });
+        const tx = await txBuilder.build();
+        return {
+            tx: tx.toBroadcastFormat(),
+            id: tx.toJson().id,
+            coin: this.getChain(),
+            startTime: tx.toJson().startTime,
+            nodeId: tx.toJson().node,
+        };
+    }
+    /**
+     * Explain a Hedera transaction from txHex
+     * @param params
+     */
+    async explainTransaction(params) {
+        const txHex = params.txHex || (params.halfSigned && params.halfSigned.txHex);
+        if (!txHex) {
+            throw new Error('missing explain tx parameters');
+        }
+        const factory = this.getBuilderFactory();
+        const txBuilder = factory.from(txHex);
+        const tx = await txBuilder.build();
+        const txJson = tx.toJson();
+        let outputAmount = new bignumber_js_1.BigNumber(0);
+        const outputs = [];
+        // TODO(BG-24809): get the memo from the toJson
+        let memo = '';
+        if (params.memo) {
+            memo = params.memo.value;
+        }
+        switch (txJson.instructionsData.type) {
+            case 'cryptoTransfer':
+                const recipients = txJson.instructionsData.params.recipients || [];
+                recipients.forEach((recipient) => {
+                    if (!recipient.tokenName) {
+                        // token transfer doesn't change outputAmount
+                        outputAmount = outputAmount.plus(recipient.amount);
+                    }
+                    outputs.push({
+                        address: recipient.address,
+                        amount: recipient.amount.toString(),
+                        memo,
+                        ...(recipient.tokenName && {
+                            tokenName: recipient.tokenName,
+                        }),
+                    });
+                });
+                break;
+            case 'tokenAssociate':
+                const tokens = txJson.instructionsData.params.tokenNames || [];
+                const accountId = txJson.instructionsData.params.accountId;
+                tokens.forEach((token) => {
+                    outputs.push({
+                        address: accountId,
+                        amount: '0',
+                        memo,
+                        tokenName: token,
+                    });
+                });
+                break;
+            default:
+                throw new Error('Transaction format outside of cryptoTransfer not supported for explanation.');
+        }
+        const displayOrder = [
+            'id',
+            'outputAmount',
+            'changeAmount',
+            'outputs',
+            'changeOutputs',
+            'fee',
+            'timestamp',
+            'expiration',
+            'memo',
+        ];
+        return {
+            displayOrder,
+            id: txJson.id,
+            outputs,
+            outputAmount: outputAmount.toString(),
+            changeOutputs: [], // account based does not use change outputs
+            changeAmount: '0', // account base does not make change
+            fee: params.feeInfo?.fee || txJson.fee, // in the instance no feeInfo is passed in as a param, show the fee given by the txJSON
+            timestamp: txJson.startTime,
+            expiration: txJson.validDuration,
+        };
+    }
+    isStellarSeed(seed) {
+        return seedValidator_1.SeedValidator.isValidEd25519SeedForCoin(seed, statics_1.CoinFamily.XLM);
+    }
+    convertFromStellarSeed(seed) {
+        // assume this is a trust custodial seed if its a valid ed25519 prv
+        if (!this.isStellarSeed(seed) || seedValidator_1.SeedValidator.hasCompetingSeedFormats(seed)) {
+            return null;
+        }
+        if (seedValidator_1.SeedValidator.isValidEd25519SeedForCoin(seed, statics_1.CoinFamily.XLM)) {
+            const keyFromSeed = new lib_1.KeyPair({ seed: stellar.StrKey.decodeEd25519SecretSeed(seed) });
+            const keys = keyFromSeed.getKeys();
+            if (keys !== undefined && keys.prv) {
+                return keys.prv;
+            }
+        }
+        return null;
+    }
+    isValidPub(pub) {
+        return Utils.isValidPublicKey(pub);
+    }
+    supportsDeriveKeyWithSeed() {
+        return false;
+    }
+    /** inherited doc */
+    getDefaultMultisigType() {
+        return sdk_core_1.multisigTypes.onchain;
+    }
+    getTokenEnablementConfig() {
+        return {
+            requiresTokenEnablement: true,
+            supportsMultipleTokenEnablements: true,
+        };
+    }
+    getBuilderFactory() {
+        return new lib_1.TransactionBuilderFactory(statics_1.coins.get(this.getChain()));
+    }
+    getHbarClient() {
+        const client = this.bitgo.getEnv() === 'prod' ? sdk_1.Client.forMainnet() : sdk_1.Client.forTestnet();
+        return client;
+    }
+    async getAccountBalance(accountId, client) {
+        try {
+            const balance = await new sdk_1.AccountBalanceQuery().setAccountId(accountId).execute(client);
+            return balance.toJSON();
+        }
+        catch (e) {
+            throw new Error('Failed to get account balance, error: ' + e.message);
+        }
+    }
+    async broadcastTransaction({ serializedSignedTransaction, startTime, }) {
+        try {
+            const hbarTx = sdk_1.Transaction.fromBytes(Utils.toUint8Array(serializedSignedTransaction));
+            if (startTime) {
+                Utils.isValidTimeString(startTime);
+                while (!Utils.shouldBroadcastNow(startTime)) {
+                    await Utils.sleep(1000);
+                }
+            }
+            return this.clientBroadcastTransaction(hbarTx);
+        }
+        catch (e) {
+            throw new Error('Failed to broadcast transaction, error: ' + e.message);
+        }
+    }
+    async clientBroadcastTransaction(hbarTx) {
+        const client = this.getHbarClient();
+        const transactionResponse = await hbarTx.execute(client);
+        const transactionReceipt = await transactionResponse.getReceipt(client);
+        return { txId: transactionResponse.transactionId.toString(), status: transactionReceipt.status.toString() };
+    }
+    /** @inheritDoc */
+    auditDecryptedKey({ prv, publicKey, multiSigType }) {
+        if (multiSigType === 'tss') {
+            throw new Error('Unsupported multiSigType');
+        }
+        let hbarKeyPair;
+        try {
+            hbarKeyPair = new lib_1.KeyPair({ prv });
+        }
+        catch (e) {
+            throw new Error(`Invalid private key: ${e.message}`);
+        }
+        const genPubKey = hbarKeyPair.getKeys().pub;
+        if (publicKey && publicKey !== genPubKey) {
+            throw new Error('Invalid public key');
+        }
+    }
+}
+exports.Hbar = Hbar;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hbar.js","sourceRoot":"","sources":["../../src/hbar.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport { CoinFamily, BaseCoin as StaticsBaseCoin, coins } from '@bitgo/statics';\nimport {\n  BaseCoin,\n  BitGoBase,\n  KeyPair,\n  ParsedTransaction,\n  ParseTransactionOptions,\n  SignedTransaction,\n  SignTransactionOptions,\n  VerifyAddressOptions as BaseVerifyAddressOptions,\n  VerifyTransactionOptions,\n  TransactionFee,\n  TransactionRecipient as Recipient,\n  TransactionPrebuild as BaseTransactionPrebuild,\n  TransactionExplanation,\n  Memo,\n  TokenEnablementConfig,\n  BaseBroadcastTransactionOptions,\n  BaseBroadcastTransactionResult,\n  NotSupported,\n  MultisigType,\n  multisigTypes,\n  AuditDecryptedKeyParams,\n} from '@bitgo/sdk-core';\nimport { BigNumber } from 'bignumber.js';\nimport * as stellar from 'stellar-sdk';\nimport { SeedValidator } from './seedValidator';\nimport { KeyPair as HbarKeyPair, TransactionBuilderFactory, Transaction } from './lib';\nimport * as Utils from './lib/utils';\nimport * as _ from 'lodash';\nimport {\n  Client,\n  Transaction as HbarTransaction,\n  AccountBalanceQuery,\n  AccountBalanceJson,\n  Hbar as HbarUnit,\n} from '@hashgraph/sdk';\nimport { PUBLIC_KEY_PREFIX } from './lib/keyPair';\nexport interface HbarSignTransactionOptions extends SignTransactionOptions {\n  txPrebuild: TransactionPrebuild;\n  prv: string;\n}\n\nexport interface TxInfo {\n  recipients: Recipient[];\n  from: string;\n  txid: string;\n}\n\nexport interface TransactionPrebuild extends BaseTransactionPrebuild {\n  txHex: string;\n  txInfo: TxInfo;\n  feeInfo: TransactionFee;\n  source: string;\n}\n\nexport interface ExplainTransactionOptions {\n  txHex?: string;\n  halfSigned?: {\n    txHex: string;\n  };\n  feeInfo?: TransactionFee;\n  // TODO(BG-24809): get the memo from the toJson\n  memo?: {\n    type: string;\n    value: string;\n  };\n}\n\nexport interface HbarVerifyTransactionOptions extends VerifyTransactionOptions {\n  txPrebuild: TransactionPrebuild;\n  memo?: Memo;\n}\n\ninterface VerifyAddressOptions extends BaseVerifyAddressOptions {\n  baseAddress: string;\n}\n\nexport interface RecoveryOptions {\n  backupKey: string;\n  userKey: string;\n  rootAddress: string;\n  recoveryDestination: string;\n  bitgoKey?: string;\n  walletPassphrase?: string;\n  maxFee?: string;\n  nodeId?: string;\n  startTime?: string;\n  tokenId?: string;\n}\n\nexport interface RecoveryInfo {\n  id: string;\n  tx: string;\n  coin: string;\n  startTime: string;\n  nodeId: string;\n}\n\nexport interface OfflineVaultTxInfo {\n  txHex: string;\n  userKey: string;\n  backupKey: string;\n  bitgoKey?: string;\n  address: string;\n  coin: string;\n  maxFee: string;\n  recipients: Recipient[];\n  amount: string;\n  startTime: string;\n  validDuration: string;\n  nodeId: string;\n  memo: string;\n  json?: any;\n}\n\nexport interface BroadcastTransactionOptions extends BaseBroadcastTransactionOptions {\n  startTime?: string;\n}\n\nexport interface BroadcastTransactionResult extends BaseBroadcastTransactionResult {\n  status?: string;\n}\n\nexport class Hbar extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n\n  constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo);\n\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n\n    this._staticsCoin = staticsCoin;\n  }\n\n  getChain() {\n    return this._staticsCoin.name;\n  }\n\n  getFamily(): CoinFamily {\n    return this._staticsCoin.family;\n  }\n\n  getFullName() {\n    return this._staticsCoin.fullName;\n  }\n\n  getBaseFactor() {\n    return Math.pow(10, this._staticsCoin.decimalPlaces);\n  }\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Hbar(bitgo, staticsCoin);\n  }\n\n  /**\n   * Flag for sending value of 0\n   * @returns {boolean} True if okay to send 0 value, false otherwise\n   */\n  valuelessTransferAllowed(): boolean {\n    return false;\n  }\n\n  /**\n   * Checks if this is a valid base58 or hex address\n   * @param address\n   */\n  isValidAddress(address: string): boolean {\n    try {\n      return Utils.isValidAddressWithPaymentId(address);\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /** inheritdoc */\n  deriveKeyWithSeed(): { derivationPath: string; key: string } {\n    throw new NotSupported('method deriveKeyWithSeed not supported for eddsa curve');\n  }\n\n  /** inheritdoc */\n  generateKeyPair(seed?: Buffer): KeyPair {\n    const keyPair = seed ? new HbarKeyPair({ seed }) : new HbarKeyPair();\n    const keys = keyPair.getKeys();\n\n    if (!keys.prv) {\n      throw new Error('Keypair generation failed to generate a prv');\n    }\n\n    return {\n      pub: keys.pub,\n      prv: keys.prv,\n    };\n  }\n\n  /** inheritdoc */\n  generateRootKeyPair(seed?: Buffer): KeyPair {\n    const keyPair = seed ? new HbarKeyPair({ seed }) : new HbarKeyPair();\n    const keys = keyPair.getKeys(true);\n    if (!keys.prv) {\n      throw new Error('Missing prv in key generation.');\n    }\n    return { prv: keys.prv + keys.pub, pub: keys.pub };\n  }\n\n  async parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    return {};\n  }\n\n  /**\n   * Check if address is valid, then make sure it matches the base address.\n   *\n   * @param {VerifyAddressOptions} params\n   * @param {String} params.address - the address to verify\n   * @param {String} params.baseAddress - the base address from the wallet\n   */\n  async isWalletAddress(params: VerifyAddressOptions): Promise<boolean> {\n    const { address, baseAddress } = params;\n    return Utils.isSameBaseAddress(address, baseAddress);\n  }\n\n  async verifyTransaction(params: HbarVerifyTransactionOptions): Promise<boolean> {\n    // asset name to transfer amount map\n    const coinConfig = coins.get(this.getChain());\n    const { txParams: txParams, txPrebuild: txPrebuild, memo: memo } = params;\n    const transaction = new Transaction(coinConfig);\n    if (!txPrebuild.txHex) {\n      throw new Error('missing required tx prebuild property txHex');\n    }\n\n    transaction.fromRawTransaction(txPrebuild.txHex);\n    const explainTxParams: ExplainTransactionOptions = {\n      txHex: txPrebuild.txHex,\n      feeInfo: txPrebuild.feeInfo,\n      memo: memo,\n    };\n    const explainedTx = await this.explainTransaction(explainTxParams);\n\n    if (!txParams.recipients) {\n      throw new Error('missing required tx params property recipients');\n    }\n\n    // for enabletoken, recipient output amount is 0\n    const recipients = txParams.recipients.map((recipient) => ({\n      ...recipient,\n      amount: txParams.type === 'enabletoken' ? '0' : recipient.amount,\n      address: Utils.getAddressDetails(recipient.address).address,\n    }));\n    if (coinConfig.isToken) {\n      recipients.forEach((recipient) => {\n        if (recipient.tokenName !== undefined && recipient.tokenName !== coinConfig.name) {\n          throw new Error('Incorrect token name specified in recipients');\n        }\n        recipient.tokenName = coinConfig.name;\n      });\n    }\n\n    // verify recipients from params and explainedTx\n    const filteredRecipients = recipients?.map((recipient) => _.pick(recipient, ['address', 'amount', 'tokenName']));\n    const filteredOutputs = explainedTx.outputs.map((output) => _.pick(output, ['address', 'amount', 'tokenName']));\n\n    if (!_.isEqual(filteredOutputs, filteredRecipients)) {\n      throw new Error('Tx outputs does not match with expected txParams recipients');\n    }\n\n    return true;\n  }\n\n  /**\n   * Assemble keychain and half-sign prebuilt transaction\n   *\n   * @param params\n   * @param params.txPrebuild {Object} prebuild object returned by platform\n   * @param params.prv {String} user prv\n   * @returns Promise<SignedTransaction>\n   */\n  async signTransaction(params: HbarSignTransactionOptions): Promise<SignedTransaction> {\n    const factory = this.getBuilderFactory();\n    const txBuilder = factory.from(params.txPrebuild.txHex);\n    txBuilder.sign({ key: params.prv });\n\n    const transaction = await txBuilder.build();\n\n    if (!transaction) {\n      throw new Error('Invalid messaged passed to signMessage');\n    }\n\n    const response = {\n      txHex: transaction.toBroadcastFormat(),\n    };\n    return transaction.signature.length >= 2 ? response : { halfSigned: response };\n  }\n\n  /**\n   * Sign message with private key\n   *\n   * @param key\n   * @param message\n   * @return {Buffer} A signature over the given message using the given key\n   */\n  async signMessage(key: KeyPair, message: string | Buffer): Promise<Buffer> {\n    const msg = Buffer.isBuffer(message) ? message.toString('utf8') : message;\n    // reconstitute keys and sign\n    return Buffer.from(new HbarKeyPair({ prv: key.prv }).signMessage(msg));\n  }\n\n  /**\n   * Builds a funds recovery transaction without BitGo.\n   * We need to do three queries during this:\n   * 1) Node query - how much money is in the account\n   * 2) Build transaction - build our transaction for the amount\n   * 3) Send signed build - send our signed build to a public node\n   * @param params\n   */\n  public async recover(params: RecoveryOptions): Promise<RecoveryInfo | OfflineVaultTxInfo> {\n    const isUnsignedSweep =\n      (params.backupKey.startsWith(PUBLIC_KEY_PREFIX) && params.userKey.startsWith(PUBLIC_KEY_PREFIX)) ||\n      (Utils.isValidPublicKey(params.userKey) && Utils.isValidPublicKey(params.backupKey));\n\n    // Validate the root address\n    if (!this.isValidAddress(params.rootAddress)) {\n      throw new Error('invalid rootAddress, got: ' + params.rootAddress);\n    }\n\n    // Validate the destination address\n    if (!this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('invalid recoveryDestination, got: ' + params.recoveryDestination);\n    }\n\n    // Validate nodeId\n    if (params.nodeId && !Utils.isValidAddress(params.nodeId)) {\n      throw new Error('invalid nodeId, got: ' + params.nodeId);\n    }\n\n    // validate fee\n    if (params.maxFee && !Utils.isValidAmount(params.maxFee)) {\n      throw new Error('invalid maxFee, got: ' + params.maxFee);\n    }\n\n    // validate startTime\n\n    if (params.startTime) {\n      Utils.validateStartTime(params.startTime);\n    }\n\n    if (isUnsignedSweep && !params.startTime) {\n      throw new Error('start time is required for unsigned sweep');\n    }\n\n    if (!isUnsignedSweep && !params.walletPassphrase) {\n      throw new Error('walletPassphrase is required for non-bitgo recovery');\n    }\n\n    let userPrv: string | undefined;\n    let backUp: string | undefined;\n    if (!isUnsignedSweep) {\n      try {\n        userPrv = this.bitgo.decrypt({ input: params.userKey, password: params.walletPassphrase });\n        backUp = this.bitgo.decrypt({ input: params.backupKey, password: params.walletPassphrase });\n      } catch (e) {\n        throw new Error(\n          'unable to decrypt userKey or backupKey with the walletPassphrase provided, got error: ' + e.message\n        );\n      }\n    }\n\n    // validate userKey for unsigned sweep\n    if (isUnsignedSweep && !Utils.isValidPublicKey(params.userKey)) {\n      throw new Error('invalid userKey, got: ' + params.userKey);\n    }\n\n    // validate backupKey for unsigned sweep\n    if (isUnsignedSweep && !Utils.isValidPublicKey(params.backupKey)) {\n      throw new Error('invalid backupKey, got: ' + params.backupKey);\n    }\n\n    const { address: destinationAddress, memoId } = Utils.getAddressDetails(params.recoveryDestination);\n    const nodeId = params.nodeId ? params.nodeId : '0.0.3';\n    const client = this.getHbarClient();\n    const balance = await this.getAccountBalance(params.rootAddress, client);\n    const fee = params.maxFee ? params.maxFee : '10000000'; // default fee to 1 hbar\n    const nativeBalance = HbarUnit.fromString(balance.hbars).toTinybars().toString();\n    const spendableAmount = new BigNumber(nativeBalance).minus(fee);\n\n    let txBuilder;\n    if (!params.tokenId) {\n      if (spendableAmount.isZero() || spendableAmount.isNegative()) {\n        throw new Error(`Insufficient balance to recover, got balance: ${nativeBalance} fee: ${fee}`);\n      }\n      txBuilder = this.getBuilderFactory().getTransferBuilder();\n      txBuilder.send({ address: destinationAddress, amount: spendableAmount.toString() });\n    } else {\n      if (spendableAmount.isNegative()) {\n        throw new Error(\n          `Insufficient native balance to recover tokens, got native balance: ${nativeBalance} fee: ${fee}`\n        );\n      }\n      const tokenBalance = balance.tokens.find((token) => token.tokenId === params.tokenId);\n      const token = Utils.getHederaTokenNameFromId(params.tokenId);\n      if (!token) {\n        throw new Error(`Unsupported token: ${params.tokenId}`);\n      }\n      if (!tokenBalance || new BigNumber(tokenBalance.balance).isZero()) {\n        throw new Error(`Insufficient balance to recover token: ${params.tokenId} for account: ${params.rootAddress}`);\n      }\n      txBuilder = this.getBuilderFactory().getTokenTransferBuilder();\n      txBuilder.send({ address: destinationAddress, amount: tokenBalance.balance, tokenName: token.name });\n    }\n\n    txBuilder.node({ nodeId });\n    txBuilder.fee({ fee });\n    txBuilder.source({ address: params.rootAddress });\n    txBuilder.validDuration(180);\n    if (memoId) {\n      txBuilder.memo(memoId);\n    }\n\n    if (params.startTime) {\n      txBuilder.startTime(Utils.normalizeStarttime(params.startTime));\n    }\n    if (isUnsignedSweep) {\n      const tx = await txBuilder.build();\n      const txJson = tx.toJson();\n      return {\n        txHex: tx.toBroadcastFormat(),\n        coin: this.getChain(),\n        id: txJson.id,\n        startTime: txJson.startTime,\n        validDuration: txJson.validDuration,\n        nodeId: txJson.node,\n        memo: txJson.memo,\n        userKey: params.userKey,\n        backupKey: params.backupKey,\n        bitgoKey: params.bitgoKey,\n        maxFee: fee,\n        address: params.rootAddress,\n        recipients: txJson.instructionsData.params.recipients,\n        amount: txJson.amount,\n        json: txJson,\n      };\n    }\n\n    txBuilder.sign({ key: userPrv });\n    txBuilder.sign({ key: backUp });\n\n    const tx = await txBuilder.build();\n\n    return {\n      tx: tx.toBroadcastFormat(),\n      id: tx.toJson().id,\n      coin: this.getChain(),\n      startTime: tx.toJson().startTime,\n      nodeId: tx.toJson().node,\n    };\n  }\n\n  /**\n   * Explain a Hedera transaction from txHex\n   * @param params\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<TransactionExplanation> {\n    const txHex = params.txHex || (params.halfSigned && params.halfSigned.txHex);\n    if (!txHex) {\n      throw new Error('missing explain tx parameters');\n    }\n\n    const factory = this.getBuilderFactory();\n    const txBuilder = factory.from(txHex);\n    const tx = await txBuilder.build();\n    const txJson = tx.toJson();\n\n    let outputAmount = new BigNumber(0);\n    const outputs: { address: string; amount: string; memo: string; tokenName?: string }[] = [];\n    // TODO(BG-24809): get the memo from the toJson\n    let memo = '';\n    if (params.memo) {\n      memo = params.memo.value;\n    }\n\n    switch (txJson.instructionsData.type) {\n      case 'cryptoTransfer':\n        const recipients = txJson.instructionsData.params.recipients || [];\n        recipients.forEach((recipient) => {\n          if (!recipient.tokenName) {\n            // token transfer doesn't change outputAmount\n            outputAmount = outputAmount.plus(recipient.amount);\n          }\n          outputs.push({\n            address: recipient.address,\n            amount: recipient.amount.toString(),\n            memo,\n            ...(recipient.tokenName && {\n              tokenName: recipient.tokenName,\n            }),\n          });\n        });\n        break;\n\n      case 'tokenAssociate':\n        const tokens = txJson.instructionsData.params.tokenNames || [];\n        const accountId = txJson.instructionsData.params.accountId;\n        tokens.forEach((token) => {\n          outputs.push({\n            address: accountId,\n            amount: '0',\n            memo,\n            tokenName: token,\n          });\n        });\n        break;\n\n      default:\n        throw new Error('Transaction format outside of cryptoTransfer not supported for explanation.');\n    }\n\n    const displayOrder = [\n      'id',\n      'outputAmount',\n      'changeAmount',\n      'outputs',\n      'changeOutputs',\n      'fee',\n      'timestamp',\n      'expiration',\n      'memo',\n    ];\n\n    return {\n      displayOrder,\n      id: txJson.id,\n      outputs,\n      outputAmount: outputAmount.toString(),\n      changeOutputs: [], // account based does not use change outputs\n      changeAmount: '0', // account base does not make change\n      fee: params.feeInfo?.fee || txJson.fee, // in the instance no feeInfo is passed in as a param, show the fee given by the txJSON\n      timestamp: txJson.startTime,\n      expiration: txJson.validDuration,\n    } as any;\n  }\n\n  isStellarSeed(seed: string): boolean {\n    return SeedValidator.isValidEd25519SeedForCoin(seed, CoinFamily.XLM);\n  }\n\n  convertFromStellarSeed(seed: string): string | null {\n    // assume this is a trust custodial seed if its a valid ed25519 prv\n    if (!this.isStellarSeed(seed) || SeedValidator.hasCompetingSeedFormats(seed)) {\n      return null;\n    }\n\n    if (SeedValidator.isValidEd25519SeedForCoin(seed, CoinFamily.XLM)) {\n      const keyFromSeed = new HbarKeyPair({ seed: stellar.StrKey.decodeEd25519SecretSeed(seed) });\n      const keys = keyFromSeed.getKeys();\n      if (keys !== undefined && keys.prv) {\n        return keys.prv;\n      }\n    }\n\n    return null;\n  }\n\n  isValidPub(pub: string): boolean {\n    return Utils.isValidPublicKey(pub);\n  }\n\n  supportsDeriveKeyWithSeed(): boolean {\n    return false;\n  }\n\n  /** inherited doc */\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.onchain;\n  }\n\n  public getTokenEnablementConfig(): TokenEnablementConfig {\n    return {\n      requiresTokenEnablement: true,\n      supportsMultipleTokenEnablements: true,\n    };\n  }\n\n  private getBuilderFactory(): TransactionBuilderFactory {\n    return new TransactionBuilderFactory(coins.get(this.getChain()));\n  }\n\n  private getHbarClient(): Client {\n    const client = this.bitgo.getEnv() === 'prod' ? Client.forMainnet() : Client.forTestnet();\n    return client;\n  }\n\n  async getAccountBalance(accountId: string, client: Client): Promise<AccountBalanceJson> {\n    try {\n      const balance = await new AccountBalanceQuery().setAccountId(accountId).execute(client);\n\n      return balance.toJSON();\n    } catch (e) {\n      throw new Error('Failed to get account balance, error: ' + e.message);\n    }\n  }\n\n  async broadcastTransaction({\n    serializedSignedTransaction,\n    startTime,\n  }: BroadcastTransactionOptions): Promise<BroadcastTransactionResult> {\n    try {\n      const hbarTx = HbarTransaction.fromBytes(Utils.toUint8Array(serializedSignedTransaction));\n\n      if (startTime) {\n        Utils.isValidTimeString(startTime);\n        while (!Utils.shouldBroadcastNow(startTime)) {\n          await Utils.sleep(1000);\n        }\n      }\n\n      return this.clientBroadcastTransaction(hbarTx);\n    } catch (e) {\n      throw new Error('Failed to broadcast transaction, error: ' + e.message);\n    }\n  }\n\n  async clientBroadcastTransaction(hbarTx: HbarTransaction) {\n    const client = this.getHbarClient();\n    const transactionResponse = await hbarTx.execute(client);\n    const transactionReceipt = await transactionResponse.getReceipt(client);\n\n    return { txId: transactionResponse.transactionId.toString(), status: transactionReceipt.status.toString() };\n  }\n\n  /** @inheritDoc */\n  auditDecryptedKey({ prv, publicKey, multiSigType }: AuditDecryptedKeyParams) {\n    if (multiSigType === 'tss') {\n      throw new Error('Unsupported multiSigType');\n    }\n\n    let hbarKeyPair;\n\n    try {\n      hbarKeyPair = new HbarKeyPair({ prv });\n    } catch (e) {\n      throw new Error(`Invalid private key: ${e.message}`);\n    }\n    const genPubKey = hbarKeyPair.getKeys().pub;\n    if (publicKey && publicKey !== genPubKey) {\n      throw new Error('Invalid public key');\n    }\n  }\n}\n"]}

package/dist/src/hbarToken.d.ts

@@ -0,0 +1,21 @@
+import { BitGoBase, CoinConstructor, NamedCoinConstructor } from '@bitgo/sdk-core';
+import { HbarTokenConfig } from '@bitgo/statics';
+import { Hbar } from './hbar';
+export declare class HbarToken extends Hbar {
+    readonly tokenConfig: HbarTokenConfig;
+    constructor(bitgo: BitGoBase, tokenConfig: HbarTokenConfig);
+    static createTokenConstructor(config: HbarTokenConfig): CoinConstructor;
+    static createTokenConstructors(tokenConfigs?: HbarTokenConfig[]): NamedCoinConstructor[];
+    get name(): string;
+    get coin(): string;
+    get network(): string;
+    get decimalPlaces(): number;
+    get nodeAccountId(): string;
+    get tokenId(): string;
+    get contractAddress(): string;
+    getChain(): string;
+    getBaseChain(): string;
+    getFullName(): string;
+    getBaseFactor(): number;
+}
+//# sourceMappingURL=hbarToken.d.ts.map

package/dist/src/hbarToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hbarToken.d.ts","sourceRoot":"","sources":["../../src/hbarToken.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACnF,OAAO,EAAS,eAAe,EAAU,MAAM,gBAAgB,CAAC;AAChE,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B,qBAAa,SAAU,SAAQ,IAAI;IACjC,SAAgB,WAAW,EAAE,eAAe,CAAC;gBAEjC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,eAAe;IAM1D,MAAM,CAAC,sBAAsB,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe;IAIvE,MAAM,CAAC,uBAAuB,CAC5B,YAAY,GAAE,eAAe,EAAmE,GAC/F,oBAAoB,EAAE;IASzB,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED,QAAQ,IAAI,MAAM;IAIlB,YAAY,IAAI,MAAM;IAItB,WAAW,IAAI,MAAM;IAIrB,aAAa,IAAI,MAAM;CAGxB"}