Remove check for deployer version number

Part of https://www.notion.so/Support-custom-domains-in-deploy-laconic-com-18aa6b22d4728067a44ae27090c02ce5 and cerc-io/snowballtools-base#47

- Support setting custom domain in deployments through targeted deployer
  - Store DNS record data for deployments
  - Show service provider IP address for creating required `A` record
  - Comment out verify domain and redirect domain functionality
  - Handle rollback deployment functionality
- Store DNS deployments record in Deployment table

Co-authored-by: IshaVenikar <ishavenikar7@gmail.com>
Co-authored-by: Shreerang Kale <shreerangkale@gmail.com>
Reviewed-on: cerc-io/snowballtools-base#49
Co-authored-by: Prathamesh Musale <prathamesh@noreply.git.vdb.to>
Co-committed-by: Prathamesh Musale <prathamesh@noreply.git.vdb.to>

.gitea/workflows/deploy-frontend.yaml

@@ -0,0 +1,61 @@
+name: Deploy Snowball frontend
+
+on:
+  push:
+    branches:
+      - main
+
+env:
+  REGISTRY_USER_KEY: ${{ secrets.REGISTRY_USER_KEY }}
+  REGISTRY_BOND_ID: ${{ secrets.REGISTRY_BOND_ID }}
+  DEPLOYER_LRN: lrn://vaasl-provider/deployers/webapp-deployer-api.apps.vaasl.io
+  AUTHORITY: laconic-deploy
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [20.x]
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v2
+
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Download yarn
+        run: |
+          curl -fsSL -o /usr/local/bin/yarn https://github.com/yarnpkg/yarn/releases/download/v1.22.21/yarn-1.22.21.js
+          chmod +x /usr/local/bin/yarn
+
+      - name: Install dependencies
+        run: |
+          yarn install
+
+      - name: Set up environment
+        run: |
+          # Create a .env file with the necessary variables
+          echo "REGISTRY_BOND_ID=$REGISTRY_BOND_ID" > packages/deployer/.env
+          echo "DEPLOYER_LRN=$DEPLOYER_LRN" >> packages/deployer/.env
+          echo "AUTHORITY=$AUTHORITY" >> packages/deployer/.env
+
+          # Create a config file with necessary endpoints and secrets
+          cat > packages/deployer/config.yml <<EOF
+          services:
+            registry:
+              rpcEndpoint: https://laconicd-sapo.laconic.com
+              gqlEndpoint: https://laconicd-sapo.laconic.com/api
+              userKey: $REGISTRY_USER_KEY
+              bondId: $REGISTRY_BOND_ID
+              chainId: laconic-testnet-2
+              gasPrice: 0.001alnt
+          EOF
+
+      - name: Run deploy script
+        run: |
+          cd packages/deployer
+          ./deploy-frontend.sh

build-webapp.sh

@@ -14,8 +14,10 @@ VITE_SERVER_URL = 'LACONIC_HOSTED_CONFIG_server_url'
 VITE_GITHUB_CLIENT_ID = 'LACONIC_HOSTED_CONFIG_github_clientid'
 VITE_GITHUB_PWA_TEMPLATE_REPO = 'LACONIC_HOSTED_CONFIG_github_pwa_templaterepo'
 VITE_GITHUB_IMAGE_UPLOAD_PWA_TEMPLATE_REPO = 'LACONIC_HOSTED_CONFIG_github_image_upload_templaterepo'
+VITE_GITHUB_NEXT_APP_TEMPLATE_REPO = 'LACONIC_HOSTED_CONFIG_github_next_app_templaterepo'
 VITE_WALLET_CONNECT_ID = 'LACONIC_HOSTED_CONFIG_wallet_connect_id'
 VITE_LACONICD_CHAIN_ID = 'LACONIC_HOSTED_CONFIG_laconicd_chain_id'
+VITE_WALLET_IFRAME_URL = 'LACONIC_HOSTED_CONFIG_wallet_iframe_url'
 VITE_LIT_RELAY_API_KEY = 'LACONIC_HOSTED_CONFIG_lit_relay_api_key'
 VITE_BUGSNAG_API_KEY = 'LACONIC_HOSTED_CONFIG_bugsnag_api_key'
 VITE_PASSKEY_WALLET_RPID = 'LACONIC_HOSTED_CONFIG_passkey_wallet_rpid'

packages/backend/package.json

@@ -27,6 +27,7 @@
     "nanoid": "3",
     "nanoid-dictionary": "^5.0.0-beta.1",
     "octokit": "^3.1.2",
+    "openpgp": "^6.0.1",
     "reflect-metadata": "^0.2.1",
     "semver": "^7.6.0",
     "toml": "^3.0.0",

packages/backend/src/database.ts

@@ -17,13 +17,14 @@ import { DatabaseConfig } from './config';
 import { User } from './entity/User';
 import { Organization } from './entity/Organization';
 import { Project } from './entity/Project';
-import { Deployment } from './entity/Deployment';
+import { Deployment, DeploymentStatus } from './entity/Deployment';
 import { ProjectMember } from './entity/ProjectMember';
 import { EnvironmentVariable } from './entity/EnvironmentVariable';
 import { Domain } from './entity/Domain';
 import { getEntities, loadAndSaveData } from './utils';
 import { UserOrganization } from './entity/UserOrganization';
 import { Deployer } from './entity/Deployer';
+import { DNSRecordAttributes } from './types';
 
 const ORGANIZATION_DATA_PATH = '../test/fixtures/organizations.json';
 
@@ -49,12 +50,25 @@ export class Database {
     await this.dataSource.initialize();
     log('database initialized');
 
-    const organizations = await this.getOrganizations({});
+    let organizations = await this.getOrganizations({});
 
     // Load an organization if none exist
     if (!organizations.length) {
       const orgEntities = await getEntities(path.resolve(__dirname, ORGANIZATION_DATA_PATH));
-      await loadAndSaveData(Organization, this.dataSource, [orgEntities[0]]);
+      organizations = await loadAndSaveData(Organization, this.dataSource, [orgEntities[0]]);
+    }
+
+    // Hotfix for updating old DB data
+    if (organizations[0].slug === 'snowball-tools-1') {
+      const [orgEntity] = await getEntities(path.resolve(__dirname, ORGANIZATION_DATA_PATH));
+
+      await this.updateOrganization(
+        organizations[0].id,
+        {
+          slug: orgEntity.slug as string,
+          name: orgEntity.name as string
+        }
+      )
     }
   }
 
@@ -121,6 +135,14 @@ export class Database {
     return newUserOrganization;
   }
 
