@injectivelabs/sdk-ts 1.15.0 → 1.15.2

package/dist/esm/core/tx/types/tx.d.ts

@@ -0,0 +1,100 @@
+import { Msgs } from '../../modules/msgs.js';
+import { StdFee } from '@cosmjs/amino';
+import { CosmosTxV1Beta1Tx, CosmosTxV1Beta1Service, CosmosTxSigningV1Beta1Signing, GoogleProtobufAny } from '@injectivelabs/core-proto-ts';
+export interface TxClientBroadcastOptions {
+    mode?: CosmosTxV1Beta1Service.BroadcastMode;
+    timeout?: number;
+    txTimeout?: number;
+}
+export interface TxClientBroadcastResponse {
+    height: number;
+    txHash: string;
+    codespace: string;
+    code: number;
+    data?: string;
+    rawLog: string;
+    logs?: any[];
+    info?: string;
+    gasWanted: number;
+    gasUsed: number;
+    timestamp: string;
+    events?: any[];
+}
+export interface TxClientSimulateResponse {
+    result: {
+        data: Uint8Array | string;
+        log: string;
+        eventsList: any[];
+    };
+    gasInfo: {
+        gasWanted: number;
+        gasUsed: number;
+    };
+}
+export interface TxConcreteApi {
+    broadcast(txRaw: CosmosTxV1Beta1Tx.TxRaw, options?: TxClientBroadcastOptions): Promise<TxClientBroadcastResponse>;
+    broadcastBlock(txRaw: CosmosTxV1Beta1Tx.TxRaw): Promise<TxClientBroadcastResponse>;
+    fetchTx(txHash: string): Promise<TxClientBroadcastResponse | undefined>;
+    fetchTxPoll(txHash: string): Promise<TxClientBroadcastResponse | undefined>;
+    simulate(txRaw: CosmosTxV1Beta1Tx.TxRaw): Promise<TxClientSimulateResponse>;
+}
+export declare enum TxClientMode {
+    gRpc = "grpc",
+    rest = "rest"
+}
+export type MsgArg = {
+    type: string;
+    message: any;
+};
+export interface SignerDetails {
+    pubKey: string | GoogleProtobufAny.Any;
+    sequence: number;
+    accountNumber: number;
+}
+/** @type {CreateTransactionWithSignersArgs} */
+export interface CreateTransactionWithSignersArgs {
+    fee?: StdFee | string;
+    memo?: string;
+    chainId: string;
+    message: Msgs | Msgs[];
+    signers: SignerDetails | SignerDetails[];
+    signMode?: CosmosTxSigningV1Beta1Signing.SignMode;
+    timeoutHeight?: number;
+}
+/** @type {CreateTransactionArgs} */
+export interface CreateTransactionArgs {
+    fee?: StdFee;
+    memo?: string;
+    chainId: string;
+    message: Msgs | Msgs[];
+    pubKey: string;
+    sequence: number;
+    accountNumber: number;
+    signMode?: CosmosTxSigningV1Beta1Signing.SignMode;
+    timeoutHeight?: number;
+}
+/** @type {CreateTransactionResult} */
+export interface CreateTransactionResult {
+    txRaw: CosmosTxV1Beta1Tx.TxRaw;
+    signDoc: CosmosTxV1Beta1Tx.SignDoc;
+    bodyBytes: Uint8Array;
+    signers: SignerDetails | SignerDetails[];
+    signer: SignerDetails;
+    authInfoBytes: Uint8Array;
+    signBytes: Uint8Array;
+    signHashedBytes: Uint8Array;
+}
+export interface TxResponse {
+    height: number;
+    txHash: string;
+    codespace: string;
+    code: number;
+    data?: string;
+    rawLog: string;
+    logs?: any[];
+    info?: string;
+    gasWanted: number;
+    gasUsed: number;
+    timestamp: string;
+    events?: any[];
+}

package/dist/esm/core/tx/types/tx.js

