@bitgo-beta/abstract-eth 1.2.3-alpha.405 → 1.2.3-alpha.407

package/dist/src/abstractEthLikeCoin.d.ts

@@ -0,0 +1,95 @@
+/**
+ * @prettier
+ */
+import type * as EthLikeCommon from '@ethereumjs/common';
+import { CoinFamily, BaseCoin as StaticsBaseCoin } from '@bitgo-beta/statics';
+import { AuditDecryptedKeyParams, BaseCoin, BitGoBase, FullySignedTransaction, HalfSignedAccountTransaction, KeyPair, ParsedTransaction, ParseTransactionOptions, SignTransactionOptions, TransactionExplanation, TransactionFee, TransactionPrebuild as BaseTransactionPrebuild, TransactionRecipient as Recipient, VerifyTransactionOptions } from '@bitgo-beta/sdk-core';
+import { TransactionBuilder } from './lib';
+import { VerifyEthAddressOptions } from './abstractEthLikeNewCoins';
+export interface EthSignTransactionOptions extends SignTransactionOptions {
+    txPrebuild: TransactionPrebuild;
+    prv: string;
+}
+export interface TxInfo {
+    recipients: Recipient[];
+    from: string;
+    txid: string;
+}
+interface TransactionPrebuild extends BaseTransactionPrebuild {
+    txHex?: string;
+    txInfo: TxInfo;
+    feeInfo: EthTransactionFee;
+    source: string;
+    dataToSign: string;
+    nextContractSequenceId?: number;
+    expireTime?: number;
+}
+export interface EthTransactionFee {
+    fee: string;
+    gasLimit?: string;
+}
+export interface ExplainTransactionOptions {
+    txHex?: string;
+    halfSigned?: {
+        txHex: string;
+    };
+    feeInfo: TransactionFee;
+    common?: EthLikeCommon.default;
+}
+export interface HalfSignedEthLikeTransaction extends HalfSignedAccountTransaction {
+    halfSigned?: {
+        txHex?: never;
+        recipients: Recipient[];
+        expiration?: number;
+    };
+}
+export type SignedEthLikeTransaction = HalfSignedEthLikeTransaction | FullySignedTransaction;
+export declare abstract class AbstractEthLikeCoin extends BaseCoin {
+    protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
+    protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>);
+    getChain(): string;
+    /**
+     * Get the base chain that the coin exists on.
+     */
+    getBaseChain(): string;
+    getFamily(): CoinFamily;
+    getFullName(): string;
+    getBaseFactor(): number;
+    getChainId(): number;
+    /** @inheritDoc */
+    isEVM(): boolean;
+    valuelessTransferAllowed(): boolean;
+    /**
+     * Check if the address is a valid eth address.
+     */
+    isValidAddress(address: string): boolean;
+    generateKeyPair(seed?: Buffer): KeyPair;
+    parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction>;
+    isWalletAddress(params: VerifyEthAddressOptions): Promise<boolean>;
+    verifyTransaction(params: VerifyTransactionOptions): Promise<boolean>;
+    signTransaction(params: EthSignTransactionOptions): Promise<SignedEthLikeTransaction>;
+    isValidPub(pub: string): boolean;
+    /**
+     * 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 The options with which to recover
+     */
+    recover(params: any): Promise<any>;
+    /**
+     * Explain a transaction from txHex
+     * @param params The options with which to explain the transaction
+     */
+    explainTransaction(params: ExplainTransactionOptions): Promise<TransactionExplanation>;
+    /**
+     * Create a new transaction builder for the current chain
+     * @return a new transaction builder
+     */
+    protected abstract getTransactionBuilder(common?: EthLikeCommon.default): TransactionBuilder;
+    /** @inheritDoc */
+    auditDecryptedKey({ multiSigType, publicKey, prv }: AuditDecryptedKeyParams): void;
+}
+export {};
+//# sourceMappingURL=abstractEthLikeCoin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"abstractEthLikeCoin.d.ts","sourceRoot":"","sources":["../../src/abstractEthLikeCoin.ts"],"names":[],"mappings":"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"}

