juno-network 0.11.0 → 0.14.0

package/src/codegen/cosmwasm/wasm/v1/authz.ts

@@ -0,0 +1,603 @@
+import { Any, AnySDKType } from "../../../google/protobuf/any";
+import { Coin, CoinSDKType } from "../../../cosmos/base/v1beta1/coin";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long } from "../../../helpers";
+/**
+ * ContractExecutionAuthorization defines authorization for wasm execute.
+ * Since: wasmd 0.30
+ */
+
+export interface ContractExecutionAuthorization {
+  /** Grants for contract executions */
+  grants: ContractGrant[];
+}
+/**
+ * ContractExecutionAuthorization defines authorization for wasm execute.
+ * Since: wasmd 0.30
+ */
+
+export interface ContractExecutionAuthorizationSDKType {
+  grants: ContractGrantSDKType[];
+}
+/**
+ * ContractMigrationAuthorization defines authorization for wasm contract
+ * migration. Since: wasmd 0.30
+ */
+
+export interface ContractMigrationAuthorization {
+  /** Grants for contract migrations */
+  grants: ContractGrant[];
+}
+/**
+ * ContractMigrationAuthorization defines authorization for wasm contract
+ * migration. Since: wasmd 0.30
+ */
+
+export interface ContractMigrationAuthorizationSDKType {
+  grants: ContractGrantSDKType[];
+}
+/**
+ * ContractGrant a granted permission for a single contract
+ * Since: wasmd 0.30
+ */
+
+export interface ContractGrant {
+  /** Contract is the bech32 address of the smart contract */
+  contract: string;
+  /**
+   * Limit defines execution limits that are enforced and updated when the grant
+   * is applied. When the limit lapsed the grant is removed.
+   */
+
+  limit?: Any;
+  /**
+   * Filter define more fine-grained control on the message payload passed
+   * to the contract in the operation. When no filter applies on execution, the
+   * operation is prohibited.
+   */
+
+  filter?: Any;
+}
+/**
+ * ContractGrant a granted permission for a single contract
+ * Since: wasmd 0.30
+ */
+
+export interface ContractGrantSDKType {
+  contract: string;
+  limit?: AnySDKType;
+  filter?: AnySDKType;
+}
+/**
+ * MaxCallsLimit limited number of calls to the contract. No funds transferable.
+ * Since: wasmd 0.30
+ */
+
+export interface MaxCallsLimit {
+  /** Remaining number that is decremented on each execution */
+  remaining: Long;
+}
+/**
+ * MaxCallsLimit limited number of calls to the contract. No funds transferable.
+ * Since: wasmd 0.30
+ */
+
+export interface MaxCallsLimitSDKType {
+  remaining: Long;
+}
+/**
+ * MaxFundsLimit defines the maximal amounts that can be sent to the contract.
+ * Since: wasmd 0.30
+ */
+
+export interface MaxFundsLimit {
+  /** Amounts is the maximal amount of tokens transferable to the contract. */
+  amounts: Coin[];
+}
+/**
+ * MaxFundsLimit defines the maximal amounts that can be sent to the contract.
+ * Since: wasmd 0.30
+ */
+
+export interface MaxFundsLimitSDKType {
+  amounts: CoinSDKType[];
+}
+/**
+ * CombinedLimit defines the maximal amounts that can be sent to a contract and
+ * the maximal number of calls executable. Both need to remain >0 to be valid.
+ * Since: wasmd 0.30
+ */
+
+export interface CombinedLimit {
+  /** Remaining number that is decremented on each execution */
+  callsRemaining: Long;
+  /** Amounts is the maximal amount of tokens transferable to the contract. */
+
+  amounts: Coin[];
+}
+/**
+ * CombinedLimit defines the maximal amounts that can be sent to a contract and
+ * the maximal number of calls executable. Both need to remain >0 to be valid.
+ * Since: wasmd 0.30
+ */
+
+export interface CombinedLimitSDKType {
+  calls_remaining: Long;
+  amounts: CoinSDKType[];
+}
+/**
+ * AllowAllMessagesFilter is a wildcard to allow any type of contract payload
+ * message.
+ * Since: wasmd 0.30
+ */
+
+export interface AllowAllMessagesFilter {}
+/**
+ * AllowAllMessagesFilter is a wildcard to allow any type of contract payload
+ * message.
+ * Since: wasmd 0.30
+ */
+
+export interface AllowAllMessagesFilterSDKType {}
+/**
+ * AcceptedMessageKeysFilter accept only the specific contract message keys in
+ * the json object to be executed.
+ * Since: wasmd 0.30
+ */
+
+export interface AcceptedMessageKeysFilter {
+  /** Messages is the list of unique keys */
+  keys: string[];
+}
+/**
+ * AcceptedMessageKeysFilter accept only the specific contract message keys in
+ * the json object to be executed.
+ * Since: wasmd 0.30
+ */
+
+export interface AcceptedMessageKeysFilterSDKType {
+  keys: string[];
+}
+/**
+ * AcceptedMessagesFilter accept only the specific raw contract messages to be
+ * executed.
+ * Since: wasmd 0.30
+ */
+
+export interface AcceptedMessagesFilter {
+  /** Messages is the list of raw contract messages */
+  messages: Uint8Array[];
+}
+/**
+ * AcceptedMessagesFilter accept only the specific raw contract messages to be
+ * executed.
+ * Since: wasmd 0.30
+ */
+
+export interface AcceptedMessagesFilterSDKType {
+  messages: Uint8Array[];
+}
+
+function createBaseContractExecutionAuthorization(): ContractExecutionAuthorization {
+  return {
+    grants: []
+  };
+}
+
+export const ContractExecutionAuthorization = {
+  encode(message: ContractExecutionAuthorization, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.grants) {
+      ContractGrant.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ContractExecutionAuthorization {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseContractExecutionAuthorization();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.grants.push(ContractGrant.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ContractExecutionAuthorization>): ContractExecutionAuthorization {
+    const message = createBaseContractExecutionAuthorization();
+    message.grants = object.grants?.map(e => ContractGrant.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseContractMigrationAuthorization(): ContractMigrationAuthorization {
+  return {
+    grants: []
+  };
+}
+
+export const ContractMigrationAuthorization = {
+  encode(message: ContractMigrationAuthorization, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.grants) {
+      ContractGrant.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ContractMigrationAuthorization {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseContractMigrationAuthorization();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.grants.push(ContractGrant.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ContractMigrationAuthorization>): ContractMigrationAuthorization {
+    const message = createBaseContractMigrationAuthorization();
+    message.grants = object.grants?.map(e => ContractGrant.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseContractGrant(): ContractGrant {
+  return {
+    contract: "",
+    limit: undefined,
+    filter: undefined
+  };
+}
+
+export const ContractGrant = {
+  encode(message: ContractGrant, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.contract !== "") {
+      writer.uint32(10).string(message.contract);
+    }
+
+    if (message.limit !== undefined) {
+      Any.encode(message.limit, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.filter !== undefined) {
+      Any.encode(message.filter, writer.uint32(26).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ContractGrant {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseContractGrant();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.contract = reader.string();
+          break;
+
+        case 2:
+          message.limit = Any.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.filter = Any.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ContractGrant>): ContractGrant {
+    const message = createBaseContractGrant();
+    message.contract = object.contract ?? "";
+    message.limit = object.limit !== undefined && object.limit !== null ? Any.fromPartial(object.limit) : undefined;
+    message.filter = object.filter !== undefined && object.filter !== null ? Any.fromPartial(object.filter) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseMaxCallsLimit(): MaxCallsLimit {
+  return {
+    remaining: Long.UZERO
+  };
+}
+
+export const MaxCallsLimit = {
+  encode(message: MaxCallsLimit, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (!message.remaining.isZero()) {
+      writer.uint32(8).uint64(message.remaining);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MaxCallsLimit {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMaxCallsLimit();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.remaining = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MaxCallsLimit>): MaxCallsLimit {
+    const message = createBaseMaxCallsLimit();
+    message.remaining = object.remaining !== undefined && object.remaining !== null ? Long.fromValue(object.remaining) : Long.UZERO;
+    return message;
+  }
+
+};
+
+function createBaseMaxFundsLimit(): MaxFundsLimit {
+  return {
+    amounts: []
+  };
+}
+
+export const MaxFundsLimit = {
+  encode(message: MaxFundsLimit, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.amounts) {
+      Coin.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MaxFundsLimit {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMaxFundsLimit();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.amounts.push(Coin.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MaxFundsLimit>): MaxFundsLimit {
+    const message = createBaseMaxFundsLimit();
+    message.amounts = object.amounts?.map(e => Coin.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseCombinedLimit(): CombinedLimit {
+  return {
+    callsRemaining: Long.UZERO,
+    amounts: []
+  };
+}
+
+export const CombinedLimit = {
+  encode(message: CombinedLimit, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (!message.callsRemaining.isZero()) {
+      writer.uint32(8).uint64(message.callsRemaining);
+    }
+
+    for (const v of message.amounts) {
+      Coin.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): CombinedLimit {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCombinedLimit();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.callsRemaining = (reader.uint64() as Long);
+          break;
+
+        case 2:
+          message.amounts.push(Coin.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<CombinedLimit>): CombinedLimit {
+    const message = createBaseCombinedLimit();
+    message.callsRemaining = object.callsRemaining !== undefined && object.callsRemaining !== null ? Long.fromValue(object.callsRemaining) : Long.UZERO;
+    message.amounts = object.amounts?.map(e => Coin.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseAllowAllMessagesFilter(): AllowAllMessagesFilter {
+  return {};
+}
+
+export const AllowAllMessagesFilter = {
+  encode(_: AllowAllMessagesFilter, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): AllowAllMessagesFilter {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAllowAllMessagesFilter();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<AllowAllMessagesFilter>): AllowAllMessagesFilter {
+    const message = createBaseAllowAllMessagesFilter();
+    return message;
+  }
+
+};
+
+function createBaseAcceptedMessageKeysFilter(): AcceptedMessageKeysFilter {
+  return {
+    keys: []
+  };
+}
+
+export const AcceptedMessageKeysFilter = {
+  encode(message: AcceptedMessageKeysFilter, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.keys) {
+      writer.uint32(10).string(v!);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): AcceptedMessageKeysFilter {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAcceptedMessageKeysFilter();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.keys.push(reader.string());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<AcceptedMessageKeysFilter>): AcceptedMessageKeysFilter {
+    const message = createBaseAcceptedMessageKeysFilter();
+    message.keys = object.keys?.map(e => e) || [];
+    return message;
+  }
+
+};
+
+function createBaseAcceptedMessagesFilter(): AcceptedMessagesFilter {
+  return {
+    messages: []
+  };
+}
+
+export const AcceptedMessagesFilter = {
+  encode(message: AcceptedMessagesFilter, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.messages) {
+      writer.uint32(10).bytes(v!);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): AcceptedMessagesFilter {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAcceptedMessagesFilter();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.messages.push(reader.bytes());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<AcceptedMessagesFilter>): AcceptedMessagesFilter {
+    const message = createBaseAcceptedMessagesFilter();
+    message.messages = object.messages?.map(e => e) || [];
+    return message;
+  }
+
+};

package/src/codegen/cosmwasm/wasm/v1/genesis.ts

@@ -1,5 +1,5 @@
 import { MsgStoreCode, MsgStoreCodeSDKType, MsgInstantiateContract, MsgInstantiateContractSDKType, MsgExecuteContract, MsgExecuteContractSDKType } from "./tx";
-import { Params, ParamsSDKType, CodeInfo, CodeInfoSDKType, ContractInfo, ContractInfoSDKType, Model, ModelSDKType } from "./types";
+import { Params, ParamsSDKType, CodeInfo, CodeInfoSDKType, ContractInfo, ContractInfoSDKType, Model, ModelSDKType, ContractCodeHistoryEntry, ContractCodeHistoryEntrySDKType } from "./types";
 import * as _m0 from "protobufjs/minimal";
 import { DeepPartial, Long } from "../../../helpers";
 /** GenesisState - genesis state of x/wasm */
@@ -56,8 +56,6 @@ export interface CodeSDKType {
   code_id: Long;
   code_info?: CodeInfoSDKType;
   code_bytes: Uint8Array;
-  /** Pinned to wasmvm cache */
-
   pinned: boolean;
 }
 /** Contract struct encompasses ContractAddress, ContractInfo, and ContractState */
@@ -66,6 +64,7 @@ export interface Contract {
   contractAddress: string;
   contractInfo?: ContractInfo;
   contractState: Model[];
+  contractCodeHistory: ContractCodeHistoryEntry[];
 }
 /** Contract struct encompasses ContractAddress, ContractInfo, and ContractState */
 
@@ -73,6 +72,7 @@ export interface ContractSDKType {
   contract_address: string;
   contract_info?: ContractInfoSDKType;
   contract_state: ModelSDKType[];
+  contract_code_history: ContractCodeHistoryEntrySDKType[];
 }
 /** Sequence key and value of an id generation counter */
 
@@ -316,7 +316,8 @@ function createBaseContract(): Contract {
   return {
     contractAddress: "",
     contractInfo: undefined,
-    contractState: []
+    contractState: [],
+    contractCodeHistory: []
   };
 }
 
@@ -334,6 +335,10 @@ export const Contract = {
       Model.encode(v!, writer.uint32(26).fork()).ldelim();
     }
 
+    for (const v of message.contractCodeHistory) {
+      ContractCodeHistoryEntry.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
+
     return writer;
   },
 
@@ -358,6 +363,10 @@ export const Contract = {
           message.contractState.push(Model.decode(reader, reader.uint32()));
           break;
 
+        case 4:
+          message.contractCodeHistory.push(ContractCodeHistoryEntry.decode(reader, reader.uint32()));
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -372,6 +381,7 @@ export const Contract = {
     message.contractAddress = object.contractAddress ?? "";
     message.contractInfo = object.contractInfo !== undefined && object.contractInfo !== null ? ContractInfo.fromPartial(object.contractInfo) : undefined;
     message.contractState = object.contractState?.map(e => Model.fromPartial(e)) || [];
+    message.contractCodeHistory = object.contractCodeHistory?.map(e => ContractCodeHistoryEntry.fromPartial(e)) || [];
     return message;
   }
 

package/src/codegen/cosmwasm/wasm/v1/ibc.ts

@@ -1,5 +1,5 @@
-import * as _m0 from "protobufjs/minimal";
 import { Long, DeepPartial } from "../../../helpers";
+import * as _m0 from "protobufjs/minimal";
 /** MsgIBCSend */
 
 export interface MsgIBCSend {
@@ -27,25 +27,9 @@ export interface MsgIBCSend {
 /** MsgIBCSend */
 
 export interface MsgIBCSendSDKType {
-  /** the channel by which the packet will be sent */
   channel: string;
-  /**
-   * Timeout height relative to the current block height.
-   * The timeout is disabled when set to 0.
-   */
-
   timeout_height: Long;
-  /**
-   * Timeout timestamp (in nanoseconds) relative to the current block timestamp.
-   * The timeout is disabled when set to 0.
-   */
-
   timeout_timestamp: Long;
-  /**
-   * Data is the payload to transfer. We must not make assumption what format or
-   * content is in here.
-   */
-
   data: Uint8Array;
 }
 /** MsgIBCCloseChannel port and channel need to be owned by the contract */