@@ -0,0 +1,5 @@
+export var TxClientMode;
+(function (TxClientMode) {
+    TxClientMode["gRpc"] = "grpc";
+    TxClientMode["rest"] = "rest";
+})(TxClientMode || (TxClientMode = {}));

package/dist/esm/core/tx/utils/api.d.ts

@@ -0,0 +1,2 @@
+export declare const isTxNotFoundError: (error: any) => boolean;
+export declare const errorToErrorMessage: (error: any) => any;

package/dist/esm/core/tx/utils/api.js

@@ -0,0 +1,26 @@
+export const isTxNotFoundError = (error) => {
+    if (!error.response) {
+        const errorToString = error.toString();
+        const acceptableErrorStrings = ['404', 'not found', 'timeout'];
+        return acceptableErrorStrings.some((code) => errorToString.includes(code));
+    }
+    const message = error.response.data
+        ? error.response.data.message
+        : error.toString();
+    if (message.includes('404')) {
+        return true;
+    }
+    if (message.includes('not found')) {
+        return true;
+    }
+    return false;
+};
+export const errorToErrorMessage = (error) => {
+    if (!error.response) {
+        return error.toString();
+    }
+    const message = error.response.data
+        ? error.response.data.message
+        : error.toString();
+    return message;
+};

package/dist/esm/core/tx/utils/classes/TxClient.d.ts

@@ -0,0 +1,18 @@
+import { CosmosTxV1Beta1Tx } from '@injectivelabs/core-proto-ts';
+export declare class TxClient {
+    /**
+     * Encode a transaction to base64-encoded protobuf
+     * @param tx transaction to encode
+     */
+    static encode(tx: CosmosTxV1Beta1Tx.TxRaw): string;
+    /**
+     * Decode a transaction from base64-encoded protobuf
+     * @param tx transaction string to decode
+     */
+    static decode(encodedTx: string): CosmosTxV1Beta1Tx.TxRaw;
+    /**
+     * Get the transaction's hash
+     * @param tx transaction to hash
+     */
+    static hash(tx: CosmosTxV1Beta1Tx.TxRaw): string;
+}

package/dist/esm/core/tx/utils/classes/TxClient.js

@@ -0,0 +1,25 @@
+import { hashToHex } from '../../../../utils/crypto.js';
+import { CosmosTxV1Beta1Tx } from '@injectivelabs/core-proto-ts';
+export class TxClient {
+    /**
+     * Encode a transaction to base64-encoded protobuf
+     * @param tx transaction to encode
+     */
+    static encode(tx) {
+        return Buffer.from(CosmosTxV1Beta1Tx.TxRaw.encode(tx).finish()).toString('base64');
+    }
+    /**
+     * Decode a transaction from base64-encoded protobuf
+     * @param tx transaction string to decode
+     */
+    static decode(encodedTx) {
+        return CosmosTxV1Beta1Tx.TxRaw.decode(Buffer.from(encodedTx, 'base64'));
+    }
+    /**
+     * Get the transaction's hash
+     * @param tx transaction to hash
+     */
+    static hash(tx) {
+        return hashToHex(TxClient.encode(tx));
+    }
+}

package/dist/esm/core/tx/utils/constants.d.ts

@@ -0,0 +1,5 @@
+import { CosmosTxSigningV1Beta1Signing } from '@injectivelabs/core-proto-ts';
+export declare const SIGN_DIRECT = CosmosTxSigningV1Beta1Signing.SignMode.SIGN_MODE_DIRECT;
+export declare const SIGN_AMINO = CosmosTxSigningV1Beta1Signing.SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
+export declare const SIGN_EIP712 = CosmosTxSigningV1Beta1Signing.SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
+export declare const SIGN_EIP712_V2 = CosmosTxSigningV1Beta1Signing.SignMode.SIGN_MODE_EIP712_V2;

package/dist/esm/core/tx/utils/constants.js

