feat(network): add API endpoints for deployment (#860)

refs #767

Author: jzsfkzm

apps/api/src/app.ts

@@ -19,6 +19,7 @@ import { apiKeysRouter } from "./auth/routes/api-keys/api-keys.router";
 import { bidsRouter } from "./bid/routes/bids/bids.router";
 import { chainDb, syncUserSchema, userDb } from "./db/dbConnection";
 import { deploymentSettingRouter } from "./deployment/routes/deployment-setting/deployment-setting.router";
+import { deploymentsRouter } from "./deployment/routes/deployments/deployments.router";
 import { clientInfoMiddleware } from "./middlewares/clientInfoMiddleware";
 import { apiRouter } from "./routers/apiRouter";
 import { dashboardRouter } from "./routers/dashboardRouter";
@@ -87,6 +88,7 @@ appHono.route("/", createAnonymousUserRouter);
 appHono.route("/", getAnonymousUserRouter);
 appHono.route("/", sendVerificationEmailRouter);
 appHono.route("/", deploymentSettingRouter);
+appHono.route("/", deploymentsRouter);
 appHono.route("/", apiKeysRouter);
 appHono.route("/", bidsRouter);
 

apps/api/src/billing/services/managed-signer/managed-signer.service.ts

@@ -45,15 +45,17 @@ export class ManagedSignerService {
   }
 
   async executeEncodedTxByUserId(userId: UserWalletOutput["userId"], messages: StringifiedEncodeObject[]) {
+    return this.executeDecodedTxByUserId(userId, this.decodeMessages(messages));
+  }
+
+  async executeDecodedTxByUserId(userId: UserWalletOutput["userId"], messages: EncodeObject[]) {
     const userWallet = await this.userWalletRepository.accessibleBy(this.authService.ability, "sign").findOneByUserId(userId);
     assert(userWallet, 404, "UserWallet Not Found");
 
-    const decodedMessages = this.decodeMessages(messages);
-
-    await Promise.all(decodedMessages.map(message => this.anonymousValidateService.validateLeaseProviders(message, userWallet)));
+    await Promise.all(messages.map(message => this.anonymousValidateService.validateLeaseProviders(message, userWallet)));
 
     try {
-      const tx = await this.executeManagedTx(userWallet.id, decodedMessages);
+      const tx = await this.executeManagedTx(userWallet.id, messages);
 
       await this.balancesService.refreshUserWalletLimits(userWallet);
 
@@ -68,7 +70,7 @@ export class ManagedSignerService {
 
       return result;
     } catch (error) {
-      throw this.chainErrorService.toAppError(error, decodedMessages);
+      throw this.chainErrorService.toAppError(error, messages);
     }
   }
 

apps/api/src/billing/services/rpc-message-service/rpc-message.service.ts

@@ -1,4 +1,5 @@
-import { DepositDeploymentAuthorization, MsgCloseDeployment, MsgDepositDeployment } from "@akashnetwork/akash-api/v1beta3";
+import { GroupSpec } from "@akashnetwork/akash-api/akash/deployment/v1beta3";
+import { DepositDeploymentAuthorization, MsgCloseDeployment, MsgCreateDeployment, MsgDepositDeployment } from "@akashnetwork/akash-api/v1beta3";
 import { MsgExec, MsgRevoke } from "cosmjs-types/cosmos/authz/v1beta1/tx";
 import { BasicAllowance } from "cosmjs-types/cosmos/feegrant/v1beta1/feegrant";
 import { MsgGrantAllowance } from "cosmjs-types/cosmos/feegrant/v1beta1/tx";
@@ -29,6 +30,12 @@ export interface ExecDepositDeploymentMsgOptions extends DepositDeploymentMsgOpt
   grantee: string;
 }
 
+export interface CreateDeploymentMsgOptions extends DepositDeploymentMsgOptionsBase {
+  groups: GroupSpec[];
+  manifestVersion: Uint8Array;
+  depositor: string;
+}
+
 export interface DepositDeploymentMsg {
   typeUrl: "/akash.deployment.v1beta3.MsgDepositDeployment";
   value: {
@@ -135,6 +142,25 @@ export class RpcMessageService {
     };
   }
 
+  getCreateDeploymentMsg({ owner, dseq, groups, manifestVersion, denom, amount, depositor }: CreateDeploymentMsgOptions) {
+    return {
+      typeUrl: `/akash.deployment.v1beta3.MsgCreateDeployment`,
+      value: MsgCreateDeployment.fromPartial({
+        id: {
+          owner,
+          dseq,
+        },
+        groups,
+        version: manifestVersion,
+        deposit: {
+          denom,
+          amount: amount.toString(),
+        },
+        depositor,
+      })
+    };
+  }
+
   getDepositDeploymentMsg({ owner, dseq, amount, denom, depositor }: DepositDeploymentMsgOptions): DepositDeploymentMsg {
     return {
       typeUrl: "/akash.deployment.v1beta3.MsgDepositDeployment",

apps/api/src/console.ts

@@ -11,7 +11,7 @@ import { z } from "zod";
 
 import { WalletController } from "@src/billing/controllers/wallet/wallet.controller";
 import { chainDb } from "@src/db/dbConnection";
-import { TopUpDeploymentsController } from "@src/deployment/controllers/deployment/deployment.controller";
+import { TopUpDeploymentsController } from "@src/deployment/controllers/deployment/top-up-deployments.controller";
 import { GpuBotController } from "@src/deployment/controllers/gpu-bot/gpu-bot.controller";
 import { UserController } from "@src/user/controllers/user/user.controller";
 import { UserConfigService } from "@src/user/services/user-config/user-config.service";

apps/api/src/core/providers/http-sdk.provider.ts

@@ -1,8 +1,8 @@
-import { AuthzHttpService, BalanceHttpService, BidHttpService, BlockHttpService } from "@akashnetwork/http-sdk";
+import { AuthzHttpService, BalanceHttpService, BidHttpService, BlockHttpService, DeploymentHttpService, LeaseHttpService } from "@akashnetwork/http-sdk";
 import { container } from "tsyringe";
 
 import { apiNodeUrl } from "@src/utils/constants";
 
-const SERVICES = [BalanceHttpService, AuthzHttpService, BlockHttpService, BidHttpService];
+const SERVICES = [BalanceHttpService, AuthzHttpService, BlockHttpService, BidHttpService, DeploymentHttpService, LeaseHttpService];
 
 SERVICES.forEach(Service => container.register(Service, { useValue: new Service({ baseURL: apiNodeUrl }) }));

apps/api/src/deployment/controllers/deployment/deployment.controller.ts

@@ -1,22 +1,39 @@
 import { singleton } from "tsyringe";
 
-import { StaleManagedDeploymentsCleanerService } from "@src/deployment/services/stale-managed-deployments-cleaner/stale-managed-deployments-cleaner.service";
-import { TopUpManagedDeploymentsService } from "@src/deployment/services/top-up-managed-deployments/top-up-managed-deployments.service";
-import { TopUpDeploymentsOptions } from "@src/deployment/types/deployments-refiller";
-import { CleanUpStaleDeploymentsParams } from "@src/deployment/types/state-deployments";
+import { AuthService, Protected } from "@src/auth/services/auth.service";
+import { UserWalletRepository } from "@src/billing/repositories";
+import { CreateDeploymentRequest, CreateDeploymentResponse, GetDeploymentResponse } from "@src/deployment/http-schemas/deployment.schema";
+import { DeploymentService } from "@src/deployment/services/deployment/deployment.service";
 
 @singleton()
-export class TopUpDeploymentsController {
+export class DeploymentController {
   constructor(
-    private readonly topUpManagedDeploymentsService: TopUpManagedDeploymentsService,
-    private readonly staleDeploymentsCleanerService: StaleManagedDeploymentsCleanerService
+    private readonly deploymentService: DeploymentService,
+    private readonly authService: AuthService,
+    private readonly userWalletRepository: UserWalletRepository
   ) {}
 
-  async topUpDeployments(options: TopUpDeploymentsOptions) {
-    await this.topUpManagedDeploymentsService.topUpDeployments(options);
+  @Protected([{ action: "sign", subject: "UserWallet" }])
+  async findByDseqAndUserId(dseq: string, userId?: string): Promise<GetDeploymentResponse> {
+    const { currentUser, ability } = this.authService;
+
+    const wallets = await this.userWalletRepository.accessibleBy(ability, "sign").findByUserId(userId ?? currentUser.userId);
+    const deployment = await this.deploymentService.findByOwnerAndDseq(wallets[0].address, dseq);
+
+    return {
+      data: deployment
+    }
   }
 
-  async cleanUpStaleDeployment(options: CleanUpStaleDeploymentsParams) {
-    await this.staleDeploymentsCleanerService.cleanup(options);
+  @Protected([{ action: "sign", subject: "UserWallet" }])
+  async create(input: CreateDeploymentRequest['data']): Promise<CreateDeploymentResponse> {
+    const { currentUser, ability } = this.authService;
+
+    const wallets = await this.userWalletRepository.accessibleBy(ability, "sign").findByUserId(currentUser.userId);
+    const result = await this.deploymentService.create(wallets[0], input);
+
+    return {
+      data: result
+    };
   }
 }

apps/api/src/deployment/controllers/deployment/top-up-deployments.controller.ts

@@ -0,0 +1,22 @@
+import { singleton } from "tsyringe";
+
+import { StaleManagedDeploymentsCleanerService } from "@src/deployment/services/stale-managed-deployments-cleaner/stale-managed-deployments-cleaner.service";
+import { TopUpManagedDeploymentsService } from "@src/deployment/services/top-up-managed-deployments/top-up-managed-deployments.service";
+import { TopUpDeploymentsOptions } from "@src/deployment/types/deployments-refiller";
+import { CleanUpStaleDeploymentsParams } from "@src/deployment/types/state-deployments";
+
+@singleton()
+export class TopUpDeploymentsController {
+  constructor(
+    private readonly topUpManagedDeploymentsService: TopUpManagedDeploymentsService,
+    private readonly staleDeploymentsCleanerService: StaleManagedDeploymentsCleanerService
+  ) {}
+
+  async topUpDeployments(options: TopUpDeploymentsOptions) {
+    await this.topUpManagedDeploymentsService.topUpDeployments(options);
+  }
+
+  async cleanUpStaleDeployment(options: CleanUpStaleDeploymentsParams) {
+    await this.staleDeploymentsCleanerService.cleanup(options);
+  }
+}

apps/api/src/deployment/http-schemas/deployment.schema.ts

@@ -0,0 +1,75 @@
+import { z } from "zod";
+
+import { SignTxResponseOutputSchema } from "@src/billing/routes/sign-and-broadcast-tx/sign-and-broadcast-tx.router";
+
+export const DeploymentResponseSchema = z.object({
+  deployment: z.object({
+    deployment_id: z.object({
+      owner: z.string(),
+      dseq: z.string(),
+    }),
+    state: z.string(),
+    version: z.string(),
+    created_at: z.string(),
+  }),
+  leases: z.array(z.object({
+    lease_id: z.object({
+        owner: z.string(),
+        dseq: z.string(),
+        gseq: z.number(),
+        oseq: z.number(),
+        provider: z.string(),
+    }),
+    state: z.string(),
+    price: z.object({
+        denom: z.string(),
+        amount: z.string(),
+    }),
+    created_at: z.string(),
+    closed_on: z.string(),
+  })),
+  escrow_account: z.object({
+    id: z.object({
+      scope: z.string(),
+      xid: z.string(),
+    }),
+    owner: z.string(),
+    state: z.string(),
+    balance: z.object({
+      denom: z.string(),
+      amount: z.string(),
+    }),
+    transferred: z.object({
+      denom: z.string(),
+      amount: z.string(),
+    }),
+    settled_at: z.string(),
+    depositor: z.string(),
+    funds: z.object({
+      denom: z.string(),
+      amount: z.string(),
+    })
+  })
+});
+
+export const GetDeploymentQuerySchema = z.object({
+  dseq: z.string(),
+  userId: z.optional(z.string()),
+});
+
+export const GetDeploymentResponseSchema = z.object({
+  data: DeploymentResponseSchema
+});
+
+export const CreateDeploymentRequestSchema = z.object({
+  data: z.object({
+    sdl: z.string(),
+    deposit: z.number(),
+  })
+});
+
+export const CreateDeploymentResponseSchema = SignTxResponseOutputSchema;
+
+export type GetDeploymentResponse = z.infer<typeof GetDeploymentResponseSchema>;
+export type CreateDeploymentRequest = z.infer<typeof CreateDeploymentRequestSchema>;
+export type CreateDeploymentResponse = z.infer<typeof CreateDeploymentResponseSchema>;

apps/api/src/deployment/routes/deployments/deployments.router.ts

@@ -0,0 +1,66 @@
+import { createRoute } from "@hono/zod-openapi";
+import { container } from "tsyringe";
+
+import { OpenApiHonoHandler } from "@src/core/services/open-api-hono-handler/open-api-hono-handler";
+import { DeploymentController } from "@src/deployment/controllers/deployment/deployment.controller";
+import { CreateDeploymentRequestSchema, CreateDeploymentResponseSchema, GetDeploymentQuerySchema, GetDeploymentResponseSchema } from "@src/deployment/http-schemas/deployment.schema";
+
+const getRoute = createRoute({
+  method: "get",
+  path: "/v1/deployments",
+  summary: "Get a deployment",
+  tags: ["Deployments"],
+  request: {
+    query: GetDeploymentQuerySchema
+  },
+  responses: {
+    200: {
+      description: "Returns deployment info",
+      content: {
+        "application/json": {
+          schema: GetDeploymentResponseSchema
+        }
+      }
+    }
+  }
+});
+
+const postRoute = createRoute({
+  method: "post",
+  path: "/v1/deployments",
+  summary: "Create new deployment",
+  tags: ["Deployments"],
+  request: {
+    body: {
+      content: {
+        "application/json": {
+          schema: CreateDeploymentRequestSchema
+        }
+      }
+    }
+  },
+  responses: {
+    201: {
+      description: "API key created successfully",
+      content: {
+        "application/json": {
+          schema: CreateDeploymentResponseSchema
+        }
+      }
+    }
+  }
+});
+
+export const deploymentsRouter = new OpenApiHonoHandler();
+
+deploymentsRouter.openapi(getRoute, async function routeGetDeployment(c) {
+  const { dseq, userId } = c.req.valid("query");
+  const result = await container.resolve(DeploymentController).findByDseqAndUserId(dseq, userId);
+  return c.json(result, 200);
+});
+
+deploymentsRouter.openapi(postRoute, async function routeCreateDeployment(c) {
+  const { data } = c.req.valid("json");
+  const result = await container.resolve(DeploymentController).create(data);
+  return c.json(result, 201);
+});

apps/api/src/deployment/services/deployment/deployment.service.ts

@@ -0,0 +1,67 @@
+import { SDL } from "@akashnetwork/akashjs/build/sdl";
+import { BlockHttpService, DeploymentHttpService, LeaseHttpService } from "@akashnetwork/http-sdk";
+import { BadRequest, InternalServerError, NotFound } from "http-errors";
+import { singleton } from "tsyringe";
+
+import { InjectWallet } from "@src/billing/providers/wallet.provider";
+import { UserWalletOutput } from "@src/billing/repositories";
+import { ManagedSignerService, RpcMessageService, Wallet } from "@src/billing/services";
+import { BillingConfigService } from "@src/billing/services/billing-config/billing-config.service";
+import { CreateDeploymentRequest, CreateDeploymentResponse, GetDeploymentResponse } from "@src/deployment/http-schemas/deployment.schema";
+
+@singleton()
+export class DeploymentService {
+  constructor(
+    private readonly blockHttpService: BlockHttpService,
+    private readonly deploymentHttpService: DeploymentHttpService,
+    private readonly leaseHttpService: LeaseHttpService,
+    private readonly signerService: ManagedSignerService,
+    @InjectWallet("MANAGED") private readonly masterWallet: Wallet,
+    private readonly billingConfigService: BillingConfigService,
+    private readonly rpcMessageService: RpcMessageService,
+  ) { }
+
+  public async findByOwnerAndDseq(owner: string, dseq: string): Promise<GetDeploymentResponse['data']> {
+    const deploymentResponse = await this.deploymentHttpService.findByOwnerAndDseq(owner, dseq);
+    if ("code" in deploymentResponse) {
+      if (deploymentResponse.message?.toLowerCase().includes("deployment not found")) {
+        throw new NotFound("Deployment not found");
+      }
+
+      throw new InternalServerError(deploymentResponse.message);
+    }
+
+    const { leases } = await this.leaseHttpService.listByOwnerAndDseq(owner, dseq);
+
+    return {
+      deployment: deploymentResponse.deployment,
+      leases: leases.map(({ lease }) => lease),
+      escrow_account: deploymentResponse.escrow_account
+    };
+  }
+
+  public async create(wallet: UserWalletOutput, input: CreateDeploymentRequest['data']): Promise<CreateDeploymentResponse['data']> {
+    let sdl: SDL;
+    try {
+      sdl = SDL.fromString(input.sdl, 'beta3');
+    } catch (error) {
+      if (error.name === 'SdlValidationError') {
+        throw new BadRequest(error.message);
+      }
+
+      throw new BadRequest("Invalid SDL");
+    }
+
+    const message = this.rpcMessageService.getCreateDeploymentMsg({
+      owner: wallet.address,
+      dseq: await this.blockHttpService.getCurrentHeight(),
+      groups: sdl.groups(),
+      denom: this.billingConfigService.get("DEPLOYMENT_GRANT_DENOM"),
+      amount: input.deposit,
+      manifestVersion: await sdl.manifestVersion(),
+      depositor: await this.masterWallet.getFirstAddress()
+    });
+
+    return await this.signerService.executeDecodedTxByUserId(wallet.userId, [message]);
+  }
+}