@akashnetwork/chain-sdk 1.0.0-alpha.41 → 1.0.0-alpha.43

package/dist/cjs/generated/createNodeSDK.cjs

@@ -59,6 +59,8 @@ const serviceLoader = (0, import_createServiceLoader.createServiceLoader)([
   () => Promise.resolve().then(() => __toESM(require("./protos/akash/provider/v1beta4/service_akash.cjs"), 1)).then((m) => m.Msg),
   () => Promise.resolve().then(() => __toESM(require("./protos/akash/take/v1/query_akash.cjs"), 1)).then((m) => m.Query),
   () => Promise.resolve().then(() => __toESM(require("./protos/akash/take/v1/service_akash.cjs"), 1)).then((m) => m.Msg),
+  () => Promise.resolve().then(() => __toESM(require("./protos/akash/verification/v1/query_akash.cjs"), 1)).then((m) => m.Query),
+  () => Promise.resolve().then(() => __toESM(require("./protos/akash/verification/v1/service_akash.cjs"), 1)).then((m) => m.Msg),
   () => Promise.resolve().then(() => __toESM(require("./protos/akash/wasm/v1/query_akash.cjs"), 1)).then((m) => m.Query),
   () => Promise.resolve().then(() => __toESM(require("./protos/akash/wasm/v1/service_akash.cjs"), 1)).then((m) => m.Msg)
 ]);
@@ -408,6 +410,13 @@ function createSDK(queryTransport, txTransport) {
             const service = await serviceLoader.loadAt(13);
             return getClient(service).lease(input, options);
           }, { path: [13, "lease"], serviceLoader }),
+          /**
+           * getProviderLeaseStats queries aggregate lease-completion stats for a provider.
+           */
+          getProviderLeaseStats: (0, import_sdkMetadata.withMetadata)(async function getProviderLeaseStats(input, options) {
+            const service = await serviceLoader.loadAt(13);
+            return getClient(service).providerLeaseStats(input, options);
+          }, { path: [13, "providerLeaseStats"], serviceLoader }),
           /**
            * getParams returns the total set of market parameters.
            */
@@ -567,6 +576,34 @@ function createSDK(queryTransport, txTransport) {
             const service = await serviceLoader.loadAt(19);
             return getClient(service).provider(input, options);
           }, { path: [19, "provider"], serviceLoader }),
+          /**
+           * getProviderMaintenance queries a provider maintenance record.
+           */
+          getProviderMaintenance: (0, import_sdkMetadata.withMetadata)(async function getProviderMaintenance(input, options) {
+            const service = await serviceLoader.loadAt(19);
+            return getClient(service).providerMaintenance(input, options);
+          }, { path: [19, "providerMaintenance"], serviceLoader }),
+          /**
+           * getProviderMaintenances queries provider maintenance records.
+           */
+          getProviderMaintenances: (0, import_sdkMetadata.withMetadata)(async function getProviderMaintenances(input, options) {
+            const service = await serviceLoader.loadAt(19);
+            return getClient(service).providerMaintenances(input, options);
+          }, { path: [19, "providerMaintenances"], serviceLoader }),
+          /**
+           * getParams returns the x/provider ProviderMaintenanceParams.
+           */
+          getParams: (0, import_sdkMetadata.withMetadata)(async function getParams(input = {}, options) {
+            const service = await serviceLoader.loadAt(19);
+            return getClient(service).params(input, options);
+          }, { path: [19, "params"], serviceLoader }),
+          /**
+           * getRegistration queries provider registration details.
+           */
+          getRegistration: (0, import_sdkMetadata.withMetadata)(async function getRegistration(input, options) {
+            const service = await serviceLoader.loadAt(19);
+            return getClient(service).registration(input, options);
+          }, { path: [19, "registration"], serviceLoader }),
           /**
            * createProvider defines a method that creates a provider given the proper inputs.
            */