@@ -0,0 +1,5 @@
+import { CosmosTxSigningV1Beta1Signing } from '@injectivelabs/core-proto-ts';
+export const SIGN_DIRECT = CosmosTxSigningV1Beta1Signing.SignMode.SIGN_MODE_DIRECT;
+export const SIGN_AMINO = CosmosTxSigningV1Beta1Signing.SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
+export const SIGN_EIP712 = CosmosTxSigningV1Beta1Signing.SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
+export const SIGN_EIP712_V2 = CosmosTxSigningV1Beta1Signing.SignMode.SIGN_MODE_EIP712_V2;

package/dist/esm/core/tx/utils/helpers.d.ts

@@ -0,0 +1,8 @@
+import { GoogleProtobufAny } from '@injectivelabs/core-proto-ts';
+export declare const createAnyMessage: (msg: {
+    type: string;
+    value: Uint8Array;
+}) => GoogleProtobufAny.Any;
+export declare const createAny: (value: any, type: string) => GoogleProtobufAny.Any;
+export declare const getInjectiveSignerAddress: (address: string | undefined) => string;
+export declare const getEthereumSignerAddress: (address: string | undefined) => string;

package/dist/esm/core/tx/utils/helpers.js

@@ -0,0 +1,38 @@
+import { GoogleProtobufAny } from '@injectivelabs/core-proto-ts';
+import { getEthereumAddress, getInjectiveAddress } from '../../../utils/index.js';
+export const createAnyMessage = (msg) => {
+    const message = GoogleProtobufAny.Any.create();
+    message.typeUrl = `${msg.type.startsWith('/') ? '' : '/'}${msg.type}`;
+    message.value = msg.value;
+    return message;
+};
+export const createAny = (value, type) => {
+    const message = GoogleProtobufAny.Any.create();
+    message.typeUrl = type;
+    message.value = value;
+    return message;
+};
+export const getInjectiveSignerAddress = (address) => {
+    if (!address) {
+        return '';
+    }
+    if (address.startsWith('inj')) {
+        return address;
+    }
+    if (address.startsWith('0x')) {
+        return getInjectiveAddress(address);
+    }
+    return address;
+};
+export const getEthereumSignerAddress = (address) => {
+    if (!address) {
+        return '';
+    }
+    if (address.startsWith('0x')) {
+        return address;
+    }
+    if (address.startsWith('inj')) {
+        return getEthereumAddress(address);
+    }
+    return `0x${address}`;
+};

package/dist/esm/core/tx/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './classes/TxClient.js';
+export * from './api.js';
+export * from './helpers.js';
+export * from './constants.js';
+export * from './tx.js';

package/dist/esm/core/tx/utils/index.js

@@ -0,0 +1,5 @@
+export * from './classes/TxClient.js';
+export * from './api.js';
+export * from './helpers.js';
+export * from './constants.js';
+export * from './tx.js';

package/dist/esm/core/tx/utils/tx.d.ts

