@bitgo-beta/sdk-coin-atom 1.0.1-beta.4 → 1.0.1-beta.41

package/dist/src/lib/transferBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transferBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/transferBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,qBAAa,eAAgB,SAAQ,kBAAkB;gBACzC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;CACF"}

package/dist/src/lib/transferBuilder.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferBuilder = void 0;
+const transactionBuilder_1 = require("./transactionBuilder");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+class TransferBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.Send;
+    }
+}
+exports.TransferBuilder = TransferBuilder;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNmZXJCdWlsZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi90cmFuc2ZlckJ1aWxkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsNkRBQTBEO0FBRTFELG1EQUF1RDtBQUV2RCxNQUFhLGVBQWdCLFNBQVEsdUNBQWtCO0lBQ3JELFlBQVksV0FBaUM7UUFDM0MsS0FBSyxDQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQ3JCLENBQUM7SUFFRCxJQUFjLGVBQWU7UUFDM0IsT0FBTywwQkFBZSxDQUFDLElBQUksQ0FBQztJQUM5QixDQUFDO0NBQ0Y7QUFSRCwwQ0FRQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFRyYW5zYWN0aW9uQnVpbGRlciB9IGZyb20gJy4vdHJhbnNhY3Rpb25CdWlsZGVyJztcbmltcG9ydCB7IEJhc2VDb2luIGFzIENvaW5Db25maWcgfSBmcm9tICdAYml0Z28tYmV0YS9zdGF0aWNzJztcbmltcG9ydCB7IFRyYW5zYWN0aW9uVHlwZSB9IGZyb20gJ0BiaXRnby1iZXRhL3Nkay1jb3JlJztcblxuZXhwb3J0IGNsYXNzIFRyYW5zZmVyQnVpbGRlciBleHRlbmRzIFRyYW5zYWN0aW9uQnVpbGRlciB7XG4gIGNvbnN0cnVjdG9yKF9jb2luQ29uZmlnOiBSZWFkb25seTxDb2luQ29uZmlnPikge1xuICAgIHN1cGVyKF9jb2luQ29uZmlnKTtcbiAgfVxuXG4gIHByb3RlY3RlZCBnZXQgdHJhbnNhY3Rpb25UeXBlKCk6IFRyYW5zYWN0aW9uVHlwZSB7XG4gICAgcmV0dXJuIFRyYW5zYWN0aW9uVHlwZS5TZW5kO1xuICB9XG59XG4iXX0=

package/dist/src/lib/utils.d.ts

