@akashnetwork/chain-sdk 1.0.0-alpha.24 → 1.0.0-alpha.25

package/dist/cjs/generated/createIbc-goSDK.cjs

@@ -70,35 +70,35 @@ function createSDK(queryTransport, txTransport) {
               getInterchainAccount: (0, import_sdkMetadata.withMetadata)(async function getInterchainAccount(input, options) {
                 const service = await serviceLoader.loadAt(0);
                 return getClient(service).interchainAccount(input, options);
-              }, { path: [0, 0] }),
+              }, { path: [0, "interchainAccount"], serviceLoader }),
               /**
                * getParams queries all parameters of the ICA controller submodule.
                */
               getParams: (0, import_sdkMetadata.withMetadata)(async function getParams(input = {}, options) {
                 const service = await serviceLoader.loadAt(0);
                 return getClient(service).params(input, options);
-              }, { path: [0, 1] }),
+              }, { path: [0, "params"], serviceLoader }),
               /**
                * registerInterchainAccount defines a rpc handler for MsgRegisterInterchainAccount.
                */
               registerInterchainAccount: (0, import_sdkMetadata.withMetadata)(async function registerInterchainAccount(input, options) {
                 const service = await serviceLoader.loadAt(1);
                 return getMsgClient(service).registerInterchainAccount(input, options);
-              }, { path: [1, 0] }),
+              }, { path: [1, "registerInterchainAccount"], serviceLoader }),
               /**
                * sendTx defines a rpc handler for MsgSendTx.
                */
               sendTx: (0, import_sdkMetadata.withMetadata)(async function sendTx(input, options) {
                 const service = await serviceLoader.loadAt(1);
                 return getMsgClient(service).sendTx(input, options);
-              }, { path: [1, 1] }),
+              }, { path: [1, "sendTx"], serviceLoader }),
               /**
                * updateParams defines a rpc handler for MsgUpdateParams.
                */
               updateParams: (0, import_sdkMetadata.withMetadata)(async function updateParams(input, options) {
                 const service = await serviceLoader.loadAt(1);
                 return getMsgClient(service).updateParams(input, options);
-              }, { path: [1, 2] })
+              }, { path: [1, "updateParams"], serviceLoader })
             }
           },
           host: {
@@ -109,21 +109,21 @@ function createSDK(queryTransport, txTransport) {
               getParams: (0, import_sdkMetadata.withMetadata)(async function getParams(input = {}, options) {
                 const service = await serviceLoader.loadAt(2);
                 return getClient(service).params(input, options);
-              }, { path: [2, 0] }),
+              }, { path: [2, "params"], serviceLoader }),
               /**
                * updateParams defines a rpc handler for MsgUpdateParams.
                */
               updateParams: (0, import_sdkMetadata.withMetadata)(async function updateParams(input, options) {
                 const service = await serviceLoader.loadAt(3);
                 return getMsgClient(service).updateParams(input, options);
-              }, { path: [3, 0] }),
+              }, { path: [3, "updateParams"], serviceLoader }),
               /**
                * moduleQuerySafe defines a rpc handler for MsgModuleQuerySafe.
                */
               moduleQuerySafe: (0, import_sdkMetadata.withMetadata)(async function moduleQuerySafe(input, options) {
                 const service = await serviceLoader.loadAt(3);
                 return getMsgClient(service).moduleQuerySafe(input, options);
-              }, { path: [3, 1] })
+              }, { path: [3, "moduleQuerySafe"], serviceLoader })
             }
           }
         },