@@ -0,0 +1,91 @@
+import { ChainId, EthereumChainId } from '@injectivelabs/ts-types';
+import { Msgs } from '../../modules/msgs.js';
+import { GoogleProtobufAny, CosmosTxV1Beta1Tx, InjectiveTypesV1Beta1TxExt, CosmosTxSigningV1Beta1Signing } from '@injectivelabs/core-proto-ts';
+export declare const getPublicKey: ({ chainId, key, }: {
+    chainId: string;
+    key: string | GoogleProtobufAny.Any;
+}) => GoogleProtobufAny.Any;
+export declare const createBody: ({ message, memo, timeoutHeight, }: {
+    message: Msgs | Msgs[];
+    memo?: string;
+    timeoutHeight?: number;
+}) => CosmosTxV1Beta1Tx.TxBody;
+export declare const createFee: ({ fee, payer, granter, gasLimit, }: {
+    fee: {
+        amount: string;
+        denom: string;
+    };
+    payer?: string;
+    granter?: string;
+    gasLimit: number;
+}) => CosmosTxV1Beta1Tx.Fee;
+export declare const createSigners: ({ chainId, mode, signers, }: {
+    chainId: string;
+    signers: {
+        pubKey: string | GoogleProtobufAny.Any;
+        sequence: number;
+    }[];
+    mode: CosmosTxSigningV1Beta1Signing.SignMode;
+}) => CosmosTxV1Beta1Tx.SignerInfo[];
+export declare const createSignerInfo: ({ chainId, publicKey, sequence, mode, }: {
+    chainId: string;
+    publicKey: string | GoogleProtobufAny.Any;
+    sequence: number;
+    mode: CosmosTxSigningV1Beta1Signing.SignMode;
+}) => CosmosTxV1Beta1Tx.SignerInfo;
+export declare const createAuthInfo: ({ signerInfo, fee, }: {
+    signerInfo: CosmosTxV1Beta1Tx.SignerInfo[];
+    fee: CosmosTxV1Beta1Tx.Fee;
+}) => CosmosTxV1Beta1Tx.AuthInfo;
+export declare const createSignDoc: ({ bodyBytes, authInfoBytes, chainId, accountNumber, }: {
+    bodyBytes: Uint8Array;
+    authInfoBytes: Uint8Array;
+    chainId: string;
+    accountNumber: number;
+}) => CosmosTxV1Beta1Tx.SignDoc;
+export declare const createSignDocFromTransaction: (args: {
+    txRaw: CosmosTxV1Beta1Tx.TxRaw;
+    chainId: string;
+    accountNumber: number;
+}) => CosmosTxV1Beta1Tx.SignDoc;
+export declare const createTxRawEIP712: (txRaw: CosmosTxV1Beta1Tx.TxRaw, extension: InjectiveTypesV1Beta1TxExt.ExtensionOptionsWeb3Tx, nonCriticalExtension?: GoogleProtobufAny.Any | GoogleProtobufAny.Any[]) => CosmosTxV1Beta1Tx.TxRaw;
+export declare const createWeb3Extension: ({ ethereumChainId, feePayer, feePayerSig, }: {
+    ethereumChainId: EthereumChainId;
+    feePayer?: string;
+    feePayerSig?: Uint8Array;
+}) => InjectiveTypesV1Beta1TxExt.ExtensionOptionsWeb3Tx;
+export declare const createNonCriticalExtensionFromObject: (object: Record<string, unknown>) => GoogleProtobufAny.Any;
+export declare const getTransactionPartsFromTxRaw: (txRaw: CosmosTxV1Beta1Tx.TxRaw) => {
+    authInfo: CosmosTxV1Beta1Tx.AuthInfo;
+    body: CosmosTxV1Beta1Tx.TxBody;
+    signatures: Uint8Array[];
+};
+export declare const getAminoStdSignDoc: ({ memo, chainId, accountNumber, timeoutHeight, sequence, gas, msgs, }: {
+    memo?: string;
+    chainId: ChainId;
+    timeoutHeight?: string;
+    accountNumber: number;
+    sequence: number;
+    gas?: string;
+    msgs: Msgs[];
+}) => {
+    chain_id: ChainId;
+    timeout_height: string;
+    account_number: string;
+    sequence: string;
+    fee: {
+        amount: {
+            denom: string;
+            amount: string;
+        }[];
+        gas: string;
+        payer: string | undefined;
+        granter: string | undefined;
+        feePayer: string | undefined;
+    };
+    msgs: {
+        type: string;
+        value: any;
+    }[];
+    memo: string;
+};

package/dist/esm/core/tx/utils/tx.js

