@ark-us/wasmx-stargate 0.0.11 → 0.0.12

package/src/modules/wasmx/aminomessages.spec.ts

@@ -1,258 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { fromBase64, toUtf8 } from "@cosmjs/encoding";
-import { AminoTypes, coins } from "@cosmjs/stargate";
-import {
-  MsgExecuteContract,
-  MsgInstantiateContract,
-  MsgStoreCode,
-  MsgDeployCode,
-} from "@ark-us/wasmxjs";
-import Long from 'long';
-
-import {
-  AminoMsgExecuteContract,
-  AminoMsgInstantiateContract,
-  AminoMsgStoreCode,
-  AminoMsgDeployCode,
-  createWasmAminoConverters,
-} from "./aminomessages";
-
-describe("AminoTypes", () => {
-  describe("toAmino", () => {
-    it("works for MsgStoreCode", () => {
-      const msg: MsgStoreCode = {
-        sender: "cosmos1pkptre7fdkl6gfrzlesjjvhxhlc3r4gmmk8rs6",
-        byteCode: fromBase64("WUVMTE9XIFNVQk1BUklORQ=="),
-        deps: [],
-      };
-      const aminoMsg = new AminoTypes(createWasmAminoConverters()).toAmino({
-        typeUrl: "/mythos.wasmx.v1.MsgStoreCode",
-        value: msg,
-      });
-      const expected: AminoMsgStoreCode = {
-        type: "wasmx/MsgStoreCode",
-        value: {
-          sender: "cosmos1pkptre7fdkl6gfrzlesjjvhxhlc3r4gmmk8rs6",
-          byte_code: "WUVMTE9XIFNVQk1BUklORQ==",
-          metadata: {name: "", categ: [], icon: "", author: "", site: "", abi: new Uint8Array(0), jsonSchema: ""},
-          deps: [],
-        },
-      };
-      expect(aminoMsg).toEqual(expected);
-    });
-
-    it("works for MsgDeployCode", () => {
-      const msg: MsgDeployCode = {
-        sender: "cosmos1pkptre7fdkl6gfrzlesjjvhxhlc3r4gmmk8rs6",
-        byteCode: fromBase64("WUVMTE9XIFNVQk1BUklORQ=="),
-        deps: [],
-        msg: toUtf8(`{"data":"0x"}`),
-        funds: coins(0, "ucosm"),
-        label: "label",
-      };
-      const aminoMsg = new AminoTypes(createWasmAminoConverters()).toAmino({
-        typeUrl: "/mythos.wasmx.v1.MsgDeployCode",
-        value: msg,
-      });
-      const expected: AminoMsgDeployCode = {
-        type: "wasmx/MsgDeployCode",
-        value: {
-          sender: "cosmos1pkptre7fdkl6gfrzlesjjvhxhlc3r4gmmk8rs6",
-          byte_code: "WUVMTE9XIFNVQk1BUklORQ==",
-          metadata: {name: "", categ: [], icon: "", author: "", site: "", abi: new Uint8Array(0), jsonSchema: ""},
-          deps: [],
-          msg: {"data":"0x"},
-          funds: coins(0, "ucosm"),
-          label: "label",
-        },
-      };
-      expect(aminoMsg).toEqual(expected);
-    });
-
-    it("works for MsgInstantiateContract", () => {
-      // With admin
-      {
-        const msg: MsgInstantiateContract = {
-          sender: "cosmos1pkptre7fdkl6gfrzlesjjvhxhlc3r4gmmk8rs6",
-          // @ts-ignore
-          codeId: Long.fromString("12345"),
-          label: "sticky",
-          msg: toUtf8(`{"foo":"bar"}`),
-          funds: coins(1234, "ucosm"),
-        };
-        const aminoMsg = new AminoTypes(createWasmAminoConverters()).toAmino({
-          typeUrl: "/mythos.wasmx.v1.MsgInstantiateContract",
-          value: msg,
-        });
-        const expected: AminoMsgInstantiateContract = {
-          type: "wasmx/MsgInstantiateContract",
-          value: {
-            sender: "cosmos1pkptre7fdkl6gfrzlesjjvhxhlc3r4gmmk8rs6",
-            code_id: "12345",
-            label: "sticky",
-            msg: { foo: "bar" },
-            funds: coins(1234, "ucosm"),
-          },
-        };
-        expect(aminoMsg).toEqual(expected);
-      }
-
-      // Without admin
-      {
-        const msg: MsgInstantiateContract = {
-          sender: "cosmos1pkptre7fdkl6gfrzlesjjvhxhlc3r4gmmk8rs6",
-          // @ts-ignore
-          codeId: Long.fromString("12345"),
-          label: "sticky",
-          msg: toUtf8(`{"foo":"bar"}`),
-          funds: coins(1234, "ucosm"),
-        };
-        const aminoMsg = new AminoTypes(createWasmAminoConverters()).toAmino({
-          typeUrl: "/mythos.wasmx.v1.MsgInstantiateContract",
-          value: msg,
-        });
-        const expected: AminoMsgInstantiateContract = {
-          type: "wasmx/MsgInstantiateContract",
-          value: {
-            sender: "cosmos1pkptre7fdkl6gfrzlesjjvhxhlc3r4gmmk8rs6",
-            code_id: "12345",
-            label: "sticky",
-            msg: { foo: "bar" },
-            funds: coins(1234, "ucosm"),
-          },
-        };
-        expect(aminoMsg).toEqual(expected);
-      }
-    });
-
-    it("works for MsgExecuteContract", () => {
-      const msg: MsgExecuteContract = {
-        sender: "cosmos1pkptre7fdkl6gfrzlesjjvhxhlc3r4gmmk8rs6",
-        contract: "cosmos1xy4yqngt0nlkdcenxymg8tenrghmek4nmqm28k",
-        msg: toUtf8(`{"foo":"bar"}`),
-        funds: coins(1234, "ucosm"),
-        dependencies: [],
-      };
-      const aminoMsg = new AminoTypes(createWasmAminoConverters()).toAmino({
-        typeUrl: "/mythos.wasmx.v1.MsgExecuteContract",
-        value: msg,
-      });
-      const expected: AminoMsgExecuteContract = {
-        type: "wasmx/MsgExecuteContract",
-        value: {
-          sender: "cosmos1pkptre7fdkl6gfrzlesjjvhxhlc3r4gmmk8rs6",
-          contract: "cosmos1xy4yqngt0nlkdcenxymg8tenrghmek4nmqm28k",
-          msg: { foo: "bar" },
-          funds: coins(1234, "ucosm"),
-          dependencies: [],
-        },
-      };
-      expect(aminoMsg).toEqual(expected);
-    });
-  })
-
-  describe("fromAmino", () => {
-    it("works for MsgStoreCode", () => {
-      const aminoMsg: AminoMsgStoreCode = {
-        type: "wasmx/MsgStoreCode",
-        value: {
-          sender: "cosmos1pkptre7fdkl6gfrzlesjjvhxhlc3r4gmmk8rs6",
-          byte_code: "WUVMTE9XIFNVQk1BUklORQ==",
-          metadata: {name: "", categ: [], icon: "", author: "", site: "", abi: new Uint8Array(0), jsonSchema: ""},
-          deps: [],
-        },
-      };
-      const msg = new AminoTypes(createWasmAminoConverters()).fromAmino(aminoMsg);
-      const expectedValue: MsgStoreCode = {
-        sender: "cosmos1pkptre7fdkl6gfrzlesjjvhxhlc3r4gmmk8rs6",
-        byteCode: fromBase64("WUVMTE9XIFNVQk1BUklORQ=="),
-        deps: [],
-      };
-      expect(msg).toEqual({
-        typeUrl: "/mythos.wasmx.v1.MsgStoreCode",
-        value: expectedValue,
-      });
-    });
-
-    it("works for MsgInstantiateContract", () => {
-      // With admin
-      {
-        const aminoMsg: AminoMsgInstantiateContract = {
-          type: "wasmx/MsgInstantiateContract",
-          value: {
-            sender: "cosmos1pkptre7fdkl6gfrzlesjjvhxhlc3r4gmmk8rs6",
-            code_id: "12345",
-            label: "sticky",
-            msg: { foo: "bar" },
-            funds: coins(1234, "ucosm"),
-          },
-        };
-        const msg = new AminoTypes(createWasmAminoConverters()).fromAmino(aminoMsg);
-        const expectedValue: MsgInstantiateContract = {
-          sender: "cosmos1pkptre7fdkl6gfrzlesjjvhxhlc3r4gmmk8rs6",
-          // @ts-ignore
-          codeId: Long.fromString("12345"),
-          label: "sticky",
-          msg: toUtf8(`{"foo":"bar"}`),
-          funds: coins(1234, "ucosm"),
-        };
-        expect(msg).toEqual({
-          typeUrl: "/mythos.wasmx.v1.MsgInstantiateContract",
-          value: expectedValue,
-        });
-      }
-
-      // Without admin
-      {
-        const aminoMsg: AminoMsgInstantiateContract = {
-          type: "wasmx/MsgInstantiateContract",
-          value: {
-            sender: "cosmos1pkptre7fdkl6gfrzlesjjvhxhlc3r4gmmk8rs6",
-            code_id: "12345",
-            label: "sticky",
-            msg: { foo: "bar" },
-            funds: coins(1234, "ucosm"),
-          },
-        };
-        const msg = new AminoTypes(createWasmAminoConverters()).fromAmino(aminoMsg);
-        const expectedValue: MsgInstantiateContract = {
-          sender: "cosmos1pkptre7fdkl6gfrzlesjjvhxhlc3r4gmmk8rs6",
-          // @ts-ignore
-          codeId: Long.fromString("12345"),
-          label: "sticky",
-          msg: toUtf8(`{"foo":"bar"}`),
-          funds: coins(1234, "ucosm"),
-        };
-        expect(msg).toEqual({
-          typeUrl: "/mythos.wasmx.v1.MsgInstantiateContract",
-          value: expectedValue,
-        });
-      }
-    });
-
-    it("works for MsgExecuteContract", () => {
-      const aminoMsg: AminoMsgExecuteContract = {
-        type: "wasmx/MsgExecuteContract",
-        value: {
-          sender: "cosmos1pkptre7fdkl6gfrzlesjjvhxhlc3r4gmmk8rs6",
-          contract: "cosmos1xy4yqngt0nlkdcenxymg8tenrghmek4nmqm28k",
-          msg: { foo: "bar" },
-          funds: coins(1234, "ucosm"),
-          dependencies: [],
-        },
-      };
-      const msg = new AminoTypes(createWasmAminoConverters()).fromAmino(aminoMsg);
-      const expectedValue: MsgExecuteContract = {
-        sender: "cosmos1pkptre7fdkl6gfrzlesjjvhxhlc3r4gmmk8rs6",
-        contract: "cosmos1xy4yqngt0nlkdcenxymg8tenrghmek4nmqm28k",
-        msg: toUtf8(`{"foo":"bar"}`),
-        funds: coins(1234, "ucosm"),
-        dependencies: [],
-      };
-      expect(msg).toEqual({
-        typeUrl: "/mythos.wasmx.v1.MsgExecuteContract",
-        value: expectedValue,
-      });
-    });
-  });
-});