package/dist/src/abstractEthLikeCoin.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractEthLikeCoin = void 0;
+const secp256k1_1 = require("@bitgo-beta/secp256k1");
+const crypto_1 = require("crypto");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const lib_1 = require("./lib");
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+class AbstractEthLikeCoin 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;
+    }
+    /**
+     * Get the base chain that the coin exists on.
+     */
+    getBaseChain() {
+        return this.getChain();
+    }
+    getFamily() {
+        return this._staticsCoin.family;
+    }
+    getFullName() {
+        return this._staticsCoin.fullName;
+    }
+    getBaseFactor() {
+        return Math.pow(10, this._staticsCoin.decimalPlaces);
+    }
+    getChainId() {
+        return this._staticsCoin.network.chainId;
+    }
+    /** @inheritDoc */
+    isEVM() {
+        return true;
+    }
+    valuelessTransferAllowed() {
+        return true;
+    }
+    /**
+     * Check if the address is a valid eth address.
+     */
+    isValidAddress(address) {
+        if (!address) {
+            return false;
+        }
+        return (0, lib_1.isValidEthAddress)(address);
+    }
+    generateKeyPair(seed) {
+        const extendedKey = secp256k1_1.bip32.fromSeed(seed || (0, crypto_1.randomBytes)(32));
+        const xpub = extendedKey.neutered().toBase58();
+        return {
+            pub: xpub,
+            prv: extendedKey.toBase58(),
+        };
+    }
+    async parseTransaction(params) {
+        return {};
+    }
+    async isWalletAddress(params) {
+        throw new sdk_core_1.MethodNotImplementedError();
+    }
+    async verifyTransaction(params) {
+        return true;
+    }
+    async signTransaction(params) {
+        const txBuilder = this.getTransactionBuilder();
+        txBuilder.from(params.txPrebuild.txHex);
+        txBuilder.transfer().key(new lib_1.KeyPair({ prv: params.prv }).getKeys().prv);
+        const transaction = await txBuilder.build();
+        const recipients = transaction.outputs.map((output) => ({ address: output.address, amount: output.value }));
+        return {
+            halfSigned: {
+                txHex: transaction.toBroadcastFormat(),
+                recipients: recipients,
+                expiration: params.txPrebuild.expireTime,
+            },
+        };
+    }
+    isValidPub(pub) {
+        let valid = true;
+        try {
+            new lib_1.KeyPair({ pub });
+        }
+        catch (e) {
+            valid = false;
+        }
+        return valid;
+    }
+    /**
+     * 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 The options with which to recover
+     */
+    async recover(params) {
+        throw new sdk_core_1.MethodNotImplementedError();
+    }
+    /**
+     * Explain a transaction from txHex
+     * @param params The options with which to explain the transaction
+     */
+    async explainTransaction(params) {
+        const txHex = params.txHex || (params.halfSigned && params.halfSigned.txHex);
+        if (!txHex || !params.feeInfo) {
+            throw new Error('missing explain tx parameters');
+        }
+        const txBuilder = this.getTransactionBuilder(params.common);
+        txBuilder.from(txHex);
+        const tx = await txBuilder.build();
+        const outputs = tx.outputs.map((output) => {
+            return {
+                address: output.address,
+                amount: output.value,
+            };
+        });
+        const displayOrder = ['id', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee'];
+        return {
+            displayOrder,
+            id: tx.id,
+            outputs: outputs,
+            outputAmount: outputs
+                .reduce((accumulator, output) => accumulator.plus(output.amount), new bignumber_js_1.default('0'))
+                .toFixed(0),
+            changeOutputs: [], // account based does not use change outputs
+            changeAmount: '0', // account base does not make change
+            fee: params.feeInfo,
+        };
+    }
+    /** @inheritDoc */
+    auditDecryptedKey({ multiSigType, publicKey, prv }) {
+        if (multiSigType === 'tss') {
+            (0, sdk_lib_mpc_1.auditEcdsaPrivateKey)(prv, publicKey);
+        }
+        else {
+            if (!(0, sdk_core_1.isValidPrv)(prv) && !(0, sdk_core_1.isValidXprv)(prv)) {
+                throw new Error('Invalid private key');
+            }
+            if (publicKey) {
+                const genPubKey = sdk_core_1.bitcoin.HDNode.fromBase58(prv).neutered().toBase58();
+                if (genPubKey !== publicKey) {
+                    throw new Error('Incorrect xpub');
+                }
+            }
+        }
+    }
+}
+exports.AbstractEthLikeCoin = AbstractEthLikeCoin;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstractEthLikeCoin.js","sourceRoot":"","sources":["../../src/abstractEthLikeCoin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport type * as EthLikeCommon from '@ethereumjs/common';\nimport { CoinFamily, BaseCoin as StaticsBaseCoin, EthereumNetwork } from '@bitgo-beta/statics';\nimport { bip32 } from '@bitgo-beta/secp256k1';\nimport { randomBytes } from 'crypto';\nimport {\n  AuditDecryptedKeyParams,\n  BaseCoin,\n  bitcoin,\n  BitGoBase,\n  FullySignedTransaction,\n  HalfSignedAccountTransaction,\n  isValidPrv,\n  isValidXprv,\n  KeyPair,\n  MethodNotImplementedError,\n  ParsedTransaction,\n  ParseTransactionOptions,\n  SignTransactionOptions,\n  TransactionExplanation,\n  TransactionFee,\n  TransactionPrebuild as BaseTransactionPrebuild,\n  TransactionRecipient as Recipient,\n  VerifyTransactionOptions,\n} from '@bitgo-beta/sdk-core';\nimport BigNumber from 'bignumber.js';\n\nimport { isValidEthAddress, KeyPair as EthKeyPair, TransactionBuilder } from './lib';\nimport { VerifyEthAddressOptions } from './abstractEthLikeNewCoins';\nimport { auditEcdsaPrivateKey } from '@bitgo-beta/sdk-lib-mpc';\n\nexport interface EthSignTransactionOptions extends SignTransactionOptions {\n  txPrebuild: TransactionPrebuild;\n  prv: string;\n}\n\nexport interface TxInfo {\n  recipients: Recipient[];\n  from: string;\n  txid: string;\n}\n\ninterface TransactionPrebuild extends BaseTransactionPrebuild {\n  txHex?: string;\n  txInfo: TxInfo;\n  feeInfo: EthTransactionFee;\n  source: string;\n  dataToSign: string;\n  nextContractSequenceId?: number;\n  expireTime?: number;\n}\n\nexport interface EthTransactionFee {\n  fee: string;\n  gasLimit?: string;\n}\n\nexport interface ExplainTransactionOptions {\n  txHex?: string;\n  halfSigned?: {\n    txHex: string;\n  };\n  feeInfo: TransactionFee;\n  common?: EthLikeCommon.default;\n}\n\nexport interface HalfSignedEthLikeTransaction extends HalfSignedAccountTransaction {\n  halfSigned?: {\n    txHex?: never;\n    recipients: Recipient[];\n    expiration?: number;\n  };\n}\n\nexport type SignedEthLikeTransaction = HalfSignedEthLikeTransaction | FullySignedTransaction;\n\nexport abstract class AbstractEthLikeCoin extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n\n  protected 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  /**\n   * Get the base chain that the coin exists on.\n   */\n  getBaseChain() {\n    return this.getChain();\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  getChainId(): number {\n    return (this._staticsCoin.network as EthereumNetwork).chainId;\n  }\n\n  /** @inheritDoc */\n  isEVM(): boolean {\n    return true;\n  }\n\n  valuelessTransferAllowed(): boolean {\n    return true;\n  }\n\n  /**\n   * Check if the address is a valid eth address.\n   */\n  isValidAddress(address: string): boolean {\n    if (!address) {\n      return false;\n    }\n    return isValidEthAddress(address);\n  }\n\n  generateKeyPair(seed?: Buffer): KeyPair {\n    const extendedKey = bip32.fromSeed(seed || randomBytes(32));\n    const xpub = extendedKey.neutered().toBase58();\n\n    return {\n      pub: xpub,\n      prv: extendedKey.toBase58(),\n    };\n  }\n\n  async parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    return {};\n  }\n\n  async isWalletAddress(params: VerifyEthAddressOptions): Promise<boolean> {\n    throw new MethodNotImplementedError();\n  }\n\n  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {\n    return true;\n  }\n\n  async signTransaction(params: EthSignTransactionOptions): Promise<SignedEthLikeTransaction> {\n    const txBuilder = this.getTransactionBuilder();\n    txBuilder.from(params.txPrebuild.txHex);\n    txBuilder.transfer().key(new EthKeyPair({ prv: params.prv }).getKeys().prv!);\n    const transaction = await txBuilder.build();\n\n    const recipients = transaction.outputs.map((output) => ({ address: output.address, amount: output.value }));\n\n    return {\n      halfSigned: {\n        txHex: transaction.toBroadcastFormat(),\n        recipients: recipients,\n        expiration: params.txPrebuild.expireTime,\n      },\n    };\n  }\n\n  isValidPub(pub: string): boolean {\n    let valid = true;\n    try {\n      new EthKeyPair({ pub });\n    } catch (e) {\n      valid = false;\n    }\n    return valid;\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 The options with which to recover\n   */\n  async recover(params: any): Promise<any> {\n    throw new MethodNotImplementedError();\n  }\n\n  /**\n   * Explain a transaction from txHex\n   * @param params The options with which to explain the transaction\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<TransactionExplanation> {\n    const txHex = params.txHex || (params.halfSigned && params.halfSigned.txHex);\n    if (!txHex || !params.feeInfo) {\n      throw new Error('missing explain tx parameters');\n    }\n    const txBuilder = this.getTransactionBuilder(params.common);\n    txBuilder.from(txHex);\n    const tx = await txBuilder.build();\n    const outputs = tx.outputs.map((output) => {\n      return {\n        address: output.address,\n        amount: output.value,\n      };\n    });\n\n    const displayOrder = ['id', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee'];\n\n    return {\n      displayOrder,\n      id: tx.id,\n      outputs: outputs,\n      outputAmount: outputs\n        .reduce((accumulator, output) => accumulator.plus(output.amount), new BigNumber('0'))\n        .toFixed(0),\n      changeOutputs: [], // account based does not use change outputs\n      changeAmount: '0', // account base does not make change\n      fee: params.feeInfo,\n    };\n  }\n\n  /**\n   * Create a new transaction builder for the current chain\n   * @return a new transaction builder\n   */\n  protected abstract getTransactionBuilder(common?: EthLikeCommon.default): TransactionBuilder;\n\n  /** @inheritDoc */\n  auditDecryptedKey({ multiSigType, publicKey, prv }: AuditDecryptedKeyParams): void {\n    if (multiSigType === 'tss') {\n      auditEcdsaPrivateKey(prv as string, publicKey as string);\n    } else {\n      if (!isValidPrv(prv) && !isValidXprv(prv)) {\n        throw new Error('Invalid private key');\n      }\n      if (publicKey) {\n        const genPubKey = bitcoin.HDNode.fromBase58(prv).neutered().toBase58();\n        if (genPubKey !== publicKey) {\n          throw new Error('Incorrect xpub');\n        }\n      }\n    }\n  }\n}\n"]}