@@ -0,0 +1,144 @@
+import { createAny, createAnyMessage } from './helpers.js';
+import { CosmosTxV1Beta1Tx, GoogleProtobufStruct, CosmosBaseV1Beta1Coin, InjectiveTypesV1Beta1TxExt, CosmosCryptoSecp256k1Keys, } from '@injectivelabs/core-proto-ts';
+import { getStdFee } from '@injectivelabs/utils';
+export const getPublicKey = ({ chainId, key, }) => {
+    if (typeof key !== 'string') {
+        return key;
+    }
+    let proto;
+    let path;
+    let baseProto;
+    if (chainId.startsWith('injective')) {
+        proto = CosmosCryptoSecp256k1Keys.PubKey.create();
+        baseProto = CosmosCryptoSecp256k1Keys.PubKey;
+        path = '/injective.crypto.v1beta1.ethsecp256k1.PubKey';
+    }
+    else if (chainId.startsWith('evmos')) {
+        proto = CosmosCryptoSecp256k1Keys.PubKey.create();
+        baseProto = CosmosCryptoSecp256k1Keys.PubKey;
+        path = '/ethermint.crypto.v1.ethsecp256k1.PubKey';
+    }
+    else {
+        proto = CosmosCryptoSecp256k1Keys.PubKey.create();
+        baseProto = CosmosCryptoSecp256k1Keys.PubKey;
+        path = '/cosmos.crypto.secp256k1.PubKey';
+    }
+    proto.key = Buffer.from(key, 'base64');
+    return createAny(baseProto.encode(proto).finish(), path);
+};
+export const createBody = ({ message, memo = '', timeoutHeight, }) => {
+    const messages = Array.isArray(message) ? message : [message];
+    const txBody = CosmosTxV1Beta1Tx.TxBody.create();
+    txBody.messages = messages.map((message) => createAnyMessage({
+        value: message.toBinary(),
+        type: message.toDirectSign().type,
+    }));
+    txBody.memo = memo;
+    if (timeoutHeight) {
+        txBody.timeoutHeight = timeoutHeight.toString();
+    }
+    return txBody;
+};
+export const createFee = ({ fee, payer, granter, gasLimit, }) => {
+    const feeAmount = CosmosBaseV1Beta1Coin.Coin.create();
+    feeAmount.amount = fee.amount;
+    feeAmount.denom = fee.denom;
+    const feeProto = CosmosTxV1Beta1Tx.Fee.create();
+    feeProto.gasLimit = gasLimit.toString();
+    feeProto.amount = [feeAmount];
+    if (payer) {
+        feeProto.payer = payer;
+    }
+    if (granter) {
+        feeProto.granter = granter;
+    }
+    return feeProto;
+};
+export const createSigners = ({ chainId, mode, signers, }) => {
+    return signers.map((s) => createSignerInfo({
+        mode,
+        chainId,
+        publicKey: s.pubKey,
+        sequence: s.sequence,
+    }));
+};
+export const createSignerInfo = ({ chainId, publicKey, sequence, mode, }) => {
+    const pubKey = getPublicKey({ chainId, key: publicKey });
+    const single = CosmosTxV1Beta1Tx.ModeInfo_Single.create();
+    single.mode = mode;
+    const modeInfo = CosmosTxV1Beta1Tx.ModeInfo.create();
+    modeInfo.single = single;
+    const signerInfo = CosmosTxV1Beta1Tx.SignerInfo.create();
+    signerInfo.publicKey = pubKey;
+    signerInfo.sequence = sequence.toString();
+    signerInfo.modeInfo = modeInfo;
+    return signerInfo;
+};
+export const createAuthInfo = ({ signerInfo, fee, }) => {
+    const authInfo = CosmosTxV1Beta1Tx.AuthInfo.create();
+    authInfo.signerInfos = signerInfo;
+    authInfo.fee = fee;
+    return authInfo;
+};
+export const createSignDoc = ({ bodyBytes, authInfoBytes, chainId, accountNumber, }) => {
+    const signDoc = CosmosTxV1Beta1Tx.SignDoc.create();
+    signDoc.accountNumber = accountNumber.toString();
+    signDoc.chainId = chainId;
+    signDoc.bodyBytes = bodyBytes;
+    signDoc.authInfoBytes = authInfoBytes;
+    return signDoc;
+};
+export const createSignDocFromTransaction = (args) => {
+    return CosmosTxV1Beta1Tx.SignDoc.fromPartial({
+        bodyBytes: args.txRaw.bodyBytes,
+        authInfoBytes: args.txRaw.authInfoBytes,
+        accountNumber: args.accountNumber.toString(),
+        chainId: args.chainId,
+    });
+};
+export const createTxRawEIP712 = (txRaw, extension, nonCriticalExtension) => {
+    const body = CosmosTxV1Beta1Tx.TxBody.decode(txRaw.bodyBytes);
+    const extensionAny = createAny(InjectiveTypesV1Beta1TxExt.ExtensionOptionsWeb3Tx.encode(extension).finish(), '/injective.types.v1beta1.ExtensionOptionsWeb3Tx');
+    body.extensionOptions = [extensionAny];
+    if (nonCriticalExtension) {
+        body.nonCriticalExtensionOptions = Array.isArray(nonCriticalExtension)
+            ? nonCriticalExtension
+            : [nonCriticalExtension];
+    }
+    txRaw.bodyBytes = CosmosTxV1Beta1Tx.TxBody.encode(body).finish();
+    return txRaw;
+};
+export const createWeb3Extension = ({ ethereumChainId, feePayer, feePayerSig, }) => {
+    const web3Extension = InjectiveTypesV1Beta1TxExt.ExtensionOptionsWeb3Tx.create();
+    web3Extension.typedDataChainID = ethereumChainId.toString();
+    if (feePayer) {
+        web3Extension.feePayer = feePayer;
+    }
+    if (feePayerSig) {
+        web3Extension.feePayerSig = feePayerSig;
+    }
+    return web3Extension;
+};
+export const createNonCriticalExtensionFromObject = (object) => {
+    const nonCriticalExtension = GoogleProtobufStruct.Struct.create();
+    nonCriticalExtension.fields = object;
+    return createAny(GoogleProtobufStruct.Struct.encode(nonCriticalExtension).finish(), '/google.protobuf.Struct');
+};
+export const getTransactionPartsFromTxRaw = (txRaw) => {
+    const authInfo = CosmosTxV1Beta1Tx.AuthInfo.decode(txRaw.authInfoBytes);
+    const body = CosmosTxV1Beta1Tx.TxBody.decode(txRaw.bodyBytes);
+    return {
+        body,
+        authInfo,
+        signatures: txRaw.signatures,
+    };
+};
+export const getAminoStdSignDoc = ({ memo, chainId, accountNumber, timeoutHeight, sequence, gas, msgs, }) => ({
+    chain_id: chainId,
+    timeout_height: timeoutHeight || '',
+    account_number: accountNumber.toString(),
+    sequence: sequence.toString(),
+    fee: getStdFee({ gas }),
+    msgs: msgs.map((m) => m.toAmino()),
+    memo: memo || '',
+});

