@bitgo/sdk-coin-atom 1.1.1 → 2.0.0

package/dist/src/lib/utils.js

@@ -0,0 +1,213 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utils = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const encoding_1 = require("@cosmjs/encoding");
+const proto_signing_1 = require("@cosmjs/proto-signing");
+const stargate_1 = require("@cosmjs/stargate");
+const amino_1 = require("@cosmjs/amino");
+const tx_1 = require("cosmjs-types/cosmos/tx/v1beta1/tx");
+class Utils {
+    /** @inheritdoc */
+    isValidBlockId(hash) {
+        return this.validateBlake2b(hash);
+    }
+    /** @inheritdoc */
+    isValidPrivateKey(key) {
+        throw new Error('Method not implemented.');
+    }
+    /** @inheritdoc */
+    isValidPublicKey(key) {
+        throw new Error('Method not implemented.');
+    }
+    /** @inheritdoc */
+    isValidSignature(signature) {
+        throw new Error('Method not implemented.');
+    }
+    /** @inheritdoc */
+    isValidTransactionId(txId) {
+        return this.validateBlake2b(txId);
+    }
+    validateBlake2b(hash) {
+        if ((hash === null || hash === void 0 ? void 0 : hash.length) !== 64) {
+            return false;
+        }
+        return hash.match(/^[a-zA-Z0-9]+$/) !== null;
+    }
+    /**
+     * Checks if raw transaction can be deserialized
+     *
+     * @param {string} rawTransaction - transaction in base64 string format
+     * @returns {boolean} - the validation result
+     */
+    isValidRawTransaction(rawTransaction) {
+        throw new Error('Method not implemented.');
+    }
+    /**
+     * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+     *
+     * @param {string} rawTransaction - Transaction in base64 string  format
+     */
+    validateRawTransaction(rawTransaction) {
+        if (!rawTransaction) {
+            throw new sdk_core_1.ParseTransactionError('Invalid raw transaction: Undefined');
+        }
+        if (!this.isValidRawTransaction(rawTransaction)) {
+            throw new sdk_core_1.ParseTransactionError('Invalid raw transaction');
+        }
+    }
+    isValidAddress(address) {
+        const allowed_chars = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';
+        const atomRegex = '^(cosmos)1([' + allowed_chars + ']+)$';
+        const re = new RegExp(atomRegex);
+        return re.test(address);
+    }
+    /**
+     * Returns whether or not the string is a valid amount
+     *
+     * @param {number[]} amounts - the amounts to validate
+     * @returns {boolean} - the validation result
+     */
+    isValidAmounts(amounts) {
+        for (const amount of amounts) {
+            if (!this.isValidAmount(amount)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    isValidAmount(amount) {
+        const bigNumberAmount = new bignumber_js_1.default(amount);
+        if (!bigNumberAmount.isInteger() || bigNumberAmount.isLessThanOrEqualTo(0)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Decodes raw tx data into messages, signing info, and fee data
+     * @param txHex - raw base64 tx
+     */
+    getDecodedTxFromRawBase64(txRaw) {
+        return proto_signing_1.decodeTxRaw(encoding_1.fromBase64(txRaw));
+    }
+    /**
+     * Returns the array of messages in the body of the decoded transaction
+     * @param decodedTx
+     */
+    getEncodedMessagesFromDecodedTx(decodedTx) {
+        return decodedTx.body.messages;
+    }
+    /**
+     * Arranges a decoded message into our MessageData value interface
+     * @param decodedMessage
+     * @private
+     */
+    getMessageValueDataFromDecodedMessage(decodedMessage) {
+        return {
+            fromAddress: decodedMessage.fromAddress,
+            toAddress: decodedMessage.toAddress,
+            amount: decodedMessage.amount,
+        };
+    }
+    /**
+     * Returns an array of MessageData[] from an encoded messages array
+     * @param encodedMessages
+     * @private
+     */
+    getMessageDataFromEncodedMessages(encodedMessages) {
+        const registry = new proto_signing_1.Registry(stargate_1.defaultRegistryTypes);
+        const messageData = [];
+        for (const message of encodedMessages) {
+            messageData.push({
+                value: this.getMessageValueDataFromDecodedMessage(registry.decode(message)),
+                typeUrl: message.typeUrl,
+            });
+        }
+        return messageData;
+    }
+    /**
+     * Pulls the sequence number from a DecodedTxRaw AuthInfo property
+     * @param decodedTx
+     * @private
+     */
+    getSequenceFromDecodedTx(decodedTx) {
+        return Number(decodedTx.authInfo.signerInfos[0].sequence);
+    }
+    /**
+     * Pulls the typeUrl from the encoded message of a DecodedTxRaw
+     * @param decodedTx
+     */
+    getTypeUrlFromDecodedTx(decodedTx) {
+        const encodedMessage = this.getEncodedMessagesFromDecodedTx(decodedTx)[0];
+        return encodedMessage.typeUrl;
+    }
+    getGasBudgetFromDecodedTx(decodedTx) {
+        var _a, _b;
+        return {
+            amount: (_a = decodedTx.authInfo.fee) === null || _a === void 0 ? void 0 : _a.amount,
+            gas: Number((_b = decodedTx.authInfo.fee) === null || _b === void 0 ? void 0 : _b.gasLimit),
+        };
+    }
+    /**
+     * Returns the array of MessageData[] from the decoded transaction
+     * @param decodedTx
+     */
+    getMessageDataFromDecodedTx(decodedTx) {
+        const encodedMessages = this.getEncodedMessagesFromDecodedTx(decodedTx);
+        return this.getMessageDataFromEncodedMessages(encodedMessages);
+    }
+    createSignDocFromAtomTransaction(pubkey, atomTransaction) {
+        const register = new proto_signing_1.Registry(stargate_1.defaultRegistryTypes);
+        const txBodyValue = {
+            messages: atomTransaction.sendMessages,
+        };
+        const txBodyBytes = register.encodeTxBody(txBodyValue);
+        const sequence = atomTransaction.sequence;
+        const authInfoBytes = proto_signing_1.makeAuthInfoBytes([{ pubkey, sequence }], atomTransaction.gasBudget.amount, atomTransaction.gasBudget.gas, undefined, undefined, undefined);
+        // Ignoring linting because makeSignDoc expects string/number inputs but are null for our purposes
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        return proto_signing_1.makeSignDoc(txBodyBytes, authInfoBytes, null, null);
+    }
+    createSignedTxRaw(atomSignature, signDoc) {
+        const stdSignature = amino_1.encodeSecp256k1Signature(encoding_1.fromHex(atomSignature.publicKey.pub), atomSignature.signature);
+        return tx_1.TxRaw.fromPartial({
+            bodyBytes: signDoc.bodyBytes,
+            authInfoBytes: signDoc.authInfoBytes,
+            signatures: [encoding_1.fromBase64(stdSignature.signature)],
+        });
+    }
+    createBase64SignedTxBytesFromSignedTxRaw(signedTxRaw) {
+        const signedTxBytes = tx_1.TxRaw.encode(signedTxRaw).finish();
+        return encoding_1.toBase64(signedTxBytes);
+    }
+    isSignedRawTx(rawTransaction) {
+        const decodedTx = this.getDecodedTxFromRawBase64(rawTransaction);
+        if (decodedTx.authInfo.signerInfos.length > 0) {
+            return true;
+        }
+        return false;
+    }
+    getSignerInfoFromRawSignedTx(rawTransaction) {
+        var _a;
+        if (!this.isSignedRawTx(rawTransaction)) {
+            throw new Error('getSignerInfoFromRawTx failed, raw tx is not signed');
+        }
+        const decodedTx = this.getDecodedTxFromRawBase64(rawTransaction);
+        const aminoPubKey = decodedTx.authInfo.signerInfos[0].publicKey;
+        const decodedPubKeyHex = encoding_1.toHex(encoding_1.fromBase64((_a = proto_signing_1.decodePubkey(aminoPubKey)) === null || _a === void 0 ? void 0 : _a.value));
+        const pubKey = {
+            pub: decodedPubKeyHex,
+        };
+        const signature = Buffer.from(decodedTx.signatures[0]);
+        return { pubKey, signature };
+    }
+}
+exports.Utils = Utils;
+const utils = new Utils();
+exports.default = utils;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseUtils, ParseTransactionError, Signature } from '@bitgo/sdk-core';\nimport BigNumber from 'bignumber.js';\nimport { fromBase64, fromHex, toBase64, toHex } from '@cosmjs/encoding';\nimport {\n  DecodedTxRaw,\n  decodePubkey,\n  decodeTxRaw,\n  EncodeObject,\n  makeAuthInfoBytes,\n  makeSignDoc,\n  Registry,\n} from '@cosmjs/proto-signing';\nimport { AtomTransaction, GasFeeLimitData, MessageData } from './iface';\nimport { Coin, defaultRegistryTypes } from '@cosmjs/stargate';\nimport { encodeSecp256k1Signature } from '@cosmjs/amino';\nimport { TxRaw, SignDoc } from 'cosmjs-types/cosmos/tx/v1beta1/tx';\nimport { Any } from 'cosmjs-types/google/protobuf/any';\n\nexport class Utils implements BaseUtils {\n  /** @inheritdoc */\n  isValidBlockId(hash: string): boolean {\n    return this.validateBlake2b(hash);\n  }\n\n  /** @inheritdoc */\n  isValidPrivateKey(key: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritdoc */\n  isValidPublicKey(key: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritdoc */\n  isValidSignature(signature: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritdoc */\n  isValidTransactionId(txId: string): boolean {\n    return this.validateBlake2b(txId);\n  }\n\n  validateBlake2b(hash: string): boolean {\n    if (hash?.length !== 64) {\n      return false;\n    }\n    return hash.match(/^[a-zA-Z0-9]+$/) !== null;\n  }\n  /**\n   * Checks if raw transaction can be deserialized\n   *\n   * @param {string} rawTransaction - transaction in base64 string format\n   * @returns {boolean} - the validation result\n   */\n  isValidRawTransaction(rawTransaction: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Check the raw transaction has a valid format in the blockchain context, throw otherwise.\n   *\n   * @param {string} rawTransaction - Transaction in base64 string  format\n   */\n  validateRawTransaction(rawTransaction: string): void {\n    if (!rawTransaction) {\n      throw new ParseTransactionError('Invalid raw transaction: Undefined');\n    }\n    if (!this.isValidRawTransaction(rawTransaction)) {\n      throw new ParseTransactionError('Invalid raw transaction');\n    }\n  }\n\n  isValidAddress(address: string): boolean {\n    const allowed_chars = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';\n    const atomRegex = '^(cosmos)1([' + allowed_chars + ']+)$';\n    const re = new RegExp(atomRegex);\n    return re.test(address);\n  }\n\n  /**\n   * Returns whether or not the string is a valid amount\n   *\n   * @param {number[]} amounts - the amounts to validate\n   * @returns {boolean} - the validation result\n   */\n  isValidAmounts(amounts: number[]): boolean {\n    for (const amount of amounts) {\n      if (!this.isValidAmount(amount)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  isValidAmount(amount: number): boolean {\n    const bigNumberAmount = new BigNumber(amount);\n    if (!bigNumberAmount.isInteger() || bigNumberAmount.isLessThanOrEqualTo(0)) {\n      return false;\n    }\n    return true;\n  }\n\n  /**\n   * Decodes raw tx data into messages, signing info, and fee data\n   * @param txHex - raw base64 tx\n   */\n  getDecodedTxFromRawBase64(txRaw: string): DecodedTxRaw {\n    return decodeTxRaw(fromBase64(txRaw));\n  }\n\n  /**\n   * Returns the array of messages in the body of the decoded transaction\n   * @param decodedTx\n   */\n  private getEncodedMessagesFromDecodedTx(decodedTx: DecodedTxRaw): EncodeObject[] {\n    return decodedTx.body.messages;\n  }\n\n  /**\n   * Arranges a decoded message into our MessageData value interface\n   * @param decodedMessage\n   * @private\n   */\n  private getMessageValueDataFromDecodedMessage(decodedMessage: any): any {\n    return {\n      fromAddress: decodedMessage.fromAddress,\n      toAddress: decodedMessage.toAddress,\n      amount: decodedMessage.amount,\n    };\n  }\n\n  /**\n   * Returns an array of MessageData[] from an encoded messages array\n   * @param encodedMessages\n   * @private\n   */\n  private getMessageDataFromEncodedMessages(encodedMessages: EncodeObject[]): MessageData[] {\n    const registry = new Registry(defaultRegistryTypes);\n    const messageData: MessageData[] = [];\n    for (const message of encodedMessages) {\n      messageData.push({\n        value: this.getMessageValueDataFromDecodedMessage(registry.decode(message)),\n        typeUrl: message.typeUrl,\n      });\n    }\n    return messageData;\n  }\n\n  /**\n   * Pulls the sequence number from a DecodedTxRaw AuthInfo property\n   * @param decodedTx\n   * @private\n   */\n  getSequenceFromDecodedTx(decodedTx: DecodedTxRaw): number {\n    return Number(decodedTx.authInfo.signerInfos[0].sequence);\n  }\n\n  /**\n   * Pulls the typeUrl from the encoded message of a DecodedTxRaw\n   * @param decodedTx\n   */\n  getTypeUrlFromDecodedTx(decodedTx: DecodedTxRaw): string {\n    const encodedMessage = this.getEncodedMessagesFromDecodedTx(decodedTx)[0];\n    return encodedMessage.typeUrl;\n  }\n\n  getGasBudgetFromDecodedTx(decodedTx: DecodedTxRaw): GasFeeLimitData {\n    return {\n      amount: decodedTx.authInfo.fee?.amount as Coin[],\n      gas: Number(decodedTx.authInfo.fee?.gasLimit),\n    };\n  }\n\n  /**\n   * Returns the array of MessageData[] from the decoded transaction\n   * @param decodedTx\n   */\n  getMessageDataFromDecodedTx(decodedTx: DecodedTxRaw): MessageData[] {\n    const encodedMessages = this.getEncodedMessagesFromDecodedTx(decodedTx);\n    return this.getMessageDataFromEncodedMessages(encodedMessages);\n  }\n\n  createSignDocFromAtomTransaction(pubkey: any, atomTransaction: AtomTransaction) {\n    const register = new Registry(defaultRegistryTypes);\n    const txBodyValue = {\n      messages: atomTransaction.sendMessages as unknown as Any[],\n    };\n    const txBodyBytes = register.encodeTxBody(txBodyValue);\n    const sequence = atomTransaction.sequence;\n    const authInfoBytes = makeAuthInfoBytes(\n      [{ pubkey, sequence }],\n      atomTransaction.gasBudget.amount,\n      atomTransaction.gasBudget.gas,\n      undefined,\n      undefined,\n      undefined\n    );\n    // Ignoring linting because makeSignDoc expects string/number inputs but are null for our purposes\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    return makeSignDoc(txBodyBytes, authInfoBytes, null, null);\n  }\n\n  createSignedTxRaw(atomSignature: Signature, signDoc: SignDoc): TxRaw {\n    const stdSignature = encodeSecp256k1Signature(fromHex(atomSignature.publicKey.pub), atomSignature.signature);\n    return TxRaw.fromPartial({\n      bodyBytes: signDoc.bodyBytes,\n      authInfoBytes: signDoc.authInfoBytes,\n      signatures: [fromBase64(stdSignature.signature)],\n    });\n  }\n\n  createBase64SignedTxBytesFromSignedTxRaw(signedTxRaw: TxRaw): string {\n    const signedTxBytes = TxRaw.encode(signedTxRaw).finish();\n    return toBase64(signedTxBytes);\n  }\n\n  isSignedRawTx(rawTransaction: string): boolean {\n    const decodedTx = this.getDecodedTxFromRawBase64(rawTransaction);\n    if (decodedTx.authInfo.signerInfos.length > 0) {\n      return true;\n    }\n    return false;\n  }\n\n  getSignerInfoFromRawSignedTx(rawTransaction: string) {\n    if (!this.isSignedRawTx(rawTransaction)) {\n      throw new Error('getSignerInfoFromRawTx failed, raw tx is not signed');\n    }\n    const decodedTx = this.getDecodedTxFromRawBase64(rawTransaction);\n    const aminoPubKey = decodedTx.authInfo.signerInfos[0].publicKey as Any;\n    const decodedPubKeyHex = toHex(fromBase64(decodePubkey(aminoPubKey)?.value));\n    const pubKey = {\n      pub: decodedPubKeyHex,\n    };\n    const signature = Buffer.from(decodedTx.signatures[0]);\n    return { pubKey, signature };\n  }\n}\n\nconst utils = new Utils();\n\nexport default utils;\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitgo/sdk-coin-atom",
-  "version": "1.1.1",
+  "version": "2.0.0",
   "description": "BitGo SDK coin library for Cosmos",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
@@ -40,15 +40,19 @@
     ]
   },
   "dependencies": {
-    "@bitgo/sdk-core": "^5.2.0",
-    "@bitgo/statics": "^14.1.0",
-    "@bitgo/utxo-lib": "^7.5.0",
+    "@bitgo/sdk-core": "^7.0.0",
+    "@bitgo/statics": "^14.3.0",
+    "@bitgo/utxo-lib": "^7.7.0",
     "@cosmjs/amino": "^0.29.5",
-    "@cosmjs/encoding": "^0.29.5"
+    "@cosmjs/encoding": "^0.29.5",
+    "@cosmjs/proto-signing": "^0.29.5",
+    "@cosmjs/stargate": "^0.29.5",
+    "bignumber.js": "^9.1.1",
+    "cosmjs-types": "^0.6.1"
   },
   "devDependencies": {
-    "@bitgo/sdk-api": "^1.9.7",
-    "@bitgo/sdk-test": "^1.2.12"
+    "@bitgo/sdk-api": "^1.9.9",
+    "@bitgo/sdk-test": "^1.2.14"
   },
-  "gitHead": "79a7ef6259ef8e2e989240cf61c45b7f24f4ab40"
+  "gitHead": "fc7357c09510d49b27b88a9c04f48f4b5a3921f8"
 }