package/src/modules/wasmx/aminomessages.ts

@@ -1,177 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { fromBase64, fromUtf8, toBase64, toUtf8 } from "@cosmjs/encoding";
-import { AminoConverters, Coin } from "@cosmjs/stargate";
-import {
-  CodeMetadataPB,
-  MsgExecuteContract,
-  MsgInstantiateContract,
-  MsgStoreCode,
-  MsgDeployCode,
-} from "@ark-us/wasmxjs";
-import Long from 'long';
-
-/**
- * The Amino JSON representation of [MsgStoreCode].
- */
-export interface AminoMsgStoreCode {
-  type: "wasmx/MsgStoreCode";
-  value: {
-    /** Bech32 account address */
-    readonly sender: string;
-    /** Base64 encoded Wasm */
-    readonly byte_code: string;
-    readonly deps: string[];
-    readonly metadata: CodeMetadataPB;
-  };
-}
-
-/**
- * The Amino JSON representation of [MsgDeployCode].
- */
-export interface AminoMsgDeployCode {
-  type: "wasmx/MsgDeployCode";
-  value: {
-    /** Bech32 account address */
-    readonly sender: string;
-    /** Base64 encoded Wasm */
-    readonly byte_code: string;
-    readonly deps: string[];
-    readonly metadata: CodeMetadataPB;
-    /** Instantiate message as JavaScript object */
-    readonly msg: any;
-    readonly funds: readonly Coin[];
-    readonly label: string;
-  };
-}
-
-/**
- * The Amino JSON representation of [MsgExecuteContract].
- */
-export interface AminoMsgExecuteContract {
-  type: "wasmx/MsgExecuteContract";
-  value: {
-    /** Bech32 account address */
-    readonly sender: string;
-    /** Bech32 account address */
-    readonly contract: string;
-    /** Execute message as JavaScript object */
-    readonly msg: any;
-    readonly funds: readonly Coin[];
-    readonly dependencies: string[];
-  };
-}
-
-/**
- * The Amino JSON representation of [MsgInstantiateContract].
- */
-export interface AminoMsgInstantiateContract {
-  type: "wasmx/MsgInstantiateContract";
-  value: {
-    /** Bech32 account address */
-    readonly sender: string;
-    /** ID of the Wasm code that was uploaded before */
-    readonly code_id: string;
-    /** Human-readable label for this contract */
-    readonly label: string;
-    /** Instantiate message as JavaScript object */
-    readonly msg: any;
-    readonly funds: readonly Coin[];
-  };
-}
-
-export function createWasmAminoConverters(): AminoConverters {
-  return {
-    "/mythos.wasmx.v1.MsgStoreCode": {
-      aminoType: "wasm/MsgStoreCode",
-      toAmino: ({ sender, byteCode, metadata, deps }: MsgStoreCode): AminoMsgStoreCode["value"] => ({
-        sender: sender,
-        byte_code: toBase64(byteCode),
-        metadata: metadata || CodeMetadataPB.fromPartial({}),
-        deps: deps,
-      }),
-      fromAmino: ({ sender, byte_code, deps, metadata }: AminoMsgStoreCode["value"]): MsgStoreCode => ({
-        sender: sender,
-        byteCode: fromBase64(byte_code),
-        deps: deps,
-        metadata: metadata || CodeMetadataPB.fromPartial({}),
-      }),
-    },
-    "/mythos.wasmx.v1.MsgDeployCode": {
-      aminoType: "wasm/MsgDeployCode",
-      toAmino: ({ sender, byteCode, metadata, deps, msg, funds, label }: MsgDeployCode): AminoMsgDeployCode["value"] => ({
-        sender: sender,
-        byte_code: toBase64(byteCode),
-        metadata: metadata || CodeMetadataPB.fromPartial({}),
-        deps: deps,
-        msg: JSON.parse(fromUtf8(msg)),
-        funds: funds,
-        label: label,
-      }),
-      fromAmino: ({ sender, byte_code, metadata, deps, msg, funds, label }: AminoMsgDeployCode["value"]): MsgDeployCode => ({
-        sender: sender,
-        byteCode: fromBase64(byte_code),
-        deps: deps,
-        label: label,
-        msg: toUtf8(JSON.stringify(msg)),
-        funds: [...funds],
-        metadata: metadata || CodeMetadataPB.fromPartial({}),
-      }),
-    },
-    "/mythos.wasmx.v1.MsgInstantiateContract": {
-      aminoType: "wasm/MsgInstantiateContract",
-      toAmino: ({
-        sender,
-        codeId,
-        label,
-        msg,
-        funds,
-      }: MsgInstantiateContract): AminoMsgInstantiateContract["value"] => ({
-        sender: sender,
-        code_id: codeId.toString(),
-        label: label,
-        msg: JSON.parse(fromUtf8(msg)),
-        funds: funds,
-      }),
-      fromAmino: ({
-        sender,
-        code_id,
-        label,
-        msg,
-        funds,
-      }: AminoMsgInstantiateContract["value"]): MsgInstantiateContract => ({
-        sender: sender,
-        // @ts-ignore
-        codeId: Long.fromString(code_id),
-        label: label,
-        msg: toUtf8(JSON.stringify(msg)),
-        funds: [...funds],
-      }),
-    },
-    "/mythos.wasmx.v1.MsgExecuteContract": {
-      aminoType: "wasm/MsgExecuteContract",
-      toAmino: ({ sender, contract, msg, funds, dependencies }: MsgExecuteContract): AminoMsgExecuteContract["value"] => ({
-        sender: sender,
-        contract: contract,
-        msg: JSON.parse(fromUtf8(msg)),
-        funds: funds,
-        dependencies: dependencies,
-      }),
-      fromAmino: ({
-        sender,
-        contract,
-        msg,
-        funds,
-        dependencies,
-      }: AminoMsgExecuteContract["value"]): MsgExecuteContract => ({
-        sender: sender,
-        contract: contract,
-        msg: toUtf8(JSON.stringify(msg)),
-        funds: [...funds],
-        dependencies: [...dependencies]
-      }),
-    },
-  };
-}
-
-/** @deprecated use `createWasmAminoConverters()` */
-export const wasmXTypes: AminoConverters = createWasmAminoConverters();