package/dist/esm/core/utils/coins.d.ts

@@ -0,0 +1,4 @@
+export declare const parseCoins: (input: string) => {
+    amount: string;
+    denom: string;
+}[];

package/dist/esm/core/utils/coins.js

@@ -0,0 +1,15 @@
+export const parseCoins = (input) => {
+    return input
+        .replace(/\s/g, '')
+        .split(',')
+        .filter(Boolean)
+        .map((part) => {
+        const match = part.match(/^([0-9]+)([a-zA-Z][a-zA-Z0-9/]{2,127})$/);
+        if (!match)
+            throw new Error('Got an invalid coin string');
+        return {
+            amount: match[1].replace(/^0+/, '') || '0',
+            denom: match[2],
+        };
+    });
+};

package/dist/esm/core/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './coins.js';

package/dist/esm/core/utils/index.js

@@ -0,0 +1 @@
+export * from './coins.js';

package/dist/esm/cosmjs.d.ts

@@ -0,0 +1,5 @@
+import MsgTransferCosmjs from './core/modules/ibc/msgs/MsgTransferCosmjs.js';
+import { accountParser as injectiveAccountParser } from './core/accounts/AccountParser.js';
+export * from './core/accounts/signers/index.js';
+export * from './core/stargate/index.js';
+export { MsgTransferCosmjs, injectiveAccountParser };