+  async updateOrganization(organizationId: string, data: DeepPartial<Organization>): Promise<boolean> {
+    const organizationRepository = this.dataSource.getRepository(Organization);
+    const updateResult = await organizationRepository.update({ id: organizationId }, data);
+    assert(updateResult.affected);
+
+    return updateResult.affected > 0;
+  }
+
   async getProjects(options: FindManyOptions<Project>): Promise<Project[]> {
     const projectRepository = this.dataSource.getRepository(Project);
     const projects = await projectRepository.find(options);
@@ -136,10 +158,9 @@ export class Database {
       .leftJoinAndSelect(
         'project.deployments',
         'deployments',
-        'deployments.isCurrent = true'
+        'deployments.isCurrent = true AND deployments.isCanonical = true'
       )
       .leftJoinAndSelect('deployments.createdBy', 'user')
-      .leftJoinAndSelect('deployments.domain', 'domain')
       .leftJoinAndSelect('deployments.deployer', 'deployer')
       .leftJoinAndSelect('project.owner', 'owner')
       .leftJoinAndSelect('project.deployers', 'deployers')
@@ -181,9 +202,8 @@ export class Database {
       .leftJoinAndSelect(
         'project.deployments',
         'deployments',
-        'deployments.isCurrent = true'
+        'deployments.isCurrent = true AND deployments.isCanonical = true'
       )
-      .leftJoinAndSelect('deployments.domain', 'domain')
       .leftJoin('project.projectMembers', 'projectMembers')
       .leftJoin('project.organization', 'organization')
       .where(
@@ -214,7 +234,6 @@ export class Database {
     return this.getDeployments({
       relations: {
         project: true,
-        domain: true,
         createdBy: true,
         deployer: true,
       },
@@ -229,6 +248,25 @@ export class Database {
     });
   }
 
+  async getNonCanonicalDeploymentsByProjectId(projectId: string): Promise<Deployment[]> {
+    return this.getDeployments({
+      relations: {
+        project: true,
+        createdBy: true,
+        deployer: true,
+      },
+      where: {
+        project: {
+          id: projectId
+        },
+        isCanonical: false
+      },
+      order: {
+        createdAt: 'DESC'
+      }
+    });
+  }
+
   async getDeployment(
     options: FindOneOptions<Deployment>
   ): Promise<Deployment | null> {
@@ -575,12 +613,56 @@ export class Database {
           id: projectId
         },
         ...filter
-      }
+      },
+      order: {
+        createdAt: 'DESC',
+      },
     });
 
     return domains;
   }
 
+  async getOldestDomainByProjectId(projectId: string): Promise<Domain | null> {
+    const domainRepository = this.dataSource.getRepository(Domain);
+
+    const domain = await domainRepository.findOne({
+      where: {
+        project: {
+          id: projectId,
+        },
+      },
+      order: {
+        createdAt: 'ASC',
+      },
+    });
+
+    return domain;
+  }
+
+  async getLatestDNSRecordByProjectId(
+    projectId: string,
+  ): Promise<DNSRecordAttributes | null> {
+    const deploymentRepository = this.dataSource.getRepository(Deployment);
+
+    const deployment = await deploymentRepository.findOne({
+      where: {
+        project: {
+          id: projectId,
+        },
+        status: DeploymentStatus.Ready,
+      },
+      order: {
+        createdAt: 'DESC'
+      }
+    });
+
+    if (deployment === null) {
+      throw new Error(`No deployment found for project ${projectId}`);
+    }
+
+    return deployment.dnsRecordData;
+  }
+
   async addDeployer(data: DeepPartial<Deployer>): Promise<Deployer> {
     const deployerRepository = this.dataSource.getRepository(Deployer);
     const newDomain = await deployerRepository.save(data);

packages/backend/src/entity/Deployer.ts

@@ -15,12 +15,18 @@ export class Deployer {
   @Column('varchar')
     baseDomain!: string;
 
+  @Column('varchar', { nullable: true})
+    publicKey!: string | null;
+
   @Column('varchar', { nullable: true })
     minimumPayment!: string | null;
 
   @Column('varchar', { nullable: true })
     paymentAddress!: string | null;
 
+  @Column('varchar', { nullable: true })
+    version!: string | null;
+
   @ManyToMany(() => Project, (project) => project.deployers)
     projects!: Project[];
 }

packages/backend/src/entity/Deployment.ts

@@ -14,7 +14,7 @@ import { Project } from './Project';
 import { Domain } from './Domain';
 import { User } from './User';
 import { Deployer } from './Deployer';
-import { AppDeploymentRecordAttributes, AppDeploymentRemovalRecordAttributes } from '../types';
+import { AppDeploymentRecordAttributes, AppDeploymentRemovalRecordAttributes, DNSRecordAttributes } from '../types';
 
 export enum Environment {
   Production = 'Production',
@@ -39,6 +39,7 @@ export interface ApplicationDeploymentRequest {
   config: string;
   meta: string;
   payment?: string;
+  dns?: string;
 }
 
 export interface ApplicationDeploymentRemovalRequest {
@@ -77,13 +78,6 @@ export class Deployment {
   @JoinColumn({ name: 'projectId' })
     project!: Project;
 
-  @Column({ nullable: true })
-    domainId!: string | null;
-
-  @OneToOne(() => Domain)
-  @JoinColumn({ name: 'domainId' })
-    domain!: Domain | null;
-
   @Column('varchar')
     branch!: string;
 
@@ -126,6 +120,9 @@ export class Deployment {
   @Column('simple-json', { nullable: true })
     applicationDeploymentRemovalRecordData!: AppDeploymentRemovalRecordAttributes | null;
 
+  @Column('simple-json', { nullable: true })
+    dnsRecordData!: DNSRecordAttributes | null;
+
   @ManyToOne(() => Deployer)
   @JoinColumn({ name: 'deployerLrn' })
     deployer!: Deployer;
@@ -138,6 +135,9 @@ export class Deployment {
   @Column('boolean', { default: false })
     isCurrent!: boolean;
 
+  @Column('boolean', { default: false })
+    isCanonical!: boolean;
+
   @Column({
     enum: DeploymentStatus
   })

packages/backend/src/registry.ts

@@ -4,6 +4,7 @@ import { DateTime } from 'luxon';
 import { Octokit } from 'octokit';
 import { inc as semverInc } from 'semver';
 import { DeepPartial } from 'typeorm';
+import * as openpgp from 'openpgp';
 
 import { Account, DEFAULT_GAS_ESTIMATION_MULTIPLIER, Registry as LaconicRegistry, getGasPrice, parseGasAndFees } from '@cerc-io/registry-sdk';
 import { DeliverTxResponse, IndexedTx } from '@cosmjs/stargate';
@@ -15,7 +16,7 @@ import {
   ApplicationDeploymentRequest,
   ApplicationDeploymentRemovalRequest
 } from './entity/Deployment';
-import { AppDeploymentRecord, AppDeploymentRemovalRecord, AuctionParams, DeployerRecord } from './types';
+import { AppDeploymentRecord, AppDeploymentRemovalRecord, AuctionParams, DeployerRecord, RegistryRecord } from './types';
 import { getConfig, getRepoDetails, registryTransactionWithRetry, sleep } from './utils';
 
 const log = debug('snowball:registry');
@@ -26,7 +27,7 @@ const APP_DEPLOYMENT_REQUEST_TYPE = 'ApplicationDeploymentRequest';
 const APP_DEPLOYMENT_REMOVAL_REQUEST_TYPE = 'ApplicationDeploymentRemovalRequest';
 const APP_DEPLOYMENT_RECORD_TYPE = 'ApplicationDeploymentRecord';
 const APP_DEPLOYMENT_REMOVAL_RECORD_TYPE = 'ApplicationDeploymentRemovalRecord';
-const WEBAPP_DEPLOYER_RECORD_TYPE = 'WebappDeployer'
+const WEBAPP_DEPLOYER_RECORD_TYPE = 'WebappDeployer';
 const SLEEP_DURATION = 1000;
 
 // TODO: Move registry code to registry-sdk/watcher-ts
@@ -107,19 +108,7 @@ export class Registry {
       ...(packageJSON.version && { app_version: packageJSON.version })
     };
 
-    const fee = parseGasAndFees(this.registryConfig.fee.gas, this.registryConfig.fee.fees);
-
-    const result = await registryTransactionWithRetry(() =>
-      this.registry.setRecord(
-        {
-          privateKey: this.registryConfig.privateKey,
-          record: applicationRecord,
-          bondId: this.registryConfig.bondId
-        },
-        this.registryConfig.privateKey,
-        fee
-      )
-    );
+    const result = await this.publishRecord(applicationRecord);
 
     log(`Published application record ${result.id}`);
     log('Application record data:', applicationRecord);
@@ -128,6 +117,8 @@ export class Registry {
     const lrn = this.getLrn(repo);
     log(`Setting name: ${lrn} for record ID: ${result.id}`);
 
+    const fee = parseGasAndFees(this.registryConfig.fee.gas, this.registryConfig.fee.fees);
+
     await sleep(SLEEP_DURATION);
     await registryTransactionWithRetry(() =>
       this.registry.setName(
@@ -219,17 +210,7 @@ export class Registry {
       type: APP_DEPLOYMENT_AUCTION_RECORD_TYPE,
     };
 
-    const result = await registryTransactionWithRetry(() =>
-      this.registry.setRecord(
-        {
-          privateKey: this.registryConfig.privateKey,
-          record: applicationDeploymentAuction,
-          bondId: this.registryConfig.bondId
-        },
-        this.registryConfig.privateKey,
-        fee
-      )
-    );
+    const result = await this.publishRecord(applicationDeploymentAuction);
 
     log(`Application deployment auction created: ${auctionResult.auction.id}`);
     log(`Application deployment auction record published: ${result.id}`);
@@ -246,8 +227,11 @@ export class Registry {
     repository: string,
     auctionId?: string | null,
     lrn: string,
+    apiUrl: string,
     environmentVariables: { [key: string]: string },
     dns: string,
+    requesterAddress: string,
+    publicKey: string,
     payment?: string | null
   }): Promise<{
     applicationDeploymentRequestId: string;
@@ -261,6 +245,16 @@ export class Registry {
       throw new Error(`No record found for ${lrn}`);
     }
 
+    let hash;
+    if (Object.keys(data.environmentVariables).length !== 0) {
+      hash = await this.generateConfigHash(
+        data.environmentVariables,
+        data.requesterAddress,
+        data.publicKey,
+        data.apiUrl,
+      );
+    }
+
     // Create record of type ApplicationDeploymentRequest and publish
     const applicationDeploymentRequest = {
       type: APP_DEPLOYMENT_REQUEST_TYPE,
@@ -270,9 +264,7 @@ export class Registry {
       dns: data.dns,
 
       // https://git.vdb.to/cerc-io/laconic-registry-cli/commit/129019105dfb93bebcea02fde0ed64d0f8e5983b
-      config: JSON.stringify({
-        env: data.environmentVariables
-      }),
+      config: JSON.stringify(hash ? { ref: hash } : {}),
       meta: JSON.stringify({
         note: `Added by Snowball @ ${DateTime.utc().toFormat(
           "EEE LLL dd HH:mm:ss 'UTC' yyyy"
@@ -287,19 +279,7 @@ export class Registry {
 
     await sleep(SLEEP_DURATION);
 
-    const fee = parseGasAndFees(this.registryConfig.fee.gas, this.registryConfig.fee.fees);
-
-    const result = await registryTransactionWithRetry(() =>
-      this.registry.setRecord(
-        {
-          privateKey: this.registryConfig.privateKey,
-          record: applicationDeploymentRequest,
-          bondId: this.registryConfig.bondId
-        },
-        this.registryConfig.privateKey,
-        fee
-      )
-    );
+    const result = await this.publishRecord(applicationDeploymentRequest);
 
     log(`Application deployment request record published: ${result.id}`);
     log('Application deployment request data:', applicationDeploymentRequest);
@@ -371,12 +351,11 @@ export class Registry {
       true
     );
 
-    // Filter records with ApplicationDeploymentRequestId ID and Deployment specific URL
+    // Filter records with ApplicationDeploymentRequestId ID
     return records.filter((record: AppDeploymentRecord) =>
       deployments.some(
         (deployment) =>
-          deployment.applicationDeploymentRequestId === record.attributes.request &&
-          record.attributes.url.includes(deployment.id)
+          deployment.applicationDeploymentRequestId === record.attributes.request
       )
     );
   }
@@ -431,6 +410,14 @@ export class Registry {
     );
   }
 
+  /**
+ * Fetch record by Id
+ */
+  async getRecordById(id: string): Promise<RegistryRecord | null> {
+    const [record] = await this.registry.getRecordsByIds([id]);
+    return record ?? null;
+  }
+
   async createApplicationDeploymentRemovalRequest(data: {
     deploymentId: string;
     deployerLrn: string;
@@ -449,18 +436,8 @@ export class Registry {
       ...(data.payment && { payment: data.payment }),
     };
 
-    const fee = parseGasAndFees(this.registryConfig.fee.gas, this.registryConfig.fee.fees);
-
-    const result = await registryTransactionWithRetry(() =>
-      this.registry.setRecord(
-        {
-          privateKey: this.registryConfig.privateKey,
-          record: applicationDeploymentRemovalRequest,
-          bondId: this.registryConfig.bondId
-        },
-        this.registryConfig.privateKey,
-        fee
-      )
+    const result = await this.publishRecord(
+      applicationDeploymentRemovalRequest,
     );
 
     log(`Application deployment removal request record published: ${result.id}`);
@@ -486,6 +463,27 @@ export class Registry {
     return completedAuctions;
   }
 
+  async publishRecord(recordData: any): Promise<any> {
+    const fee = parseGasAndFees(
+      this.registryConfig.fee.gas,
+      this.registryConfig.fee.fees,
+    );
+
+    const result = await registryTransactionWithRetry(() =>
+      this.registry.setRecord(
+        {
+          privateKey: this.registryConfig.privateKey,
+          record: recordData,
+          bondId: this.registryConfig.bondId,
+        },
+        this.registryConfig.privateKey,
+        fee,
+      ),
+    );
+
+    return result;
+  }
+
   async getRecordsByName(name: string): Promise<any> {
     return this.registry.resolveNames([name]);
   }
@@ -532,4 +530,43 @@ export class Registry {
     assert(this.registryConfig.authority, "Authority doesn't exist");
     return `lrn://${this.registryConfig.authority}/applications/${appName}`;
   }
+
+  async generateConfigHash(
+    environmentVariables: { [key: string]: string },
+    requesterAddress: string,
+    pubKey: string,
+    url: string,
+  ): Promise<string> {
+    // Config to be encrypted
+    const config = {
+      authorized: [requesterAddress],
+      config: { env: environmentVariables },
+    };
+
+    // Serialize the config
+    const serialized = JSON.stringify(config, null, 2);
+
+    const armoredKey = `-----BEGIN PGP PUBLIC KEY BLOCK-----\n\n${pubKey}\n\n-----END PGP PUBLIC KEY BLOCK-----`;
+    const publicKey = await openpgp.readKey({ armoredKey });
+
+    // Encrypt the config
+    const encrypted = await openpgp.encrypt({
+      message: await openpgp.createMessage({ text: serialized }),
+      encryptionKeys: publicKey,
+      format: 'binary',
+    });
+
+    // Get the hash after uploading encrypted config
+    const response = await fetch(`${url}/upload/config`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/octet-stream',
+      },
+      body: encrypted,
+    });
+
+    const configHash = await response.json();
+
+    return configHash.id;
+  }
 }

packages/backend/src/resolvers.ts

@@ -38,7 +38,7 @@ export const createResolvers = async (service: Service): Promise<any> => {
       },
 
       deployments: async (_: any, { projectId }: { projectId: string }) => {
-        return service.getDeploymentsByProjectId(projectId);
+        return service.getNonCanonicalDeploymentsByProjectId(projectId);
       },
 
       environmentVariables: async (
@@ -95,6 +95,13 @@ export const createResolvers = async (service: Service): Promise<any> => {
       ) => {
         return service.verifyTx(txHash, amount, senderAddress);
       },
+
+      latestDNSRecord: async (
+        _: any,
+        { projectId }: { projectId: string },
+      ) => {
+        return service.getLatestDNSRecordByProjectId(projectId);
+      },
     },
 
     // TODO: Return error in GQL response
@@ -338,10 +345,11 @@ export const createResolvers = async (service: Service): Promise<any> => {
         {
           projectId,
           deploymentId,
-        }: { deploymentId: string; projectId: string },
+          deployerId,
+        }: { deploymentId: string; projectId: string, deployerId: string },
       ) => {
         try {
-          return await service.rollbackDeployment(projectId, deploymentId);
+          return await service.rollbackDeployment(projectId, deploymentId, deployerId);
         } catch (err) {
           log(err);
           return false;

packages/backend/src/schema.gql

@@ -100,7 +100,6 @@ type ProjectMember {
 
 type Deployment {
   id: String!
-  domain: Domain
   branch: String!
   commitHash: String!
   commitMessage: String!
@@ -108,9 +107,11 @@ type Deployment {
   environment: Environment!
   deployer: Deployer
   applicationDeploymentRequestId: String
+  applicationDeploymentRecordData: AppDeploymentRecordAttributes
   isCurrent: Boolean!
   baseDomain: String
   status: DeploymentStatus!
+  dnsRecordData: DNSRecordAttributes
   createdAt: String!
   updatedAt: String!
   createdBy: User!
@@ -249,9 +250,30 @@ type Auction {
   bids: [Bid!]!
 }
 
+type DNSRecordAttributes {
+  name: String
+  value: String
+  request: String
+  resourceType: String
+  version: String
+}
+
+type AppDeploymentRecordAttributes {
+  application: String
+  auction: String
+  deployer: String
+  dns: String
+  meta: String
+  name: String
+  request: String
+  type: String
+  url: String
+  version: String
+}
+
 input AuctionParams {
-  maxPrice: String,
-  numProviders: Int,
+  maxPrice: String
+  numProviders: Int
 }
 
 type Query {
@@ -265,6 +287,7 @@ type Query {
   projectMembers(projectId: String!): [ProjectMember!]
   searchProjects(searchText: String!): [Project!]
   getAuctionData(auctionId: String!): Auction!
+  latestDNSRecord(projectId: String!): DNSRecordAttributes
   domains(projectId: String!, filter: FilterDomainsInput): [Domain]
   deployers: [Deployer]
   address: String!

packages/backend/src/service.ts

@@ -1,12 +1,18 @@
 import assert from 'assert';
 import debug from 'debug';
-import { DeepPartial, FindOptionsWhere, IsNull, Not } from 'typeorm';
+import { DeepPartial, FindOptionsWhere } from 'typeorm';
 import { Octokit, RequestError } from 'octokit';
+import { DateTime } from 'luxon';
 
 import { OAuthApp } from '@octokit/oauth-app';
 
 import { Database } from './database';
-import { ApplicationRecord, Deployment, DeploymentStatus, Environment } from './entity/Deployment';
+import {
+  ApplicationRecord,
+  Deployment,
+  DeploymentStatus,
+  Environment,
+} from './entity/Deployment';
 import { Domain } from './entity/Domain';
 import { EnvironmentVariable } from './entity/EnvironmentVariable';
 import { Organization } from './entity/Organization';
@@ -22,6 +28,8 @@ import {
   AppDeploymentRemovalRecord,
   AuctionParams,
   DeployerRecord,
+  DNSRecord,
+  DNSRecordAttributes,
   EnvironmentVariables,
   GitPushEventPayload,
 } from './types';
@@ -116,7 +124,8 @@ export class Service {
       }
 
       // Fetch ApplicationDeploymentRecord for deployments
-      const records = await this.laconicRegistry.getDeploymentRecords(deployments);
+      const records =
+        await this.laconicRegistry.getDeploymentRecords(deployments);
       log(`Found ${records.length} ApplicationDeploymentRecords`);
 
       // Update deployments for which ApplicationDeploymentRecords were returned
@@ -199,52 +208,130 @@ export class Service {
       if (!deployment.project) {
         log(`Project ${deployment.projectId} not found`);
         return;
-      } else {
-        deployment.applicationDeploymentRecordId = record.id;
-        deployment.applicationDeploymentRecordData = record.attributes;
-        deployment.url = record.attributes.url;
-        deployment.status = DeploymentStatus.Ready;
-        deployment.isCurrent = deployment.environment === Environment.Production;
-
-        await this.db.updateDeploymentById(deployment.id, deployment);
-
-        // Release deployer funds on successful deployment
-        if (!deployment.project.fundsReleased) {
-          const fundsReleased = await this.releaseDeployerFundsByProjectId(deployment.projectId);
-
-          // Return remaining amount to owner
-          await this.returnUserFundsByProjectId(deployment.projectId, true);
-
-          await this.db.updateProjectById(deployment.projectId, {
-            fundsReleased,
-          });
-        }
-
-        log(
-          `Updated deployment ${deployment.id} with URL ${record.attributes.url}`,
-        );
       }
+
+      const registryRecord = await this.laconicRegistry.getRecordById(
+        record.attributes.dns,
+      );
+
+      if (!registryRecord) {
+        log(`DNS record not found for deployment ${deployment.id}`);
+        return;
+      }
+
+      const dnsRecord = registryRecord as DNSRecord;
+
+      const dnsRecordData: DNSRecordAttributes = {
+        name: dnsRecord.attributes.name,
+        request: dnsRecord.attributes.request,
+        resourceType: dnsRecord.attributes.resource_type,
+        value: dnsRecord.attributes.value,
+        version: dnsRecord.attributes.version,
+      };
+
+      deployment.applicationDeploymentRecordId = record.id;
+      deployment.applicationDeploymentRecordData = record.attributes;
+      deployment.url = record.attributes.url;
+      deployment.status = DeploymentStatus.Ready;
+      deployment.isCurrent = deployment.environment === Environment.Production;
+      deployment.dnsRecordData = dnsRecordData;
+
+      if (deployment.isCanonical) {
+        const previousCanonicalDeployment = await this.db.getDeployment({
+          where: {
+            projectId: deployment.project.id,
+            deployer: deployment.deployer,
+            isCanonical: true,
+            isCurrent: true,
+          },
+          relations: {
+            project: true,
+            deployer: true,
+          },
+        });
+
+        if (previousCanonicalDeployment) {
+          // If all the DNS in the previous canonical deployment request are different from the new deployment request
+          // Send removal request for the previous canonical deployment and delete DB entry
+          const previousDnsList =
+            previousCanonicalDeployment.applicationDeploymentRequestData?.dns ||
+            '';
+          const newDnsList =
+            deployment.applicationDeploymentRequestData?.dns || '';
+
+          const previousDnsSet = new Set(
+            previousDnsList.split(',').map((item) => item.trim()),
+          );
+
+          const newDnsSet = new Set(
+            newDnsList.split(',').map((item) => item.trim()),
+          );
+
+          const isMatch = [...previousDnsSet].some((item) => newDnsSet.has(item));
+
+          if (!isMatch) {
+            await this.laconicRegistry.createApplicationDeploymentRemovalRequest(
+              {
+                deploymentId:
+                  previousCanonicalDeployment.applicationDeploymentRecordId!,
+                deployerLrn: previousCanonicalDeployment.deployer.deployerLrn,
+                auctionId: previousCanonicalDeployment.project.auctionId,
+                payment: previousCanonicalDeployment.project.txHash,
+              },
+            );
+          }
+
+          await this.db.deleteDeploymentById(previousCanonicalDeployment.id);
+        }
+      }
+
+      await this.db.updateDeploymentById(deployment.id, deployment);
+
+      // Release deployer funds on successful deployment
+      if (!deployment.project.fundsReleased) {
+        const fundsReleased = await this.releaseDeployerFundsByProjectId(
+          deployment.projectId,
+        );
+
+        // Return remaining amount to owner
+        await this.returnUserFundsByProjectId(deployment.projectId, true);
+
+        await this.db.updateProjectById(deployment.projectId, {
+          fundsReleased,
+        });
+      }
+
+      log(
+        `Updated deployment ${deployment.id} with URL ${record.attributes.url}`,
+      );
     });
 
     await Promise.all(deploymentUpdatePromises);
 
     // Get deployments that are in production environment
-    const prodDeployments = Object.values(recordToDeploymentsMap).filter(deployment => deployment.isCurrent);
-
+    const prodDeployments = Object.values(recordToDeploymentsMap).filter(
+      (deployment) => deployment.isCurrent,
+    );
     // Set the isCurrent state to false for the old deployments
     for (const deployment of prodDeployments) {
-      const projectDeployments = await this.db.getDeploymentsByProjectId(deployment.projectId);
-      const oldDeployments = projectDeployments
-        .filter(projectDeployment => projectDeployment.deployer.deployerLrn === deployment.deployer.deployerLrn && projectDeployment.id !== deployment.id);
+      const projectDeployments = await this.db.getDeploymentsByProjectId(
+        deployment.projectId,
+      );
+
+      const oldDeployments = projectDeployments.filter(
+        (projectDeployment) =>
+          projectDeployment.deployer.deployerLrn ===
+          deployment.deployer.deployerLrn &&
+          projectDeployment.id !== deployment.id &&
+          projectDeployment.isCanonical == deployment.isCanonical,
+      );
       for (const oldDeployment of oldDeployments) {
         await this.db.updateDeployment(
           { id: oldDeployment.id },
-          { isCurrent: false }
+          { isCurrent: false },
         );
       }
     }
-
-    await Promise.all(deploymentUpdatePromises);
   }
 
   /**
@@ -428,9 +515,19 @@ export class Service {
     return dbProjects;
   }
 
-  async getDeploymentsByProjectId(projectId: string): Promise<Deployment[]> {
-    const dbDeployments = await this.db.getDeploymentsByProjectId(projectId);
-    return dbDeployments;
+  async getNonCanonicalDeploymentsByProjectId(
+    projectId: string,
+  ): Promise<Deployment[]> {
+    const nonCanonicalDeployments =
+      await this.db.getNonCanonicalDeploymentsByProjectId(projectId);
+    return nonCanonicalDeployments;
+  }
+
+  async getLatestDNSRecordByProjectId(
+    projectId: string,
+  ): Promise<DNSRecordAttributes | null> {
+    const dnsRecord = await this.db.getLatestDNSRecordByProjectId(projectId);
+    return dnsRecord;
   }
 
   async getEnvironmentVariablesByProjectId(
@@ -572,6 +669,7 @@ export class Service {
       where: { id: deploymentId },
       relations: {
         project: true,
+        deployer: true,
       },
     });
 
@@ -579,22 +677,25 @@ export class Service {
       throw new Error('Deployment does not exist');
     }
 
-    const prodBranchDomains = await this.db.getDomainsByProjectId(
-      oldDeployment.project.id,
-      { branch: oldDeployment.project.prodBranch },
-    );
-
     const octokit = await this.getOctokit(user.id);
 
-    const newDeployment = await this.createDeployment(user.id, octokit, {
-      project: oldDeployment.project,
-      branch: oldDeployment.branch,
-      environment: Environment.Production,
-      domain: prodBranchDomains[0],
-      commitHash: oldDeployment.commitHash,
-      commitMessage: oldDeployment.commitMessage,
-      deployer: oldDeployment.deployer
-    });
+    let newDeployment: Deployment;
+
+    if (oldDeployment.project.auctionId) {
+      newDeployment = await this.createDeploymentFromAuction(
+        oldDeployment.project,
+        oldDeployment.deployer,
+      );
+    } else {
+      newDeployment = await this.createDeployment(user.id, octokit, {
+        project: oldDeployment.project,
+        branch: oldDeployment.branch,
+        environment: Environment.Production,
+        commitHash: oldDeployment.commitHash,
+        commitMessage: oldDeployment.commitMessage,
+        deployer: oldDeployment.deployer,
+      });
+    }
 
     return newDeployment;
   }
@@ -603,7 +704,7 @@ export class Service {
     userId: string,
     octokit: Octokit,
     data: DeepPartial<Deployment>,
-    deployerLrn?: string
+    deployerLrn?: string,
   ): Promise<Deployment> {
     assert(data.project?.repository, 'Project repository not found');
     log(
@@ -619,19 +720,6 @@ export class Service {
         commitHash: data.commitHash!,
       });
 
-    // Update previous deployment with prod branch domain
-    // TODO: Fix unique constraint error for domain
-    if (data.domain) {
-      await this.db.updateDeployment(
-        {
-          domainId: data.domain.id,
-        },
-        {
-          domain: null,
-        },
-      );
-    }
-
     let deployer;
     if (deployerLrn) {
       deployer = await this.db.getDeployerByLRN(deployerLrn);
@@ -639,49 +727,89 @@ export class Service {
       deployer = data.deployer;
     }
 
-    const newDeployment = await this.createDeploymentFromData(userId, data, deployer!.deployerLrn!, applicationRecordId, applicationRecordData);
+    const deployment = await this.createDeploymentFromData(
+      userId,
+      data,
+      deployer!.deployerLrn!,
+      applicationRecordId,
+      applicationRecordData,
+      false,
+    );
+
+    const address = await this.getAddress();
+    const { repo, repoUrl } = await getRepoDetails(
+      octokit,
+      data.project.repository,
+      data.commitHash,
+    );
+    const environmentVariablesObj = await this.getEnvVariables(
+      data.project!.id!,
+    );
 
-    const { repo, repoUrl } = await getRepoDetails(octokit, data.project.repository, data.commitHash);
-    const environmentVariablesObj = await this.getEnvVariables(data.project!.id!);
     // To set project DNS
     if (data.environment === Environment.Production) {
-      // On deleting deployment later, project DNS deployment is also deleted
-      // So publish project DNS deployment first so that ApplicationDeploymentRecord for the same is available when deleting deployment later
-      await this.laconicRegistry.createApplicationDeploymentRequest({
-        deployment: newDeployment,
+      const canonicalDeployment = await this.createDeploymentFromData(
+        userId,
+        data,
+        deployer!.deployerLrn!,
+        applicationRecordId,
+        applicationRecordData,
+        true,
+      );
+
+      const dns = await this.getDnsForDeployerByProjectId(data.project.id!, deployer!.version, canonicalDeployment.project.name);
+
+      // On deleting deployment later, project canonical deployment is also deleted
+      // So publish project canonical deployment first so that ApplicationDeploymentRecord for the same is available when deleting deployment later
+      const {
+        applicationDeploymentRequestData,
+        applicationDeploymentRequestId,
+      } = await this.laconicRegistry.createApplicationDeploymentRequest({
+        deployment: canonicalDeployment,
         appName: repo,
         repository: repoUrl,
         environmentVariables: environmentVariablesObj,
-        dns: `${newDeployment.project.name}`,
+        dns,
         lrn: deployer!.deployerLrn!,
+        apiUrl: deployer!.deployerApiUrl!,
         payment: data.project.txHash,
-        auctionId: data.project.auctionId
+        auctionId: data.project.auctionId,
+        requesterAddress: address,
+        publicKey: deployer!.publicKey!,
+      });
+
+      await this.db.updateDeploymentById(canonicalDeployment.id, {
+        applicationDeploymentRequestId,
+        applicationDeploymentRequestData,
       });
     }
 
     const { applicationDeploymentRequestId, applicationDeploymentRequestData } =
       await this.laconicRegistry.createApplicationDeploymentRequest({
-        deployment: newDeployment,
+        deployment: deployment,
         appName: repo,
         repository: repoUrl,
         lrn: deployer!.deployerLrn!,
+        apiUrl: deployer!.deployerApiUrl!,
         environmentVariables: environmentVariablesObj,
-        dns: `${newDeployment.project.name}-${newDeployment.id}`,
+        dns: `${deployment.project.name}-${deployment.id}`,
         payment: data.project.txHash,
-        auctionId: data.project.auctionId
+        auctionId: data.project.auctionId,
+        requesterAddress: address,
+        publicKey: deployer!.publicKey!,
       });
 
-    await this.db.updateDeploymentById(newDeployment.id, {
+    await this.db.updateDeploymentById(deployment.id, {
       applicationDeploymentRequestId,
       applicationDeploymentRequestData,
     });
 
-    return newDeployment;
+    return deployment;
   }
 
   async createDeploymentFromAuction(
     project: DeepPartial<Project>,
-    deployer: Deployer
+    deployer: Deployer,
   ): Promise<Deployment> {
     const octokit = await this.getOctokit(project.ownerId!);
     const [owner, repo] = project.repository!.split('/');
@@ -707,7 +835,7 @@ export class Service {
     const applicationRecordId = record.id;
     const applicationRecordData = record.attributes;
 
-    const deployerLrn = deployer!.deployerLrn
+    const deployerLrn = deployer!.deployerLrn;
 
     // Create deployment with prod branch and latest commit
     const deploymentData = {
@@ -719,42 +847,77 @@ export class Service {
       commitMessage: latestCommit.commit.message,
     };
 
-    const newDeployment = await this.createDeploymentFromData(project.ownerId!, deploymentData, deployerLrn, applicationRecordId, applicationRecordData);
+    const deployment = await this.createDeploymentFromData(
+      project.ownerId!,
+      deploymentData,
+      deployerLrn,
+      applicationRecordId,
+      applicationRecordData,
+      false,
+    );
+
+    const address = await this.getAddress();
 
     const environmentVariablesObj = await this.getEnvVariables(project!.id!);
     // To set project DNS
     if (deploymentData.environment === Environment.Production) {
-      // On deleting deployment later, project DNS deployment is also deleted
-      // So publish project DNS deployment first so that ApplicationDeploymentRecord for the same is available when deleting deployment later
-      await this.laconicRegistry.createApplicationDeploymentRequest({
-        deployment: newDeployment,
+      const canonicalDeployment = await this.createDeploymentFromData(
+        project.ownerId!,
+        deploymentData,
+        deployerLrn,
+        applicationRecordId,
+        applicationRecordData,
+        true,
+      );
+
+      // If a custom domain is present then use that as the DNS in the deployment request
+      const dns = await this.getDnsForDeployerByProjectId(project.id!, deployer.version, project.name!);
+
+      // On deleting deployment later, project canonical deployment is also deleted
+      // So publish project canonical deployment first so that ApplicationDeploymentRecord for the same is available when deleting deployment later
+      const {
+        applicationDeploymentRequestId,
+        applicationDeploymentRequestData,
+      } = await this.laconicRegistry.createApplicationDeploymentRequest({
+        deployment: canonicalDeployment,
         appName: repo,
         repository: repoUrl,
         environmentVariables: environmentVariablesObj,
-        dns: `${newDeployment.project.name}`,
+        dns,
         auctionId: project.auctionId!,
         lrn: deployerLrn,
+        apiUrl: deployer!.deployerApiUrl!,
+        requesterAddress: address,
+        publicKey: deployer!.publicKey!,
+      });
+
+      await this.db.updateDeploymentById(canonicalDeployment.id, {
+        applicationDeploymentRequestId,
+        applicationDeploymentRequestData,
       });
     }
 
     const { applicationDeploymentRequestId, applicationDeploymentRequestData } =
       // Create requests for all the deployers
       await this.laconicRegistry.createApplicationDeploymentRequest({
-        deployment: newDeployment,
+        deployment: deployment,
         appName: repo,
         repository: repoUrl,
         auctionId: project.auctionId!,
         lrn: deployerLrn,
+        apiUrl: deployer!.deployerApiUrl!,
         environmentVariables: environmentVariablesObj,
-        dns: `${newDeployment.project.name}-${newDeployment.id}`,
+        dns: `${deployment.project.name}-${deployment.id}`,
+        requesterAddress: address,
+        publicKey: deployer!.publicKey!,
       });
 
-    await this.db.updateDeploymentById(newDeployment.id, {
+    await this.db.updateDeploymentById(deployment.id, {
       applicationDeploymentRequestId,
       applicationDeploymentRequestData,
     });
 
-    return newDeployment;
+    return deployment;
   }
 
   async createDeploymentFromData(
@@ -763,6 +926,7 @@ export class Service {
     deployerLrn: string,
     applicationRecordId: string,
     applicationRecordData: ApplicationRecord,
+    isCanonical: boolean,
   ): Promise<Deployment> {
     const newDeployment = await this.db.addDeployment({
       project: data.project,
@@ -773,13 +937,13 @@ export class Service {
       status: DeploymentStatus.Building,
       applicationRecordId,
       applicationRecordData,
-      domain: data.domain,
       createdBy: Object.assign(new User(), {
         id: userId,
       }),
       deployer: Object.assign(new Deployer(), {
         deployerLrn,
       }),
+      isCanonical,
     });
 
     log(`Created deployment ${newDeployment.id}`);
@@ -789,11 +953,11 @@ export class Service {
 
   async updateProjectWithDeployer(
     projectId: string,
-    deployer: Deployer
+    deployer: Deployer,
   ): Promise<Deployer> {
     const deploymentProject = await this.db.getProjects({
       where: { id: projectId },
-      relations: ['deployers']
+      relations: ['deployers'],
     });
 
     if (!deploymentProject[0].deployers) {
@@ -838,15 +1002,22 @@ export class Service {
 
       const prodBranch = createdTemplateRepo.data.default_branch ?? 'main';
 
-      const project = await this.addProject(user, organizationSlug, {
-        name: `${gitRepo.data.owner!.login}-${gitRepo.data.name}`,
-        prodBranch,
-        repository: gitRepo.data.full_name,
-        // TODO: Set selected template
-        template: 'webapp',
-        paymentAddress: data.paymentAddress,
-        txHash: data.txHash
-      }, lrn, auctionParams, environmentVariables);
+      const project = await this.addProject(
+        user,
+        organizationSlug,
+        {
+          name: `${gitRepo.data.owner!.login}-${gitRepo.data.name}`,
+          prodBranch,
+          repository: gitRepo.data.full_name,
+          // TODO: Set selected template
+          template: 'webapp',
+          paymentAddress: data.paymentAddress,
+          txHash: data.txHash,
+        },
+        lrn,
+        auctionParams,
+        environmentVariables,
+      );
 
       if (!project || !project.id) {
         throw new Error('Failed to create project from template');
@@ -905,7 +1076,9 @@ export class Service {
         commitHash: latestCommit.sha,
         commitMessage: latestCommit.commit.message,
       };
+
       const { applicationDeploymentAuctionId } = await this.laconicRegistry.createApplicationDeploymentAuction(repo, octokit, auctionParams!, deploymentData);
+
       await this.updateProject(project.id, { auctionId: applicationDeploymentAuctionId });
     } else {
       const deployer = await this.db.getDeployerByLRN(lrn!);
@@ -1012,9 +1185,6 @@ export class Service {
 
     for await (const project of projects) {
       const octokit = await this.getOctokit(project.ownerId);
-      const [domain] = await this.db.getDomainsByProjectId(project.id, {
-        branch,
-      });
 
       const deployers = project.deployers;
       if (!deployers) {
@@ -1032,7 +1202,6 @@ export class Service {
               project.prodBranch === branch
                 ? Environment.Production
                 : Environment.Preview,
-            domain,
             commitHash: headCommit.id,
             commitMessage: headCommit.message,
             deployer: deployer
@@ -1074,7 +1243,6 @@ export class Service {
     const oldDeployment = await this.db.getDeployment({
       relations: {
         project: true,
-        domain: true,
         deployer: true,
         createdBy: true,
       },
@@ -1092,20 +1260,20 @@ export class Service {
     let newDeployment: Deployment;
 
     if (oldDeployment.project.auctionId) {
-      newDeployment = await this.createDeploymentFromAuction(oldDeployment.project, oldDeployment.deployer);
-    } else {
-      newDeployment = await this.createDeployment(user.id, octokit,
-        {
-          project: oldDeployment.project,
-          // TODO: Put isCurrent field in project
-          branch: oldDeployment.branch,
-          environment: Environment.Production,
-          domain: oldDeployment.domain,
-          commitHash: oldDeployment.commitHash,
-          commitMessage: oldDeployment.commitMessage,
-          deployer: oldDeployment.deployer
-        }
+      newDeployment = await this.createDeploymentFromAuction(
+        oldDeployment.project,
+        oldDeployment.deployer,
       );
+    } else {
+      newDeployment = await this.createDeployment(user.id, octokit, {
+        project: oldDeployment.project,
+        // TODO: Put isCurrent field in project
+        branch: oldDeployment.branch,
+        environment: Environment.Production,
+        commitHash: oldDeployment.commitHash,
+        commitMessage: oldDeployment.commitMessage,
+        deployer: oldDeployment.deployer,
+      });
     }
 
     return newDeployment;
@@ -1114,35 +1282,92 @@ export class Service {
   async rollbackDeployment(
     projectId: string,
     deploymentId: string,
+    deployerId: string,
   ): Promise<boolean> {
     // TODO: Implement transactions
     const oldCurrentDeployment = await this.db.getDeployment({
       relations: {
-        domain: true,
+        project: true,
+        deployer: true,
       },
       where: {
         project: {
           id: projectId,
         },
+        deployer: {
+          deployerId
+        },
         isCurrent: true,
+        isCanonical: false,
       },
     });
 
     if (!oldCurrentDeployment) {
-      throw new Error('Current deployment doesnot exist');
+      throw new Error('Current deployment does not exist');
     }
 
     const oldCurrentDeploymentUpdate = await this.db.updateDeploymentById(
       oldCurrentDeployment.id,
-      { isCurrent: false, domain: null },
+      { isCurrent: false },
     );
 
     const newCurrentDeploymentUpdate = await this.db.updateDeploymentById(
       deploymentId,
-      { isCurrent: true, domain: oldCurrentDeployment?.domain },
+      { isCurrent: true },
     );
 
-    return newCurrentDeploymentUpdate && oldCurrentDeploymentUpdate;
+    if (!newCurrentDeploymentUpdate || !oldCurrentDeploymentUpdate) {
+      return false;
+    }
+
+    const newCurrentDeployment = await this.db.getDeployment({
+      where: { id: deploymentId },
+      relations: { project: true, deployer: true },
+    });
+
+    if (!newCurrentDeployment) {
+      throw new Error(`Deployment with Id ${deploymentId} not found`);
+    }
+
+    const applicationDeploymentRequestData =
+      newCurrentDeployment.applicationDeploymentRequestData;
+
+    const dns = await this.getDnsForDeployerByProjectId(projectId, newCurrentDeployment.deployer!.version, newCurrentDeployment.project.name)
+
+    applicationDeploymentRequestData!.dns = dns
+
+    // Create a canonical deployment for the new current deployment
+    const canonicalDeployment = await this.createDeploymentFromData(
+      newCurrentDeployment.project.ownerId,
+      newCurrentDeployment,
+      newCurrentDeployment.deployer!.deployerLrn!,
+      newCurrentDeployment.applicationRecordId,
+      newCurrentDeployment.applicationRecordData,
+      true,
+    );
+
+    applicationDeploymentRequestData!.meta = JSON.stringify({
+      ...JSON.parse(applicationDeploymentRequestData!.meta),
+      note: `Updated by Snowball @ ${DateTime.utc().toFormat(
+        "EEE LLL dd HH:mm:ss 'UTC' yyyy",
+      )}`,
+    });
+
+    const result = await this.laconicRegistry.publishRecord(
+      applicationDeploymentRequestData,
+    );
+
+    log(`Application deployment request record published: ${result.id}`);
+
+    const updateResult = await this.db.updateDeploymentById(
+      canonicalDeployment.id,
+      {
+        applicationDeploymentRequestId: result.id,
+        applicationDeploymentRequestData,
+      },
+    );
+
+    return updateResult;
   }
 
   async deleteDeployment(deploymentId: string): Promise<boolean> {
@@ -1159,33 +1384,65 @@ export class Service {
     if (deployment && deployment.applicationDeploymentRecordId) {
       // If deployment is current, remove deployment for project subdomain as well
       if (deployment.isCurrent) {
-        const currentDeploymentURL = `https://${(deployment.project.name).toLowerCase()}.${deployment.deployer.baseDomain}`;
+        const canonicalDeployment = await this.db.getDeployment({
+          where: {
+            projectId: deployment.project.id,
+            deployer: deployment.deployer,
+            isCanonical: true
+          },
+          relations: {
+            project: true,
+            deployer: true,
+          },
+        })
 
-        // TODO: Store the latest DNS deployment record
-        const deploymentRecords =
-          await this.laconicRegistry.getDeploymentRecordsByFilter({
-            application: deployment.applicationRecordId,
-            url: currentDeploymentURL,
+        // If the canonical deployment is not present then query the chain for the deployment record for backward compatibility
+        if (!canonicalDeployment) {
+          log(`Canonical deployment for deployment with id ${deployment.id} not found, querying the chain..`);
+          const currentDeploymentURL = `https://${(deployment.project.name).toLowerCase()}.${deployment.deployer.baseDomain}`;
+
+          const deploymentRecords =
+            await this.laconicRegistry.getDeploymentRecordsByFilter({
+              application: deployment.applicationRecordId,
+              url: currentDeploymentURL,
+            });
+
+          if (!deploymentRecords.length) {
+            log(
+              `No ApplicationDeploymentRecord found for URL ${currentDeploymentURL} and ApplicationDeploymentRecord id ${deployment.applicationDeploymentRecordId}`,
+            );
+
+            return false;
+          }
+
+          // Multiple records are fetched, take the latest record
+          const latestRecord = deploymentRecords
+            .sort((a, b) => new Date(b.createTime).getTime() - new Date(a.createTime).getTime())[0];
+
+          await this.laconicRegistry.createApplicationDeploymentRemovalRequest({
+            deploymentId: latestRecord.id,
+            deployerLrn: deployment.deployer.deployerLrn,
+            auctionId: deployment.project.auctionId,
+            payment: deployment.project.txHash
           });
+        } else {
+          // If canonical deployment is found in the DB, then send the removal request with that deployment record Id
+          const result =
+            await this.laconicRegistry.createApplicationDeploymentRemovalRequest({
+              deploymentId: canonicalDeployment.applicationDeploymentRecordId!,
+              deployerLrn: canonicalDeployment.deployer.deployerLrn,
+              auctionId: canonicalDeployment.project.auctionId,
+              payment: canonicalDeployment.project.txHash
+            });
 
-        if (!deploymentRecords.length) {
-          log(
-            `No ApplicationDeploymentRecord found for URL ${currentDeploymentURL} and ApplicationDeploymentRecord id ${deployment.applicationDeploymentRecordId}`,
-          );
-
-          return false;
+          await this.db.updateDeploymentById(canonicalDeployment.id, {
+            status: DeploymentStatus.Deleting,
+            applicationDeploymentRemovalRequestId:
+              result.applicationDeploymentRemovalRequestId,
+            applicationDeploymentRemovalRequestData:
+              result.applicationDeploymentRemovalRequestData,
+          });
         }
-
-        // Multiple records are fetched, take the latest record
-        const latestRecord = deploymentRecords
-          .sort((a, b) => new Date(b.createTime).getTime() - new Date(a.createTime).getTime())[0];
-
-        await this.laconicRegistry.createApplicationDeploymentRemovalRequest({
-          deploymentId: latestRecord.id,
-          deployerLrn: deployment.deployer.deployerLrn,
-          auctionId: deployment.project.auctionId,
-          payment: deployment.project.txHash
-        });
       }
 
       const result =
@@ -1215,7 +1472,7 @@ export class Service {
     data: { name: string },
   ): Promise<{
     primaryDomain: Domain;
-    redirectedDomain: Domain;
+    // redirectedDomain: Domain;
   }> {
     const currentProject = await this.db.getProjectById(projectId);
 
@@ -1231,22 +1488,22 @@ export class Service {
 
     const savedPrimaryDomain = await this.db.addDomain(primaryDomainDetails);
 
-    const domainArr = data.name.split('www.');
+    // const domainArr = data.name.split('www.');
 
-    const redirectedDomainDetails = {
-      name: domainArr.length > 1 ? domainArr[1] : `www.${domainArr[0]}`,
-      branch: currentProject.prodBranch,
-      project: currentProject,
-      redirectTo: savedPrimaryDomain,
-    };
+    // const redirectedDomainDetails = {
+    //   name: domainArr.length > 1 ? domainArr[1] : `www.${domainArr[0]}`,
+    //   branch: currentProject.prodBranch,
+    //   project: currentProject,
+    //   redirectTo: savedPrimaryDomain,
+    // };
 
-    const savedRedirectedDomain = await this.db.addDomain(
-      redirectedDomainDetails,
-    );
+    // const savedRedirectedDomain = await this.db.addDomain(
+    //   redirectedDomainDetails,
+    // );
 
     return {
       primaryDomain: savedPrimaryDomain,
-      redirectedDomain: savedRedirectedDomain,
+      // redirectedDomain: savedRedirectedDomain,
     };
   }
 
@@ -1434,6 +1691,9 @@ export class Service {
         const deployerApiUrl = record.attributes.apiUrl;
         const minimumPayment = record.attributes.minimumPayment;
         const paymentAddress = record.attributes.paymentAddress;
+        const publicKey = record.attributes.publicKey;
+        const version = record.attributes.deployerVersion;
+
         const baseDomain = deployerApiUrl.substring(deployerApiUrl.indexOf('.') + 1);
 
         const deployerData = {
@@ -1442,7 +1702,9 @@ export class Service {
           deployerApiUrl,
           baseDomain,
           minimumPayment,
-          paymentAddress
+          paymentAddress,
+          publicKey,
+          version,
         };
 
         // TODO: Update deployers table in a separate job
@@ -1481,4 +1743,28 @@ export class Service {
 
     return amount === amountSent && sender === senderAddress && recipient === recipientAddress;
   }
+
+  async getDnsForDeployerByProjectId(projectId: string, deployerVersion: string | undefined | null, projectName: string): Promise<string> {
+    let dns;
+    // If a custom domain is present then use that as the DNS in the deployment request
+    // Only deployers with version > 1 support multiple custom domains
+    // TODO: Check version number
+    if (deployerVersion) {
+      const customDomains = await this.db.getDomainsByProjectId(
+        projectId,
+      );
+
+      dns =
+        customDomains.length > 0
+          ? customDomains.map((d) => d.name).join(',')
+          : `${projectName}`;
+    } else {
+      const domain = await this.db.getOldestDomainByProjectId(
+        projectId
+      );
+      dns = domain?.name ?? `${projectName}`;
+    }
+
+    return dns;
+  }
 }

packages/backend/src/types.ts

@@ -40,6 +40,22 @@ export interface AppDeploymentRecordAttributes {
   version: string;
 }
 
+export interface DNSRecordAttributes {
+  name: string;
+  value: string;
+  request: string;
+  resourceType: string;
+  version: string;
+}
+
+export interface RegistryDNSRecordAttributes {
+  name: string;
+  value: string;
+  request: string;
+  resource_type: string;
+  version: string;
+}
+
 export interface AppDeploymentRemovalRecordAttributes {
   deployment: string;
   request: string;
@@ -47,7 +63,7 @@ export interface AppDeploymentRemovalRecordAttributes {
   version: string;
 }
 
-interface RegistryRecord {
+export interface RegistryRecord {
   id: string;
   names: string[] | null;
   owners: string[];
@@ -64,6 +80,10 @@ export interface AppDeploymentRemovalRecord extends RegistryRecord {
   attributes: AppDeploymentRemovalRecordAttributes;
 }
 
+export interface DNSRecord extends RegistryRecord {
+  attributes: RegistryDNSRecordAttributes
+}
+
 export interface AddProjectFromTemplateInput {
   templateOwner: string;
   templateRepo: string;
@@ -100,5 +120,6 @@ export interface DeployerRecord {
     publicKey: string;
     type: string;
     version: string;
+    deployerVersion: string;
   };
 }

packages/backend/test/publish-deploy-records.ts

@@ -10,7 +10,7 @@ import { Deployment, DeploymentStatus, Environment } from '../src/entity/Deploym
 const log = debug('snowball:publish-deploy-records');
 
 async function main() {
-  const { registryConfig, database, misc } = await getConfig();
+  const { registryConfig, database } = await getConfig();
 
   const registry = new Registry(
     registryConfig.gqlEndpoint,

packages/deployer/.gitignore

@@ -0,0 +1 @@
+records/*.yml

packages/deployer/config.yml

@@ -2,7 +2,7 @@ services:
   registry:
     rpcEndpoint: https://laconicd-sapo.laconic.com
     gqlEndpoint: https://laconicd-sapo.laconic.com/api
-    userKey: 
-    bondId: 
-    chainId: laconic_9000-2
-    gasPrice: 1alnt
+    userKey:
+    bondId:
+    chainId: laconic-testnet-2
+    gasPrice: 0.001alnt

packages/deployer/deploy-frontend.sh

@@ -8,8 +8,11 @@ echo "Using AUTHORITY: $AUTHORITY"
 # Repository URL
 REPO_URL="https://git.vdb.to/cerc-io/snowballtools-base"
 
-# Get the latest commit hash from the repository
-LATEST_HASH=$(git ls-remote $REPO_URL HEAD | awk '{print $1}')
+# Get the latest commit hash for a branch
+BRANCH_NAME="main"
+LATEST_HASH=$(git ls-remote $REPO_URL refs/heads/$BRANCH_NAME | awk '{print $1}')
+
+echo "Latest commit hash for branch $BRANCH_NAME: $LATEST_HASH"
 
 # Extract version from ../frontend/package.json
 PACKAGE_VERSION=$(jq -r '.version' ../frontend/package.json)
@@ -99,6 +102,9 @@ fi
 # Get payment address for deployer
 paymentAddress=$(yarn --silent laconic -c config.yml registry name resolve "$DEPLOYER_LRN" | jq -r '.[0].attributes.paymentAddress')
 paymentAmount=$(yarn --silent laconic -c config.yml registry name resolve "$DEPLOYER_LRN" | jq -r '.[0].attributes.minimumPayment' | sed 's/alnt//g')
+
+echo "Paying address: $paymentAddress with amount $paymentAmount..."
+
 # Pay deployer if paymentAmount is not null
 if [[ -n "$paymentAmount" && "$paymentAmount" != "null" ]]; then
   payment=$(yarn --silent laconic -c config.yml registry tokens send --address "$paymentAddress" --type alnt --quantity "$paymentAmount")
@@ -119,17 +125,19 @@ record:
   name: deploy-frontend@$PACKAGE_VERSION
   application: lrn://$AUTHORITY/applications/deploy-frontend@$PACKAGE_VERSION
   deployer: $DEPLOYER_LRN
-  dns: deploy
+  dns: deploy.laconic.com
   config:
     env:
-      LACONIC_HOSTED_CONFIG_server_url: https://deploy-backend.apps.vaasl.io
-      LACONIC_HOSTED_CONFIG_github_clientid: Ov23liaet4yc0KX0iM1c
+      LACONIC_HOSTED_CONFIG_server_url: https://deploy-backend.laconic.com
+      LACONIC_HOSTED_CONFIG_github_clientid: Ov23li4NtYybQlF6u5Dk
       LACONIC_HOSTED_CONFIG_github_pwa_templaterepo: laconic-templates/test-progressive-web-app
       LACONIC_HOSTED_CONFIG_github_image_upload_templaterepo: laconic-templates/image-upload-pwa-example
+      LACONIC_HOSTED_CONFIG_github_next_app_templaterepo: laconic-templates/starter.nextjs-react-tailwind
       LACONIC_HOSTED_CONFIG_wallet_connect_id: 63cad7ba97391f63652161f484670e15
       LACONIC_HOSTED_CONFIG_laconicd_chain_id: laconic-testnet-2
+      LACONIC_HOSTED_CONFIG_wallet_iframe_url: https://wallet.laconic.com
   meta:
-    note: Added by Snowball @ $CURRENT_DATE_TIME
+    note: Added @ $CURRENT_DATE_TIME
     repository: "$REPO_URL"
     repository_ref: $LATEST_HASH
   payment: $txHash

packages/deployer/deploy-frontend.vaasl.sh

@@ -1,5 +1,10 @@
 #!/bin/bash
 
+source .env
+echo "Using REGISTRY_BOND_ID: $REGISTRY_BOND_ID"
+echo "Using DEPLOYER_LRN: $DEPLOYER_LRN"
+echo "Using AUTHORITY: $AUTHORITY"
+
 # Repository URL
 REPO_URL="https://git.vdb.to/cerc-io/snowballtools-base"
 
@@ -12,63 +17,33 @@ PACKAGE_VERSION=$(jq -r '.version' ../frontend/package.json)
 # Current date and time for note
 CURRENT_DATE_TIME=$(date -u)
 
-CONFIG_FILE=config.staging.yml
-REGISTRY_BOND_ID="098c906850b87412f02200e41f449bc79e055eab77acfef32c0b22443bb46661"
+CONFIG_FILE=config.yml
 
 # Reference: https://git.vdb.to/cerc-io/test-progressive-web-app/src/branch/main/scripts
 
 # Get latest version from registry and increment application-record version
-NEW_APPLICATION_VERSION=$(yarn --silent laconic -c $CONFIG_FILE registry record list --type ApplicationRecord --all --name "staging-snowballtools-base-frontend" 2>/dev/null | jq -r -s ".[] | sort_by(.createTime) | reverse | [ .[] | select(.bondId == \"$REGISTRY_BOND_ID\") ] | .[0].attributes.version" | awk -F. -v OFS=. '{$NF += 1 ; print}')
+NEW_APPLICATION_VERSION=$(yarn --silent laconic -c $CONFIG_FILE registry record list --type ApplicationRecord --all --name "deploy-frontend" 2>/dev/null | jq -r -s ".[] | sort_by(.createTime) | reverse | [ .[] | select(.bondId == \"$REGISTRY_BOND_ID\") ] | .[0].attributes.version" | awk -F. -v OFS=. '{$NF += 1 ; print}')
 
 if [ -z "$NEW_APPLICATION_VERSION" ] || [ "1" == "$NEW_APPLICATION_VERSION" ]; then
   # Set application-record version if no previous records were found
   NEW_APPLICATION_VERSION=0.0.1
 fi
 
-# Generate application-deployment-request.yml
-cat >./staging-records/application-deployment-request.yml <<EOF
-record:
-  type: ApplicationDeploymentRequest
-  version: '1.0.0'
-  name: staging-snowballtools-base-frontend@$PACKAGE_VERSION
-  application: lrn://staging-snowballtools/applications/staging-snowballtools-base-frontend@$PACKAGE_VERSION
-  dns: dashboard.staging.apps.snowballtools.com
-  config:
-    env:
-      LACONIC_HOSTED_CONFIG_server_url: https://snowballtools-base-api.staging.apps.snowballtools.com
-      LACONIC_HOSTED_CONFIG_github_clientid: Ov23liOaoahRTYd4nSCV
-      LACONIC_HOSTED_CONFIG_github_templaterepo: snowball-tools/test-progressive-web-app
-      LACONIC_HOSTED_CONFIG_github_pwa_templaterepo: snowball-tools/test-progressive-web-app
-      LACONIC_HOSTED_CONFIG_github_image_upload_templaterepo: snowball-tools/image-upload-pwa-example
-      LACONIC_HOSTED_CONFIG_wallet_connect_id: eda9ba18042a5ea500f358194611ece2
-      LACONIC_HOSTED_CONFIG_laconicd_chain_id: laconic-testnet-2
-      LACONIC_HOSTED_CONFIG_lit_relay_api_key: 15DDD969-E75F-404D-AAD9-58A37C4FD354_snowball
-      LACONIC_HOSTED_CONFIG_aplchemy_api_key: THvPart_gqI5x02RNYSBntlmwA66I_qc
-      LACONIC_HOSTED_CONFIG_bugsnag_api_key: 8c480cd5386079f9dd44f9581264a073
-      LACONIC_HOSTED_CONFIG_passkey_wallet_rpid: dashboard.staging.apps.snowballtools.com
-      LACONIC_HOSTED_CONFIG_turnkey_api_base_url: https://api.turnkey.com
-      LACONIC_HOSTED_CONFIG_turnkey_organization_id: 5049ae99-5bca-40b3-8317-504384d4e591
-  meta:
-    note: Added by Snowball @ $CURRENT_DATE_TIME
-    repository: "$REPO_URL"
-    repository_ref: $LATEST_HASH
-EOF
-
 # Generate application-record.yml with incremented version
-cat >./staging-records/application-record.yml <<EOF
+cat >./records/application-record.yml <<EOF
 record:
   type: ApplicationRecord
   version: $NEW_APPLICATION_VERSION
   repository_ref: $LATEST_HASH
   repository: ["$REPO_URL"]
   app_type: webapp
-  name: staging-snowballtools-base-frontend
+  name: deploy-frontend
   app_version: $PACKAGE_VERSION
 EOF
 
-echo "Files generated successfully."
+echo "Files generated successfully"
 
-RECORD_FILE=staging-records/application-record.yml
+RECORD_FILE=records/application-record.yml
 
 # Publish ApplicationRecord
 publish_response=$(yarn --silent laconic -c $CONFIG_FILE registry record publish --filename $RECORD_FILE)
@@ -82,7 +57,7 @@ echo "ApplicationRecord published"
 echo $RECORD_ID
 
 # Set name to record
-REGISTRY_APP_LRN="lrn://staging-snowballtools/applications/staging-snowballtools-base-frontend"
+REGISTRY_APP_LRN="lrn://$AUTHORITY/applications/deploy-frontend"
 
 sleep 2
 yarn --silent laconic -c $CONFIG_FILE registry name set "$REGISTRY_APP_LRN@${PACKAGE_VERSION}" "$RECORD_ID"
@@ -121,7 +96,47 @@ if [ -z "$APP_RECORD" ] || [ "null" == "$APP_RECORD" ]; then
   exit 1
 fi
 
-RECORD_FILE=staging-records/application-deployment-request.yml
+# Get payment address for deployer
+paymentAddress=$(yarn --silent laconic -c config.yml registry name resolve "$DEPLOYER_LRN" | jq -r '.[0].attributes.paymentAddress')
+paymentAmount=$(yarn --silent laconic -c config.yml registry name resolve "$DEPLOYER_LRN" | jq -r '.[0].attributes.minimumPayment' | sed 's/alnt//g')
+# Pay deployer if paymentAmount is not null
+if [[ -n "$paymentAmount" && "$paymentAmount" != "null" ]]; then
+  payment=$(yarn --silent laconic -c config.yml registry tokens send --address "$paymentAddress" --type alnt --quantity "$paymentAmount")
+
+  # Extract the transaction hash
+  txHash=$(echo "$payment" | jq -r '.tx.hash')
+  echo "Paid deployer with txHash as $txHash"
+
+else
+  echo "Payment amount is null; skipping payment."
+fi
+
+# Generate application-deployment-request.yml
+cat >./records/application-deployment-request.yml <<EOF
+record:
+  type: ApplicationDeploymentRequest
+  version: '1.0.0'
+  name: deploy-frontend@$PACKAGE_VERSION
+  application: lrn://$AUTHORITY/applications/deploy-frontend@$PACKAGE_VERSION
+  deployer: $DEPLOYER_LRN
+  dns: deploy
+  config:
+    env:
+      LACONIC_HOSTED_CONFIG_server_url: https://deploy-backend.apps.vaasl.io
+      LACONIC_HOSTED_CONFIG_github_clientid: Ov23liaet4yc0KX0iM1c
+      LACONIC_HOSTED_CONFIG_github_pwa_templaterepo: laconic-templates/test-progressive-web-app
+      LACONIC_HOSTED_CONFIG_github_image_upload_templaterepo: laconic-templates/image-upload-pwa-example
+      LACONIC_HOSTED_CONFIG_github_next_app_templaterepo: laconic-templates/starter.nextjs-react-tailwind
+      LACONIC_HOSTED_CONFIG_wallet_connect_id: 63cad7ba97391f63652161f484670e15
+      LACONIC_HOSTED_CONFIG_laconicd_chain_id: laconic-testnet-2
+  meta:
+    note: Added by Snowball @ $CURRENT_DATE_TIME
+    repository: "$REPO_URL"
+    repository_ref: $LATEST_HASH
+  payment: $txHash
+EOF
+
+RECORD_FILE=records/application-deployment-request.yml
 
 sleep 2
 deployment_response=$(yarn --silent laconic -c $CONFIG_FILE registry record publish --filename $RECORD_FILE)

packages/deployer/records/application-deployment-request.yml

@@ -1,17 +0,0 @@
-record:
-  type: ApplicationDeploymentRequest
-  version: '1.0.0'
-  name: deploy-frontend@1.0.0
-  application: lrn://vaasl/applications/deploy-frontend@1.0.0
-  dns: deploy
-  config:
-    env:
-      LACONIC_HOSTED_CONFIG_server_url: https://deploy-backend.apps.vaasl.io
-      LACONIC_HOSTED_CONFIG_github_clientid: Ov23liaet4yc0KX0iM1c
-      LACONIC_HOSTED_CONFIG_github_pwa_templaterepo: laconic-templates/test-progressive-web-app
-      LACONIC_HOSTED_CONFIG_github_image_upload_templaterepo: laconic-templates/image-upload-pwa-example
-      LACONIC_HOSTED_CONFIG_wallet_connect_id: 63cad7ba97391f63652161f484670e15
-  meta:
-    note: Added by Snowball @ Thu Apr  4 14:49:41 UTC 2024
-    repository: "https://git.vdb.to/cerc-io/snowballtools-base"
-    repository_ref: 351db16336eacc3e1f9119ceb8d1282b8e27a27e

packages/deployer/records/application-record.yml

@@ -1,8 +0,0 @@
-record:
-  type: ApplicationRecord
-  version: 0.0.2
-  repository_ref: 351db16336eacc3e1f9119ceb8d1282b8e27a27e
-  repository: ["https://git.vdb.to/cerc-io/snowballtools-base"]
-  app_type: webapp
-  name: deploy-frontend
-  app_version: 1.0.0

packages/deployer/remove-deployment.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+
+source .env
+echo "Using DEPLOYER_LRN: $DEPLOYER_LRN"
+
+# Generate application-deployment-removal-request.yml
+REMOVAL_REQUEST_RECORD_FILE=records/application-deployment-removal-request.yml
+# TODO: Pass deployment record ID as arg
+DEPLOYMENT_RECORD_ID=bafyreidjho77xeczaqpyawhc4wbpm5it5atibtuxk6ost6vnpu2svlp3ka
+
+cat > $REMOVAL_REQUEST_RECORD_FILE <<EOF
+record:
+  deployer: $DEPLOYER_LRN
+  deployment: $DEPLOYMENT_RECORD_ID
+  type: ApplicationDeploymentRemovalRequest
+  version: 1.0.0
+EOF
+
+CONFIG_FILE=config.yml
+
+sleep 2
+REMOVAL_REQUEST_ID=$(yarn --silent laconic -c $CONFIG_FILE registry record publish --filename $REMOVAL_REQUEST_RECORD_FILE | jq -r '.id')
+echo "ApplicationDeploymentRemovalRequest published"
+echo $REMOVAL_REQUEST_ID
+
+# Deployment checks
+RETRY_INTERVAL=30
+MAX_RETRIES=20
+
+# Check that an ApplicationDeploymentRemovalRecord is published
+retry_count=0
+while true; do
+  removal_records_response=$(yarn --silent laconic -c $CONFIG_FILE registry record list --type ApplicationDeploymentRemovalRecord --all request $REMOVAL_REQUEST_ID)
+  len_removal_records=$(echo $removal_records_response | jq 'length')
+
+  # Check if number of records returned is 0
+  if [ $len_removal_records -eq 0 ]; then
+    # Check if retries are exhausted
+    if [ $retry_count -eq $MAX_RETRIES ]; then
+      echo "Retries exhausted"
+      echo "ApplicationDeploymentRemovalRecord for deployment removal request $REMOVAL_REQUEST_ID not found"
+      exit 1
+    else
+      echo "ApplicationDeploymentRemovalRecord not found, retrying in $RETRY_INTERVAL sec..."
+      sleep $RETRY_INTERVAL
+      retry_count=$((retry_count+1))
+    fi
+  else
+    echo "ApplicationDeploymentRemovalRecord found"
+    REMOVAL_RECORD_ID=$(echo $removal_records_response | jq -r '.[0].id')
+    echo $REMOVAL_RECORD_ID
+    break
+  fi
+done
+
+echo "Deployment removal successful"

packages/deployer/staging-records/application-deployment-request.yml

@@ -1,24 +0,0 @@
-record:
-  type: ApplicationDeploymentRequest
-  version: '1.0.0'
-  name: staging-snowballtools-base-frontend@0.0.0
-  application: crn://staging-snowballtools/applications/staging-snowballtools-base-frontend@0.0.0
-  dns: dashboard.staging.apps.snowballtools.com
-  config:
-    env:
-      LACONIC_HOSTED_CONFIG_server_url: https://snowballtools-base-api.staging.apps.snowballtools.com
-      LACONIC_HOSTED_CONFIG_github_clientid: Ov23liOaoahRTYd4nSCV
-      LACONIC_HOSTED_CONFIG_github_templaterepo: snowball-tools/test-progressive-web-app
-      LACONIC_HOSTED_CONFIG_github_pwa_templaterepo: snowball-tools/test-progressive-web-app
-      LACONIC_HOSTED_CONFIG_github_image_upload_templaterepo: snowball-tools/image-upload-pwa-example
-      LACONIC_HOSTED_CONFIG_wallet_connect_id: eda9ba18042a5ea500f358194611ece2
-      LACONIC_HOSTED_CONFIG_lit_relay_api_key: 15DDD969-E75F-404D-AAD9-58A37C4FD354_snowball
-      LACONIC_HOSTED_CONFIG_aplchemy_api_key: THvPart_gqI5x02RNYSBntlmwA66I_qc
-      LACONIC_HOSTED_CONFIG_bugsnag_api_key: 8c480cd5386079f9dd44f9581264a073
-      LACONIC_HOSTED_CONFIG_passkey_wallet_rpid: dashboard.staging.apps.snowballtools.com
-      LACONIC_HOSTED_CONFIG_turnkey_api_base_url: https://api.turnkey.com
-      LACONIC_HOSTED_CONFIG_turnkey_organization_id: 5049ae99-5bca-40b3-8317-504384d4e591
-  meta:
-    note: Added by Snowball @ Mon Jun 24 23:51:48 UTC 2024
-    repository: "https://git.vdb.to/cerc-io/snowballtools-base"
-    repository_ref: 61e3e88a6c9d57e95441059369ee5a46f5c07601

packages/deployer/staging-records/application-record.yml

@@ -1,8 +0,0 @@
-record:
-  type: ApplicationRecord
-  version: 0.0.1
-  repository_ref: 61e3e88a6c9d57e95441059369ee5a46f5c07601
-  repository: ["https://git.vdb.to/cerc-io/snowballtools-base"]
-  app_type: webapp
-  name: staging-snowballtools-base-frontend
-  app_version: 0.0.0

packages/frontend/.env.example

@@ -3,6 +3,7 @@ VITE_SERVER_URL='http://localhost:8000'
 VITE_GITHUB_CLIENT_ID=
 VITE_GITHUB_PWA_TEMPLATE_REPO="snowball-tools/test-progressive-web-app"
 VITE_GITHUB_IMAGE_UPLOAD_PWA_TEMPLATE_REPO="snowball-tools/image-upload-pwa-example"
+VITE_GITHUB_NEXT_APP_TEMPLATE_REPO="snowball-tools/starter.nextjs-react-tailwind"
 
 VITE_WALLET_CONNECT_ID=
 
@@ -14,3 +15,4 @@ VITE_PASSKEY_WALLET_RPID=
 VITE_TURNKEY_API_BASE_URL=
 
 VITE_LACONICD_CHAIN_ID=
+VITE_WALLET_IFRAME_URL=

packages/frontend/src/assets/templates.ts

@@ -1,13 +1,14 @@
 import {
   VITE_GITHUB_IMAGE_UPLOAD_PWA_TEMPLATE_REPO,
   VITE_GITHUB_PWA_TEMPLATE_REPO,
+  VITE_GITHUB_NEXT_APP_TEMPLATE_REPO,
 } from 'utils/constants';
 
 export default [
   {
     id: '1',
     name: 'Progressive Web App (PWA)',
-    icon: 'pwa',
+    icon: 'web',
     repoFullName: `${VITE_GITHUB_PWA_TEMPLATE_REPO}`,
     isComingSoon: false,
   },
@@ -20,23 +21,9 @@ export default [
   },
   {
     id: '3',
-    name: 'Kotlin',
-    icon: 'kotlin',
-    repoFullName: '',
-    isComingSoon: true,
-  },
-  {
-    id: '4',
-    name: 'React Native',
-    icon: 'react-native',
-    repoFullName: '',
-    isComingSoon: true,
-  },
-  {
-    id: '5',
-    name: 'Swift',
-    icon: 'swift',
-    repoFullName: '',
-    isComingSoon: true,
+    name: 'Next.js + React + TailwindCSS',
+    icon: 'web',
+    repoFullName: `${VITE_GITHUB_NEXT_APP_TEMPLATE_REPO}`,
+    isComingSoon: false,
   },
 ];

packages/frontend/src/components/projects/Dialog/ChangeStateToProductionDialog.tsx

@@ -47,6 +47,7 @@ export const ChangeStateToProductionDialog = ({
       handleCancel={handleCancel}
       open={open}
       handleConfirm={handleConfirm}
+      confirmButtonTitle={isConfirmButtonLoading ? 'Redeploying' : 'Redeploy'}
       confirmButtonProps={{
         disabled: isConfirmButtonLoading,
         rightIcon: isConfirmButtonLoading ? (

packages/frontend/src/components/projects/ProjectCard/ProjectCard.tsx

@@ -4,7 +4,11 @@ import {
   MenuItem,
   MenuList,
 } from '@snowballtools/material-tailwind-react-fork';
-import { ComponentPropsWithoutRef, MouseEvent, useCallback } from 'react';
+import {
+  ComponentPropsWithoutRef,
+  MouseEvent,
+  useCallback,
+} from 'react';
 import { useNavigate } from 'react-router-dom';
 import { Project } from 'gql-client';
 import { Avatar } from 'components/shared/Avatar';
@@ -83,7 +87,7 @@ export const ProjectCard = ({
             <p className={theme.title()}>{project.name}</p>
           </Tooltip>
           <p className={theme.description()}>
-            {project.deployments[0]?.domain?.name ?? 'No domain'}
+            {project.deployments[0]?.applicationDeploymentRecordData?.url ?? 'No domain'}
           </p>
         </div>
         {/* Icons */}

packages/frontend/src/components/projects/create/AccountsDropdown.tsx

@@ -0,0 +1,60 @@
+import {
+  Select,
+  Option,
+  Spinner,
+} from '@snowballtools/material-tailwind-react-fork';
+
+const AccountsDropdown = ({
+  accounts,
+  isDataReceived,
+  onAccountChange,
+}: {
+  accounts: string[];
+  isDataReceived: boolean;
+  onAccountChange: (selectedAccount: string) => void;
+}) => {
+  return (
+    <div className="p-6 bg-slate-100 dark:bg-overlay3 rounded-lg mb-6 shadow-md">
+      {isDataReceived ? (
+        !accounts.length ? (
+          <div className="text-center">
+            <p className="text-gray-700 dark:text-gray-300 mb-4">
+              No accounts found. Please visit{' '}
+              <a
+                href="https://store.laconic.com"
+                target="_blank"
+                rel="noopener noreferrer"
+                className="text-blue-600 underline dark:text-blue-400"
+              >
+                store.laconic.com
+              </a>{' '}
+              to create a wallet.
+            </p>
+          </div>
+        ) : (
+          <div>
+            <Select
+              label="Select Account"
+              defaultValue={accounts[0]}
+              onChange={(value) => value && onAccountChange(value)}
+              className="dark:bg-overlay2 dark:text-foreground"
+              aria-label="Wallet Account Selector"
+            >
+              {accounts.map((account, index) => (
+                <Option key={index} value={account}>
+                  {account}
+                </Option>
+              ))}
+            </Select>
+          </div>
+        )
+      ) : (
+        <div className="flex items-center justify-center h-12">
+          <Spinner className="h-6 w-6" />
+        </div>
+      )}
+    </div>
+  );
+};
+
+export default AccountsDropdown;

packages/frontend/src/components/projects/create/Configure.tsx

@@ -20,10 +20,14 @@ import { Button } from '../../shared/Button';
 import { Input } from 'components/shared/Input';
 import { useToast } from 'components/shared/Toast';
 import { useGQLClient } from '../../../context/GQLClientContext';
+import IFrameModal from './IFrameModal';
 import EnvironmentVariablesForm from 'pages/org-slug/projects/id/settings/EnvironmentVariablesForm';
 import { EnvironmentVariablesFormValues } from 'types/types';
-import ConnectWallet from './ConnectWallet';
-import { useWalletConnectClient } from 'context/WalletConnectContext';
+import {
+  VITE_LACONICD_CHAIN_ID,
+  VITE_WALLET_IFRAME_URL,
+} from 'utils/constants';
+import AccountsDropdown from './AccountsDropdown';
 
 type ConfigureDeploymentFormValues = {
   option: string;
@@ -36,16 +40,18 @@ type ConfigureFormValues = ConfigureDeploymentFormValues &
   EnvironmentVariablesFormValues;
 
 const DEFAULT_MAX_PRICE = '10000';
+const TX_APPROVAL_TIMEOUT_MS = 60000;
 
 const Configure = () => {
-  const { signClient, session, accounts } = useWalletConnectClient();
-
   const [isLoading, setIsLoading] = useState(false);
   const [deployers, setDeployers] = useState<Deployer[]>([]);
   const [selectedAccount, setSelectedAccount] = useState<string>();
+  const [accounts, setAccounts] = useState<string[]>([]);
   const [selectedDeployer, setSelectedDeployer] = useState<Deployer>();
   const [isPaymentLoading, setIsPaymentLoading] = useState(false);
   const [isPaymentDone, setIsPaymentDone] = useState(false);
+  const [isFrameVisible, setIsFrameVisible] = useState(false);
+  const [isAccountsDataReceived, setIsAccountsDataReceived] = useState(false);
 
   const [searchParams] = useSearchParams();
   const templateId = searchParams.get('templateId');
@@ -182,7 +188,7 @@ const Configure = () => {
 
         let amount: string;
         let senderAddress: string;
-        let txHash: string;
+        let txHash: string | null = null;
         if (createFormData.option === 'LRN' && !deployer?.minimumPayment) {
           toast({
             id: 'no-payment-required',
@@ -196,7 +202,7 @@ const Configure = () => {
         } else {
           if (!selectedAccount) return;
 
-          senderAddress = selectedAccount.split(':')[2];
+          senderAddress = selectedAccount;
 
           if (createFormData.option === 'LRN') {
             amount = deployer?.minimumPayment!;
@@ -208,27 +214,44 @@ const Configure = () => {
 
           const amountToBePaid = amount.replace(/\D/g, '').toString();
 
-          const txHashResponse = await cosmosSendTokensHandler(
-            selectedAccount,
-            amountToBePaid,
-          );
+          txHash = await cosmosSendTokensHandler(senderAddress, amountToBePaid);
 
-          if (!txHashResponse) {
-            console.error('Tx not successful');
-            return;
+          if (!txHash) {
+            toast({
+              id: 'unsuccessful-tx',
+              title: 'Transaction rejected',
+              variant: 'error',
+              onDismiss: dismiss,
+            });
+            setIsFrameVisible(false);
+            setIsPaymentLoading(false);
+            throw new Error('Transaction rejected');
           }
 
-          txHash = txHashResponse;
-
+          // Validate transaction hash
           const isTxHashValid = await verifyTx(
             senderAddress,
             txHash,
-            amountToBePaid.toString(),
+            amountToBePaid,
           );
+          setIsPaymentLoading(false);
 
-          if (isTxHashValid === false) {
-            console.error('Invalid Tx hash', txHash);
-            return;
+          if (isTxHashValid) {
+            toast({
+              id: 'payment-successful',
+              title: 'Payment successful',
+              variant: 'success',
+              onDismiss: dismiss,
+            });
+            setIsPaymentDone(true);
+          } else {
+            toast({
+              id: 'invalid-tx-hash',
+              title: 'Transaction validation failed',
+              variant: 'error',
+              onDismiss: dismiss,
+            });
+            throw new Error('Transaction validation failed');
           }
         }
 
@@ -248,7 +271,7 @@ const Configure = () => {
           createFormData,
           environmentVariables,
           senderAddress,
-          txHash,
+          txHash!,
         );
 
         await client.getEnvironmentVariables(projectId);
@@ -270,14 +293,14 @@ const Configure = () => {
                 `/${orgSlug}/projects/create/deploy?projectId=${projectId}`,
               );
         }
-      } catch (error) {
-        console.error(error);
+      } catch (error: any) {
         toast({
           id: 'error-deploying-app',
           title: 'Error deploying app',
           variant: 'error',
           onDismiss: dismiss,
         });
+        throw new Error(error);
       }
     },
     [client, createProject, dismiss, toast],
@@ -302,72 +325,95 @@ const Configure = () => {
 
   const cosmosSendTokensHandler = useCallback(
     async (selectedAccount: string, amount: string) => {
-      if (!signClient || !session || !selectedAccount) {
-        return;
+      if (!selectedAccount) {
+        throw new Error('Account not selected');
       }
 
-      const chainId = selectedAccount.split(':')[1];
-      const senderAddress = selectedAccount.split(':')[2];
+      const senderAddress = selectedAccount;
       const snowballAddress = await client.getAddress();
+      let timeoutId;
 
       try {
         setIsPaymentDone(false);
         setIsPaymentLoading(true);
 
-        toast({
-          id: 'sending-payment-request',
-          title: 'Check your wallet and approve payment request',
-          variant: 'loading',
-          onDismiss: dismiss,
+        await requestTx(senderAddress, snowballAddress, amount);
+
+        const txHash = await new Promise<string | null>((resolve, reject) => {
+          const handleTxStatus = async (event: MessageEvent) => {
+            if (event.origin !== VITE_WALLET_IFRAME_URL) return;
+
+            if (event.data.type === 'TRANSACTION_RESPONSE') {
+              const txResponse = event.data.data;
+              resolve(txResponse);
+            } else if (event.data.type === 'ERROR') {
+              console.error('Error from wallet:', event.data.message);
+              reject(new Error('Transaction failed'));
+              toast({
+                id: 'error-transaction',
+                title: 'Error during transaction',
+                variant: 'error',
+                onDismiss: dismiss,
+              });
+            }
+            setIsFrameVisible(false);
+
+            window.removeEventListener('message', handleTxStatus);
+          };
+
+          window.addEventListener('message', handleTxStatus);
+
+          // Set a timeout, consider unsuccessful after 1 min
+          timeoutId = setTimeout(() => {
+            reject(new Error('Transaction timeout'));
+            window.removeEventListener('message', handleTxStatus);
+            toast({
+              id: 'transaction-timeout',
+              title: 'The transaction request timed out. Please try again',
+              variant: 'error',
+              onDismiss: dismiss,
+            });
+            setIsFrameVisible(false);
+            setIsPaymentLoading(false);
+          }, TX_APPROVAL_TIMEOUT_MS);
         });
-
-        const result: { signature: string } = await signClient.request({
-          topic: session.topic,
-          chainId: `cosmos:${chainId}`,
-          request: {
-            method: 'cosmos_sendTokens',
-            params: [
-              {
-                from: senderAddress,
-                to: snowballAddress,
-                value: amount,
-              },
-            ],
-          },
-        });
-
-        if (!result) {
-          throw new Error('Error completing transaction');
-        }
-
-        toast({
-          id: 'payment-successful',
-          title: 'Payment successful',
-          variant: 'success',
-          onDismiss: dismiss,
-        });
-
-        setIsPaymentDone(true);
-
-        return result.signature;
-      } catch (error: any) {
-        console.error('Error sending tokens', error);
-
-        toast({
-          id: 'error-sending-tokens',
-          title: 'Error sending tokens',
-          variant: 'error',
-          onDismiss: dismiss,
-        });
-
-        setIsPaymentDone(false);
+        return txHash;
+      } catch (error) {
+        console.error('Error in transaction:', error);
+        throw new Error('Error in transaction');
       } finally {
-        setIsPaymentLoading(false);
+        clearTimeout(timeoutId);
       }
     },
-    [session, signClient, toast],
+    [client, dismiss, toast],
   );
 
+  const requestTx = async (
+    sender: string,
+    recipient: string,
+    amount: string,
+  ) => {
+    const iframe = document.getElementById('walletIframe') as HTMLIFrameElement;
+
+    if (!iframe.contentWindow) {
+      console.error('Iframe not found or not loaded');
+      throw new Error('Iframe not found or not loaded');
+    }
+
+    iframe.contentWindow.postMessage(
+      {
+        type: 'REQUEST_TX',
+        chainId: VITE_LACONICD_CHAIN_ID,
+        fromAddress: sender,
+        toAddress: recipient,
+        amount,
+      },
+      VITE_WALLET_IFRAME_URL,
+    );
+
+    setIsFrameVisible(true);
+  };
+
   useEffect(() => {
     fetchDeployers();
   }, []);
@@ -520,7 +566,7 @@ const Configure = () => {
                 <Button
                   {...buttonSize}
                   type="submit"
-                  disabled={isLoading || !selectedDeployer || !selectedAccount}
+                  disabled={isLoading || !selectedDeployer}
                   rightIcon={
                     isLoading ? (
                       <LoadingIcon className="animate-spin" />
@@ -534,10 +580,11 @@ const Configure = () => {
               </div>
             ) : (
               <>
-                <Heading as="h4" className="md:text-lg font-medium mb-3">
-                  Connect to your wallet
-                </Heading>
-                <ConnectWallet onAccountChange={onAccountChange} />
+                <AccountsDropdown
+                  accounts={accounts}
+                  onAccountChange={onAccountChange}
+                  isDataReceived={isAccountsDataReceived}
+                />
                 {accounts.length > 0 && (
                   <div>
                     <Button
@@ -569,6 +616,12 @@ const Configure = () => {
             )}
           </form>
         </FormProvider>
+
+        <IFrameModal
+          setAccounts={setAccounts}
+          setIsDataReceived={setIsAccountsDataReceived}
+          isVisible={isFrameVisible}
+        />
       </div>
     </div>
   );

packages/frontend/src/components/projects/create/ConnectWallet.tsx

@@ -1,47 +0,0 @@
-import { Select, Option } from '@snowballtools/material-tailwind-react-fork';
-
-import { Button } from '../../shared/Button';
-import { useWalletConnectClient } from 'context/WalletConnectContext';
-
-const ConnectWallet = ({
-  onAccountChange,
-}: {
-  onAccountChange: (selectedAccount: string) => void;
-}) => {
-  const { onConnect, accounts } = useWalletConnectClient();
-
-  const handleConnect = async () => {
-    await onConnect();
-  };
-
-  return (
-    <div className="p-4 bg-slate-100 dark:bg-overlay3 rounded-lg mb-6">
-      {accounts.length === 0 ? (
-        <div>
-          <Button type={'button'} onClick={handleConnect}>
-            Connect Wallet
-          </Button>
-        </div>
-      ) : (
-        <div>
-          <Select
-            label="Select Account"
-            defaultValue={accounts[0].address}
-            onChange={(value) => {
-              value && onAccountChange(value);
-            }}
-            className="dark:bg-overlay2 dark:text-foreground"
-          >
-            {accounts.map((account, index) => (
-              <Option key={index} value={account.address}>
-                {account.address.split(':').slice(1).join(':')}
-              </Option>
-            ))}
-          </Select>
-        </div>
-      )}
-    </div>
-  );
-};
-
-export default ConnectWallet;

packages/frontend/src/components/projects/create/IFrameModal.tsx

@@ -0,0 +1,88 @@
+import { useCallback, useEffect } from 'react';
+
+import { Box, Modal } from '@mui/material';
+
+import {
+  VITE_LACONICD_CHAIN_ID,
+  VITE_WALLET_IFRAME_URL,
+} from 'utils/constants';
+
+const IFrameModal = ({
+  setAccounts,
+  setIsDataReceived,
+  isVisible,
+}: {
+  setAccounts: (accounts: string[]) => void;
+  setIsDataReceived: (isReceived: boolean) => void;
+  isVisible: boolean;
+}) => {
+  useEffect(() => {
+    const handleMessage = (event: MessageEvent) => {
+      if (event.origin !== VITE_WALLET_IFRAME_URL) return;
+
+      setIsDataReceived(true);
+      if (event.data.type === 'WALLET_ACCOUNTS_DATA') {
+        setAccounts(event.data.data);
+      } else if (event.data.type === 'ERROR') {
+        console.error('Error from wallet:', event.data.message);
+      }
+    };
+
+    window.addEventListener('message', handleMessage);
+
+    return () => {
+      window.removeEventListener('message', handleMessage);
+    };
+  }, []);
+
+  const getDataFromWallet = useCallback(() => {
+    const iframe = document.getElementById('walletIframe') as HTMLIFrameElement;
+
+    if (!iframe.contentWindow) {
+      console.error('Iframe not found or not loaded');
+      return;
+    }
+
+    iframe.contentWindow.postMessage(
+      {
+        type: 'REQUEST_WALLET_ACCOUNTS',
+        chainId: VITE_LACONICD_CHAIN_ID,
+      },
+      VITE_WALLET_IFRAME_URL,
+    );
+  }, []);
+
+  return (
+    <Modal open={isVisible} disableEscapeKeyDown keepMounted>
+      <Box
+        sx={{
+          position: 'absolute',
+          top: '50%',
+          left: '50%',
+          transform: 'translate(-50%, -50%)',
+          width: '90%',
+          maxWidth: '1200px',
+          height: '600px',
+          maxHeight: '80vh',
+          overflow: 'auto',
+          boxShadow: 24,
+          borderRadius: '8px',
+          outline: 'none',
+          bgcolor: 'background.paper',
+        }}
+      >
+        <iframe
+          onLoad={getDataFromWallet}
+          id="walletIframe"
+          src={`${VITE_WALLET_IFRAME_URL}/wallet-embed`}
+          width="100%"
+          height="100%"
+          sandbox="allow-scripts allow-same-origin"
+          className="border rounded-md shadow-sm"
+        ></iframe>
+      </Box>
+    </Modal>
+  );
+};
+
+export default IFrameModal;

packages/frontend/src/components/projects/create/MockConnectGitCard.tsx

@@ -1,6 +1,8 @@
 import React, { useMemo } from 'react';
 import { SegmentedControls } from 'components/shared/SegmentedControls';
 import { useState } from 'react';
+import { useMediaQuery } from 'usehooks-ts';
+
 import {
   GithubIcon,
   LockIcon,
@@ -8,7 +10,7 @@ import {
   TemplateIconType,
 } from 'components/shared/CustomIcon';
 import { relativeTimeISO } from 'utils/time';
-import { useMediaQuery } from 'usehooks-ts';
+import templates from 'assets/templates';
 
 export const MockConnectGitCard = () => {
   const [segmentedControlsValue, setSegmentedControlsValue] =
@@ -46,29 +48,6 @@ export const MockConnectGitCard = () => {
     },
   ];
 
-  const TEMPLATE_CONTENT = [
-    {
-      name: 'Web app',
-      icon: 'web',
-    },
-    {
-      name: 'Progressive Web App (PWA)',
-      icon: 'pwa',
-    },
-    {
-      name: 'React Native',
-      icon: 'react-native',
-    },
-    {
-      name: 'Kotlin',
-      icon: 'kotlin',
-    },
-    {
-      name: 'Swift',
-      icon: 'swift',
-    },
-  ];
-
   const renderContent = useMemo(() => {
     if (segmentedControlsValue === 'import') {
       return (
@@ -86,7 +65,7 @@ export const MockConnectGitCard = () => {
     }
     return (
       <div className="grid grid-cols-1 lg:grid-cols-2 relative z-0">
-        {TEMPLATE_CONTENT.map((template, index) => (
+        {templates.map((template, index) => (
           <MockTemplateCard key={index} {...template} />
         ))}
       </div>

packages/frontend/src/components/projects/project/deployments/AssignDomainDialog.tsx

@@ -1,42 +0,0 @@
-import { CopyBlock, atomOneLight } from 'react-code-blocks';
-import { Link } from 'react-router-dom';
-
-import { Modal } from 'components/shared/Modal';
-import { Button } from 'components/shared/Button';
-
-interface AssignDomainProps {
-  open: boolean;
-  handleOpen: () => void;
-}
-
-const AssignDomainDialog = ({ open, handleOpen }: AssignDomainProps) => {
-  return (
-    <Modal open={open} onOpenChange={handleOpen}>
-      <Modal.Content>
-        <Modal.Header>Assign Domain</Modal.Header>
-        <Modal.Body>
-          In order to assign a domain to your production deployments, configure
-          it in the{' '}
-          {/* TODO: Fix selection of project settings tab on navigation to domains */}
-          <Link to="../settings/domains" className="text-light-blue-800 inline">
-            project settings{' '}
-          </Link>
-          (recommended). If you want to assign to this specific deployment,
-          however, you can do so using our command-line interface:
-          {/* https://github.com/rajinwonderland/react-code-blocks/issues/138 */}
-          <CopyBlock
-            text="snowball alias <deployment> <domain>"
-            language=""
-            showLineNumbers={false}
-            theme={atomOneLight}
-          />
-        </Modal.Body>
-        <Modal.Footer className="flex justify-start">
-          <Button onClick={handleOpen}>Okay</Button>
-        </Modal.Footer>
-      </Modal.Content>
-    </Modal>
-  );
-};
-
-export default AssignDomainDialog;

packages/frontend/src/components/projects/project/deployments/DeploymentDetailsCard.tsx

@@ -92,7 +92,7 @@ const DeploymentDetailsCard = ({
     }
   };
 
-  const fetchDeploymentLogs = async () => {
+  const fetchDeploymentLogs = useCallback(async () => {
     setDeploymentLogs('Loading logs...');
     handleOpenDialog();
     const statusUrl = `${deployment.deployer.deployerApiUrl}/${deployment.applicationDeploymentRequestId}`;
@@ -108,7 +108,7 @@ const DeploymentDetailsCard = ({
       );
       setDeploymentLogs(logsRes);
     }
-  };
+  }, [deployment.deployer, deployment.applicationDeploymentRequestId]);
 
   const renderDeploymentStatus = useCallback(
     (className?: string) => {
@@ -127,7 +127,7 @@ const DeploymentDetailsCard = ({
         </Tooltip>
       );
     },
-    [deployment.status, deployment.commitHash],
+    [deployment.status, deployment.commitHash, fetchDeploymentLogs],
   );
 
   return (

packages/frontend/src/components/projects/project/deployments/DeploymentMenu.tsx

@@ -10,7 +10,6 @@ import {
 import { Deployment, Domain, Environment, Project } from 'gql-client';
 import { Button } from 'components/shared/Button';
 import {
-  GlobeIcon,
   HorizontalDotIcon,
   LinkIcon,
   RefreshIcon,
@@ -18,7 +17,6 @@ import {
   UndoIcon,
   CrossCircleIcon,
 } from 'components/shared/CustomIcon';
-import AssignDomainDialog from './AssignDomainDialog';
 import { useGQLClient } from 'context/GQLClientContext';
 import { cn } from 'utils/classnames';
 import { ChangeStateToProductionDialog } from 'components/projects/Dialog/ChangeStateToProductionDialog';
@@ -49,8 +47,8 @@ export const DeploymentMenu = ({
   const [redeployToProduction, setRedeployToProduction] = useState(false);
   const [deleteDeploymentDialog, setDeleteDeploymentDialog] = useState(false);
   const [isConfirmDeleteLoading, setIsConfirmDeleteLoading] = useState(false);
+  const [isConfirmUpdateLoading, setIsConfirmUpdateLoading] = useState(false);
   const [rollbackDeployment, setRollbackDeployment] = useState(false);
-  const [assignDomainDialog, setAssignDomainDialog] = useState(false);
   const [isConfirmButtonLoading, setConfirmButtonLoadingLoading] =
     useState(false);
 
@@ -58,6 +56,8 @@ export const DeploymentMenu = ({
     const isUpdated = await client.updateDeploymentToProd(deployment.id);
     if (isUpdated.updateDeploymentToProd) {
       await onUpdate();
+      setIsConfirmUpdateLoading(false);
+
       toast({
         id: 'deployment_changed_to_production',
         title: 'Deployment changed to production',
@@ -99,9 +99,12 @@ export const DeploymentMenu = ({
     const isRollbacked = await client.rollbackDeployment(
       project.id,
       deployment.id,
+      deployment.deployer.deployerId
     );
     if (isRollbacked.rollbackDeployment) {
       await onUpdate();
+      setIsConfirmUpdateLoading(false);
+
       toast({
         id: 'deployment_rolled_back',
         title: 'Deployment rolled back',
@@ -173,12 +176,6 @@ export const DeploymentMenu = ({
                 <LinkIcon /> Visit
               </a>
             </MenuItem>
-            <MenuItem
-              className="hover:bg-base-bg-emphasized flex items-center gap-3"
-              onClick={() => setAssignDomainDialog(!assignDomainDialog)}
-            >
-              <GlobeIcon /> Assign domain
-            </MenuItem>
             <MenuItem
               className="hover:bg-base-bg-emphasized flex items-center gap-3"
               onClick={() => setChangeToProduction(!changeToProduction)}
@@ -226,9 +223,11 @@ export const DeploymentMenu = ({
         handleCancel={() => setChangeToProduction((preVal) => !preVal)}
         open={changeToProduction}
         handleConfirm={async () => {
+          setIsConfirmUpdateLoading(true);
           await updateDeployment();
           setChangeToProduction((preVal) => !preVal);
         }}
+        isConfirmButtonLoading={isConfirmUpdateLoading}
         deployment={deployment}
         domains={prodBranchDomains}
       />
@@ -243,7 +242,7 @@ export const DeploymentMenu = ({
           setRedeployToProduction((preVal) => !preVal);
         }}
         deployment={deployment}
-        domains={deployment.domain ? [deployment.domain] : []}
+        domains={prodBranchDomains}
         isConfirmButtonLoading={isConfirmButtonLoading}
       />
       {Boolean(currentDeployment) && (
@@ -253,18 +252,16 @@ export const DeploymentMenu = ({
           open={rollbackDeployment}
           confirmButtonTitle="Rollback"
           handleConfirm={async () => {
+            setIsConfirmUpdateLoading(true);
             await rollbackDeploymentHandler();
             setRollbackDeployment((preVal) => !preVal);
           }}
           deployment={currentDeployment}
           newDeployment={deployment}
-          domains={currentDeployment.domain ? [currentDeployment.domain] : []}
+          domains={prodBranchDomains}
+          isConfirmButtonLoading={isConfirmUpdateLoading}
         />
       )}
-      <AssignDomainDialog
-        open={assignDomainDialog}
-        handleOpen={() => setAssignDomainDialog(!assignDomainDialog)}
-      />
       <DeleteDeploymentDialog
         open={deleteDeploymentDialog}
         handleConfirm={async () => {

packages/frontend/src/components/projects/project/settings/DomainCard.tsx

@@ -1,5 +1,5 @@
-import { useState } from 'react';
-import { Domain, DomainStatus, Project } from 'gql-client';
+import { useEffect, useState } from 'react';
+import { DNSRecordAttributes, Domain, DomainStatus, Project } from 'gql-client';
 
 import {
   Typography,
@@ -8,28 +8,34 @@ import {
   MenuList,
   MenuItem,
   Card,
+  Tooltip,
 } from '@snowballtools/material-tailwind-react-fork';
 
 import EditDomainDialog from './EditDomainDialog';
 import { useGQLClient } from 'context/GQLClientContext';
 import { DeleteDomainDialog } from 'components/projects/Dialog/DeleteDomainDialog';
 import { useToast } from 'components/shared/Toast';
-import { Tag } from 'components/shared/Tag';
-import {
-  CheckIcon,
-  CrossIcon,
-  GearIcon,
-  LoadingIcon,
-} from 'components/shared/CustomIcon';
+import { GearIcon, InfoRoundFilledIcon } from 'components/shared/CustomIcon';
 import { Heading } from 'components/shared/Heading';
 import { Button } from 'components/shared/Button';
+import { useParams } from 'react-router-dom';
 
-enum RefreshStatus {
-  IDLE,
-  CHECKING,
-  CHECK_SUCCESS,
-  CHECK_FAIL,
-}
+// NOTE: Commented code for verify domain functionality
+// import { Tag } from 'components/shared/Tag';
+// import {
+//   CheckIcon,
+//   CrossIcon,
+//   LoadingIcon,
+// } from 'components/shared/CustomIcon';
+
+// enum RefreshStatus {
+//   IDLE,
+//   CHECKING,
+//   CHECK_SUCCESS,
+//   CHECK_FAIL,
+// }
+
+// const CHECK_FAIL_TIMEOUT = 5000; // In milliseconds
 
 interface DomainCardProps {
   domains: Domain[];
@@ -39,15 +45,6 @@ interface DomainCardProps {
   onUpdate: () => Promise<void>;
 }
 
-const CHECK_FAIL_TIMEOUT = 5000; // In milliseconds
-
-// TODO: Get domain record
-const DOMAIN_RECORD = {
-  type: 'A',
-  name: '@',
-  value: '56.49.19.21',
-};
-
 const DomainCard = ({
   domains,
   domain,
@@ -56,9 +53,13 @@ const DomainCard = ({
   onUpdate,
 }: DomainCardProps) => {
   const { toast, dismiss } = useToast();
-  const [refreshStatus, SetRefreshStatus] = useState(RefreshStatus.IDLE);
+  const { id } = useParams();
   const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
   const [editDialogOpen, setEditDialogOpen] = useState(false);
+  const [dnsRecordsWithLRN, setDnsRecordsWithLRN] = useState<
+    { dnsRecord: DNSRecordAttributes; deployerLRN: string }[]
+  >([]);
+  // const [refreshStatus, SetRefreshStatus] = useState(RefreshStatus.IDLE);
 
   const client = useGQLClient();
 
@@ -83,13 +84,50 @@ const DomainCard = ({
     }
   };
 
+  useEffect(() => {
+    const fetchDNSData = async () => {
+      if (id === undefined) {
+        toast({
+          id: 'domain_cannot_find_project',
+          title: 'Cannot find project',
+          variant: 'error',
+          onDismiss: dismiss,
+        });
+        return;
+      }
+
+      const dnsRecordResponse = await client.getProject(id);
+
+      if (!dnsRecordResponse.project) {
+        return;
+      }
+
+      const tempDNSRecords: {
+        dnsRecord: DNSRecordAttributes;
+        deployerLRN: string;
+      }[] = [];
+      for (const deployment of dnsRecordResponse.project.deployments) {
+        if (deployment.dnsRecordData.value) {
+          tempDNSRecords.push({
+            dnsRecord: deployment.dnsRecordData,
+            deployerLRN: deployment.deployer.deployerLrn,
+          });
+        }
+      }
+
+      setDnsRecordsWithLRN(tempDNSRecords);
+    };
+
+    fetchDNSData();
+  }, [id, client]);
+
   return (
     <>
       <div className="flex justify-between py-3">
         <div className="flex justify-start gap-1">
           <Heading as="h6" className="flex-col">
             {domain.name}{' '}
-            <Tag
+            {/* <Tag
               type={
                 domain.status === DomainStatus.Live ? 'positive' : 'negative'
               }
@@ -102,12 +140,12 @@ const DomainCard = ({
               }
             >
               {domain.status}
-            </Tag>
+            </Tag> */}
           </Heading>
         </div>
 
         <div className="flex justify-start gap-1">
-          <i
+          {/* <i
             id="refresh"
             className="cursor-pointer"
             onClick={() => {
@@ -122,7 +160,7 @@ const DomainCard = ({
             ) : (
               'L'
             )}
-          </i>
+          </i> */}
           <Menu placement="bottom-end">
             <MenuHandler>
               <Button iconOnly>
@@ -163,11 +201,16 @@ const DomainCard = ({
       <Typography variant="small">Production</Typography>
       {domain.status === DomainStatus.Pending && (
         <Card className="bg-slate-100 p-4 text-sm">
-          {refreshStatus === RefreshStatus.IDLE ? (
-            <Heading>
-              ^ Add these records to your domain and refresh to check
-            </Heading>
-          ) : refreshStatus === RefreshStatus.CHECKING ? (
+          {dnsRecordsWithLRN.length ? (
+            <>
+              {/* {refreshStatus === RefreshStatus.IDLE ? ( */}
+              <Heading>
+                <p className="text-blue-gray-500 pb-3">
+                  ^ Add these records to your domain{' '}
+                  {/* and refresh to check */}
+                </p>
+              </Heading>
+              {/* ) : refreshStatus === RefreshStatus.CHECKING ? (
             <Heading className="text-blue-500">
               ^ Checking records for {domain.name}
             </Heading>
@@ -178,24 +221,51 @@ const DomainCard = ({
                 hours. Please ensure you added the correct records and refresh.
               </div>
             </div>
-          )}
+          )} */}
 
-          <table>
-            <thead>
-              <tr>
-                <th className="text-left">Type</th>
-                <th className="text-left">Name</th>
-                <th className="text-left">Value</th>
-              </tr>
-            </thead>
-            <tbody>
-              <tr>
-                <td>{DOMAIN_RECORD.type}</td>
-                <td>{DOMAIN_RECORD.name}</td>
-                <td>{DOMAIN_RECORD.value}</td>
-              </tr>
-            </tbody>
-          </table>
+              <table>
+                <thead>
+                  <tr>
+                    <th></th>
+                    <th className="text-left">Type</th>
+                    <th className="text-left">Name</th>
+                    <th className="text-left">Value</th>
+                  </tr>
+                </thead>
+                {dnsRecordsWithLRN.map((record) => {
+                  return (
+                    <>
+                      <tbody>
+                        <tr>
+                          <Tooltip
+                            content={
+                              <div>
+                                <p className="inline text-white">
+                                  Service Provider:
+                                </p>
+                                <p className="text-blue-gray-300 pl-2 inline">
+                                  {record.deployerLRN}
+                                </p>
+                              </div>
+                            }
+                          >
+                            <td>
+                              <InfoRoundFilledIcon />
+                            </td>
+                          </Tooltip>
+                          <td>{record.dnsRecord.resourceType}</td>
+                          <td>@</td>
+                          <td>{record.dnsRecord.value}</td>
+                        </tr>
+                      </tbody>
+                    </>
+                  );
+                })}
+              </table>
+            </>
+          ) : (
+            <p className="text-red-500">DNS record data not available</p>
+          )}
         </Card>
       )}
 

packages/frontend/src/components/projects/project/settings/EditDomainDialog.tsx

@@ -1,11 +1,15 @@
-import { useCallback, useEffect, useMemo } from 'react';
-import { Controller, useForm, SubmitHandler } from 'react-hook-form';
+import {
+  useCallback,
+  useEffect,
+} from 'react';
+import {
+  useForm,
+  SubmitHandler,
+} from 'react-hook-form';
 import { Domain } from 'gql-client';
 
 import {
   Typography,
-  Select,
-  Option,
 } from '@snowballtools/material-tailwind-react-fork';
 
 import { useGQLClient } from 'context/GQLClientContext';
@@ -14,7 +18,15 @@ import { Button } from 'components/shared/Button';
 import { Input } from 'components/shared/Input';
 import { useToast } from 'components/shared/Toast';
 
-const DEFAULT_REDIRECT_OPTIONS = ['none'];
+// NOTE: Commented code for redirect domain functionality
+// import {
+//   Select,
+//   Option,
+// } from '@snowballtools/material-tailwind-react-fork';
+// import { Controller } from 'react-hook-form';
+// import { useMemo } from 'react';
+
+// const DEFAULT_REDIRECT_OPTIONS = ['none'];
 
 interface EditDomainDialogProp {
   domains: Domain[];
@@ -28,7 +40,7 @@ interface EditDomainDialogProp {
 type EditDomainValues = {
   name: string;
   branch: string;
-  redirectedTo: string;
+  // redirectedTo: string;
 };
 
 const EditDomainDialog = ({
@@ -42,58 +54,58 @@ const EditDomainDialog = ({
   const client = useGQLClient();
   const { toast, dismiss } = useToast();
 
-  const getRedirectUrl = (domain: Domain) => {
-    const redirectDomain = domain.redirectTo;
+  // const getRedirectUrl = (domain: Domain) => {
+  //   const redirectDomain = domain.redirectTo;
 
-    if (redirectDomain !== null) {
-      return redirectDomain?.name;
-    } else {
-      return 'none';
-    }
-  };
+  //   if (redirectDomain !== null) {
+  //     return redirectDomain?.name;
+  //   } else {
+  //     return 'none';
+  //   }
+  // };
 
-  const redirectOptions = useMemo(() => {
-    const domainNames = domains
-      .filter((domainData) => domainData.id !== domain.id)
-      .map((domain) => domain.name);
-    return ['none', ...domainNames];
-  }, [domain, domains]);
+  // const redirectOptions = useMemo(() => {
+  //   const domainNames = domains
+  //     .filter((domainData) => domainData.id !== domain.id)
+  //     .map((domain) => domain.name);
+  //   return ['none', ...domainNames];
+  // }, [domain, domains]);
 
-  const domainRedirectedFrom = useMemo(() => {
-    return domains.find(
-      (domainData) => domainData.redirectTo?.id === domain.id,
-    );
-  }, [domains, domain]);
+  // const domainRedirectedFrom = useMemo(() => {
+  //   return domains.find(
+  //     (domainData) => domainData.redirectTo?.id === domain.id,
+  //   );
+  // }, [domains, domain]);
 
-  const isDisableDropdown = useMemo(() => {
-    return domainRedirectedFrom !== undefined;
-  }, [domain, domains]);
+  // const isDisableDropdown = useMemo(() => {
+  //   return domainRedirectedFrom !== undefined;
+  // }, [domain, domains]);
 
   const {
     handleSubmit,
     register,
-    control,
-    watch,
+    // control,
+    // watch,
     reset,
     formState: { isValid, isDirty },
   } = useForm({
     defaultValues: {
       name: domain.name,
       branch: domain.branch,
-      redirectedTo: getRedirectUrl(domain),
+      // redirectedTo: getRedirectUrl(domain),
     },
   });
 
   const updateDomainHandler: SubmitHandler<EditDomainValues> = useCallback(
     async (data) => {
-      const domainRedirectTo = domains.find(
-        (domainData) => data.redirectedTo === domainData.name,
-      );
+      // const domainRedirectTo = domains.find(
+      //   (domainData) => data.redirectedTo === domainData.name,
+      // );
 
       const updates = {
         name: data.name ? data.name : domain.name,
         branch: data.branch ? data.branch : domain.branch,
-        redirectToId: domainRedirectTo ? domainRedirectTo.id : null,
+        // redirectToId: domainRedirectTo ? domainRedirectTo.id : null,
       };
 
       const { updateDomain } = await client.updateDomain(domain.id, updates);
@@ -125,7 +137,7 @@ const EditDomainDialog = ({
     reset({
       name: domain.name,
       branch: domain.branch,
-      redirectedTo: getRedirectUrl(domain),
+      // redirectedTo: getRedirectUrl(domain),
     });
   }, [domain]);
 
@@ -137,7 +149,7 @@ const EditDomainDialog = ({
           <Modal.Body className="flex flex-col gap-2">
             <Typography variant="small">Domain name</Typography>
             <Input {...register('name')} />
-            <Typography variant="small">Redirect to</Typography>
+            {/* <Typography variant="small">Redirect to</Typography>
             <Controller
               name="redirectedTo"
               control={control}
@@ -161,7 +173,7 @@ const EditDomainDialog = ({
                   further.
                 </Typography>
               </div>
-            )}
+            )} */}
             <Typography variant="small">Git branch</Typography>
             <Input
               {...register('branch', {
@@ -169,8 +181,8 @@ const EditDomainDialog = ({
                   Boolean(branches.length) ? branches.includes(value) : true,
               })}
               disabled={
-                !Boolean(branches.length) ||
-                watch('redirectedTo') !== DEFAULT_REDIRECT_OPTIONS[0]
+                !Boolean(branches.length)
+                // || watch('redirectedTo') !== DEFAULT_REDIRECT_OPTIONS[0]
               }
             />
             {!isValid && (

packages/frontend/src/components/projects/project/settings/GitSelectionSection.tsx

@@ -17,6 +17,7 @@ const GitSelectionSection = ({
         <div className="grow">Github</div>
         <div>{'>'}</div>
       </div>
+      {/* 
       <div
         className="flex gap-4 border-b-2 border-gray-200 cursor-pointer p-1"
         onClick={() => {}}
@@ -25,6 +26,7 @@ const GitSelectionSection = ({
         <div className="grow">Gitea</div>
         <div>{'>'}</div>
       </div>
+      */}
     </>
   );
 };

packages/frontend/src/components/projects/project/settings/SetupDomain.tsx

@@ -1,12 +1,14 @@
-import { useEffect, useState } from 'react';
 import { useNavigate } from 'react-router-dom';
 import { useForm } from 'react-hook-form';
 
 import { Heading } from 'components/shared/Heading';
-import { InlineNotification } from 'components/shared/InlineNotification';
 import { Input } from 'components/shared/Input';
 import { Button } from 'components/shared/Button';
-import { Radio } from 'components/shared/Radio';
+
+// NOTE: Commented code for redirect domain functionality
+// import { useEffect, useState } from 'react';
+// import { InlineNotification } from 'components/shared/InlineNotification';
+// import { Radio } from 'components/shared/Radio';
 
 interface SetupDomainFormValues {
   domainName: string;
@@ -18,47 +20,45 @@ const SetupDomain = () => {
     register,
     handleSubmit,
     formState: { isValid },
-    watch,
-    setValue,
+    // watch,
+    // setValue,
   } = useForm<SetupDomainFormValues>({
     defaultValues: {
       domainName: '',
-      isWWW: 'false',
+      // isWWW: 'false',
     },
     mode: 'onChange',
   });
 
-  const [domainStr, setDomainStr] = useState<string>('');
   const navigate = useNavigate();
-  const isWWWRadioOptions = [
-    { label: domainStr, value: 'false' },
-    { label: `www.${domainStr}`, value: 'true' },
-  ];
+  // const [domainStr, setDomainStr] = useState<string>('');
+  // const isWWWRadioOptions = [
+  //   { label: domainStr, value: 'false' },
+  //   { label: `www.${domainStr}`, value: 'true' },
+  // ];
 
-  useEffect(() => {
-    const subscription = watch((value, { name }) => {
-      if (name === 'domainName' && value.domainName) {
-        const domainArr = value.domainName.split('www.');
-        const cleanedDomain =
-          domainArr.length > 1 ? domainArr[1] : domainArr[0];
-        setDomainStr(cleanedDomain);
+  // useEffect(() => {
+  //   const subscription = watch((value, { name }) => {
+  //     if (name === 'domainName' && value.domainName) {
+  //       const domainArr = value.domainName.split('www.');
+  //       const cleanedDomain =
+  //         domainArr.length > 1 ? domainArr[1] : domainArr[0];
+  //       setDomainStr(cleanedDomain);
 
-        setValue(
-          'isWWW',
-          value.domainName.startsWith('www.') ? 'true' : 'false',
-        );
-      }
-    });
+  //       setValue(
+  //         'isWWW',
+  //         value.domainName.startsWith('www.') ? 'true' : 'false',
+  //       );
+  //     }
+  //   });
 
-    return () => subscription.unsubscribe();
-  }, [watch, setValue]);
+  //   return () => subscription.unsubscribe();
+  // }, [watch, setValue]);
 
   return (
     <form
-      onSubmit={handleSubmit(() => {
-        watch('isWWW') === 'true'
-          ? navigate(`config?name=www.${domainStr}`)
-          : navigate(`config?name=${domainStr}`);
+      onSubmit={handleSubmit((e) => {
+        navigate(`config?name=${e.domainName}`)
       })}
       className="flex flex-col gap-6 w-full"
     >
@@ -67,7 +67,7 @@ const SetupDomain = () => {
           Setup domain name
         </Heading>
         <p className="text-slate-500 text-sm font-normal leading-tight">
-          Add your domain and setup redirects
+          Add your domain {/* and setup redirects */}
         </p>
       </div>
 
@@ -80,7 +80,7 @@ const SetupDomain = () => {
         label="Domain name"
       />
 
-      {isValid && (
+      {/* {isValid && (
         <div className="self-stretch flex flex-col gap-4">
           <Heading className="text-sky-950 text-lg font-medium leading-normal">
             Primary domain
@@ -99,7 +99,7 @@ const SetupDomain = () => {
             }. Redirect preferences can be changed later`}
           />
         </div>
-      )}
+      )} */}
 
       <div className="self-stretch">
         <Button disabled={!isValid} type="submit" shape="default">

packages/frontend/src/components/shared/CustomIcon/templates/TemplateIcon.tsx

@@ -1,19 +1,10 @@
 import { useMemo } from 'react';
 import { CustomIconProps } from '../CustomIcon';
-import { ReactNativeIcon } from './ReactNativeIcon';
 import { cloneIcon } from 'utils/cloneIcon';
 import { PWAIcon } from './PWAIcon';
 import { WebAppIcon } from './WebAppIcon';
-import { KotlinIcon } from './KotlinIcon';
-import { SwitfIcon } from './SwiftIcon';
 
-const TEMPLATE_ICONS = [
-  'react-native',
-  'pwa',
-  'web',
-  'kotlin',
-  'swift',
-] as const;
+const TEMPLATE_ICONS = ['pwa', 'web'] as const;
 export type TemplateIconType = (typeof TEMPLATE_ICONS)[number];
 
 export interface TemplateIconProps extends CustomIconProps {
@@ -23,16 +14,10 @@ export interface TemplateIconProps extends CustomIconProps {
 export const TemplateIcon = ({ type, ...props }: TemplateIconProps) => {
   const renderIcon = useMemo(() => {
     switch (type) {
-      case 'react-native':
-        return <ReactNativeIcon />;
       case 'pwa':
         return <PWAIcon />;
       case 'web':
         return <WebAppIcon />;
-      case 'kotlin':
-        return <KotlinIcon />;
-      case 'swift':
-        return <SwitfIcon />;
       default:
         throw new Error(`Invalid template icon type: ${type}`);
     }

packages/frontend/src/components/shared/Sidebar/Sidebar.tsx

@@ -92,10 +92,20 @@ export const Sidebar = ({ mobileOpen }: SidebarProps) => {
                 </a>
               </Tabs.Trigger>
               <Tabs.Trigger icon={<QuestionMarkRoundIcon />} value="">
-                <a className="cursor-pointer font-mono">DOCUMENTATION</a>
+                <a
+                  className="cursor-pointer font-mono"
+                  href="https://store.laconic.com/pages/instruction-faq"
+                >
+                  DOCUMENTATION
+                </a>
               </Tabs.Trigger>
               <Tabs.Trigger icon={<LifeBuoyIcon />} value="">
-                <a className="cursor-pointer font-mono">SUPPORT</a>
+                <a
+                  className="cursor-pointer font-mono"
+                  href="https://discord.com/invite/ukhbBemyxY"
+                >
+                  SUPPORT
+                </a>
               </Tabs.Trigger>
             </Tabs.List>
           </Tabs>

packages/frontend/src/context/WalletConnectContext.tsx

@@ -1,210 +0,0 @@
-import {
-  createContext,
-  useCallback,
-  useContext,
-  useEffect,
-  useRef,
-  useState,
-} from 'react';
-
-import SignClient from '@walletconnect/sign-client';
-import { getSdkError } from '@walletconnect/utils';
-import { SessionTypes } from '@walletconnect/types';
-
-import { walletConnectModal } from '../utils/web3modal';
-import {
-  VITE_LACONICD_CHAIN_ID,
-  VITE_WALLET_CONNECT_ID,
-} from 'utils/constants';
-
-interface ClientInterface {
-  signClient: SignClient | undefined;
-  session: SessionTypes.Struct | undefined;
-  loadingSession: boolean;
-  onConnect: () => Promise<void>;
-  onDisconnect: () => Promise<void>;
-  onSessionDelete: () => void;
-  accounts: { address: string }[];
-}
-
-const ClientContext = createContext({} as ClientInterface);
-
-export const useWalletConnectClient = () => {
-  return useContext(ClientContext);
-};
-
-export const WalletConnectClientProvider = ({
-  children,
-}: {
-  children: JSX.Element;
-}) => {
-  const [signClient, setSignClient] = useState<SignClient>();
-  const [session, setSession] = useState<SessionTypes.Struct>();
-  const [loadingSession, setLoadingSession] = useState(true);
-  const [accounts, setAccounts] = useState<{ address: string }[]>([]);
-
-  const isSignClientInitializing = useRef<boolean>(false);
-
-  const onSessionConnect = useCallback(async (session: SessionTypes.Struct) => {
-    setSession(session);
-  }, []);
-
-  const subscribeToEvents = useCallback(
-    async (client: SignClient) => {
-      client.on('session_update', ({ topic, params }) => {
-        const { namespaces } = params;
-        const currentSession = client.session.get(topic);
-        const updatedSession = { ...currentSession, namespaces };
-        setSession(updatedSession);
-      });
-    },
-    [setSession],
-  );
-
-  const onConnect = async () => {
-    const proposalNamespace = {
-      cosmos: {
-        methods: ['cosmos_sendTokens'],
-        chains: [`cosmos:${VITE_LACONICD_CHAIN_ID}`],
-        events: [],
-      },
-    };
-
-    try {
-      const { uri, approval } = await signClient!.connect({
-        requiredNamespaces: proposalNamespace,
-      });
-
-      if (uri) {
-        walletConnectModal.openModal({ uri });
-        const session = await approval();
-        onSessionConnect(session);
-        walletConnectModal.closeModal();
-      }
-    } catch (e) {
-      console.error(e);
-    }
-  };
-
-  const onDisconnect = useCallback(async () => {
-    if (typeof signClient === 'undefined') {
-      throw new Error('WalletConnect is not initialized');
-    }
-    if (typeof session === 'undefined') {
-      throw new Error('Session is not connected');
-    }
-
-    await signClient.disconnect({
-      topic: session.topic,
-      reason: getSdkError('USER_DISCONNECTED'),
-    });
-
-    onSessionDelete();
-  }, [signClient, session]);
-
-  const onSessionDelete = () => {
-    setAccounts([]);
-    setSession(undefined);
-  };
-
-  const checkPersistedState = useCallback(
-    async (signClient: SignClient) => {
-      if (typeof signClient === 'undefined') {
-        throw new Error('WalletConnect is not initialized');
-      }
-
-      if (typeof session !== 'undefined') return;
-      if (signClient.session.length) {
-        const lastKeyIndex = signClient.session.keys.length - 1;
-        const previousSsession = signClient.session.get(
-          signClient.session.keys[lastKeyIndex],
-        );
-
-        await onSessionConnect(previousSsession);
-        return previousSsession;
-      }
-    },
-    [session, onSessionConnect],
-  );
-
-  const createClient = useCallback(async () => {
-    isSignClientInitializing.current = true;
-    try {
-      const signClient = await SignClient.init({
-        projectId: VITE_WALLET_CONNECT_ID,
-        metadata: {
-          name: 'Deploy App',
-          description: '',
-          url: window.location.href,
-          icons: ['https://avatars.githubusercontent.com/u/92608123'],
-        },
-      });
-
-      setSignClient(signClient);
-      await checkPersistedState(signClient);
-      await subscribeToEvents(signClient);
-      setLoadingSession(false);
-    } catch (e) {
-      console.error('error in createClient', e);
-    }
-    isSignClientInitializing.current = false;
-  }, [setSignClient, checkPersistedState, subscribeToEvents]);
-
-  useEffect(() => {
-    if (!signClient && !isSignClientInitializing.current) {
-      createClient();
-    }
-  }, [signClient, createClient]);
-
-  useEffect(() => {
-    const populateAccounts = async () => {
-      if (!session) {
-        return;
-      }
-      if (!session.namespaces['cosmos']) {
-        console.log('Accounts for cosmos namespace not found');
-        return;
-      }
-
-      const cosmosAddresses = session.namespaces['cosmos'].accounts;
-
-      const cosmosAccounts = cosmosAddresses.map((address) => ({
-        address,
-      }));
-
-      const allAccounts = cosmosAccounts;
-
-      setAccounts(allAccounts);
-    };
-
-    populateAccounts();
-  }, [session]);
-
-  useEffect(() => {
-    if (!signClient) {
-      return;
-    }
-
-    signClient.on('session_delete', onSessionDelete);
-
-    return () => {
-      signClient.off('session_delete', onSessionDelete);
-    };
-  });
-
-  return (
-    <ClientContext.Provider
-      value={{
-        signClient,
-        onConnect,
-        onDisconnect,
-        onSessionDelete,
-        loadingSession,
-        session,
-        accounts,
-      }}
-    >
-      {children}
-    </ClientContext.Provider>
-  );
-};

packages/frontend/src/context/Web3Provider.tsx

@@ -17,7 +17,7 @@ import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { VITE_WALLET_CONNECT_ID, BASE_URL } from 'utils/constants';
 
 if (!VITE_WALLET_CONNECT_ID) {
-  throw new Error('Error: REACT_APP_WALLET_CONNECT_ID env config is not set');
+  throw new Error('Error: VITE_WALLET_CONNECT_ID env config is not set');
 }
 assert(BASE_URL, 'VITE_SERVER_URL is not set in env');
 

packages/frontend/src/index.tsx

@@ -4,10 +4,9 @@ import assert from 'assert';
 import { GQLClient } from 'gql-client';
 
 import { ThemeProvider } from '@snowballtools/material-tailwind-react-fork';
-
-import './index.css';
 import '@fontsource/inter';
 import '@fontsource-variable/jetbrains-mono';
+
 import App from './App';
 import reportWebVitals from './reportWebVitals';
 import { GQLClientProvider } from './context/GQLClientContext';
@@ -16,7 +15,7 @@ import { Toaster } from 'components/shared/Toast';
 import { LogErrorBoundary } from 'utils/log-error';
 import { BASE_URL } from 'utils/constants';
 import Web3ModalProvider from './context/Web3Provider';
-import { WalletConnectClientProvider } from 'context/WalletConnectContext';
+import './index.css';
 
 console.log(`v-0.0.9`);
 
@@ -32,16 +31,14 @@ const gqlClient = new GQLClient({ gqlEndpoint });
 root.render(
   <LogErrorBoundary>
     <React.StrictMode>
-      <WalletConnectClientProvider>
-        <ThemeProvider>
-          <Web3ModalProvider>
-            <GQLClientProvider client={gqlClient}>
-              <App />
-              <Toaster />
-            </GQLClientProvider>
-          </Web3ModalProvider>
-        </ThemeProvider>
-      </WalletConnectClientProvider>
+      <ThemeProvider>
+        <Web3ModalProvider>
+          <GQLClientProvider client={gqlClient}>
+            <App />
+            <Toaster />
+          </GQLClientProvider>
+        </Web3ModalProvider>
+      </ThemeProvider>
     </React.StrictMode>
   </LogErrorBoundary>,
 );

packages/frontend/src/pages/components/modals.tsx

@@ -10,8 +10,10 @@ import { DeleteVariableDialog } from 'components/projects/Dialog/DeleteVariableD
 import { DeleteDomainDialog } from 'components/projects/Dialog/DeleteDomainDialog';
 import { CancelDeploymentDialog } from 'components/projects/Dialog/CancelDeploymentDialog';
 import {
+  AppDeploymentRecordAttributes,
   Deployment,
   DeploymentStatus,
+  DNSRecordAttributes,
   Domain,
   DomainStatus,
   Environment,
@@ -20,15 +22,6 @@ import { ChangeStateToProductionDialog } from 'components/projects/Dialog/Change
 
 const deployment: Deployment = {
   id: '1',
-  domain: {
-    id: 'domain1',
-    branch: 'main',
-    name: 'example.com',
-    status: DomainStatus.Live,
-    redirectTo: null,
-    createdAt: '1677609600', // 2023-02-25T12:00:00Z
-    updatedAt: '1677613200', // 2023-02-25T13:00:00Z
-  },
   branch: 'main',
   commitHash: 'a1b2c3d',
   commitMessage:
@@ -57,6 +50,8 @@ const deployment: Deployment = {
   updatedAt: '1677680400', // 2023-03-01T13:00:00Z
   applicationDeploymentRequestId:
     'bafyreiaycvq6imoppnpwdve4smj6t6ql5svt5zl3x6rimu4qwyzgjorize',
+  applicationDeploymentRecordData: {} as AppDeploymentRecordAttributes,
+  dnsRecordData: {} as DNSRecordAttributes,
 };
 
 const domains: Domain[] = [
@@ -252,7 +247,7 @@ const ModalsPage: React.FC = () => {
                   setRedeployToProduction((preVal) => !preVal)
                 }
                 deployment={deployment}
-                domains={deployment.domain ? [deployment.domain] : []}
+                domains={domains}
               />
               {/* Rollback to this deployment */}
               <Button onClick={() => setRollbackDeployment(true)}>
@@ -268,7 +263,7 @@ const ModalsPage: React.FC = () => {
                 }
                 deployment={deployment}
                 newDeployment={deployment}
-                domains={deployment.domain ? [deployment.domain] : []}
+                domains={domains}
               />
             </div>
           </div>

packages/frontend/src/pages/org-slug/projects/Id.tsx

@@ -60,9 +60,9 @@ const Id = () => {
     fetchProject(id);
   }, [id]);
 
-  const onUpdate = async () => {
+  const onUpdate = useCallback(async () => {
     await fetchProject(id);
-  };
+  }, [fetchProject, id]);
 
   return (
     <div className="h-full">
@@ -118,9 +118,11 @@ const Id = () => {
                 <Tabs.Trigger value="deployments">
                   <Link to="deployments">Deployments</Link>
                 </Tabs.Trigger>
+                {/*
                 <Tabs.Trigger value="integrations">
                   <Link to="integrations">Integrations</Link>
                 </Tabs.Trigger>
+	              */}
                 <Tabs.Trigger value="settings">
                   <Link to="settings">Settings</Link>
                 </Tabs.Trigger>

packages/frontend/src/pages/org-slug/projects/create/Template.tsx

@@ -57,7 +57,7 @@ const CreateWithTemplate = () => {
 
   return (
     <div className="flex flex-col items-center gap-6 lg:gap-10 mx-auto w-full lg:w-5/6">
-      <div className="flex flex-col lg:flex-row justify-between w-full my-4 bg-base-bg-alternate rounded-xl p-6 gap-3 items-start lg:items-center">
+      <div className="flex flex-col lg:flex-row justify-between w-full my-4 bg-base-bg-alternate dark:bg-overlay rounded-xl p-6 gap-3 items-start lg:items-center">
         <div className="flex items-center gap-3">
           <TemplateIcon type={template?.icon as TemplateIconType} size={48} />
           <Heading className="font-medium">{template?.name}</Heading>

packages/frontend/src/pages/org-slug/projects/create/layout.tsx

@@ -1,12 +1,14 @@
 import { ComponentPropsWithoutRef } from 'react';
 import { Link, Outlet, useParams } from 'react-router-dom';
+import { useMediaQuery } from 'usehooks-ts';
+
+import * as Dialog from '@radix-ui/react-dialog';
 
 import { Heading } from 'components/shared/Heading';
 import { WavyBorder } from 'components/shared/WavyBorder';
 import { Button } from 'components/shared/Button';
 import { CrossIcon } from 'components/shared/CustomIcon';
 import { cn } from 'utils/classnames';
-import * as Dialog from '@radix-ui/react-dialog';
 
 export interface CreateProjectLayoutProps
   extends ComponentPropsWithoutRef<'section'> {}
@@ -16,6 +18,7 @@ export const CreateProjectLayout = ({
   ...props
 }: CreateProjectLayoutProps) => {
   const { orgSlug } = useParams();
+  const isDesktopView = useMediaQuery('(min-width: 720px)'); // md:
 
   const closeBtnLink = `/${orgSlug}`;
 
@@ -28,72 +31,69 @@ export const CreateProjectLayout = ({
     </Heading>
   );
 
-  return (
-    <>
-      {/* Desktop */}
-      <section
-        {...props}
-        className={cn(
-          'dark:bg-background h-full flex-col hidden md:flex',
-          className,
-        )}
-      >
-        <div className="sticky top-0">
-          <div className="flex px-6 py-4 dark:bg-overlay bg-base-bg items-center gap-4">
-            {heading}
+  return isDesktopView ? (
+    // Desktop
+    <section
+      {...props}
+      className={cn(
+        'dark:bg-background h-full flex-col hidden md:flex',
+        className,
+      )}
+    >
+      <div className="sticky top-0">
+        <div className="flex px-6 py-4 dark:bg-overlay bg-base-bg items-center gap-4">
+          {heading}
 
-            {/* Cannot save btn as variable since responsive variant don't work with compoundVariant */}
-            <Link to={closeBtnLink}>
-              <Button
-                iconOnly
-                variant="primary"
-                leftIcon={<CrossIcon />}
-                aria-label="close"
-              />
-            </Link>
-          </div>
-          <WavyBorder />
+          {/* Cannot save btn as variable since responsive variant don't work with compoundVariant */}
+          <Link to={closeBtnLink}>
+            <Button
+              iconOnly
+              variant="primary"
+              leftIcon={<CrossIcon />}
+              aria-label="close"
+            />
+          </Link>
         </div>
-
-        <section className="px-6 h-full flex-1 py-6 overflow-y-auto">
-          <Outlet />
-        </section>
+        <WavyBorder />
+      </div>
+      <section className="px-6 h-full flex-1 py-6 overflow-y-auto">
+        <Outlet />
       </section>
+    </section>
+  ) : (
+    // Mobile
+    // Setting modal={false} so even if modal is active on desktop, it doesn't block clicks
+    <Dialog.Root modal={false} open={true}>
+      <Dialog.Portal>
+        {/* Not using <Dialog.Overlay> since modal={false} disables it and its content will not show */}
+        <div className="bg-base-canvas fixed inset-0 md:hidden overflow-y-auto p-1">
+          <Dialog.Content className="min-h-full overflow-hidden rounded-2xl bg-base-bg shadow-card focus:outline-none">
+            {/* Heading */}
+            <div className="flex px-6 py-4 h-20 items-center gap-4">
+              {heading}
+              <Dialog.Close asChild>
+                <Link to={closeBtnLink}>
+                  <Button
+                    iconOnly
+                    variant="tertiary"
+                    leftIcon={<CrossIcon />}
+                    aria-label="close"
+                    size="sm"
+                  />
+                </Link>
+              </Dialog.Close>
+            </div>
 
-      {/* Mobile */}
-      {/* Setting modal={false} so even if modal is active on desktop, it doesn't block clicks */}
-      <Dialog.Root modal={false} open={true}>
-        <Dialog.Portal>
-          {/* Not using <Dialog.Overlay> since modal={false} disables it and its content will not show */}
-          <div className="bg-base-canvas fixed inset-0 md:hidden overflow-y-auto p-1">
-            <Dialog.Content className="min-h-full overflow-hidden rounded-2xl bg-base-bg shadow-card focus:outline-none">
-              {/* Heading */}
-              <div className="flex px-6 py-4 h-20 items-center gap-4">
-                {heading}
-                <Dialog.Close asChild>
-                  <Link to={closeBtnLink}>
-                    <Button
-                      iconOnly
-                      variant="tertiary"
-                      leftIcon={<CrossIcon />}
-                      aria-label="close"
-                      size="sm"
-                    />
-                  </Link>
-                </Dialog.Close>
-              </div>
+            {/* Border */}
+            <WavyBorder />
 
-              {/* Border */}
-              <WavyBorder />
-
-              {/* Page content */}
-              <div className="px-4 py-6">
-                <Outlet />
-              </div>
-            </Dialog.Content>
-          </div>
-        </Dialog.Portal>
-      </Dialog.Root>
-    </>
+            {/* Page content */}
+            <div className="px-4 py-6">
+              <Outlet />
+            </div>
+          </Dialog.Content>
+        </div>
+      </Dialog.Portal>
+    </Dialog.Root>
   );
 };

packages/frontend/src/pages/org-slug/projects/create/success/Id.tsx

@@ -55,7 +55,7 @@ const Id = () => {
           </div>
 
           {/* Card */}
-          <div className="bg-base-bg-alternate rounded-xl shadow-inset w-full px-1 py-1">
+          <div className="bg-base-bg-alternate dark:bg-overlay2 rounded-xl shadow-inset w-full px-1 py-1">
             {/* Trigger question */}
             <div className="flex gap-2 justify-center items-center py-3">
               <div className="h-5 w-5">
@@ -67,7 +67,7 @@ const Id = () => {
             </div>
 
             {/* CTA card */}
-            <div className="bg-surface-card rounded-xl shadow-card-sm px-4 py-4">
+            <div className="bg-surface-card dark:bg-overlay rounded-xl shadow-card-sm dark:shadow-background px-4 py-4">
               <div className="flex gap-2">
                 <Badge variant="secondary">1</Badge>
                 <div className="space-y-3">
@@ -75,7 +75,7 @@ const Id = () => {
                     <Heading as="h6" className="text-sm font-sans">
                       Add a custom domain
                     </Heading>
-                    <p className="text-xs text-elements-low-em font-sans">
+                    <p className="text-xs text-elements-low-em dark:text-foreground-secondary font-sans">
                       Make it easy for your visitors to remember your URL with a
                       custom domain.
                     </p>

packages/frontend/src/pages/org-slug/projects/create/template/index.tsx

@@ -152,13 +152,18 @@ const CreateRepo = () => {
           <Heading as="h3" className="text-lg font-medium">
             Create a repository
           </Heading>
-          <Heading as="h5" className="text-sm font-sans text-elements-low-em">
+          <Heading
+            as="h5"
+            className="text-sm font-sans text-elements-low-em dark:text-foreground-secondary"
+          >
             The project will be cloned into this repository
           </Heading>
         </div>
 
         <div className="flex flex-col justify-start gap-3">
-          <span className="text-sm text-elements-high-em">Git account</span>
+          <span className="text-sm text-elements-high-em dark:text-foreground">
+            Git account
+          </span>
           {gitAccounts.length > 0 ? (
             <Controller
               name="account"
@@ -181,7 +186,9 @@ const CreateRepo = () => {
           )}
         </div>
         <div className="flex flex-col justify-start gap-3">
-          <span className="text-sm text-elements-high-em">Name the repo</span>
+          <span className="text-sm text-elements-high-em dark:text-foreground">
+            Name the repo
+          </span>
           <Controller
             name="repoName"
             control={control}

packages/frontend/src/pages/org-slug/projects/id/Overview.tsx

@@ -1,40 +1,55 @@
 import { useEffect, useState } from 'react';
-import { Link, useNavigate, useOutletContext } from 'react-router-dom';
+import {
+  Link,
+  useOutletContext,
+} from 'react-router-dom';
 import { RequestError } from 'octokit';
 
-import { useOctokit } from 'context/OctokitContext';
-import { GitCommitWithBranch, OutletContextType } from '../../../../types';
-import { useGQLClient } from 'context/GQLClientContext';
-import { Button, Heading, Avatar, Tag } from 'components/shared';
-import { getInitials } from 'utils/geInitials';
+import {
+  Heading,
+  Avatar,
+} from 'components/shared';
 import {
   BranchStrokeIcon,
-  CheckRoundFilledIcon,
-  ClockIcon,
   CursorBoxIcon,
   GithubStrokeIcon,
-  GlobeIcon,
   LinkIcon,
   CalendarDaysIcon,
 } from 'components/shared/CustomIcon';
+import { useOctokit } from 'context/OctokitContext';
+import { GitCommitWithBranch, OutletContextType } from '../../../../types';
+import { getInitials } from 'utils/geInitials';
 import { Activity } from 'components/projects/project/overview/Activity';
 import { OverviewInfo } from 'components/projects/project/overview/OverviewInfo';
 import { relativeTimeMs } from 'utils/time';
-import { Domain, DomainStatus } from 'gql-client';
 import { AuctionCard } from 'components/projects/project/overview/Activity/AuctionCard';
 
+// NOTE: Commented code for verify domain functionality
+// import { useGQLClient } from 'context/GQLClientContext';
+// import { Domain, DomainStatus } from 'gql-client';
+// import {
+//   CheckRoundFilledIcon,
+//   ClockIcon,
+//   GlobeIcon,
+// } from 'components/shared/CustomIcon';
+// import {
+//   Button,
+//   Tag,
+// } from 'components/shared';
+// import { useNavigate } from 'react-router-dom';
+
 const COMMITS_PER_PAGE = 4;
+const PROJECT_UPDATE_WAIT_MS = 5000;
 
 const OverviewTabPanel = () => {
   const { octokit } = useOctokit();
-  const navigate = useNavigate();
+  // const navigate = useNavigate();
   const [activities, setActivities] = useState<GitCommitWithBranch[]>([]);
   const [fetchingActivities, setFetchingActivities] = useState(true);
-  const [liveDomain, setLiveDomain] = useState<Domain>();
+  // const [liveDomain, setLiveDomain] = useState<Domain>();
 
-  const client = useGQLClient();
-
-  const { project } = useOutletContext<OutletContextType>();
+  // const client = useGQLClient();
+  const { project, onUpdate } = useOutletContext<OutletContextType>();
 
   useEffect(() => {
     setFetchingActivities(true);
@@ -96,24 +111,33 @@ const OverviewTabPanel = () => {
     };
 
     fetchRepoActivity();
-  }, [octokit, project]);
+  }, [project.repository]);
 
   useEffect(() => {
-    const fetchLiveProdDomain = async () => {
-      const { domains } = await client.getDomains(project.id, {
-        branch: project.prodBranch,
-        status: DomainStatus.Live,
-      });
+    onUpdate();
+    const timerId = setInterval(() => {
+      onUpdate();
+    }, PROJECT_UPDATE_WAIT_MS);
 
-      if (domains.length === 0) {
-        return;
-      }
+    return () => clearInterval(timerId);
+  }, [onUpdate]);
 
-      setLiveDomain(domains[0]);
-    };
+  // useEffect(() => {
+  //   const fetchLiveProdDomain = async () => {
+  //     const { domains } = await client.getDomains(project.id, {
+  //       branch: project.prodBranch,
+  //       status: DomainStatus.Live,
+  //     });
 
-    fetchLiveProdDomain();
-  }, [project]);
+  //     if (domains.length === 0) {
+  //       return;
+  //     }
+
+  //     setLiveDomain(domains[0]);
+  //   };
+
+  //   fetchLiveProdDomain();
+  // }, [project]);
 
   return (
     <div className="grid grid-cols-5 gap-6 md:gap-[72px]">
@@ -132,19 +156,16 @@ const OverviewTabPanel = () => {
             {project.deployments &&
               project.deployments.length > 0 &&
               project.deployments.map((deployment, index) => (
-                <p>
-                  <a
-                    key={index}
-                    href={`https://${project.name.toLowerCase()}.${deployment.deployer.baseDomain}`}
-                    className="text-sm text-elements-low-em dark:text-foreground tracking-tight truncate"
-                  >
-                    {deployment.deployer.baseDomain}
-                  </a>
+                <p
+                  key={index}
+                  className="text-sm text-elements-low-em dark:text-foreground tracking-tight truncate"
+                >
+                  {deployment.deployer.baseDomain}
                 </p>
               ))}
           </div>
         </div>
-        <OverviewInfo label="Domain" icon={<GlobeIcon />}>
+        {/* <OverviewInfo label="Domain" icon={<GlobeIcon />}>
           {liveDomain ? (
             <Tag type="positive" size="xs" leftIcon={<CheckRoundFilledIcon />}>
               Connected
@@ -165,7 +186,7 @@ const OverviewTabPanel = () => {
               </Button>
             </div>
           )}
-        </OverviewInfo>
+        </OverviewInfo> */}
         {project.deployments.length !== 0 ? (
           <>
             {/* SOURCE */}
@@ -184,11 +205,9 @@ const OverviewTabPanel = () => {
                 project.deployments.length > 0 &&
                 project.deployments.map((deployment) => (
                   <div className="flex gap-2 items-center">
-                    <Link
-                      to={`https://${project.name.toLowerCase()}.${deployment.deployer.baseDomain}`}
-                    >
+                    <Link to={deployment.applicationDeploymentRecordData.url}>
                       <span className="text-controls-primary dark:text-foreground group hover:border-controls-primary transition-colors border-b border-b-transparent flex gap-2 items-center text-sm tracking-tight">
-                        {`https://${project.name.toLowerCase()}.${deployment.deployer.baseDomain}`}
+                        {deployment.applicationDeploymentRecordData.url}
                         <LinkIcon className="group-hover:rotate-45 transition-transform" />
                       </span>
                     </Link>

packages/frontend/src/pages/org-slug/projects/id/Settings.tsx

@@ -10,7 +10,7 @@ import {
 } from 'components/shared/Tabs';
 import {
   BranchStrokeIcon,
-  CollaboratorsIcon,
+  //CollaboratorsIcon,
   GearIcon,
   GlobeIcon,
   SwitchIcon,
@@ -37,11 +37,11 @@ const tabsData = [
     icon: <SwitchIcon />,
     value: 'environment-variables',
   },
-  {
-    label: 'Collaborators',
-    icon: <CollaboratorsIcon />,
-    value: 'collaborators',
-  },
+  //  {
+  //    label: 'Collaborators',
+  //    icon: <CollaboratorsIcon />,
+  //    value: 'collaborators',
+  //  },
 ];
 
 const SettingsTabPanel = () => {

packages/frontend/src/pages/org-slug/projects/id/settings/EnvironmentVariablesForm.tsx

@@ -1,11 +1,15 @@
 import { useEffect, useMemo } from 'react';
 import { useFieldArray, useFormContext } from 'react-hook-form';
 
+// TODO: Use custom checkbox component
+// Custom checkbox component does not work with react-hook-form
+import { Checkbox } from '@snowballtools/material-tailwind-react-fork';
+// import { Checkbox } from 'components/shared/Checkbox';
+
 import { Button } from 'components/shared/Button';
 import { InlineNotification } from 'components/shared/InlineNotification';
 import AddEnvironmentVariableRow from 'components/projects/project/settings/AddEnvironmentVariableRow';
 import { EnvironmentVariablesFormValues } from 'types/types';
-import { Checkbox } from 'components/shared/Checkbox';
 
 const EnvironmentVariablesForm = () => {
   const {
@@ -67,10 +71,19 @@ const EnvironmentVariablesForm = () => {
         />
       )}
       <div className="flex gap-2 p-2">
-        <Checkbox label="Production" {...register('environment.production')} />
-        <Checkbox label="Preview" {...register('environment.preview')} />
+        <Checkbox
+          label="Production"
+          labelProps={{ className: 'text-gray-900 dark:text-white' }}
+          {...register('environment.production')}
+        />
+        <Checkbox
+          label="Preview"
+          labelProps={{ className: 'text-gray-900 dark:text-white' }}
+          {...register('environment.preview')}
+        />
         <Checkbox
           label="Development"
+          labelProps={{ className: 'text-gray-900 dark:text-white' }}
           {...register('environment.development')}
         />
       </div>

packages/frontend/src/pages/org-slug/projects/id/settings/General.tsx

@@ -18,7 +18,6 @@ const GeneralTabPanel = () => {
   const client = useGQLClient();
   const { toast } = useToast();
   const { project, onUpdate } = useOutletContext<OutletContextType>();
-  console.log(project);
 
   const [transferOrganizations, setTransferOrganizations] = useState<
     SelectOption[]

packages/frontend/src/pages/org-slug/projects/id/settings/domains/add/Config.tsx

@@ -7,6 +7,8 @@ import { InlineNotification } from 'components/shared/InlineNotification';
 import { ArrowRightCircleIcon } from 'components/shared/CustomIcon';
 import { ProjectSettingContainer } from 'components/projects/project/settings/ProjectSettingContainer';
 import { useToast } from 'components/shared/Toast';
+import { useEffect, useState } from 'react';
+import { DNSRecordAttributes } from 'gql-client';
 
 const Config = () => {
   const { id, orgSlug } = useParams();
@@ -16,6 +18,10 @@ const Config = () => {
   const primaryDomainName = searchParams.get('name');
   const { toast, dismiss } = useToast();
 
+  const [dnsRecordsWithLRN, setDnsRecordsWithLRN] = useState<
+    { dnsRecord: DNSRecordAttributes; deployerLRN: string }[]
+  >([]);
+
   const handleSubmitDomain = async () => {
     if (primaryDomainName === null) {
       toast({
@@ -59,47 +65,104 @@ const Config = () => {
     }
   };
 
+  useEffect(() => {
+    const fetchDNSData = async () => {
+      if (id === undefined) {
+        toast({
+          id: 'domain_cannot_find_project',
+          title: 'Cannot find project',
+          variant: 'error',
+          onDismiss: dismiss,
+        });
+        return;
+      }
+
+      const dnsRecordResponse = await client.getProject(id);
+
+      if (!dnsRecordResponse.project) {
+        return;
+      }
+
+      const tempDNSRecords: {
+        dnsRecord: DNSRecordAttributes;
+        deployerLRN: string;
+      }[] = [];
+      for (const deployment of dnsRecordResponse.project.deployments) {
+        if (deployment.dnsRecordData.value) {
+          tempDNSRecords.push({
+            dnsRecord: deployment.dnsRecordData,
+            deployerLRN: deployment.deployer.deployerLrn,
+          });
+        }
+      }
+
+      setDnsRecordsWithLRN(tempDNSRecords);
+
+      // console.log('DNS RECORD', dnsRecordResponse)
+
+      // setDnsRecord({} as DNSRecordAttributes);
+    };
+
+    fetchDNSData();
+  }, [id, client]);
+
   // TODO: Figure out DNS Provider if possible and update appropriatly
+  // TODO: Handle case where dnsRecords only have one entry and IP address for that record is not availble
   return (
     <ProjectSettingContainer headingText="Setup domain name">
-      <p className="text-blue-gray-500">
-        Add the following records to your domain.&nbsp;
-        <a href="https://www.namecheap.com/" target="_blank" rel="noreferrer">
-          <span className="underline">Go to NameCheap</span>
-        </a>
-      </p>
-
-      <Table>
-        <Table.Header>
-          <Table.Row>
-            <Table.ColumnHeaderCell>Type</Table.ColumnHeaderCell>
-            <Table.ColumnHeaderCell>Host</Table.ColumnHeaderCell>
-            <Table.ColumnHeaderCell>Value</Table.ColumnHeaderCell>
-          </Table.Row>
-        </Table.Header>
-
-        <Table.Body>
-          <Table.Row>
-            <Table.RowHeaderCell>A</Table.RowHeaderCell>
-            <Table.Cell>@</Table.Cell>
-            <Table.Cell>56.49.19.21</Table.Cell>
-          </Table.Row>
-
-          <Table.Row>
-            <Table.RowHeaderCell>CNAME</Table.RowHeaderCell>
-            <Table.Cell>www</Table.Cell>
-            <Table.Cell>cname.snowballtools.xyz</Table.Cell>
-          </Table.Row>
-        </Table.Body>
-      </Table>
-
-      <InlineNotification
-        variant="info"
-        title={`It can take up to 48 hours for these updates to reflect
-        globally.`}
-      />
+      {dnsRecordsWithLRN.length ? (
+        <>
+          <p className="text-blue-gray-500">
+            Add the following records to your domain.
+          </p>
+          {dnsRecordsWithLRN.map((record) => {
+            if (record.dnsRecord.value) {
+              return (
+                <>
+                  <div className="pt-6">
+                    <p className="text-gray-100 inline">Service Provider:</p>
+                    <p className="text-blue-gray-500 pl-2 inline">
+                      {record.deployerLRN}
+                    </p>
+                  </div>
+                  <Table>
+                    <Table.Header>
+                      <Table.Row>
+                        <Table.ColumnHeaderCell>Type</Table.ColumnHeaderCell>
+                        <Table.ColumnHeaderCell>Host</Table.ColumnHeaderCell>
+                        <Table.ColumnHeaderCell>Value</Table.ColumnHeaderCell>
+                      </Table.Row>
+                    </Table.Header>
+                    <Table.Body>
+                      <Table.Row>
+                        <Table.RowHeaderCell>
+                          {record.dnsRecord.resourceType}
+                        </Table.RowHeaderCell>
+                        <Table.Cell>@</Table.Cell>
+                        <Table.Cell>
+                          <p>{record.dnsRecord.value}</p>
+                        </Table.Cell>
+                      </Table.Row>
+                    </Table.Body>
+                  </Table>
+                </>
+              );
+            }
+          })}
+        </>
+      ) : (
+        <p className={'text-red-500'}>DNS record data not available</p>
+      )}
+      {dnsRecordsWithLRN.length && (
+        <InlineNotification
+          variant="info"
+          title={`It can take up to 48 hours for these updates to reflect
+                  globally.`}
+        />
+      )}
       <Button
         className="w-fit"
+        disabled={!dnsRecordsWithLRN.length}
         onClick={handleSubmitDomain}
         variant="primary"
         shape="default"
@@ -107,6 +170,7 @@ const Config = () => {
       >
         FINISH
       </Button>
+      ;
     </ProjectSettingContainer>
   );
 };

packages/frontend/src/pages/org-slug/projects/id/settings/domains/add/index.tsx

@@ -49,9 +49,6 @@ const AddDomain = () => {
       <div className=" w-2/3 mx-auto">
         <div className="bg-blue-gray-50 dark:bg-overlay rounded-lg mt-6 mb-10">
           <div className="flex justify-start gap-3 p-5">
-            <i className="bg-gray-100 dark:bg-overlay dark:text-foreground w-12 h-12 rounded-lg">
-              ^
-            </i>
             <Typography
               className="my-auto w-1/3 dark:text-foreground"
               variant="h5"

packages/frontend/src/stories/MockStoriesData.ts

@@ -12,6 +12,8 @@ import {
   Domain,
   Environment,
   Permission,
+  AppDeploymentRecordAttributes,
+  DNSRecordAttributes,
 } from 'gql-client';
 
 export const user: User = {
@@ -99,7 +101,6 @@ export const deployment0: Deployment = {
   environment: Environment.Development,
   isCurrent: true,
   commitHash: 'Commit Hash',
-  domain: domain0,
   commitMessage: 'Commit Message',
   createdBy: user,
   deployer: {
@@ -111,6 +112,8 @@ export const deployment0: Deployment = {
   },
   applicationDeploymentRequestId:
     'bafyreiaycvq6imoppnpwdve4smj6t6ql5svt5zl3x6rimu4qwyzgjorize',
+  applicationDeploymentRecordData: {} as AppDeploymentRecordAttributes,
+  dnsRecordData: {} as DNSRecordAttributes,
 };
 
 export const project: Project = {

packages/frontend/src/utils/constants.ts

@@ -5,8 +5,11 @@ export const VITE_GITHUB_PWA_TEMPLATE_REPO = import.meta.env
   .VITE_GITHUB_PWA_TEMPLATE_REPO;
 export const VITE_GITHUB_IMAGE_UPLOAD_PWA_TEMPLATE_REPO = import.meta.env
   .VITE_GITHUB_IMAGE_UPLOAD_PWA_TEMPLATE_REPO;
+export const VITE_GITHUB_NEXT_APP_TEMPLATE_REPO = import.meta.env
+  .VITE_GITHUB_NEXT_APP_TEMPLATE_REPO;
 export const VITE_GITHUB_CLIENT_ID = import.meta.env.VITE_GITHUB_CLIENT_ID;
 export const VITE_WALLET_CONNECT_ID = import.meta.env.VITE_WALLET_CONNECT_ID;
 export const VITE_BUGSNAG_API_KEY = import.meta.env.VITE_BUGSNAG_API_KEY;
 export const VITE_LIT_RELAY_API_KEY = import.meta.env.VITE_LIT_RELAY_API_KEY;
 export const VITE_LACONICD_CHAIN_ID = import.meta.env.VITE_LACONICD_CHAIN_ID;
+export const VITE_WALLET_IFRAME_URL = import.meta.env.VITE_WALLET_IFRAME_URL;

packages/gql-client/src/client.ts

@@ -337,13 +337,15 @@ export class GQLClient {
 
   async rollbackDeployment(
     projectId: string,
-    deploymentId: string
+    deploymentId: string,
+    deployerId: string,
   ): Promise<types.RollbackDeploymentResponse> {
     const { data } = await this.client.mutate({
       mutation: mutations.rollbackDeployment,
       variables: {
         projectId,
         deploymentId,
+        deployerId,
       },
     });
 
@@ -453,4 +455,15 @@ export class GQLClient {
 
     return data.verifyTx;
   }
+
+  async getLatestDNSRecordByProjectId(projectId: string): Promise<types.GetLatestDNSDataResponse> {
+    const { data } = await this.client.query({
+      query: queries.getLatestDNSRecordByProjectId,
+      variables: {
+        projectId,
+      },
+    });
+
+    return data;
+  }
 }

packages/gql-client/src/queries.ts

@@ -57,21 +57,24 @@ query ($projectId: String!) {
       commitHash
       createdAt
       environment
+      applicationDeploymentRecordData {
+        url
+      }
       deployer {
         baseDomain
-      }
-      domain {
-        status
-        branch
-        createdAt
-        updatedAt
-        id
-        name
+        deployerLrn
       }
       createdBy {
         id
         name
       }
+      dnsRecordData {
+        name
+        value
+        request
+        resourceType
+        version
+      }
     }
   }
 }
@@ -112,13 +115,8 @@ query ($organizationSlug: String!) {
       commitMessage
       createdAt
       environment
-      domain {
-        status
-        branch
-        createdAt
-        updatedAt
-        id
-        name
+      applicationDeploymentRecordData {
+        url
       }
     }
   }
@@ -141,14 +139,6 @@ export const getDeployments = gql`
 query ($projectId: String!)  {
   deployments(projectId: $projectId) {
     id
-    domain{
-      branch
-      createdAt
-      id
-      name
-      status
-      updatedAt
-    }
     branch
     commitHash
     commitMessage
@@ -343,3 +333,15 @@ query ($txHash: String!, $amount: String!, $senderAddress: String!) {
   verifyTx(txHash: $txHash, amount: $amount, senderAddress: $senderAddress)
 }
 `;
+
+export const getLatestDNSRecordByProjectId = gql`
+query($projectId: String!) {
+  latestDNSRecord(projectId: $projectId) {
+    name
+    value
+    request
+    resourceType
+    version
+  }
+}
+`;

packages/gql-client/src/types.ts

@@ -99,7 +99,6 @@ export type User = {
 
 export type Deployment = {
   id: string;
-  domain: Domain;
   branch: string;
   commitHash: string;
   commitMessage: string;
@@ -108,10 +107,12 @@ export type Deployment = {
   environment: Environment;
   isCurrent: boolean;
   baseDomain?: string;
+  applicationDeploymentRecordData: AppDeploymentRecordAttributes;
   status: DeploymentStatus;
   createdBy: User;
   createdAt: string;
   updatedAt: string;
+  dnsRecordData: DNSRecordAttributes;
   applicationDeploymentRequestId: string;
 };
 
@@ -376,3 +377,28 @@ export type AuctionParams = {
   maxPrice: string;
   numProviders: number;
 };
+
+export type DNSRecordAttributes = {
+  name: string;
+  value: string;
+  request: string;
+  resourceType: string;
+  version: string;
+}
+
+export type GetLatestDNSDataResponse = {
+  latestDNSRecord: DNSRecordAttributes | null
+}
+
+export interface AppDeploymentRecordAttributes {
+  application: string;
+  auction: string;
+  deployer: string;
+  dns: string;
+  meta: string;
+  name: string;
+  request: string;
+  type: string;
+  url: string;
+  version: string;
+}

yarn.lock

@@ -14407,6 +14407,11 @@ open@^8.0.4, open@^8.4.0:
     is-docker "^2.1.1"
     is-wsl "^2.2.0"
 
+openpgp@^6.0.1:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/openpgp/-/openpgp-6.0.1.tgz#ab3a2c08a3e23ac7f85c4fc62a3e715d50dc08fb"
+  integrity sha512-3lReDKjgWsKFArZT4Y/yj7/Q0q6/VhXarn4WqKEkyiBWckNjrThSGoB1t0IKo3Ke0ClvBpyQfTwumkGUkxOwww==
+
 optimism@^0.18.0:
   version "0.18.0"
   resolved "https://registry.yarnpkg.com/optimism/-/optimism-0.18.0.tgz#e7bb38b24715f3fdad8a9a7fc18e999144bbfa63"