@@ -587,7 +624,31 @@ function createSDK(queryTransport, txTransport) {
           deleteProvider: (0, import_sdkMetadata.withMetadata)(async function deleteProvider(input, options) {
             const service = await serviceLoader.loadAt(20);
             return getMsgClient(service).deleteProvider(input, options);
-          }, { path: [20, "deleteProvider"], serviceLoader })
+          }, { path: [20, "deleteProvider"], serviceLoader }),
+          /**
+           * openProviderMaintenance opens a provider maintenance window.
+           */
+          openProviderMaintenance: (0, import_sdkMetadata.withMetadata)(async function openProviderMaintenance(input, options) {
+            const service = await serviceLoader.loadAt(20);
+            return getMsgClient(service).openProviderMaintenance(input, options);
+          }, { path: [20, "openProviderMaintenance"], serviceLoader }),
+          /**
+           * closeProviderMaintenance closes an open maintenance window.
+           */
+          closeProviderMaintenance: (0, import_sdkMetadata.withMetadata)(async function closeProviderMaintenance(input, options) {
+            const service = await serviceLoader.loadAt(20);
+            return getMsgClient(service).closeProviderMaintenance(input, options);
+          }, { path: [20, "closeProviderMaintenance"], serviceLoader }),
+          /**
+           * updateParams is a governance operation for updating the x/provider
+           * parameters.
+           *
+           * Since: akash v1.0.0
+           */
+          updateParams: (0, import_sdkMetadata.withMetadata)(async function updateParams(input, options) {
+            const service = await serviceLoader.loadAt(20);
+            return getMsgClient(service).updateParams(input, options);
+          }, { path: [20, "updateParams"], serviceLoader })
         }
       },
       take: {
@@ -611,15 +672,277 @@ function createSDK(queryTransport, txTransport) {
           }, { path: [22, "updateParams"], serviceLoader })
         }
       },