package/dist/esm/cosmjs.js

@@ -0,0 +1,5 @@
+import MsgTransferCosmjs from './core/modules/ibc/msgs/MsgTransferCosmjs.js';
+import { accountParser as injectiveAccountParser } from './core/accounts/AccountParser.js';
+export * from './core/accounts/signers/index.js';
+export * from './core/stargate/index.js';
+export { MsgTransferCosmjs, injectiveAccountParser };

package/dist/esm/exports.d.ts

@@ -0,0 +1,6 @@
+import MsgTransferCosmjs from './core/modules/ibc/msgs/MsgTransferCosmjs.js';
+import { accountParser as injectiveAccountParser } from './core/accounts/AccountParser.js';
+/** @deprecated use @injectivelabs/sdk-ts/cosmjs */
+export * from './core/accounts/signers/index.js';
+export * from './core/stargate/index.js';
+export { MsgTransferCosmjs, injectiveAccountParser };

package/dist/esm/exports.js

@@ -0,0 +1,6 @@
+import MsgTransferCosmjs from './core/modules/ibc/msgs/MsgTransferCosmjs.js';
+import { accountParser as injectiveAccountParser } from './core/accounts/AccountParser.js';
+/** @deprecated use @injectivelabs/sdk-ts/cosmjs */
+export * from './core/accounts/signers/index.js';
+export * from './core/stargate/index.js';
+export { MsgTransferCosmjs, injectiveAccountParser };

package/dist/esm/index.d.ts

@@ -0,0 +1,7 @@
+export * from './core/index.js';
+export * from './client/index.js';
+export * from './utils/index.js';
+export * from './service/index.js';
+export * from './types/index.js';
+export * from './json/index.js';
+export * from './core/accounts/AccountParserNoCosmjs.js';

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+export * from './core/index.js';
+export * from './client/index.js';
+export * from './utils/index.js';
+export * from './service/index.js';
+export * from './types/index.js';
+export * from './json/index.js';
+export * from './core/accounts/AccountParserNoCosmjs.js';

package/dist/esm/json/index.d.ts

@@ -0,0 +1 @@
+export * from './ofac.js';

package/dist/esm/json/index.js

@@ -0,0 +1 @@
+export * from './ofac.js';

package/dist/esm/json/ofac.d.ts

@@ -0,0 +1 @@
+export declare const ofacWallets: string[];

package/dist/esm/json/ofac.js