package/src/modules/wasmx/messages.ts

@@ -1,54 +0,0 @@
-import { EncodeObject, GeneratedType } from "@cosmjs/proto-signing";
-import {
-  MsgExecuteContract,
-  MsgInstantiateContract,
-  MsgStoreCode,
-  MsgDeployCode,
-} from "@ark-us/wasmxjs";
-
-export const wasmTypes: ReadonlyArray<[string, GeneratedType]> = [
-  ["/mythos.wasmx.v1.MsgExecuteContract", MsgExecuteContract],
-  ["/mythos.wasmx.v1.MsgStoreCode", MsgStoreCode],
-  ["/mythos.wasmx.v1.MsgDeployCode", MsgDeployCode],
-  ["/mythos.wasmx.v1.MsgInstantiateContract", MsgInstantiateContract],
-];
-
-export interface MsgStoreCodeEncodeObject extends EncodeObject {
-  readonly typeUrl: "/mythos.wasmx.v1.MsgStoreCode";
-  readonly value: Partial<MsgStoreCode>;
-}
-
-export function isMsgStoreCodeEncodeObject(object: EncodeObject): object is MsgStoreCodeEncodeObject {
-  return (object as MsgStoreCodeEncodeObject).typeUrl === "/mythos.wasmx.v1.MsgStoreCode";
-}
-
-export interface MsgDeployCodeEncodeObject extends EncodeObject {
-  readonly typeUrl: "/mythos.wasmx.v1.MsgDeployCode";
-  readonly value: Partial<MsgDeployCode>;
-}
-
-export function isMsgDeployCodeEncodeObject(object: EncodeObject): object is MsgDeployCodeEncodeObject {
-  return (object as MsgDeployCodeEncodeObject).typeUrl === "/mythos.wasmx.v1.MsgDeployCode";
-}
-
-export interface MsgInstantiateContractEncodeObject extends EncodeObject {
-  readonly typeUrl: "/mythos.wasmx.v1.MsgInstantiateContract";
-  readonly value: Partial<MsgInstantiateContract>;
-}
-
-export function isMsgInstantiateContractEncodeObject(
-  object: EncodeObject,
-): object is MsgInstantiateContractEncodeObject {
-  return (
-    (object as MsgInstantiateContractEncodeObject).typeUrl === "/mythos.wasmx.v1.MsgInstantiateContract"
-  );
-}
-
-export interface MsgExecuteContractEncodeObject extends EncodeObject {
-  readonly typeUrl: "/mythos.wasmx.v1.MsgExecuteContract";
-  readonly value: Partial<MsgExecuteContract>;
-}
-
-export function isMsgExecuteEncodeObject(object: EncodeObject): object is MsgExecuteContractEncodeObject {
-  return (object as MsgExecuteContractEncodeObject).typeUrl === "/mythos.wasmx.v1.MsgExecuteContract";
-}