@@ -135,56 +135,56 @@ function createSDK(queryTransport, txTransport) {
             getParams: (0, import_sdkMetadata.withMetadata)(async function getParams(input = {}, options) {
               const service = await serviceLoader.loadAt(4);
               return getClient(service).params(input, options);
-            }, { path: [4, 0] }),
+            }, { path: [4, "params"], serviceLoader }),
             /**
              * getDenoms queries all denominations
              */
             getDenoms: (0, import_sdkMetadata.withMetadata)(async function getDenoms(input, options) {
               const service = await serviceLoader.loadAt(4);
               return getClient(service).denoms(input, options);
-            }, { path: [4, 1] }),
+            }, { path: [4, "denoms"], serviceLoader }),
             /**
              * getDenom queries a denomination
              */
             getDenom: (0, import_sdkMetadata.withMetadata)(async function getDenom(input, options) {
               const service = await serviceLoader.loadAt(4);
               return getClient(service).denom(input, options);
-            }, { path: [4, 2] }),
+            }, { path: [4, "denom"], serviceLoader }),
             /**
              * getDenomHash queries a denomination hash information.
              */
             getDenomHash: (0, import_sdkMetadata.withMetadata)(async function getDenomHash(input, options) {
               const service = await serviceLoader.loadAt(4);
               return getClient(service).denomHash(input, options);
-            }, { path: [4, 3] }),
+            }, { path: [4, "denomHash"], serviceLoader }),
             /**
              * getEscrowAddress returns the escrow address for a particular port and channel id.
              */
             getEscrowAddress: (0, import_sdkMetadata.withMetadata)(async function getEscrowAddress(input, options) {
               const service = await serviceLoader.loadAt(4);
               return getClient(service).escrowAddress(input, options);
-            }, { path: [4, 4] }),
+            }, { path: [4, "escrowAddress"], serviceLoader }),
             /**
              * getTotalEscrowForDenom returns the total amount of tokens in escrow based on the denom.
              */
             getTotalEscrowForDenom: (0, import_sdkMetadata.withMetadata)(async function getTotalEscrowForDenom(input, options) {
               const service = await serviceLoader.loadAt(4);
               return getClient(service).totalEscrowForDenom(input, options);
-            }, { path: [4, 5] }),
+            }, { path: [4, "totalEscrowForDenom"], serviceLoader }),
             /**
              * transfer defines a rpc handler method for MsgTransfer.
              */
             transfer: (0, import_sdkMetadata.withMetadata)(async function transfer(input, options) {
               const service = await serviceLoader.loadAt(5);
               return getMsgClient(service).transfer(input, options);
-            }, { path: [5, 0] }),
+            }, { path: [5, "transfer"], serviceLoader }),
             /**
              * updateParams defines a rpc handler for MsgUpdateParams.
              */
             updateParams: (0, import_sdkMetadata.withMetadata)(async function updateParams(input, options) {
               const service = await serviceLoader.loadAt(5);
               return getMsgClient(service).updateParams(input, options);
-            }, { path: [5, 1] })
+            }, { path: [5, "updateParams"], serviceLoader })
           }
         }
       },