@@ -0,0 +1,48 @@
+export const ofacWallets = [
+    "0x179f48c78f57a3a78f0608cc9197b8972921d1d2",
+    "0x1967d8af5bd86a497fb3dd7899a020e47560daaf",
+    "0x19aa5fe80d33a56d56c78e82ea5e50e5d80b4dff",
+    "0x19aa5fe80d33a56d56c78e82ea5e50e5d80b4dff",
+    "0x1da5821544e25c636c1417ba96ade4cf6d2f9b5a",
+    "0x2f389ce8bd8ff92de3402ffce4691d17fc4f6535",
+    "0x2f389ce8bd8ff92de3402ffce4691d17fc4f6535",
+    "0x2f50508a8a3d323b91336fa3ea6ae50e55f32185",
+    "0x308ed4b7b49797e1a98d3818bff6fe5385410370",
+    "0x3cbded43efdaf0fc77b9c55f6fc9988fcc9b757d",
+    "0x3efa30704d2b8bbac821307230376556cf8cc39e",
+    "0x48549a34ae37b12f6a30566245176994e17c6b4a",
+    "0x4f47bc496083c727c5fbe3ce9cdf2b0f6496270c",
+    "0x4f47bc496083c727c5fbe3ce9cdf2b0f6496270c",
+    "0x4f47bc496083c727c5fbe3ce9cdf2b0f6496270c",
+    "0x530a64c0ce595026a4a556b703644228179e2d57",
+    "0x5512d943ed1f7c8a43f3435c85f7ab68b30121b0",
+    "0x5a7a51bfb49f190e5a6060a5bc6052ac14a3b59f",
+    "0x5f48c2a71b2cc96e3f0ccae4e39318ff0dc375b2",
+    "0x6be0ae71e6c41f2f9d0d1a3b8d0f75e6f6a0b46e",
+    "0x6f1ca141a28907f78ebaa64fb83a9088b02a8352",
+    "0x746aebc06d2ae31b71ac51429a19d54e797878e9",
+    "0x77777feddddffc19ff86db637967013e6c6a116c",
+    "0x797d7ae72ebddcdea2a346c1834e04d1f8df102b",
+    "0x8576acc5c05d6ce88f4e49bf65bdf0c62f91353c",
+    "0x901bb9583b24d97e995513c6778dc6888ab6870e",
+    "0x961c5be54a2ffc17cf4cb021d863c42dacd47fc1",
+    "0x97b1043abd9e6fc31681635166d430a458d14f9c",
+    "0x9c2bc757b66f24d60f016b6237f8cdd414a879fa",
+    "0x9f4cda013e354b8fc285bf4b9a60460cee7f7ea9",
+    "0xa7e5d5a720f06526557c513402f2e6b5fa20b008",
+    "0xb6f5ec1a0a9cd1526536d3f0426c429529471f40",
+    "0xb6f5ec1a0a9cd1526536d3f0426c429529471f40",
+    "0xb6f5ec1a0a9cd1526536d3f0426c429529471f40",
+    "0xc455f7fd3e0e12afd51fba5c106909934d8a0e4a",
+    "0xca0840578f57fe71599d29375e16783424023357",
+    "0xd0975b32cea532eadddfc9c60481976e39db3472",
+    "0xd882cfc20f52f2599d84b8e8d58c7fb62cfe344b",
+    "0xd882cfc20f52f2599d84b8e8d58c7fb62cfe344b",
+    "0xe1d865c3d669dcc8c57c8d023140cb204e672ee4",
+    "0xe7aa314c77f4233c18c6cc84384a9247c0cf367b",
+    "0xed6e0a7e4ac94d976eebfb82ccf777a3c6bad921",
+    "0xf3701f445b6bdafedbca97d1e477357839e4120d",
+    "0xfac583c0cf07ea434052c49115a4682172ab6b4f",
+    "0xfec8a60023265364d066a1212fde3930f6ae8da7",
+    "0xffbac21a641dcfe4552920138d90f3638b3c9fba"
+];

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/dist/esm/service/TokenFactoryStatic.d.ts

@@ -0,0 +1,16 @@
+import { TokenType, TokenSource, TokenStatic, TokenVerification } from './../types/index.js';
+/** @deprecated */
+export declare class TokenFactoryStatic {
+    registry: TokenStatic[];
+    tokensByDenom: Record<string, TokenStatic>;
+    tokensBySymbol: Record<string, TokenStatic[]>;
+    tokensByAddress: Record<string, TokenStatic[]>;
+    constructor(registry: TokenStatic[]);
+    toToken(denom: string): TokenStatic | undefined;
+    getMetaBySymbol(symbol: string, { type, source, verification, }?: {
+        source?: TokenSource;
+        type?: TokenType;
+        verification?: TokenVerification;
+    }): TokenStatic | undefined;
+    getMetaByDenomOrAddress(denomOrAddress: string): TokenStatic | undefined;
+}