package/src/modules/wasmx/queries.ts

@@ -1,141 +0,0 @@
-import { fromUtf8, toUtf8 } from "@cosmjs/encoding";
-import { createPagination, createProtobufRpcClient, QueryClient, Coin } from "@cosmjs/stargate";
-import {
-  QueryAllContractStateResponse,
-  QueryCodeResponse,
-  QueryCodeInfoResponse,
-  QueryCodesResponse,
-  QueryContractInfoResponse,
-  QueryContractsByCodeResponse,
-  QueryRawContractStateResponse,
-  QueryClientImpl,
-} from "@ark-us/wasmxjs";
-import Long from 'long';
-
-/**
- * An object containing a parsed JSON document. The result of JSON.parse().
- * This doesn't provide any type safety over `any` but expresses intent in the code.
- *
- * This type is returned by `queryContractSmart`.
- */
-export type JsonObject = any;
-
-export interface WasmExtension {
-  readonly wasm: {
-    readonly listCodeInfo: (paginationKey?: Uint8Array) => Promise<QueryCodesResponse>;
-    /**
-     * Downloads the original wasm bytecode by code ID.
-     *
-     * Throws an error if no code with this id
-     */
-    readonly getCode: (id: number) => Promise<QueryCodeResponse>;
-    readonly getCodeInfo: (id: number) => Promise<QueryCodeInfoResponse>;
-    readonly listContractsByCodeId: (
-      id: number,
-      paginationKey?: Uint8Array,
-    ) => Promise<QueryContractsByCodeResponse>;
-    /**
-     * Returns null when contract was not found at this address.
-     */
-    readonly getContractInfo: (address: string) => Promise<QueryContractInfoResponse>;
-    /**
-     * Returns all contract state.
-     * This is an empty array if no such contract, or contract has no data.
-     */
-    readonly getAllContractState: (
-      address: string,
-      paginationKey?: Uint8Array,
-    ) => Promise<QueryAllContractStateResponse>;
-    /**
-     * Returns the data at the key if present (unknown decoded json),
-     * or null if no data at this (contract address, key) pair
-     */
-    readonly queryContractRaw: (address: string, key: Uint8Array) => Promise<QueryRawContractStateResponse>;
-    /**
-     * Makes a smart query on the contract and parses the response as JSON.
-     * Throws error if no such contract exists, the query format is invalid or the response is invalid.
-     */
-    readonly queryContractSmart: (address: string, query: JsonObject) => Promise<JsonObject>;
-    readonly queryContractFull: (sender: string, address: string, query: JsonObject, funds: Coin[], dependencies: string[]) => Promise<JsonObject>;
-  };
-}
-
-export function setupWasmExtension(base: QueryClient): WasmExtension {
-  const rpc = createProtobufRpcClient(base);
-  // Use this service to get easy typed access to query methods
-  // This cannot be used for proof verification
-  const queryService = new QueryClientImpl(rpc);
-
-  return {
-    wasm: {
-      listCodeInfo: async (paginationKey?: Uint8Array) => {
-        const request = {
-          pagination: createPagination(paginationKey),
-        };
-        // @ts-ignore
-        return queryService.codes(request);
-      },
-      getCode: async (id: number) => {
-        const request = { codeId: Long.fromNumber(id) };
-        // @ts-ignore
-        return queryService.code(request);
-      },
-      getCodeInfo: async (id: number) => {
-        const request = { codeId: Long.fromNumber(id) };
-        // @ts-ignore
-        return queryService.codeInfo(request);
-      },
-      listContractsByCodeId: async (id: number, paginationKey?: Uint8Array) => {
-        const request = {
-          codeId: Long.fromNumber(id),
-          pagination: createPagination(paginationKey),
-        };
-        // @ts-ignore
-        return queryService.contractsByCode(request);
-      },
-      getContractInfo: async (address: string) => {
-        const request = { address: address };
-        return queryService.contractInfo(request);
-      },
-
-      getAllContractState: async (address: string, paginationKey?: Uint8Array) => {
-        const request = {
-          address: address,
-          pagination: createPagination(paginationKey),
-        };
-        // @ts-ignore
-        return queryService.allContractState(request);
-      },
-
-      queryContractRaw: async (address: string, key: Uint8Array) => {
-        const request = { address: address, queryData: key };
-        return queryService.rawContractState(request);
-      },
-
-      queryContractSmart: async (address: string, query: JsonObject) => {
-        const request = { address: address, queryData: toUtf8(JSON.stringify(query)) };
-        const { items } = await queryService.allContractState(request);
-        return items;
-      },
-
-      queryContractFull: async (sender: string, address: string, query: JsonObject, funds: Coin[], dependencies: string[]) => {
-        const request = { sender: sender, address: address, queryData: toUtf8(JSON.stringify(query)), funds: funds, dependencies };
-        const { data } = await queryService.smartContractCall(request);
-        // By convention, smart queries must return a valid JSON document (see https://github.com/CosmWasm/cosmwasm/issues/144)
-        let responseText;
-        try {
-            responseText = fromUtf8(data);
-        }
-        catch (error) {
-            throw new Error(`Could not UTF-8 decode smart query response from contract: ${error}`);
-        }
-        try {
-            return JSON.parse(responseText);
-        }
-        catch (error) {
-            throw new Error(`Could not JSON parse smart query response from contract: ${error}`);
-        }
-      },
-    },
-  };
-}