-      wasm: {
+      verification: {
         v1: {
           /**
-           * getParams returns the total set of wasm parameters.
+           * getAuditor returns the on-chain record for a single auditor identified by
+           * its bech32 address.
+           */
+          getAuditor: (0, import_sdkMetadata.withMetadata)(async function getAuditor(input, options) {
+            const service = await serviceLoader.loadAt(23);
+            return getClient(service).auditor(input, options);
+          }, { path: [23, "auditor"], serviceLoader }),
+          /**
+           * getAuditors returns a paginated list of auditor records, optionally filtered
+           * by AuditorStatus.
+           */
+          getAuditors: (0, import_sdkMetadata.withMetadata)(async function getAuditors(input, options) {
+            const service = await serviceLoader.loadAt(23);
+            return getClient(service).auditors(input, options);
+          }, { path: [23, "auditors"], serviceLoader }),
+          /**
+           * getAttestation returns the attestation record for a specific
+           * (provider, auditor) pair.
+           */
+          getAttestation: (0, import_sdkMetadata.withMetadata)(async function getAttestation(input, options) {
+            const service = await serviceLoader.loadAt(23);
+            return getClient(service).attestation(input, options);
+          }, { path: [23, "attestation"], serviceLoader }),
+          /**
+           * getProviderAttestations returns a paginated list of all attestation records
+           * for the given provider, optionally filtered by AttestationStatus.
+           */
+          getProviderAttestations: (0, import_sdkMetadata.withMetadata)(async function getProviderAttestations(input, options) {
+            const service = await serviceLoader.loadAt(23);
+            return getClient(service).providerAttestations(input, options);
+          }, { path: [23, "providerAttestations"], serviceLoader }),
+          /**
+           * getAuditorAttestations returns a paginated list of all attestation records
+           * submitted by the given auditor. No status filter is applied; callers can
+           * page through every attestation the auditor has emitted.
+           */
+          getAuditorAttestations: (0, import_sdkMetadata.withMetadata)(async function getAuditorAttestations(input, options) {
+            const service = await serviceLoader.loadAt(23);
+            return getClient(service).auditorAttestations(input, options);
+          }, { path: [23, "auditorAttestations"], serviceLoader }),
+          /**
+           * getDiscrepancy returns a single discrepancy event by its numeric id.
+           */
+          getDiscrepancy: (0, import_sdkMetadata.withMetadata)(async function getDiscrepancy(input, options) {
+            const service = await serviceLoader.loadAt(23);
+            return getClient(service).discrepancy(input, options);
+          }, { path: [23, "discrepancy"], serviceLoader }),
+          /**
+           * getDiscrepancies returns a paginated list of discrepancy events, optionally
+           * filtered by DiscrepancyStatus.
+           */
+          getDiscrepancies: (0, import_sdkMetadata.withMetadata)(async function getDiscrepancies(input, options) {
+            const service = await serviceLoader.loadAt(23);
+            return getClient(service).discrepancies(input, options);
+          }, { path: [23, "discrepancies"], serviceLoader }),
+          /**
+           * getAuditEscrow returns a single audit-escrow record by its numeric id.
+           */
+          getAuditEscrow: (0, import_sdkMetadata.withMetadata)(async function getAuditEscrow(input, options) {
+            const service = await serviceLoader.loadAt(23);
+            return getClient(service).auditEscrow(input, options);
+          }, { path: [23, "auditEscrow"], serviceLoader }),
+          /**
+           * getProviderAuditEscrows returns a paginated list of audit-escrow records
+           * opened by the given provider, optionally filtered by AuditEscrowStatus.
+           */
+          getProviderAuditEscrows: (0, import_sdkMetadata.withMetadata)(async function getProviderAuditEscrows(input, options) {
+            const service = await serviceLoader.loadAt(23);
+            return getClient(service).providerAuditEscrows(input, options);
+          }, { path: [23, "providerAuditEscrows"], serviceLoader }),
+          /**
+           * getProviderVerificationGrace returns the verification-grace record for the
+           * given provider, if one is currently tracked.
+           */
+          getProviderVerificationGrace: (0, import_sdkMetadata.withMetadata)(async function getProviderVerificationGrace(input, options) {
+            const service = await serviceLoader.loadAt(23);
+            return getClient(service).providerVerificationGrace(input, options);
+          }, { path: [23, "providerVerificationGrace"], serviceLoader }),
+          /**
+           * getProviderBond returns the provider's bond record.
+           */
+          getProviderBond: (0, import_sdkMetadata.withMetadata)(async function getProviderBond(input, options) {
+            const service = await serviceLoader.loadAt(23);
+            return getClient(service).providerBond(input, options);
+          }, { path: [23, "providerBond"], serviceLoader }),
+          /**
+           * getProviderSnapshot returns the most recent provider snapshot record posted
+           * on-chain by the given provider.
+           */
+          getProviderSnapshot: (0, import_sdkMetadata.withMetadata)(async function getProviderSnapshot(input, options) {
+            const service = await serviceLoader.loadAt(23);
+            return getClient(service).providerSnapshot(input, options);
+          }, { path: [23, "providerSnapshot"], serviceLoader }),
+          /**
+           * getParams returns the current parameter set for the verification module.
            */
           getParams: (0, import_sdkMetadata.withMetadata)(async function getParams(input = {}, options) {
             const service = await serviceLoader.loadAt(23);
             return getClient(service).params(input, options);
           }, { path: [23, "params"], serviceLoader }),
+          /**
+           * postAuditorBond posts (or tops up) an auditor's verification bond.
+           */
+          postAuditorBond: (0, import_sdkMetadata.withMetadata)(async function postAuditorBond(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).postAuditorBond(input, options);
+          }, { path: [24, "postAuditorBond"], serviceLoader }),
+          /**
+           * openAuditEscrow opens a new audit escrow funding a pending attestation.
+           */
+          openAuditEscrow: (0, import_sdkMetadata.withMetadata)(async function openAuditEscrow(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).openAuditEscrow(input, options);
+          }, { path: [24, "openAuditEscrow"], serviceLoader }),
+          /**
+           * cancelAuditEscrow cancels an open, unconsumed audit escrow before expiry
+           * and returns the fee and provider deposit to the provider.
+           */
+          cancelAuditEscrow: (0, import_sdkMetadata.withMetadata)(async function cancelAuditEscrow(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).cancelAuditEscrow(input, options);
+          }, { path: [24, "cancelAuditEscrow"], serviceLoader }),
+          /**
+           * settleAuditEscrow settles an unconsumed audit escrow with an explicit
+           * reason, fault attribution, and evidence reference.
+           */
+          settleAuditEscrow: (0, import_sdkMetadata.withMetadata)(async function settleAuditEscrow(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).settleAuditEscrow(input, options);
+          }, { path: [24, "settleAuditEscrow"], serviceLoader }),
+          /**
+           * submitAttestation submits an attestation about a provider; the first
+           * valid submission against a matching open escrow consumes it.
+           */
+          submitAttestation: (0, import_sdkMetadata.withMetadata)(async function submitAttestation(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).submitAttestation(input, options);
+          }, { path: [24, "submitAttestation"], serviceLoader }),
+          /**
+           * revokeAttestation revokes a previously submitted attestation with a
+           * typed reason and evidence reference.
+           */
+          revokeAttestation: (0, import_sdkMetadata.withMetadata)(async function revokeAttestation(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).revokeAttestation(input, options);
+          }, { path: [24, "revokeAttestation"], serviceLoader }),
+          /**
+           * removeAttestation voluntarily removes an attestation associated with the
+           * signing provider.
+           */
+          removeAttestation: (0, import_sdkMetadata.withMetadata)(async function removeAttestation(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).removeAttestation(input, options);
+          }, { path: [24, "removeAttestation"], serviceLoader }),
+          /**
+           * resignAuditor voluntarily exits the auditor role and begins unbonding
+           * of any posted auditor bond.
+           */
+          resignAuditor: (0, import_sdkMetadata.withMetadata)(async function resignAuditor(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).resignAuditor(input, options);
+          }, { path: [24, "resignAuditor"], serviceLoader }),
+          /**
+           * postProviderBond posts (or tops up) a provider's resource-scaled
+           * verification bond.
+           */
+          postProviderBond: (0, import_sdkMetadata.withMetadata)(async function postProviderBond(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).postProviderBond(input, options);
+          }, { path: [24, "postProviderBond"], serviceLoader }),
+          /**
+           * withdrawProviderBond initiates withdrawal of part or all of a provider's
+           * verification bond.
+           */
+          withdrawProviderBond: (0, import_sdkMetadata.withMetadata)(async function withdrawProviderBond(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).withdrawProviderBond(input, options);
+          }, { path: [24, "withdrawProviderBond"], serviceLoader }),
+          /**
+           * postSnapshotHash posts the provider's most recent resource snapshot hash
+           * and inline resource summary.
+           */
+          postSnapshotHash: (0, import_sdkMetadata.withMetadata)(async function postSnapshotHash(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).postSnapshotHash(input, options);
+          }, { path: [24, "postSnapshotHash"], serviceLoader }),
+          /**
+           * registerAuditor registers a new auditor with a maximum attestation tier;
+           * governance only.
+           */
+          registerAuditor: (0, import_sdkMetadata.withMetadata)(async function registerAuditor(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).registerAuditor(input, options);
+          }, { path: [24, "registerAuditor"], serviceLoader }),
+          /**
+           * renewAuditor renews an auditor's registration and resets the renewal
+           * deadline; governance only.
+           */
+          renewAuditor: (0, import_sdkMetadata.withMetadata)(async function renewAuditor(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).renewAuditor(input, options);
+          }, { path: [24, "renewAuditor"], serviceLoader }),
+          /**
+           * removeAuditor removes an auditor from the active set; governance only.
+           */
+          removeAuditor: (0, import_sdkMetadata.withMetadata)(async function removeAuditor(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).removeAuditor(input, options);
+          }, { path: [24, "removeAuditor"], serviceLoader }),
+          /**
+           * revokeProviderAttestation revokes a single attestation for a specific
+           * provider/auditor pair; governance only.
+           */
+          revokeProviderAttestation: (0, import_sdkMetadata.withMetadata)(async function revokeProviderAttestation(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).revokeProviderAttestation(input, options);
+          }, { path: [24, "revokeProviderAttestation"], serviceLoader }),
+          /**
+           * revokeAllProviderAttestations revokes every active attestation for a
+           * single provider; governance only.
+           */
+          revokeAllProviderAttestations: (0, import_sdkMetadata.withMetadata)(async function revokeAllProviderAttestations(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).revokeAllProviderAttestations(input, options);
+          }, { path: [24, "revokeAllProviderAttestations"], serviceLoader }),
+          /**
+           * revokeAuditorAttestations revokes every active attestation issued by a
+           * single auditor; governance only.
+           */
+          revokeAuditorAttestations: (0, import_sdkMetadata.withMetadata)(async function revokeAuditorAttestations(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).revokeAuditorAttestations(input, options);
+          }, { path: [24, "revokeAuditorAttestations"], serviceLoader }),
+          /**
+           * resolveDiscrepancy resolves a pending discrepancy between two auditors
+           * over the same provider; governance only.
+           */
+          resolveDiscrepancy: (0, import_sdkMetadata.withMetadata)(async function resolveDiscrepancy(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).resolveDiscrepancy(input, options);
+          }, { path: [24, "resolveDiscrepancy"], serviceLoader }),
+          /**
+           * slashProviderBond slashes a fraction of a provider's verification bond;
+           * governance only.
+           */
+          slashProviderBond: (0, import_sdkMetadata.withMetadata)(async function slashProviderBond(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).slashProviderBond(input, options);
+          }, { path: [24, "slashProviderBond"], serviceLoader }),
+          /**
+           * updateParams updates the x/verification module parameters; governance
+           * only.
+           */
+          updateParams: (0, import_sdkMetadata.withMetadata)(async function updateParams(input, options) {
+            const service = await serviceLoader.loadAt(24);
+            return getMsgClient(service).updateParams(input, options);
+          }, { path: [24, "updateParams"], serviceLoader })
+        }
+      },
+      wasm: {
+        v1: {
+          /**
+           * getParams returns the total set of wasm parameters.
+           */
+          getParams: (0, import_sdkMetadata.withMetadata)(async function getParams(input = {}, options) {
+            const service = await serviceLoader.loadAt(25);
+            return getClient(service).params(input, options);
+          }, { path: [25, "params"], serviceLoader }),
           /**
            * updateParams defines a governance operation for updating the x/wasm module
            * parameters. The authority is hard-coded to the x/gov module account.
@@ -627,9 +950,9 @@ function createSDK(queryTransport, txTransport) {
            * Since: akash v2.0.0
            */
           updateParams: (0, import_sdkMetadata.withMetadata)(async function updateParams(input, options) {
-            const service = await serviceLoader.loadAt(24);
+            const service = await serviceLoader.loadAt(26);
             return getMsgClient(service).updateParams(input, options);
-          }, { path: [24, "updateParams"], serviceLoader })
+          }, { path: [26, "updateParams"], serviceLoader })
         }
       }
     }