@ark-us/wasmx-stargate 0.0.10 → 0.0.12

package/src/encoding.ts

@@ -1,21 +0,0 @@
-import { fromBase64, fromUtf8, toBase64, toUtf8 } from "@cosmjs/encoding";
-
-/**
- * Takes a value, serializes it to JSON and encodes it as base64.
- *
- * This can be used for creating values of fields that have the WasmX Binary type.
- */
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function toBinary(obj: any): string {
-  return toBase64(toUtf8(JSON.stringify(obj)));
-}
-
-/**
- * Takes a base64 string, decodes it and parses the content from JSON to an object.
- *
- * This can be used for parsing the values of a WasmX Binary field.
- */
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function fromBinary(base64: string): any {
-  return JSON.parse(fromUtf8(fromBase64(base64)));
-}

package/src/index.ts

@@ -1,30 +0,0 @@
-export { Code, CodeDetails, Contract, ContractCodeHistoryEntry, WasmXClient } from "./wasmxclient";
-export { fromBinary, toBinary } from "./encoding";
-export {
-  wasmXTypes,
-  createWasmAminoConverters,
-  isMsgExecuteEncodeObject,
-  isMsgInstantiateContractEncodeObject,
-  isMsgStoreCodeEncodeObject,
-  JsonObject,
-  MsgExecuteContractEncodeObject,
-  MsgInstantiateContractEncodeObject,
-  MsgStoreCodeEncodeObject,
-  setupWasmExtension,
-  WasmExtension,
-} from "./modules";
-export {
-  ChangeAdminResult,
-  ExecuteInstruction,
-  ExecuteResult,
-  InstantiateOptions,
-  InstantiateResult,
-  MigrateResult,
-  SigningWasmXClient,
-  SigningWasmXClientOptions,
-  UploadResult,
-} from "./signingwasmxclient";
-
-// Re-exported because this is part of the WasmXClient/SigningWasmXClient APIs
-export { Attribute, DeliverTxResponse, Event, IndexedTx } from "@cosmjs/stargate";
-export { HttpEndpoint } from "@cosmjs/tendermint-rpc";

package/src/modules/index.ts

@@ -1,20 +0,0 @@
-export {
-  AminoMsgExecuteContract,
-  AminoMsgInstantiateContract,
-  AminoMsgStoreCode,
-  AminoMsgDeployCode,
-  wasmXTypes,
-  createWasmAminoConverters,
-} from "./wasmx/aminomessages";
-export {
-  isMsgExecuteEncodeObject,
-  isMsgInstantiateContractEncodeObject,
-  isMsgStoreCodeEncodeObject,
-  isMsgDeployCodeEncodeObject,
-  MsgExecuteContractEncodeObject,
-  MsgInstantiateContractEncodeObject,
-  MsgStoreCodeEncodeObject,
-  MsgDeployCodeEncodeObject,
-  wasmTypes,
-} from "./wasmx/messages";
-export { JsonObject, setupWasmExtension, WasmExtension } from "./wasmx/queries";

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: "", 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: "", 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: "", 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 {
-  CodeMetadata,
-  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: CodeMetadata;
-  };
-}
-
-/**
- * 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: CodeMetadata;
-    /** 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 || CodeMetadata.fromPartial({}),
-        deps: deps,
-      }),
-      fromAmino: ({ sender, byte_code, deps, metadata }: AminoMsgStoreCode["value"]): MsgStoreCode => ({
-        sender: sender,
-        byteCode: fromBase64(byte_code),
-        deps: deps,
-        metadata: metadata || CodeMetadata.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 || CodeMetadata.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 || CodeMetadata.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";
-}