package/src/modules/wasmx/utils.ts

@@ -1,43 +0,0 @@
-import {
-  accountFromAny,
-} from "@cosmjs/stargate";
-import { decodePubkey } from "@cosmjs/proto-signing";
-import { Uint64 } from "@cosmjs/math";
-import { assert } from "@cosmjs/utils";
-import { mythos } from "@ark-us/wasmxjs"
-
-/**
- * Basic implementation of AccountParser. This is supposed to support the most relevant
- * common Cosmos SDK account types. If you need support for exotic account types,
- * you'll need to write your own account decoder.
- */
-export function accountFromAnyWasmx(input: any) {
-    const { typeUrl, value } = input;
-    switch (typeUrl) {
-        // auth
-        case "/mythos.cosmosmod.v1.BaseAccount":
-            return accountFromBaseAccount(mythos.cosmosmod.v1.BaseAccount.decode(value));
-        case "/mythos.cosmosmod.v1.ModuleAccount": {
-            const baseAccount = mythos.cosmosmod.v1.ModuleAccount.decode(value).baseAccount;
-            assert(baseAccount);
-            return accountFromBaseAccount(baseAccount);
-        }
-        default:
-            return accountFromAny(input)
-    }
-}
-
-function accountFromBaseAccount(input: any) {
-    const { address, pubKey, accountNumber, sequence } = input;
-    const pubkey = pubKey ? decodePubkey(pubKey) : null;
-    return {
-        address: address,
-        pubkey: pubkey,
-        accountNumber: uint64FromProto(accountNumber).toNumber(),
-        sequence: uint64FromProto(sequence).toNumber(),
-    };
-}
-
-function uint64FromProto(input: any) {
-    return Uint64.fromString(input.toString());
-}