@@ -0,0 +1,155 @@
+/// <reference types="node" />
+import { BaseUtils, Signature } from '@bitgo-beta/sdk-core';
+import { DecodedTxRaw } from '@cosmjs/proto-signing';
+import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
+import { AtomTransaction, FeeData, MessageData } from './iface';
+export declare class Utils implements BaseUtils {
+    private registry;
+    /** @inheritdoc */
+    isValidBlockId(hash: string): boolean;
+    /** @inheritdoc */
+    isValidPrivateKey(key: string): boolean;
+    /** @inheritdoc */
+    isValidPublicKey(key: string): boolean;
+    /** @inheritdoc */
+    isValidSignature(signature: string): boolean;
+    /** @inheritdoc */
+    isValidTransactionId(txId: string): boolean;
+    /**
+     * Checks if transaction hash is in valid black2b format
+     */
+    validateBlake2b(hash: string): boolean;
+    /**
+     * Checks if raw transaction can be deserialized
+     *
+     * @param {string} rawTransaction - transaction in base64 string format
+     * @returns {boolean} - the validation result
+     */
+    private isValidRawTransaction;
+    /**
+     * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+     *
+     * @param {string} rawTransaction - Transaction in base64 string  format
+     */
+    validateRawTransaction(rawTransaction: string | undefined): void;
+    /**
+     * Validates if the address matches with regex @see accountAddressRegex
+     *
+     * @param address
+     */
+    isValidAddress(address: string): boolean;
+    /**
+     * Validates whether amounts are in range
+     *
+     * @param {number[]} amounts - the amounts to validate
+     * @returns {boolean} - the validation result
+     */
+    isValidAmounts(amounts: number[]): boolean;
+    /**
+     * Validates whether amount is in range
+     *
+     * @param amount
+     * @returns
+     */
+    isValidAmount(amount: number): boolean;
+    /**
+     * Decodes raw tx data into messages, signing info, and fee data
+     * @param txHex - raw base64 tx
+     */
+    getDecodedTxFromRawBase64(txRaw: string): DecodedTxRaw;
+    /**
+     * Returns the array of messages in the body of the decoded transaction
+     * @param decodedTx
+     */
+    private getEncodedMessagesFromDecodedTx;
+    /**
+     * Arranges a decoded message into our MessageData value interface
+     * @param decodedMessage
+     * @private
+     */
+    private getMessageValueDataFromDecodedMessage;
+    /**
+     * Returns an array of MessageData[] from an encoded messages array
+     * @param encodedMessages
+     * @private
+     */
+    private getMessageDataFromEncodedMessages;
+    /**
+     * Pulls the sequence number from a DecodedTxRaw AuthInfo property
+     * @param decodedTx
+     * @private
+     */
+    getSequenceFromDecodedTx(decodedTx: DecodedTxRaw): number;
+    /**
+     * Pulls the typeUrl from the encoded message of a DecodedTxRaw
+     * @param decodedTx
+     */
+    getTypeUrlFromDecodedTx(decodedTx: DecodedTxRaw): string;
+    /**
+     * Returns the fee data from the decoded transaction
+     * @param decodedTx
+     * @returns
+     */
+    getGasBudgetFromDecodedTx(decodedTx: DecodedTxRaw): FeeData;
+    /**
+     * Returns the publicKey from the decoded transaction
+     * @param decodedTx
+     * @returns publicKey in hex format if it exists, undefined otherwise
+     */
+    getPublicKeyFromDecodedTx(decodedTx: DecodedTxRaw): string | undefined;
+    /**
+     * Returns the array of MessageData[] from the decoded transaction
+     * @param decodedTx
+     */
+    getMessageDataFromDecodedTx(decodedTx: DecodedTxRaw): MessageData[];
+    /**
+     * Creates a sign doc from an atom transaction @see AtomTransaction
+     *
+     * @Precondition atomTransaction.accountNumber and atomTransaction.chainId must be defined
+     * @param atomTransaction
+     * @returns
+     */
+    createSignDocFromAtomTransaction(atomTransaction: AtomTransaction): import("cosmjs-types/cosmos/tx/v1beta1/tx").SignDoc;
+    /**
+     * Creates a txRaw from an atom transaction @see AtomTransaction
+     *
+     * @Precondition atomTransaction.publicKey must be defined
+     * @param atomTransaction
+     * @returns
+     */
+    createTxRawFromAtomTransaction(atomTransaction: AtomTransaction): TxRaw;
+    /**
+     * Encodes a signature into a txRaw
+     *
+     * @param signature
+     * @param tx
+     * @returns
+     */
+    createSignedTxRaw(signature: Signature, tx: {
+        bodyBytes: Uint8Array;
+        authInfoBytes: Uint8Array;
+    }): TxRaw;
+    /**
+     * Decodes a raw transaction into a DecodedTxRaw and checks if it has non empty signatures
+     *
+     * @param rawTransaction
+     * @returns
+     */
+    isSignedRawTx(rawTransaction: string): boolean;
+    /**
+     * Decodes a raw transaction into a DecodedTxRaw and returns the signer info in form of {pubKey, signature}
+     *
+     * @Assumption Only one signature is present in the raw transaction
+     * @param rawTransaction
+     * @returns
+     */
+    getSignerInfoFromRawSignedTx(rawTransaction: string): {
+        pubKey: {
+            pub: string;
+        };
+        signature: Buffer;
+    };
+}
+declare const utils: Utils;
+export default utils;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAA8C,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAGxG,OAAO,EACL,YAAY,EAQb,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAI1D,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAGhE,qBAAa,KAAM,YAAW,SAAS;IACrC,OAAO,CAAC,QAAQ,CAA2C;IAE3D,kBAAkB;IAClB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIrC,kBAAkB;IAClB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IASvC,kBAAkB;IAClB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAStC,kBAAkB;IAClB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI5C,kBAAkB;IAClB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI3C;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAMtC;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IA8B7B;;;;OAIG;IACH,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAShE;;;;OAIG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIxC;;;;;OAKG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO;IAS1C;;;;;OAKG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAQtC;;;OAGG;IACH,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY;IAItD;;;OAGG;IACH,OAAO,CAAC,+BAA+B;IAIvC;;;;OAIG;IACH,OAAO,CAAC,qCAAqC;IAQ7C;;;;OAIG;IACH,OAAO,CAAC,iCAAiC;IAWzC;;;;OAIG;IACH,wBAAwB,CAAC,SAAS,EAAE,YAAY,GAAG,MAAM;IAIzD;;;OAGG;IACH,uBAAuB,CAAC,SAAS,EAAE,YAAY,GAAG,MAAM;IAKxD;;;;OAIG;IACH,yBAAyB,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO;IAO3D;;;;OAIG;IACH,yBAAyB,CAAC,SAAS,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS;IAQtE;;;OAGG;IACH,2BAA2B,CAAC,SAAS,EAAE,YAAY,GAAG,WAAW,EAAE;IAKnE;;;;;;OAMG;IACH,gCAAgC,CAAC,eAAe,EAAE,eAAe;IAWjE;;;;;;OAMG;IACH,8BAA8B,CAAC,eAAe,EAAE,eAAe,GAAG,KAAK;IAwBvE;;;;;;OAMG;IACH,iBAAiB,CAAC,SAAS,EAAE,SAAS,EAAE,EAAE,EAAE;QAAE,SAAS,EAAE,UAAU,CAAC;QAAC,aAAa,EAAE,UAAU,CAAA;KAAE,GAAG,KAAK;IASxG;;;;;OAKG;IACH,aAAa,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO;IAQ9C;;;;;;OAMG;IACH,4BAA4B,CAAC,cAAc,EAAE,MAAM;;;;;;CAapD;AAED,QAAA,MAAM,KAAK,OAAc,CAAC;AAE1B,eAAe,KAAK,CAAC"}