@@ -197,14 +197,14 @@ function createSDK(queryTransport, txTransport) {
             getChannel: (0, import_sdkMetadata.withMetadata)(async function getChannel(input, options) {
               const service = await serviceLoader.loadAt(6);
               return getClient(service).channel(input, options);
-            }, { path: [6, 0] }),
+            }, { path: [6, "channel"], serviceLoader }),
             /**
              * getChannels queries all the IBC channels of a chain.
              */
             getChannels: (0, import_sdkMetadata.withMetadata)(async function getChannels(input, options) {
               const service = await serviceLoader.loadAt(6);
               return getClient(service).channels(input, options);
-            }, { path: [6, 1] }),
+            }, { path: [6, "channels"], serviceLoader }),
             /**
              * getConnectionChannels queries all the channels associated with a connection
              * end.
@@ -212,7 +212,7 @@ function createSDK(queryTransport, txTransport) {
             getConnectionChannels: (0, import_sdkMetadata.withMetadata)(async function getConnectionChannels(input, options) {
               const service = await serviceLoader.loadAt(6);
               return getClient(service).connectionChannels(input, options);
-            }, { path: [6, 2] }),
+            }, { path: [6, "connectionChannels"], serviceLoader }),
             /**
              * getChannelClientState queries for the client state for the channel associated
              * with the provided channel identifiers.
@@ -220,7 +220,7 @@ function createSDK(queryTransport, txTransport) {
             getChannelClientState: (0, import_sdkMetadata.withMetadata)(async function getChannelClientState(input, options) {
               const service = await serviceLoader.loadAt(6);
               return getClient(service).channelClientState(input, options);
-            }, { path: [6, 3] }),
+            }, { path: [6, "channelClientState"], serviceLoader }),
             /**
              * getChannelConsensusState queries for the consensus state for the channel
              * associated with the provided channel identifiers.
@@ -228,14 +228,14 @@ function createSDK(queryTransport, txTransport) {
             getChannelConsensusState: (0, import_sdkMetadata.withMetadata)(async function getChannelConsensusState(input, options) {
               const service = await serviceLoader.loadAt(6);
               return getClient(service).channelConsensusState(input, options);
-            }, { path: [6, 4] }),
+            }, { path: [6, "channelConsensusState"], serviceLoader }),
             /**
              * getPacketCommitment queries a stored packet commitment hash.
              */
             getPacketCommitment: (0, import_sdkMetadata.withMetadata)(async function getPacketCommitment(input, options) {
               const service = await serviceLoader.loadAt(6);
               return getClient(service).packetCommitment(input, options);
-            }, { path: [6, 5] }),
+            }, { path: [6, "packetCommitment"], serviceLoader }),
             /**
              * getPacketCommitments returns all the packet commitments hashes associated
              * with a channel.
@@ -243,7 +243,7 @@ function createSDK(queryTransport, txTransport) {
             getPacketCommitments: (0, import_sdkMetadata.withMetadata)(async function getPacketCommitments(input, options) {
               const service = await serviceLoader.loadAt(6);
               return getClient(service).packetCommitments(input, options);
-            }, { path: [6, 6] }),
+            }, { path: [6, "packetCommitments"], serviceLoader }),
             /**
              * getPacketReceipt queries if a given packet sequence has been received on the
              * queried chain
@@ -251,14 +251,14 @@ function createSDK(queryTransport, txTransport) {
             getPacketReceipt: (0, import_sdkMetadata.withMetadata)(async function getPacketReceipt(input, options) {
               const service = await serviceLoader.loadAt(6);
               return getClient(service).packetReceipt(input, options);
-            }, { path: [6, 7] }),
+            }, { path: [6, "packetReceipt"], serviceLoader }),
             /**
              * getPacketAcknowledgement queries a stored packet acknowledgement hash.
              */
             getPacketAcknowledgement: (0, import_sdkMetadata.withMetadata)(async function getPacketAcknowledgement(input, options) {
               const service = await serviceLoader.loadAt(6);
               return getClient(service).packetAcknowledgement(input, options);
-            }, { path: [6, 8] }),
+            }, { path: [6, "packetAcknowledgement"], serviceLoader }),
             /**
              * getPacketAcknowledgements returns all the packet acknowledgements associated
              * with a channel.
@@ -266,7 +266,7 @@ function createSDK(queryTransport, txTransport) {
             getPacketAcknowledgements: (0, import_sdkMetadata.withMetadata)(async function getPacketAcknowledgements(input, options) {
               const service = await serviceLoader.loadAt(6);
               return getClient(service).packetAcknowledgements(input, options);
-            }, { path: [6, 9] }),
+            }, { path: [6, "packetAcknowledgements"], serviceLoader }),
             /**
              * getUnreceivedPackets returns all the unreceived IBC packets associated with a
              * channel and sequences.
@@ -274,7 +274,7 @@ function createSDK(queryTransport, txTransport) {
             getUnreceivedPackets: (0, import_sdkMetadata.withMetadata)(async function getUnreceivedPackets(input, options) {
               const service = await serviceLoader.loadAt(6);
               return getClient(service).unreceivedPackets(input, options);
-            }, { path: [6, 10] }),
+            }, { path: [6, "unreceivedPackets"], serviceLoader }),
             /**
              * getUnreceivedAcks returns all the unreceived IBC acknowledgements associated
              * with a channel and sequences.
@@ -282,56 +282,56 @@ function createSDK(queryTransport, txTransport) {
             getUnreceivedAcks: (0, import_sdkMetadata.withMetadata)(async function getUnreceivedAcks(input, options) {
               const service = await serviceLoader.loadAt(6);
               return getClient(service).unreceivedAcks(input, options);
-            }, { path: [6, 11] }),
+            }, { path: [6, "unreceivedAcks"], serviceLoader }),
             /**
              * getNextSequenceReceive returns the next receive sequence for a given channel.
              */
             getNextSequenceReceive: (0, import_sdkMetadata.withMetadata)(async function getNextSequenceReceive(input, options) {
               const service = await serviceLoader.loadAt(6);
               return getClient(service).nextSequenceReceive(input, options);
-            }, { path: [6, 12] }),
+            }, { path: [6, "nextSequenceReceive"], serviceLoader }),
             /**
              * getNextSequenceSend returns the next send sequence for a given channel.
              */
             getNextSequenceSend: (0, import_sdkMetadata.withMetadata)(async function getNextSequenceSend(input, options) {
               const service = await serviceLoader.loadAt(6);
               return getClient(service).nextSequenceSend(input, options);
-            }, { path: [6, 13] }),
+            }, { path: [6, "nextSequenceSend"], serviceLoader }),
             /**
              * channelOpenInit defines a rpc handler method for MsgChannelOpenInit.
              */
             channelOpenInit: (0, import_sdkMetadata.withMetadata)(async function channelOpenInit(input, options) {
               const service = await serviceLoader.loadAt(7);
               return getMsgClient(service).channelOpenInit(input, options);
-            }, { path: [7, 0] }),
+            }, { path: [7, "channelOpenInit"], serviceLoader }),
             /**
              * channelOpenTry defines a rpc handler method for MsgChannelOpenTry.
              */
             channelOpenTry: (0, import_sdkMetadata.withMetadata)(async function channelOpenTry(input, options) {
               const service = await serviceLoader.loadAt(7);
               return getMsgClient(service).channelOpenTry(input, options);
-            }, { path: [7, 1] }),
+            }, { path: [7, "channelOpenTry"], serviceLoader }),
             /**
              * channelOpenAck defines a rpc handler method for MsgChannelOpenAck.
              */
             channelOpenAck: (0, import_sdkMetadata.withMetadata)(async function channelOpenAck(input, options) {
               const service = await serviceLoader.loadAt(7);
               return getMsgClient(service).channelOpenAck(input, options);
-            }, { path: [7, 2] }),
+            }, { path: [7, "channelOpenAck"], serviceLoader }),
             /**
              * channelOpenConfirm defines a rpc handler method for MsgChannelOpenConfirm.
              */
             channelOpenConfirm: (0, import_sdkMetadata.withMetadata)(async function channelOpenConfirm(input, options) {
               const service = await serviceLoader.loadAt(7);
               return getMsgClient(service).channelOpenConfirm(input, options);
-            }, { path: [7, 3] }),
+            }, { path: [7, "channelOpenConfirm"], serviceLoader }),
             /**
              * channelCloseInit defines a rpc handler method for MsgChannelCloseInit.
              */
             channelCloseInit: (0, import_sdkMetadata.withMetadata)(async function channelCloseInit(input, options) {
               const service = await serviceLoader.loadAt(7);
               return getMsgClient(service).channelCloseInit(input, options);
-            }, { path: [7, 4] }),
+            }, { path: [7, "channelCloseInit"], serviceLoader }),
             /**
              * channelCloseConfirm defines a rpc handler method for
              * MsgChannelCloseConfirm.
@@ -339,35 +339,35 @@ function createSDK(queryTransport, txTransport) {
             channelCloseConfirm: (0, import_sdkMetadata.withMetadata)(async function channelCloseConfirm(input, options) {
               const service = await serviceLoader.loadAt(7);
               return getMsgClient(service).channelCloseConfirm(input, options);
-            }, { path: [7, 5] }),
+            }, { path: [7, "channelCloseConfirm"], serviceLoader }),
             /**
              * recvPacket defines a rpc handler method for MsgRecvPacket.
              */
             recvPacket: (0, import_sdkMetadata.withMetadata)(async function recvPacket(input, options) {
               const service = await serviceLoader.loadAt(7);
               return getMsgClient(service).recvPacket(input, options);
-            }, { path: [7, 6] }),
+            }, { path: [7, "recvPacket"], serviceLoader }),
             /**
              * timeout defines a rpc handler method for MsgTimeout.
              */
             timeout: (0, import_sdkMetadata.withMetadata)(async function timeout(input, options) {
               const service = await serviceLoader.loadAt(7);
               return getMsgClient(service).timeout(input, options);
-            }, { path: [7, 7] }),
+            }, { path: [7, "timeout"], serviceLoader }),
             /**
              * timeoutOnClose defines a rpc handler method for MsgTimeoutOnClose.
              */
             timeoutOnClose: (0, import_sdkMetadata.withMetadata)(async function timeoutOnClose(input, options) {
               const service = await serviceLoader.loadAt(7);
               return getMsgClient(service).timeoutOnClose(input, options);
-            }, { path: [7, 8] }),
+            }, { path: [7, "timeoutOnClose"], serviceLoader }),
             /**
              * acknowledgement defines a rpc handler method for MsgAcknowledgement.
              */
             acknowledgement: (0, import_sdkMetadata.withMetadata)(async function acknowledgement(input, options) {
               const service = await serviceLoader.loadAt(7);
               return getMsgClient(service).acknowledgement(input, options);
-            }, { path: [7, 9] })
+            }, { path: [7, "acknowledgement"], serviceLoader })
           },
           v2: {
             /**
@@ -376,84 +376,84 @@ function createSDK(queryTransport, txTransport) {
             getNextSequenceSend: (0, import_sdkMetadata.withMetadata)(async function getNextSequenceSend(input, options) {
               const service = await serviceLoader.loadAt(8);
               return getClient(service).nextSequenceSend(input, options);
-            }, { path: [8, 0] }),
+            }, { path: [8, "nextSequenceSend"], serviceLoader }),
             /**
              * getPacketCommitment queries a stored packet commitment hash.
              */
             getPacketCommitment: (0, import_sdkMetadata.withMetadata)(async function getPacketCommitment(input, options) {
               const service = await serviceLoader.loadAt(8);
               return getClient(service).packetCommitment(input, options);
-            }, { path: [8, 1] }),
+            }, { path: [8, "packetCommitment"], serviceLoader }),
             /**
              * getPacketCommitments queries a stored packet commitment hash.
              */
             getPacketCommitments: (0, import_sdkMetadata.withMetadata)(async function getPacketCommitments(input, options) {
               const service = await serviceLoader.loadAt(8);
               return getClient(service).packetCommitments(input, options);
-            }, { path: [8, 2] }),
+            }, { path: [8, "packetCommitments"], serviceLoader }),
             /**
              * getPacketAcknowledgement queries a stored acknowledgement commitment hash.
              */
             getPacketAcknowledgement: (0, import_sdkMetadata.withMetadata)(async function getPacketAcknowledgement(input, options) {
               const service = await serviceLoader.loadAt(8);
               return getClient(service).packetAcknowledgement(input, options);
-            }, { path: [8, 3] }),
+            }, { path: [8, "packetAcknowledgement"], serviceLoader }),
             /**
              * getPacketAcknowledgements returns all packet acknowledgements associated with a channel.
              */
             getPacketAcknowledgements: (0, import_sdkMetadata.withMetadata)(async function getPacketAcknowledgements(input, options) {
               const service = await serviceLoader.loadAt(8);
               return getClient(service).packetAcknowledgements(input, options);
-            }, { path: [8, 4] }),
+            }, { path: [8, "packetAcknowledgements"], serviceLoader }),
             /**
              * getPacketReceipt queries a stored packet receipt.
              */
             getPacketReceipt: (0, import_sdkMetadata.withMetadata)(async function getPacketReceipt(input, options) {
               const service = await serviceLoader.loadAt(8);
               return getClient(service).packetReceipt(input, options);
-            }, { path: [8, 5] }),
+            }, { path: [8, "packetReceipt"], serviceLoader }),
             /**
              * getUnreceivedPackets returns all the unreceived IBC packets associated with a channel and sequences.
              */
             getUnreceivedPackets: (0, import_sdkMetadata.withMetadata)(async function getUnreceivedPackets(input, options) {
               const service = await serviceLoader.loadAt(8);
               return getClient(service).unreceivedPackets(input, options);
-            }, { path: [8, 6] }),
+            }, { path: [8, "unreceivedPackets"], serviceLoader }),
             /**
              * getUnreceivedAcks returns all the unreceived IBC acknowledgements associated with a channel and sequences.
              */
             getUnreceivedAcks: (0, import_sdkMetadata.withMetadata)(async function getUnreceivedAcks(input, options) {
               const service = await serviceLoader.loadAt(8);
               return getClient(service).unreceivedAcks(input, options);
-            }, { path: [8, 7] }),
+            }, { path: [8, "unreceivedAcks"], serviceLoader }),
             /**
              * sendPacket defines a rpc handler method for MsgSendPacket.
              */
             sendPacket: (0, import_sdkMetadata.withMetadata)(async function sendPacket(input, options) {
               const service = await serviceLoader.loadAt(9);
               return getMsgClient(service).sendPacket(input, options);
-            }, { path: [9, 0] }),
+            }, { path: [9, "sendPacket"], serviceLoader }),
             /**
              * recvPacket defines a rpc handler method for MsgRecvPacket.
              */
             recvPacket: (0, import_sdkMetadata.withMetadata)(async function recvPacket(input, options) {
               const service = await serviceLoader.loadAt(9);
               return getMsgClient(service).recvPacket(input, options);
-            }, { path: [9, 1] }),
+            }, { path: [9, "recvPacket"], serviceLoader }),
             /**
              * timeout defines a rpc handler method for MsgTimeout.
              */
             timeout: (0, import_sdkMetadata.withMetadata)(async function timeout(input, options) {
               const service = await serviceLoader.loadAt(9);
               return getMsgClient(service).timeout(input, options);
-            }, { path: [9, 2] }),
+            }, { path: [9, "timeout"], serviceLoader }),
             /**
              * acknowledgement defines a rpc handler method for MsgAcknowledgement.
              */
             acknowledgement: (0, import_sdkMetadata.withMetadata)(async function acknowledgement(input, options) {
               const service = await serviceLoader.loadAt(9);
               return getMsgClient(service).acknowledgement(input, options);
-            }, { path: [9, 3] })
+            }, { path: [9, "acknowledgement"], serviceLoader })
           }
         },
         client: {
@@ -464,14 +464,14 @@ function createSDK(queryTransport, txTransport) {
             getClientState: (0, import_sdkMetadata.withMetadata)(async function getClientState(input, options) {
               const service = await serviceLoader.loadAt(10);
               return getClient(service).clientState(input, options);
-            }, { path: [10, 0] }),
+            }, { path: [10, "clientState"], serviceLoader }),
             /**
              * getClientStates queries all the IBC light clients of a chain.
              */
             getClientStates: (0, import_sdkMetadata.withMetadata)(async function getClientStates(input, options) {
               const service = await serviceLoader.loadAt(10);
               return getClient(service).clientStates(input, options);
-            }, { path: [10, 1] }),
+            }, { path: [10, "clientStates"], serviceLoader }),
             /**
              * getConsensusState queries a consensus state associated with a client state at
              * a given height.
@@ -479,7 +479,7 @@ function createSDK(queryTransport, txTransport) {
             getConsensusState: (0, import_sdkMetadata.withMetadata)(async function getConsensusState(input, options) {
               const service = await serviceLoader.loadAt(10);
               return getClient(service).consensusState(input, options);
-            }, { path: [10, 2] }),
+            }, { path: [10, "consensusState"], serviceLoader }),
             /**
              * getConsensusStates queries all the consensus state associated with a given
              * client.
@@ -487,112 +487,112 @@ function createSDK(queryTransport, txTransport) {
             getConsensusStates: (0, import_sdkMetadata.withMetadata)(async function getConsensusStates(input, options) {
               const service = await serviceLoader.loadAt(10);
               return getClient(service).consensusStates(input, options);
-            }, { path: [10, 3] }),
+            }, { path: [10, "consensusStates"], serviceLoader }),
             /**
              * getConsensusStateHeights queries the height of every consensus states associated with a given client.
              */
             getConsensusStateHeights: (0, import_sdkMetadata.withMetadata)(async function getConsensusStateHeights(input, options) {
               const service = await serviceLoader.loadAt(10);
               return getClient(service).consensusStateHeights(input, options);
-            }, { path: [10, 4] }),
+            }, { path: [10, "consensusStateHeights"], serviceLoader }),
             /**
              * Status queries the status of an IBC client.
              */
             getClientStatus: (0, import_sdkMetadata.withMetadata)(async function getClientStatus(input, options) {
               const service = await serviceLoader.loadAt(10);
               return getClient(service).clientStatus(input, options);
-            }, { path: [10, 5] }),
+            }, { path: [10, "clientStatus"], serviceLoader }),
             /**
              * getClientParams queries all parameters of the ibc client submodule.
              */
             getClientParams: (0, import_sdkMetadata.withMetadata)(async function getClientParams(input = {}, options) {
               const service = await serviceLoader.loadAt(10);
               return getClient(service).clientParams(input, options);
-            }, { path: [10, 6] }),
+            }, { path: [10, "clientParams"], serviceLoader }),
             /**
              * getClientCreator queries the creator of a given client.
              */
             getClientCreator: (0, import_sdkMetadata.withMetadata)(async function getClientCreator(input, options) {
               const service = await serviceLoader.loadAt(10);
               return getClient(service).clientCreator(input, options);
-            }, { path: [10, 7] }),
+            }, { path: [10, "clientCreator"], serviceLoader }),
             /**
              * getUpgradedClientState queries an Upgraded IBC light client.
              */
             getUpgradedClientState: (0, import_sdkMetadata.withMetadata)(async function getUpgradedClientState(input = {}, options) {
               const service = await serviceLoader.loadAt(10);
               return getClient(service).upgradedClientState(input, options);
-            }, { path: [10, 8] }),
+            }, { path: [10, "upgradedClientState"], serviceLoader }),
             /**
              * getUpgradedConsensusState queries an Upgraded IBC consensus state.
              */
             getUpgradedConsensusState: (0, import_sdkMetadata.withMetadata)(async function getUpgradedConsensusState(input = {}, options) {
               const service = await serviceLoader.loadAt(10);
               return getClient(service).upgradedConsensusState(input, options);
-            }, { path: [10, 9] }),
+            }, { path: [10, "upgradedConsensusState"], serviceLoader }),
             /**
              * getVerifyMembership queries an IBC light client for proof verification of a value at a given key path.
              */
             getVerifyMembership: (0, import_sdkMetadata.withMetadata)(async function getVerifyMembership(input, options) {
               const service = await serviceLoader.loadAt(10);
               return getClient(service).verifyMembership(input, options);
-            }, { path: [10, 10] }),
+            }, { path: [10, "verifyMembership"], serviceLoader }),
             /**
              * createClient defines a rpc handler method for MsgCreateClient.
              */
             createClient: (0, import_sdkMetadata.withMetadata)(async function createClient(input, options) {
               const service = await serviceLoader.loadAt(11);
               return getMsgClient(service).createClient(input, options);
-            }, { path: [11, 0] }),
+            }, { path: [11, "createClient"], serviceLoader }),
             /**
              * updateClient defines a rpc handler method for MsgUpdateClient.
              */
             updateClient: (0, import_sdkMetadata.withMetadata)(async function updateClient(input, options) {
               const service = await serviceLoader.loadAt(11);
               return getMsgClient(service).updateClient(input, options);
-            }, { path: [11, 1] }),
+            }, { path: [11, "updateClient"], serviceLoader }),
             /**
              * upgradeClient defines a rpc handler method for MsgUpgradeClient.
              */
             upgradeClient: (0, import_sdkMetadata.withMetadata)(async function upgradeClient(input, options) {
               const service = await serviceLoader.loadAt(11);
               return getMsgClient(service).upgradeClient(input, options);
-            }, { path: [11, 2] }),
+            }, { path: [11, "upgradeClient"], serviceLoader }),
             /**
              * submitMisbehaviour defines a rpc handler method for MsgSubmitMisbehaviour.
              */
             submitMisbehaviour: (0, import_sdkMetadata.withMetadata)(async function submitMisbehaviour(input, options) {
               const service = await serviceLoader.loadAt(11);
               return getMsgClient(service).submitMisbehaviour(input, options);
-            }, { path: [11, 3] }),
+            }, { path: [11, "submitMisbehaviour"], serviceLoader }),
             /**
              * recoverClient defines a rpc handler method for MsgRecoverClient.
              */
             recoverClient: (0, import_sdkMetadata.withMetadata)(async function recoverClient(input, options) {
               const service = await serviceLoader.loadAt(11);
               return getMsgClient(service).recoverClient(input, options);
-            }, { path: [11, 4] }),
+            }, { path: [11, "recoverClient"], serviceLoader }),
             /**
              * iBCSoftwareUpgrade defines a rpc handler method for MsgIBCSoftwareUpgrade.
              */
             iBCSoftwareUpgrade: (0, import_sdkMetadata.withMetadata)(async function iBCSoftwareUpgrade(input, options) {
               const service = await serviceLoader.loadAt(11);
               return getMsgClient(service).iBCSoftwareUpgrade(input, options);
-            }, { path: [11, 5] }),
+            }, { path: [11, "iBCSoftwareUpgrade"], serviceLoader }),
             /**
              * updateClientParams defines a rpc handler method for MsgUpdateParams.
              */
             updateClientParams: (0, import_sdkMetadata.withMetadata)(async function updateClientParams(input, options) {
               const service = await serviceLoader.loadAt(11);
               return getMsgClient(service).updateClientParams(input, options);
-            }, { path: [11, 6] }),
+            }, { path: [11, "updateClientParams"], serviceLoader }),
             /**
              * deleteClientCreator defines a rpc handler method for MsgDeleteClientCreator.
              */
             deleteClientCreator: (0, import_sdkMetadata.withMetadata)(async function deleteClientCreator(input, options) {
               const service = await serviceLoader.loadAt(11);
               return getMsgClient(service).deleteClientCreator(input, options);
-            }, { path: [11, 7] })
+            }, { path: [11, "deleteClientCreator"], serviceLoader })
           },
           v2: {
             /**
@@ -601,28 +601,28 @@ function createSDK(queryTransport, txTransport) {
             getCounterpartyInfo: (0, import_sdkMetadata.withMetadata)(async function getCounterpartyInfo(input, options) {
               const service = await serviceLoader.loadAt(12);
               return getClient(service).counterpartyInfo(input, options);
-            }, { path: [12, 0] }),
+            }, { path: [12, "counterpartyInfo"], serviceLoader }),
             /**
              * getConfig queries the IBC client v2 configuration for a given client.
              */
             getConfig: (0, import_sdkMetadata.withMetadata)(async function getConfig(input, options) {
               const service = await serviceLoader.loadAt(12);
               return getClient(service).config(input, options);
-            }, { path: [12, 1] }),
+            }, { path: [12, "config"], serviceLoader }),
             /**
              * registerCounterparty defines a rpc handler method for MsgRegisterCounterparty.
              */
             registerCounterparty: (0, import_sdkMetadata.withMetadata)(async function registerCounterparty(input, options) {
               const service = await serviceLoader.loadAt(13);
               return getMsgClient(service).registerCounterparty(input, options);
-            }, { path: [13, 0] }),
+            }, { path: [13, "registerCounterparty"], serviceLoader }),
             /**
              * updateClientConfig defines a rpc handler method for MsgUpdateClientConfig.
              */
             updateClientConfig: (0, import_sdkMetadata.withMetadata)(async function updateClientConfig(input, options) {
               const service = await serviceLoader.loadAt(13);
               return getMsgClient(service).updateClientConfig(input, options);
-            }, { path: [13, 1] })
+            }, { path: [13, "updateClientConfig"], serviceLoader })
           }
         },
         connection: {
@@ -633,14 +633,14 @@ function createSDK(queryTransport, txTransport) {
             getConnection: (0, import_sdkMetadata.withMetadata)(async function getConnection(input, options) {
               const service = await serviceLoader.loadAt(14);
               return getClient(service).connection(input, options);
-            }, { path: [14, 0] }),
+            }, { path: [14, "connection"], serviceLoader }),
             /**
              * getConnections queries all the IBC connections of a chain.
              */
             getConnections: (0, import_sdkMetadata.withMetadata)(async function getConnections(input, options) {
               const service = await serviceLoader.loadAt(14);
               return getClient(service).connections(input, options);
-            }, { path: [14, 1] }),
+            }, { path: [14, "connections"], serviceLoader }),
             /**
              * getClientConnections queries the connection paths associated with a client
              * state.
@@ -648,7 +648,7 @@ function createSDK(queryTransport, txTransport) {
             getClientConnections: (0, import_sdkMetadata.withMetadata)(async function getClientConnections(input, options) {
               const service = await serviceLoader.loadAt(14);
               return getClient(service).clientConnections(input, options);
-            }, { path: [14, 2] }),
+            }, { path: [14, "clientConnections"], serviceLoader }),
             /**
              * getConnectionClientState queries the client state associated with the
              * connection.
@@ -656,7 +656,7 @@ function createSDK(queryTransport, txTransport) {
             getConnectionClientState: (0, import_sdkMetadata.withMetadata)(async function getConnectionClientState(input, options) {
               const service = await serviceLoader.loadAt(14);
               return getClient(service).connectionClientState(input, options);
-            }, { path: [14, 3] }),
+            }, { path: [14, "connectionClientState"], serviceLoader }),
             /**
              * getConnectionConsensusState queries the consensus state associated with the
              * connection.
@@ -664,35 +664,35 @@ function createSDK(queryTransport, txTransport) {
             getConnectionConsensusState: (0, import_sdkMetadata.withMetadata)(async function getConnectionConsensusState(input, options) {
               const service = await serviceLoader.loadAt(14);
               return getClient(service).connectionConsensusState(input, options);
-            }, { path: [14, 4] }),
+            }, { path: [14, "connectionConsensusState"], serviceLoader }),
             /**
              * getConnectionParams queries all parameters of the ibc connection submodule.
              */
             getConnectionParams: (0, import_sdkMetadata.withMetadata)(async function getConnectionParams(input = {}, options) {
               const service = await serviceLoader.loadAt(14);
               return getClient(service).connectionParams(input, options);
-            }, { path: [14, 5] }),
+            }, { path: [14, "connectionParams"], serviceLoader }),
             /**
              * connectionOpenInit defines a rpc handler method for MsgConnectionOpenInit.
              */
             connectionOpenInit: (0, import_sdkMetadata.withMetadata)(async function connectionOpenInit(input, options) {
               const service = await serviceLoader.loadAt(15);
               return getMsgClient(service).connectionOpenInit(input, options);
-            }, { path: [15, 0] }),
+            }, { path: [15, "connectionOpenInit"], serviceLoader }),
             /**
              * connectionOpenTry defines a rpc handler method for MsgConnectionOpenTry.
              */
             connectionOpenTry: (0, import_sdkMetadata.withMetadata)(async function connectionOpenTry(input, options) {
               const service = await serviceLoader.loadAt(15);
               return getMsgClient(service).connectionOpenTry(input, options);
-            }, { path: [15, 1] }),
+            }, { path: [15, "connectionOpenTry"], serviceLoader }),
             /**
              * connectionOpenAck defines a rpc handler method for MsgConnectionOpenAck.
              */
             connectionOpenAck: (0, import_sdkMetadata.withMetadata)(async function connectionOpenAck(input, options) {
               const service = await serviceLoader.loadAt(15);
               return getMsgClient(service).connectionOpenAck(input, options);
-            }, { path: [15, 2] }),
+            }, { path: [15, "connectionOpenAck"], serviceLoader }),
             /**
              * connectionOpenConfirm defines a rpc handler method for
              * MsgConnectionOpenConfirm.
@@ -700,7 +700,7 @@ function createSDK(queryTransport, txTransport) {
             connectionOpenConfirm: (0, import_sdkMetadata.withMetadata)(async function connectionOpenConfirm(input, options) {
               const service = await serviceLoader.loadAt(15);
               return getMsgClient(service).connectionOpenConfirm(input, options);
-            }, { path: [15, 3] }),
+            }, { path: [15, "connectionOpenConfirm"], serviceLoader }),
             /**
              * updateConnectionParams defines a rpc handler method for
              * MsgUpdateParams.
@@ -708,7 +708,7 @@ function createSDK(queryTransport, txTransport) {
             updateConnectionParams: (0, import_sdkMetadata.withMetadata)(async function updateConnectionParams(input, options) {
               const service = await serviceLoader.loadAt(15);
               return getMsgClient(service).updateConnectionParams(input, options);
-            }, { path: [15, 4] })
+            }, { path: [15, "updateConnectionParams"], serviceLoader })
           }
         }
       },
@@ -721,35 +721,35 @@ function createSDK(queryTransport, txTransport) {
             getChecksums: (0, import_sdkMetadata.withMetadata)(async function getChecksums(input, options) {
               const service = await serviceLoader.loadAt(16);
               return getClient(service).checksums(input, options);
-            }, { path: [16, 0] }),
+            }, { path: [16, "checksums"], serviceLoader }),
             /**
              * Get Wasm code for given checksum
              */
             getCode: (0, import_sdkMetadata.withMetadata)(async function getCode(input, options) {
               const service = await serviceLoader.loadAt(16);
               return getClient(service).code(input, options);
-            }, { path: [16, 1] }),
+            }, { path: [16, "code"], serviceLoader }),
             /**
              * storeCode defines a rpc handler method for MsgStoreCode.
              */
             storeCode: (0, import_sdkMetadata.withMetadata)(async function storeCode(input, options) {
               const service = await serviceLoader.loadAt(17);
               return getMsgClient(service).storeCode(input, options);
-            }, { path: [17, 0] }),
+            }, { path: [17, "storeCode"], serviceLoader }),
             /**
              * removeChecksum defines a rpc handler method for MsgRemoveChecksum.
              */
             removeChecksum: (0, import_sdkMetadata.withMetadata)(async function removeChecksum(input, options) {
               const service = await serviceLoader.loadAt(17);
               return getMsgClient(service).removeChecksum(input, options);
-            }, { path: [17, 1] }),
+            }, { path: [17, "removeChecksum"], serviceLoader }),
             /**
              * migrateContract defines a rpc handler method for MsgMigrateContract.
              */
             migrateContract: (0, import_sdkMetadata.withMetadata)(async function migrateContract(input, options) {
               const service = await serviceLoader.loadAt(17);
               return getMsgClient(service).migrateContract(input, options);
-            }, { path: [17, 2] })
+            }, { path: [17, "migrateContract"], serviceLoader })
           }
         }
       }