package/dist/src/lib/utils.js

@@ -0,0 +1,328 @@
+"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-beta/sdk-core");
+const amino_1 = require("@cosmjs/amino");
+const encoding_1 = require("@cosmjs/encoding");
+const proto_signing_1 = require("@cosmjs/proto-signing");
+const stargate_1 = require("@cosmjs/stargate");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const tx_1 = require("cosmjs-types/cosmos/tx/v1beta1/tx");
+const constants_1 = require("./constants");
+const keyPair_1 = require("./keyPair");
+class Utils {
+    constructor() {
+        this.registry = new proto_signing_1.Registry([...stargate_1.defaultRegistryTypes]);
+    }
+    /** @inheritdoc */
+    isValidBlockId(hash) {
+        return this.validateBlake2b(hash);
+    }
+    /** @inheritdoc */
+    isValidPrivateKey(key) {
+        try {
+            new keyPair_1.KeyPair({ prv: key });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** @inheritdoc */
+    isValidPublicKey(key) {
+        try {
+            new keyPair_1.KeyPair({ pub: key });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** @inheritdoc */
+    isValidSignature(signature) {
+        throw new sdk_core_1.NotImplementedError('isValidSignature not implemented');
+    }
+    /** @inheritdoc */
+    isValidTransactionId(txId) {
+        return this.validateBlake2b(txId);
+    }
+    /**
+     * Checks if transaction hash is in valid black2b format
+     */
+    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) {
+        try {
+            const decodedTx = this.getDecodedTxFromRawBase64(rawTransaction);
+            if (decodedTx) {
+                if (!decodedTx.body) {
+                    return false;
+                }
+                if (!decodedTx.body.messages || !decodedTx.body.messages.length) {
+                    return false;
+                }
+                if (!decodedTx.authInfo) {
+                    return false;
+                }
+                if (!decodedTx.authInfo.fee) {
+                    return false;
+                }
+                if (!decodedTx.authInfo.signerInfos || !decodedTx.authInfo.signerInfos.length) {
+                    return false;
+                }
+                if (!decodedTx.authInfo.signerInfos[0].publicKey) {
+                    return false;
+                }
+                return true;
+            }
+            return false;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * 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');
+        }
+    }
+    /**
+     * Validates if the address matches with regex @see accountAddressRegex
+     *
+     * @param address
+     */
+    isValidAddress(address) {
+        return constants_1.accountAddressRegex.test(address);
+    }
+    /**
+     * Validates whether amounts are in range
+     *
+     * @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;
+    }
+    /**
+     * Validates whether amount is in range
+     *
+     * @param amount
+     * @returns
+     */
+    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 messageData = [];
+        for (const message of encodedMessages) {
+            messageData.push({
+                value: this.getMessageValueDataFromDecodedMessage(this.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;
+    }
+    /**
+     * Returns the fee data from the decoded transaction
+     * @param decodedTx
+     * @returns
+     */
+    getGasBudgetFromDecodedTx(decodedTx) {
+        var _a, _b;
+        return {
+            amount: (_a = decodedTx.authInfo.fee) === null || _a === void 0 ? void 0 : _a.amount,
+            gasLimit: Number((_b = decodedTx.authInfo.fee) === null || _b === void 0 ? void 0 : _b.gasLimit),
+        };
+    }
+    /**
+     * Returns the publicKey from the decoded transaction
+     * @param decodedTx
+     * @returns publicKey in hex format if it exists, undefined otherwise
+     */
+    getPublicKeyFromDecodedTx(decodedTx) {
+        var _a, _b, _c, _d;
+        const publicKeyUInt8Array = (_b = (_a = decodedTx.authInfo.signerInfos) === null || _a === void 0 ? void 0 : _a[0].publicKey) === null || _b === void 0 ? void 0 : _b.value;
+        if (publicKeyUInt8Array) {
+            return encoding_1.toHex(encoding_1.fromBase64((_d = proto_signing_1.decodePubkey((_c = decodedTx.authInfo.signerInfos) === null || _c === void 0 ? void 0 : _c[0].publicKey)) === null || _d === void 0 ? void 0 : _d.value));
+        }
+        return undefined;
+    }
+    /**
+     * Returns the array of MessageData[] from the decoded transaction
+     * @param decodedTx
+     */
+    getMessageDataFromDecodedTx(decodedTx) {
+        const encodedMessages = this.getEncodedMessagesFromDecodedTx(decodedTx);
+        return this.getMessageDataFromEncodedMessages(encodedMessages);
+    }
+    /**
+     * Creates a sign doc from an atom transaction @see AtomTransaction
+     *
+     * @Precondition atomTransaction.accountNumber and atomTransaction.chainId must be defined
+     * @param atomTransaction
+     * @returns
+     */
+    createSignDocFromAtomTransaction(atomTransaction) {
+        if (!atomTransaction.accountNumber) {
+            throw new Error('accountNumber is required to create a sign doc');
+        }
+        if (!atomTransaction.chainId) {
+            throw new Error('chainId is required to create a sign doc');
+        }
+        const txRaw = this.createTxRawFromAtomTransaction(atomTransaction);
+        return proto_signing_1.makeSignDoc(txRaw.bodyBytes, txRaw.authInfoBytes, atomTransaction.chainId, atomTransaction.accountNumber);
+    }
+    /**
+     * Creates a txRaw from an atom transaction @see AtomTransaction
+     *
+     * @Precondition atomTransaction.publicKey must be defined
+     * @param atomTransaction
+     * @returns
+     */
+    createTxRawFromAtomTransaction(atomTransaction) {
+        if (!atomTransaction.publicKey) {
+            throw new Error('publicKey is required to create a txRaw');
+        }
+        const encodedPublicKey = proto_signing_1.encodePubkey(amino_1.encodeSecp256k1Pubkey(encoding_1.fromHex(atomTransaction.publicKey)));
+        const txBodyValue = {
+            messages: atomTransaction.sendMessages,
+        };
+        const txBodyBytes = this.registry.encodeTxBody(txBodyValue);
+        const sequence = atomTransaction.sequence;
+        const authInfoBytes = proto_signing_1.makeAuthInfoBytes([{ pubkey: encodedPublicKey, sequence }], atomTransaction.gasBudget.amount, atomTransaction.gasBudget.gasLimit, undefined, undefined, undefined);
+        return tx_1.TxRaw.fromPartial({
+            bodyBytes: txBodyBytes,
+            authInfoBytes: authInfoBytes,
+        });
+    }
+    /**
+     * Encodes a signature into a txRaw
+     *
+     * @param signature
+     * @param tx
+     * @returns
+     */
+    createSignedTxRaw(signature, tx) {
+        const stdSignature = amino_1.encodeSecp256k1Signature(encoding_1.fromHex(signature.publicKey.pub), signature.signature);
+        return tx_1.TxRaw.fromPartial({
+            bodyBytes: tx.bodyBytes,
+            authInfoBytes: tx.authInfoBytes,
+            signatures: [encoding_1.fromBase64(stdSignature.signature)],
+        });
+    }
+    /**
+     * Decodes a raw transaction into a DecodedTxRaw and checks if it has non empty signatures
+     *
+     * @param rawTransaction
+     * @returns
+     */
+    isSignedRawTx(rawTransaction) {
+        const decodedTx = this.getDecodedTxFromRawBase64(rawTransaction);
+        if (decodedTx.signatures.length > 0) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Decodes a raw transaction into a DecodedTxRaw and returns the signer info in form of {pubKey, signature}
+     *
+     * @Assumption Only one signature is present in the raw transaction
+     * @param rawTransaction
+     * @returns
+     */
+    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, NotImplementedError, ParseTransactionError, Signature } from '@bitgo-beta/sdk-core';\nimport { encodeSecp256k1Pubkey, encodeSecp256k1Signature } from '@cosmjs/amino';\nimport { fromBase64, fromHex, toHex } from '@cosmjs/encoding';\nimport {\n  DecodedTxRaw,\n  decodePubkey,\n  decodeTxRaw,\n  EncodeObject,\n  encodePubkey,\n  makeAuthInfoBytes,\n  makeSignDoc,\n  Registry,\n} from '@cosmjs/proto-signing';\nimport { Coin, defaultRegistryTypes } from '@cosmjs/stargate';\nimport BigNumber from 'bignumber.js';\nimport { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';\nimport { Any } from 'cosmjs-types/google/protobuf/any';\n\nimport { accountAddressRegex } from './constants';\nimport { AtomTransaction, FeeData, MessageData } from './iface';\nimport { KeyPair } from './keyPair';\n\nexport class Utils implements BaseUtils {\n  private registry = new Registry([...defaultRegistryTypes]);\n\n  /** @inheritdoc */\n  isValidBlockId(hash: string): boolean {\n    return this.validateBlake2b(hash);\n  }\n\n  /** @inheritdoc */\n  isValidPrivateKey(key: string): boolean {\n    try {\n      new KeyPair({ prv: key });\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /** @inheritdoc */\n  isValidPublicKey(key: string): boolean {\n    try {\n      new KeyPair({ pub: key });\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /** @inheritdoc */\n  isValidSignature(signature: string): boolean {\n    throw new NotImplementedError('isValidSignature not implemented');\n  }\n\n  /** @inheritdoc */\n  isValidTransactionId(txId: string): boolean {\n    return this.validateBlake2b(txId);\n  }\n\n  /**\n   * Checks if transaction hash is in valid black2b format\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  private isValidRawTransaction(rawTransaction: string): boolean {\n    try {\n      const decodedTx: DecodedTxRaw = this.getDecodedTxFromRawBase64(rawTransaction);\n      if (decodedTx) {\n        if (!decodedTx.body) {\n          return false;\n        }\n        if (!decodedTx.body.messages || !decodedTx.body.messages.length) {\n          return false;\n        }\n        if (!decodedTx.authInfo) {\n          return false;\n        }\n        if (!decodedTx.authInfo.fee) {\n          return false;\n        }\n        if (!decodedTx.authInfo.signerInfos || !decodedTx.authInfo.signerInfos.length) {\n          return false;\n        }\n        if (!decodedTx.authInfo.signerInfos[0].publicKey) {\n          return false;\n        }\n        return true;\n      }\n      return false;\n    } catch (e) {\n      return false;\n    }\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 | undefined): 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  /**\n   * Validates if the address matches with regex @see accountAddressRegex\n   *\n   * @param address\n   */\n  isValidAddress(address: string): boolean {\n    return accountAddressRegex.test(address);\n  }\n\n  /**\n   * Validates whether amounts are in range\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  /**\n   * Validates whether amount is in range\n   *\n   * @param amount\n   * @returns\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 messageData: MessageData[] = [];\n    for (const message of encodedMessages) {\n      messageData.push({\n        value: this.getMessageValueDataFromDecodedMessage(this.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  /**\n   * Returns the fee data from the decoded transaction\n   * @param decodedTx\n   * @returns\n   */\n  getGasBudgetFromDecodedTx(decodedTx: DecodedTxRaw): FeeData {\n    return {\n      amount: decodedTx.authInfo.fee?.amount as Coin[],\n      gasLimit: Number(decodedTx.authInfo.fee?.gasLimit),\n    };\n  }\n\n  /**\n   * Returns the publicKey from the decoded transaction\n   * @param decodedTx\n   * @returns publicKey in hex format if it exists, undefined otherwise\n   */\n  getPublicKeyFromDecodedTx(decodedTx: DecodedTxRaw): string | undefined {\n    const publicKeyUInt8Array = decodedTx.authInfo.signerInfos?.[0].publicKey?.value;\n    if (publicKeyUInt8Array) {\n      return toHex(fromBase64(decodePubkey(decodedTx.authInfo.signerInfos?.[0].publicKey)?.value));\n    }\n    return undefined;\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  /**\n   * Creates a sign doc from an atom transaction @see AtomTransaction\n   *\n   * @Precondition atomTransaction.accountNumber and atomTransaction.chainId must be defined\n   * @param atomTransaction\n   * @returns\n   */\n  createSignDocFromAtomTransaction(atomTransaction: AtomTransaction) {\n    if (!atomTransaction.accountNumber) {\n      throw new Error('accountNumber is required to create a sign doc');\n    }\n    if (!atomTransaction.chainId) {\n      throw new Error('chainId is required to create a sign doc');\n    }\n    const txRaw = this.createTxRawFromAtomTransaction(atomTransaction);\n    return makeSignDoc(txRaw.bodyBytes, txRaw.authInfoBytes, atomTransaction.chainId, atomTransaction.accountNumber);\n  }\n\n  /**\n   * Creates a txRaw from an atom transaction @see AtomTransaction\n   *\n   * @Precondition atomTransaction.publicKey must be defined\n   * @param atomTransaction\n   * @returns\n   */\n  createTxRawFromAtomTransaction(atomTransaction: AtomTransaction): TxRaw {\n    if (!atomTransaction.publicKey) {\n      throw new Error('publicKey is required to create a txRaw');\n    }\n    const encodedPublicKey: Any = encodePubkey(encodeSecp256k1Pubkey(fromHex(atomTransaction.publicKey)));\n    const txBodyValue = {\n      messages: atomTransaction.sendMessages as unknown as Any[],\n    };\n    const txBodyBytes = this.registry.encodeTxBody(txBodyValue);\n    const sequence = atomTransaction.sequence;\n    const authInfoBytes = makeAuthInfoBytes(\n      [{ pubkey: encodedPublicKey, sequence }],\n      atomTransaction.gasBudget.amount,\n      atomTransaction.gasBudget.gasLimit,\n      undefined,\n      undefined,\n      undefined\n    );\n    return TxRaw.fromPartial({\n      bodyBytes: txBodyBytes,\n      authInfoBytes: authInfoBytes,\n    });\n  }\n\n  /**\n   * Encodes a signature into a txRaw\n   *\n   * @param signature\n   * @param tx\n   * @returns\n   */\n  createSignedTxRaw(signature: Signature, tx: { bodyBytes: Uint8Array; authInfoBytes: Uint8Array }): TxRaw {\n    const stdSignature = encodeSecp256k1Signature(fromHex(signature.publicKey.pub), signature.signature);\n    return TxRaw.fromPartial({\n      bodyBytes: tx.bodyBytes,\n      authInfoBytes: tx.authInfoBytes,\n      signatures: [fromBase64(stdSignature.signature)],\n    });\n  }\n\n  /**\n   * Decodes a raw transaction into a DecodedTxRaw and checks if it has non empty signatures\n   *\n   * @param rawTransaction\n   * @returns\n   */\n  isSignedRawTx(rawTransaction: string): boolean {\n    const decodedTx = this.getDecodedTxFromRawBase64(rawTransaction);\n    if (decodedTx.signatures.length > 0) {\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Decodes a raw transaction into a DecodedTxRaw and returns the signer info in form of {pubKey, signature}\n   *\n   * @Assumption Only one signature is present in the raw transaction\n   * @param rawTransaction\n   * @returns\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-beta/sdk-coin-atom",
-  "version": "1.0.1-beta.4",
+  "version": "1.0.1-beta.41",
   "description": "BitGo SDK coin library for Cosmos",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
@@ -40,15 +40,21 @@
     ]
   },
   "dependencies": {
-    "@bitgo-beta/sdk-core": "1.1.1-beta.126",
-    "@bitgo-beta/statics": "7.0.1-beta.126",
-    "@bitgo-beta/utxo-lib": "2.4.2-beta.126",
+    "@bitgo-beta/sdk-core": "1.1.1-beta.163",
+    "@bitgo-beta/statics": "7.0.1-beta.163",
+    "@bitgo-beta/utxo-lib": "2.4.2-beta.163",
     "@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",
+    "lodash": "^4.17.21"
   },
   "devDependencies": {
-    "@bitgo-beta/sdk-api": "1.1.1-beta.126",
-    "@bitgo-beta/sdk-test": "^1.2.11"
+    "@bitgo-beta/sdk-api": "1.1.1-beta.163",
+    "@bitgo-beta/sdk-test": "^1.2.15",
+    "@types/lodash": "^4.14.183"
   },
-  "gitHead": "fcefa0ebbda46136b89bd7b2f5e794aed1984c21"
+  "gitHead": "302bac4872efd799253b783a9e64569f82d9a7a1"
 }