Use deployer LRN instead of ID in rollback deployment

Add custom domain support for auctions flow
Add UI to show multiple domains
2025-02-07 10:31:51 +05:30 · 2025-02-06 10:01:39 +05:30 · 2025-02-06 10:01:39 +05:30 · 2025-02-06 10:01:39 +05:30 · 2025-02-06 10:01:39 +05:30
49 changed files with 2040 additions and 1404 deletions
--- a/.gitea/workflows/deploy-frontend.yaml
+++ b/.gitea/workflows/deploy-frontend.yaml
@ -47,11 +47,11 @@ jobs:
          cat > packages/deployer/config.yml <<EOF
          services:
            registry:
-              rpcEndpoint: https://laconicd-mainnet-1.laconic.com
-              gqlEndpoint: https://laconicd-mainnet-1.laconic.com/api
+              rpcEndpoint: https://laconicd-sapo.laconic.com
+              gqlEndpoint: https://laconicd-sapo.laconic.com/api
              userKey: $REGISTRY_USER_KEY
              bondId: $REGISTRY_BOND_ID
-              chainId: laconic-mainnet
+              chainId: laconic-testnet-2
              gasPrice: 0.001alnt
          EOF

--- a/build-webapp.sh
+++ b/build-webapp.sh
@ -15,6 +15,8 @@ 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'
--- a/package.json
+++ b/package.json
@ -14,6 +14,5 @@
    "prepare": "husky install",
    "build": "lerna run build --stream",
    "lint": "lerna run lint --stream"
-  },
-  "packageManager": "yarn@1.22.19+sha1.4ba7fc5c6e704fce2066ecbfb0b0d8976fe62447"
+  }
 }
--- a/packages/backend/src/database.ts
+++ b/packages/backend/src/database.ts
@ -5,7 +5,7 @@ import {
  FindOneOptions,
  FindOptionsWhere,
  IsNull,
-  Not,
+  Not
 } from 'typeorm';
 import path from 'path';
 import debug from 'debug';
@ -16,7 +16,7 @@ import { lowercase, numbers } from 'nanoid-dictionary';
 import { DatabaseConfig } from './config';
 import { User } from './entity/User';
 import { Organization } from './entity/Organization';
-import { AuctionStatus, Project } from './entity/Project';
+import { Project } from './entity/Project';
 import { Deployment, DeploymentStatus } from './entity/Deployment';
 import { ProjectMember } from './entity/ProjectMember';
 import { EnvironmentVariable } from './entity/EnvironmentVariable';
@ -42,7 +42,7 @@ export class Database {
      database: dbPath,
      entities: [path.join(__dirname, '/entity/*')],
      synchronize: true,
-      logging: false,
+      logging: false
    });
  }

@ -54,24 +54,21 @@ export class Database {

    // Load an organization if none exist
    if (!organizations.length) {
-      const orgEntities = await getEntities(
-        path.resolve(__dirname, ORGANIZATION_DATA_PATH),
-      );
-      organizations = await loadAndSaveData(Organization, this.dataSource, [
-        orgEntities[0],
-      ]);
+      const orgEntities = await getEntities(path.resolve(__dirname, ORGANIZATION_DATA_PATH));
+      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),
-      );
+      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,
-      });
+      await this.updateOrganization(
+        organizations[0].id,
+        {
+          slug: orgEntity.slug as string,
+          name: orgEntity.name as string
+        }
+      )
    }
  }

@ -98,7 +95,7 @@ export class Database {
  }

  async getOrganizations(
-    options: FindManyOptions<Organization>,
+    options: FindManyOptions<Organization>
  ): Promise<Organization[]> {
    const organizationRepository = this.dataSource.getRepository(Organization);
    const organizations = await organizationRepository.find(options);
@ -107,7 +104,7 @@ export class Database {
  }

  async getOrganization(
-    options: FindOneOptions<Organization>,
+    options: FindOneOptions<Organization>
  ): Promise<Organization | null> {
    const organizationRepository = this.dataSource.getRepository(Organization);
    const organization = await organizationRepository.findOne(options);
@ -122,34 +119,25 @@ export class Database {
      where: {
        userOrganizations: {
          member: {
-            id: userId,
-          },
-        },
-      },
+            id: userId
+          }
+        }
+      }
    });

    return userOrgs;
  }

-  async addUserOrganization(
-    data: DeepPartial<UserOrganization>,
-  ): Promise<UserOrganization> {
-    const userOrganizationRepository =
-      this.dataSource.getRepository(UserOrganization);
+  async addUserOrganization(data: DeepPartial<UserOrganization>): Promise<UserOrganization> {
+    const userOrganizationRepository = this.dataSource.getRepository(UserOrganization);
    const newUserOrganization = await userOrganizationRepository.save(data);

    return newUserOrganization;
  }

-  async updateOrganization(
-    organizationId: string,
-    data: DeepPartial<Organization>,
-  ): Promise<boolean> {
+  async updateOrganization(organizationId: string, data: DeepPartial<Organization>): Promise<boolean> {
    const organizationRepository = this.dataSource.getRepository(Organization);
-    const updateResult = await organizationRepository.update(
-      { id: organizationId },
-      data,
-    );
+    const updateResult = await organizationRepository.update({ id: organizationId }, data);
    assert(updateResult.affected);

    return updateResult.affected > 0;
@ -170,7 +158,7 @@ export class Database {
      .leftJoinAndSelect(
        'project.deployments',
        'deployments',
-        'deployments.isCurrent = true AND deployments.isCanonical = true',
+        'deployments.isCurrent = true AND deployments.isCanonical = true'
      )
      .leftJoinAndSelect('deployments.createdBy', 'user')
      .leftJoinAndSelect('deployments.deployer', 'deployer')
@ -178,7 +166,7 @@ export class Database {
      .leftJoinAndSelect('project.deployers', 'deployers')
      .leftJoinAndSelect('project.organization', 'organization')
      .where('project.id = :projectId', {
-        projectId,
+        projectId
      })
      .getOne();

@ -186,28 +174,26 @@ export class Database {
  }

  async allProjectsWithoutDeployments(): Promise<Project[]> {
-    // Fetch all projects with auction not completed and wihout any deployments
    const allProjects = await this.getProjects({
      where: {
        auctionId: Not(IsNull()),
-        auctionStatus: Not(AuctionStatus.Completed),
      },
      relations: ['deployments'],
      withDeleted: true,
    });

-    const activeProjectsWithoutDeployments = allProjects.filter((project) => {
+    const projects = allProjects.filter(project => {
      if (project.deletedAt !== null) return false;

      return project.deployments.length === 0;
    });

-    return activeProjectsWithoutDeployments;
+    return projects;
  }

  async getProjectsInOrganization(
    userId: string,
-    organizationSlug: string,
+    organizationSlug: string
  ): Promise<Project[]> {
    const projectRepository = this.dataSource.getRepository(Project);

@ -216,7 +202,7 @@ export class Database {
      .leftJoinAndSelect(
        'project.deployments',
        'deployments',
-        'deployments.isCurrent = true AND deployments.isCanonical = true',
+        'deployments.isCurrent = true AND deployments.isCanonical = true'
      )
      .leftJoin('project.projectMembers', 'projectMembers')
      .leftJoin('project.organization', 'organization')
@ -224,8 +210,8 @@ export class Database {
        '(project.ownerId = :userId OR projectMembers.userId = :userId) AND organization.slug = :organizationSlug',
        {
          userId,
-          organizationSlug,
-        },
+          organizationSlug
+        }
      )
      .getMany();

@ -236,7 +222,7 @@ export class Database {
   * Get deployments with specified filter
   */
  async getDeployments(
-    options: FindManyOptions<Deployment>,
+    options: FindManyOptions<Deployment>
  ): Promise<Deployment[]> {
    const deploymentRepository = this.dataSource.getRepository(Deployment);
    const deployments = await deploymentRepository.find(options);
@ -253,18 +239,16 @@ export class Database {
      },
      where: {
        project: {
-          id: projectId,
-        },
+          id: projectId
+        }
      },
      order: {
-        createdAt: 'DESC',
-      },
+        createdAt: 'DESC'
+      }
    });
  }

-  async getNonCanonicalDeploymentsByProjectId(
-    projectId: string,
-  ): Promise<Deployment[]> {
+  async getNonCanonicalDeploymentsByProjectId(projectId: string): Promise<Deployment[]> {
    return this.getDeployments({
      relations: {
        project: true,
@ -273,18 +257,18 @@ export class Database {
      },
      where: {
        project: {
-          id: projectId,
+          id: projectId
        },
-        isCanonical: false,
+        isCanonical: false
      },
      order: {
-        createdAt: 'DESC',
-      },
+        createdAt: 'DESC'
+      }
    });
  }

  async getDeployment(
-    options: FindOneOptions<Deployment>,
+    options: FindOneOptions<Deployment>
  ): Promise<Deployment | null> {
    const deploymentRepository = this.dataSource.getRepository(Deployment);
    const deployment = await deploymentRepository.findOne(options);
@ -306,7 +290,7 @@ export class Database {

    const updatedData = {
      ...data,
-      id,
+      id
    };
    const deployment = await deploymentRepository.save(updatedData);

@ -314,7 +298,7 @@ export class Database {
  }

  async getProjectMembersByProjectId(
-    projectId: string,
+    projectId: string
  ): Promise<ProjectMember[]> {
    const projectMemberRepository =
      this.dataSource.getRepository(ProjectMember);
@ -322,13 +306,13 @@ export class Database {
    const projectMembers = await projectMemberRepository.find({
      relations: {
        project: true,
-        member: true,
+        member: true
      },
      where: {
        project: {
-          id: projectId,
-        },
-      },
+          id: projectId
+        }
+      }
    });

    return projectMembers;
@ -336,7 +320,7 @@ export class Database {

  async getEnvironmentVariablesByProjectId(
    projectId: string,
-    filter?: FindOptionsWhere<EnvironmentVariable>,
+    filter?: FindOptionsWhere<EnvironmentVariable>
  ): Promise<EnvironmentVariable[]> {
    const environmentVariableRepository =
      this.dataSource.getRepository(EnvironmentVariable);
@ -344,10 +328,10 @@ export class Database {
    const environmentVariables = await environmentVariableRepository.find({
      where: {
        project: {
-          id: projectId,
+          id: projectId
        },
-        ...filter,
-      },
+        ...filter
+      }
    });

    return environmentVariables;
@ -358,7 +342,7 @@ export class Database {
      this.dataSource.getRepository(ProjectMember);

    const deleteResult = await projectMemberRepository.delete({
-      id: projectMemberId,
+      id: projectMemberId
    });

    if (deleteResult.affected) {
@ -370,20 +354,20 @@ export class Database {

  async updateProjectMemberById(
    projectMemberId: string,
-    data: DeepPartial<ProjectMember>,
+    data: DeepPartial<ProjectMember>
  ): Promise<boolean> {
    const projectMemberRepository =
      this.dataSource.getRepository(ProjectMember);
    const updateResult = await projectMemberRepository.update(
      { id: projectMemberId },
-      data,
+      data
    );

    return Boolean(updateResult.affected);
  }

  async addProjectMember(
-    data: DeepPartial<ProjectMember>,
+    data: DeepPartial<ProjectMember>
  ): Promise<ProjectMember> {
    const projectMemberRepository =
      this.dataSource.getRepository(ProjectMember);
@ -393,7 +377,7 @@ export class Database {
  }

  async addEnvironmentVariables(
-    data: DeepPartial<EnvironmentVariable>[],
+    data: DeepPartial<EnvironmentVariable>[]
  ): Promise<EnvironmentVariable[]> {
    const environmentVariableRepository =
      this.dataSource.getRepository(EnvironmentVariable);
@ -405,25 +389,25 @@ export class Database {

  async updateEnvironmentVariable(
    environmentVariableId: string,
-    data: DeepPartial<EnvironmentVariable>,
+    data: DeepPartial<EnvironmentVariable>
  ): Promise<boolean> {
    const environmentVariableRepository =
      this.dataSource.getRepository(EnvironmentVariable);
    const updateResult = await environmentVariableRepository.update(
      { id: environmentVariableId },
-      data,
+      data
    );

    return Boolean(updateResult.affected);
  }

  async deleteEnvironmentVariable(
-    environmentVariableId: string,
+    environmentVariableId: string
  ): Promise<boolean> {
    const environmentVariableRepository =
      this.dataSource.getRepository(EnvironmentVariable);
    const deleteResult = await environmentVariableRepository.delete({
-      id: environmentVariableId,
+      id: environmentVariableId
    });

    if (deleteResult.affected) {
@ -440,13 +424,13 @@ export class Database {
    const projectMemberWithProject = await projectMemberRepository.find({
      relations: {
        project: {
-          owner: true,
+          owner: true
        },
-        member: true,
+        member: true
      },
      where: {
-        id: projectMemberId,
-      },
+        id: projectMemberId
+      }
    });

    if (projectMemberWithProject.length === 0) {
@ -458,7 +442,7 @@ export class Database {

  async getProjectsBySearchText(
    userId: string,
-    searchText: string,
+    searchText: string
  ): Promise<Project[]> {
    const projectRepository = this.dataSource.getRepository(Project);

@ -470,8 +454,8 @@ export class Database {
        '(project.owner = :userId OR projectMembers.member.id = :userId) AND project.name LIKE :searchText',
        {
          userId,
-          searchText: `%${searchText}%`,
-        },
+          searchText: `%${searchText}%`
+        }
      )
      .getMany();

@ -480,14 +464,14 @@ export class Database {

  async updateDeploymentById(
    deploymentId: string,
-    data: DeepPartial<Deployment>,
+    data: DeepPartial<Deployment>
  ): Promise<boolean> {
    return this.updateDeployment({ id: deploymentId }, data);
  }

  async updateDeployment(
    criteria: FindOptionsWhere<Deployment>,
-    data: DeepPartial<Deployment>,
+    data: DeepPartial<Deployment>
  ): Promise<boolean> {
    const deploymentRepository = this.dataSource.getRepository(Deployment);
    const updateResult = await deploymentRepository.update(criteria, data);
@ -497,7 +481,7 @@ export class Database {

  async updateDeploymentsByProjectIds(
    projectIds: string[],
-    data: DeepPartial<Deployment>,
+    data: DeepPartial<Deployment>
  ): Promise<boolean> {
    const deploymentRepository = this.dataSource.getRepository(Deployment);

@ -515,8 +499,8 @@ export class Database {
    const deploymentRepository = this.dataSource.getRepository(Deployment);
    const deployment = await deploymentRepository.findOneOrFail({
      where: {
-        id: deploymentId,
-      },
+        id: deploymentId
+      }
    });

    const deleteResult = await deploymentRepository.softRemove(deployment);
@ -524,11 +508,7 @@ export class Database {
    return Boolean(deleteResult);
  }

-  async addProject(
-    user: User,
-    organizationId: string,
-    data: DeepPartial<Project>,
-  ): Promise<Project> {
+  async addProject(user: User, organizationId: string, data: DeepPartial<Project>): Promise<Project> {
    const projectRepository = this.dataSource.getRepository(Project);

    // TODO: Check if organization exists
@ -541,7 +521,7 @@ export class Database {
    newProject.owner = user;

    newProject.organization = Object.assign(new Organization(), {
-      id: organizationId,
+      id: organizationId
    });

    return projectRepository.save(newProject);
@ -555,12 +535,12 @@ export class Database {

  async updateProjectById(
    projectId: string,
-    data: DeepPartial<Project>,
+    data: DeepPartial<Project>
  ): Promise<boolean> {
    const projectRepository = this.dataSource.getRepository(Project);
    const updateResult = await projectRepository.update(
      { id: projectId },
-      data,
+      data
    );

    return Boolean(updateResult.affected);
@ -570,11 +550,11 @@ export class Database {
    const projectRepository = this.dataSource.getRepository(Project);
    const project = await projectRepository.findOneOrFail({
      where: {
-        id: projectId,
+        id: projectId
      },
      relations: {
-        projectMembers: true,
-      },
+        projectMembers: true
+      }
    });

    const deleteResult = await projectRepository.softRemove(project);
@ -610,7 +590,7 @@ export class Database {

  async updateDomainById(
    domainId: string,
-    data: DeepPartial<Domain>,
+    data: DeepPartial<Domain>
  ): Promise<boolean> {
    const domainRepository = this.dataSource.getRepository(Domain);
    const updateResult = await domainRepository.update({ id: domainId }, data);
@ -620,37 +600,39 @@ export class Database {

  async getDomainsByProjectId(
    projectId: string,
-    filter?: FindOptionsWhere<Domain>,
+    filter?: FindOptionsWhere<Domain>
  ): Promise<Domain[]> {
    const domainRepository = this.dataSource.getRepository(Domain);

    const domains = await domainRepository.find({
      relations: {
-        redirectTo: true,
+        redirectTo: true
      },
      where: {
        project: {
-          id: projectId,
+          id: projectId
        },
-        ...filter,
-      },
+        ...filter
+      }
    });

    return domains;
  }

-  async getOldestDomainByProjectId(projectId: string): Promise<Domain | null> {
+  async getOldestDomainByProjectId(
+    projectId: string,
+  ): Promise<Domain | null> {
    const domainRepository = this.dataSource.getRepository(Domain);

    const domain = await domainRepository.findOne({
      where: {
        project: {
-          id: projectId,
+          id: projectId
        },
      },
      order: {
-        createdAt: 'ASC',
-      },
+        createdAt: 'ASC'
+      }
    });

    return domain;
@ -669,8 +651,8 @@ export class Database {
        status: DeploymentStatus.Ready,
      },
      order: {
-        createdAt: 'DESC',
-      },
+        createdAt: 'DESC'
+      }
    });

    if (deployment === null) {
@ -695,9 +677,7 @@ export class Database {

  async getDeployerByLRN(deployerLrn: string): Promise<Deployer | null> {
    const deployerRepository = this.dataSource.getRepository(Deployer);
-    const deployer = await deployerRepository.findOne({
-      where: { deployerLrn },
-    });
+    const deployer = await deployerRepository.findOne({ where: { deployerLrn } });

    return deployer;
  }
--- a/packages/backend/src/entity/Project.ts
+++ b/packages/backend/src/entity/Project.ts
@ -9,7 +9,7 @@ import {
  OneToMany,
  DeleteDateColumn,
  JoinTable,
-  ManyToMany,
+  ManyToMany
 } from 'typeorm';

 import { User } from './User';
@ -18,12 +18,6 @@ import { ProjectMember } from './ProjectMember';
 import { Deployment } from './Deployment';
 import { Deployer } from './Deployer';

-export enum AuctionStatus {
-  Commit = 'commit',
-  Reveal = 'reveal',
-  Completed = 'completed',
-}
-
@Entity()
 export class Project {
  @PrimaryGeneratedColumn('uuid')
@ -55,23 +49,16 @@ export class Project {
  @Column('text', { default: '' })
    description!: string;

+  @Column('varchar', { nullable: true })
+    auctionId!: string | null;
+
  // Tx hash for sending coins from snowball to deployer
  @Column('varchar', { nullable: true })
    txHash!: string | null;

-  @ManyToMany(() => Deployer, (deployer) => deployer.projects)
+  @ManyToMany(() => Deployer, (deployer) => (deployer.projects))
  @JoinTable()
-    deployers!: Deployer[];
-
-  @Column('varchar', { nullable: true })
-    auctionId!: string | null;
-
-  @Column({
-    enum: AuctionStatus,
-    // TODO: Remove later after all projects auction status have been set
-    default: AuctionStatus.Completed,
-  })
-    auctionStatus!: AuctionStatus;
+    deployers!: Deployer[]

  @Column('boolean', { default: false, nullable: true })
    fundsReleased!: boolean;
--- a/packages/backend/src/registry.ts
+++ b/packages/backend/src/registry.ts
@ -6,13 +6,7 @@ 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 { Account, DEFAULT_GAS_ESTIMATION_MULTIPLIER, Registry as LaconicRegistry, getGasPrice, parseGasAndFees } from '@cerc-io/registry-sdk';
 import { DeliverTxResponse, IndexedTx } from '@cosmjs/stargate';

 import { RegistryConfig } from './config';
@ -20,30 +14,17 @@ import {
  ApplicationRecord,
  Deployment,
  ApplicationDeploymentRequest,
-  ApplicationDeploymentRemovalRequest,
+  ApplicationDeploymentRemovalRequest
 } from './entity/Deployment';
-import {
-  AppDeploymentRecord,
-  AppDeploymentRemovalRecord,
-  AuctionParams,
-  DeployerRecord,
-  RegistryRecord,
-} from './types';
-import {
-  getConfig,
-  getRepoDetails,
-  registryTransactionWithRetry,
-  sleep,
-} from './utils';
-import { MsgCreateAuctionResponse } from '@cerc-io/registry-sdk/dist/proto/cerc/auction/v1/tx';
+import { AppDeploymentRecord, AppDeploymentRemovalRecord, AuctionParams, DeployerRecord, RegistryRecord } from './types';
+import { getConfig, getRepoDetails, registryTransactionWithRetry, sleep } from './utils';

 const log = debug('snowball:registry');

 const APP_RECORD_TYPE = 'ApplicationRecord';
 const APP_DEPLOYMENT_AUCTION_RECORD_TYPE = 'ApplicationDeploymentAuction';
 const APP_DEPLOYMENT_REQUEST_TYPE = 'ApplicationDeploymentRequest';
-const APP_DEPLOYMENT_REMOVAL_REQUEST_TYPE =
-  'ApplicationDeploymentRemovalRequest';
+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';
@ -62,7 +43,7 @@ export class Registry {
    this.registry = new LaconicRegistry(
      registryConfig.gqlEndpoint,
      registryConfig.restEndpoint,
-      { chainId: registryConfig.chainId, gasPrice },
+      { chainId: registryConfig.chainId, gasPrice }
    );
  }

@ -72,7 +53,7 @@ export class Registry {
    commitHash,
    appType,
  }: {
-    octokit: Octokit;
+    octokit: Octokit
    repository: string;
    commitHash: string;
    appType: string;
@ -80,33 +61,29 @@ export class Registry {
    applicationRecordId: string;
    applicationRecordData: ApplicationRecord;
  }> {
-    const { repo, repoUrl, packageJSON } = await getRepoDetails(
-      octokit,
-      repository,
-      commitHash,
-    );
+    const { repo, repoUrl, packageJSON } = await getRepoDetails(octokit, repository, commitHash)
    // Use registry-sdk to publish record
    // Reference: https://git.vdb.to/cerc-io/test-progressive-web-app/src/branch/main/scripts/publish-app-record.sh
    // Fetch previous records
    const records = await this.registry.queryRecords(
      {
        type: APP_RECORD_TYPE,
-        name: packageJSON.name,
+        name: packageJSON.name
      },
-      true,
+      true
    );

    // Get next version of record
    const bondRecords = records.filter(
-      (record: any) => record.bondId === this.registryConfig.bondId,
+      (record: any) => record.bondId === this.registryConfig.bondId
    );
    const [latestBondRecord] = bondRecords.sort(
      (a: any, b: any) =>
-        new Date(b.createTime).getTime() - new Date(a.createTime).getTime(),
+        new Date(b.createTime).getTime() - new Date(a.createTime).getTime()
    );
    const nextVersion = semverInc(
      latestBondRecord?.attributes.version ?? '0.0.0',
-      'patch',
+      'patch'
    );

    assert(nextVersion, 'Application record version not valid');
@ -126,9 +103,9 @@ export class Registry {
        author:
          typeof packageJSON.author === 'object'
            ? JSON.stringify(packageJSON.author)
-            : packageJSON.author,
+            : packageJSON.author
      }),
-      ...(packageJSON.version && { app_version: packageJSON.version }),
+      ...(packageJSON.version && { app_version: packageJSON.version })
    };

    const result = await this.publishRecord(applicationRecord);
@ -140,9 +117,18 @@ 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,
+    const fee = parseGasAndFees(this.registryConfig.fee.gas, this.registryConfig.fee.fees);
+
+    await sleep(SLEEP_DURATION);
+    await registryTransactionWithRetry(() =>
+      this.registry.setName(
+        {
+          cid: result.id,
+          lrn
+        },
+        this.registryConfig.privateKey,
+        fee
+      )
    );

    await sleep(SLEEP_DURATION);
@ -150,11 +136,11 @@ export class Registry {
      this.registry.setName(
        {
          cid: result.id,
-          lrn,
+          lrn: `${lrn}@${applicationRecord.app_version}`
        },
        this.registryConfig.privateKey,
-        fee,
-      ),
+        fee
+      )
    );

    await sleep(SLEEP_DURATION);
@ -162,28 +148,16 @@ export class Registry {
      this.registry.setName(
        {
          cid: result.id,
-          lrn: `${lrn}@${applicationRecord.app_version}`,
+          lrn: `${lrn}@${applicationRecord.repository_ref}`
        },
        this.registryConfig.privateKey,
-        fee,
-      ),
-    );
-
-    await sleep(SLEEP_DURATION);
-    await registryTransactionWithRetry(() =>
-      this.registry.setName(
-        {
-          cid: result.id,
-          lrn: `${lrn}@${applicationRecord.repository_ref}`,
-        },
-        this.registryConfig.privateKey,
-        fee,
-      ),
+        fee
+      )
    );

    return {
      applicationRecordId: result.id,
-      applicationRecordData: applicationRecord,
+      applicationRecordData: applicationRecord
    };
  }

@ -193,7 +167,7 @@ export class Registry {
    auctionParams: AuctionParams,
    data: DeepPartial<Deployment>,
  ): Promise<{
-    applicationDeploymentAuction: MsgCreateAuctionResponse['auction'];
+    applicationDeploymentAuctionId: string;
  }> {
    assert(data.project?.repository, 'Project repository not found');

@ -208,11 +182,8 @@ export class Registry {
    const config = await getConfig();
    const auctionConfig = config.auction;

-    const fee = parseGasAndFees(
-      this.registryConfig.fee.gas,
-      this.registryConfig.fee.fees,
-    );
-    const auctionResult = (await registryTransactionWithRetry(() =>
+    const fee = parseGasAndFees(this.registryConfig.fee.gas, this.registryConfig.fee.fees);
+    const auctionResult = await registryTransactionWithRetry(() =>
      this.registry.createProviderAuction(
        {
          commitFee: auctionConfig.commitFee,
@ -224,9 +195,9 @@ export class Registry {
          numProviders: auctionParams.numProviders,
        },
        this.registryConfig.privateKey,
-        fee,
-      ),
-    )) as MsgCreateAuctionResponse;
+        fee
+      )
+    );

    if (!auctionResult.auction) {
      throw new Error('Error creating auction');
@ -246,22 +217,22 @@ export class Registry {
    log('Application deployment auction data:', applicationDeploymentAuction);

    return {
-      applicationDeploymentAuction: auctionResult.auction!,
+      applicationDeploymentAuctionId: auctionResult.auction.id,
    };
  }

  async createApplicationDeploymentRequest(data: {
-    deployment: Deployment;
-    appName: string;
-    repository: string;
-    auctionId?: string | null;
-    lrn: string;
-    apiUrl: string;
-    environmentVariables: { [key: string]: string };
-    dns: string;
-    requesterAddress: string;
-    publicKey: string;
-    payment?: string | null;
+    deployment: Deployment,
+    appName: string,
+    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;
    applicationDeploymentRequestData: ApplicationDeploymentRequest;
@ -296,10 +267,10 @@ export class Registry {
      config: JSON.stringify(hash ? { ref: hash } : {}),
      meta: JSON.stringify({
        note: `Added by Snowball @ ${DateTime.utc().toFormat(
-          "EEE LLL dd HH:mm:ss 'UTC' yyyy",
+          "EEE LLL dd HH:mm:ss 'UTC' yyyy"
        )}`,
        repository: data.repository,
-        repository_ref: data.deployment.commitHash,
+        repository_ref: data.deployment.commitHash
      }),
      deployer: data.lrn,
      ...(data.auctionId && { auction: data.auctionId }),
@ -315,12 +286,12 @@ export class Registry {

    return {
      applicationDeploymentRequestId: result.id,
-      applicationDeploymentRequestData: applicationDeploymentRequest,
+      applicationDeploymentRequestData: applicationDeploymentRequest
    };
  }

  async getAuctionWinningDeployerRecords(
-    auctionId: string,
+    auctionId: string
  ): Promise<DeployerRecord[]> {
    const records = await this.registry.getAuctionsByIds([auctionId]);
    const auctionResult = records[0];
@ -333,7 +304,7 @@ export class Registry {
        paymentAddress: auctionWinner,
      });

-      const newRecords = records.filter((record) => {
+      const newRecords = records.filter(record => {
        return record.names !== null && record.names.length > 0;
      });

@ -348,19 +319,18 @@ export class Registry {
    return deployerRecords;
  }

-  async releaseDeployerFunds(auctionId: string): Promise<any> {
-    const fee = parseGasAndFees(
-      this.registryConfig.fee.gas,
-      this.registryConfig.fee.fees,
-    );
+  async releaseDeployerFunds(
+    auctionId: string
+  ): Promise<any> {
+    const fee = parseGasAndFees(this.registryConfig.fee.gas, this.registryConfig.fee.fees);
    const auction = await registryTransactionWithRetry(() =>
      this.registry.releaseFunds(
        {
-          auctionId,
+          auctionId
        },
        this.registryConfig.privateKey,
-        fee,
-      ),
+        fee
+      )
    );

    return auction;
@ -370,54 +340,49 @@ export class Registry {
   * Fetch ApplicationDeploymentRecords for deployments
   */
  async getDeploymentRecords(
-    deployments: Deployment[],
+    deployments: Deployment[]
  ): Promise<AppDeploymentRecord[]> {
    // Fetch ApplicationDeploymentRecords for corresponding ApplicationRecord set in deployments
    // TODO: Implement Laconicd GQL query to filter records by multiple values for an attribute
    const records = await this.registry.queryRecords(
      {
-        type: APP_DEPLOYMENT_RECORD_TYPE,
+        type: APP_DEPLOYMENT_RECORD_TYPE
      },
-      true,
+      true
    );

    // Filter records with ApplicationDeploymentRequestId ID
    return records.filter((record: AppDeploymentRecord) =>
      deployments.some(
        (deployment) =>
-          deployment.applicationDeploymentRequestId ===
-          record.attributes.request,
-      ),
+          deployment.applicationDeploymentRequestId === record.attributes.request
+      )
    );
  }

  /**
   * Fetch WebappDeployer Records by filter
   */
-  async getDeployerRecordsByFilter(filter: {
-    [key: string]: any;
-  }): Promise<DeployerRecord[]> {
+  async getDeployerRecordsByFilter(filter: { [key: string]: any }): Promise<DeployerRecord[]> {
    return this.registry.queryRecords(
      {
        type: WEBAPP_DEPLOYER_RECORD_TYPE,
-        ...filter,
+        ...filter
      },
-      true,
+      true
    );
  }

  /**
   * Fetch ApplicationDeploymentRecords by filter
   */
-  async getDeploymentRecordsByFilter(filter: {
-    [key: string]: any;
-  }): Promise<AppDeploymentRecord[]> {
+  async getDeploymentRecordsByFilter(filter: { [key: string]: any }): Promise<AppDeploymentRecord[]> {
    return this.registry.queryRecords(
      {
        type: APP_DEPLOYMENT_RECORD_TYPE,
-        ...filter,
+        ...filter
      },
-      true,
+      true
    );
  }

@ -425,31 +390,29 @@ export class Registry {
   * Fetch ApplicationDeploymentRemovalRecords for deployments
   */
  async getDeploymentRemovalRecords(
-    deployments: Deployment[],
+    deployments: Deployment[]
  ): Promise<AppDeploymentRemovalRecord[]> {
    // Fetch ApplicationDeploymentRemovalRecords for corresponding ApplicationDeploymentRecord set in deployments
    const records = await this.registry.queryRecords(
      {
-        type: APP_DEPLOYMENT_REMOVAL_RECORD_TYPE,
+        type: APP_DEPLOYMENT_REMOVAL_RECORD_TYPE
      },
-      true,
+      true
    );

    // Filter records with ApplicationDeploymentRecord and ApplicationDeploymentRemovalRequest IDs
    return records.filter((record: AppDeploymentRemovalRecord) =>
      deployments.some(
        (deployment) =>
-          deployment.applicationDeploymentRemovalRequestId ===
-            record.attributes.request &&
-          deployment.applicationDeploymentRecordId ===
-            record.attributes.deployment,
-      ),
+          deployment.applicationDeploymentRemovalRequestId === record.attributes.request &&
+          deployment.applicationDeploymentRecordId === record.attributes.deployment
+      )
    );
  }

  /**
-   * Fetch record by Id
-   */
+ * Fetch record by Id
+ */
  async getRecordById(id: string): Promise<RegistryRecord | null> {
    const [record] = await this.registry.getRecordsByIds([id]);
    return record ?? null;
@ -477,18 +440,12 @@ export class Registry {
      applicationDeploymentRemovalRequest,
    );

-    log(
-      `Application deployment removal request record published: ${result.id}`,
-    );
-    log(
-      'Application deployment removal request data:',
-      applicationDeploymentRemovalRequest,
-    );
+    log(`Application deployment removal request record published: ${result.id}`);
+    log('Application deployment removal request data:', applicationDeploymentRemovalRequest);

    return {
      applicationDeploymentRemovalRequestId: result.id,
-      applicationDeploymentRemovalRequestData:
-        applicationDeploymentRemovalRequest,
+      applicationDeploymentRemovalRequestData: applicationDeploymentRemovalRequest
    };
  }

@ -500,11 +457,8 @@ export class Registry {
    const auctions = await this.registry.getAuctionsByIds(auctionIds);

    const completedAuctions = auctions
-      .filter(
-        (auction: { id: string; status: string }) =>
-          auction.status === 'completed',
-      )
-      .map((auction: { id: string; status: string }) => auction.id);
+      .filter((auction: { id: string, status: string }) => auction.status === 'completed')
+      .map((auction: { id: string, status: string }) => auction.id);

    return completedAuctions;
  }
@ -538,38 +492,27 @@ export class Registry {
    return this.registry.getAuctionsByIds([auctionId]);
  }

-  async sendTokensToAccount(
-    receiverAddress: string,
-    amount: string,
-  ): Promise<DeliverTxResponse> {
-    const fee = parseGasAndFees(
-      this.registryConfig.fee.gas,
-      this.registryConfig.fee.fees,
-    );
+  async sendTokensToAccount(receiverAddress: string, amount: string): Promise<DeliverTxResponse> {
+    const fee = parseGasAndFees(this.registryConfig.fee.gas, this.registryConfig.fee.fees);
    const account = await this.getAccount();
    const laconicClient = await this.registry.getLaconicClient(account);
-    const txResponse: DeliverTxResponse = await registryTransactionWithRetry(
-      () =>
-        laconicClient.sendTokens(
-          account.address,
-          receiverAddress,
+    const txResponse: DeliverTxResponse =
+      await registryTransactionWithRetry(() =>
+        laconicClient.sendTokens(account.address, receiverAddress,
          [
            {
              denom: 'alnt',
-              amount,
-            },
+              amount
+            }
          ],
-          fee || DEFAULT_GAS_ESTIMATION_MULTIPLIER,
-        ),
-    );
+          fee || DEFAULT_GAS_ESTIMATION_MULTIPLIER)
+      );

    return txResponse;
  }

  async getAccount(): Promise<Account> {
-    const account = new Account(
-      Buffer.from(this.registryConfig.privateKey, 'hex'),
-    );
+    const account = new Account(Buffer.from(this.registryConfig.privateKey, 'hex'));
    await account.init();

    return account;
--- a/packages/backend/src/resolvers.ts
+++ b/packages/backend/src/resolvers.ts
@ -345,10 +345,11 @@ export const createResolvers = async (service: Service): Promise<any> => {
        {
          projectId,
          deploymentId,
-        }: { deploymentId: string; projectId: string },
+          deployerLrn,
+        }: { deploymentId: string; projectId: string, deployerLrn: string },
      ) => {
        try {
-          return await service.rollbackDeployment(projectId, deploymentId);
+          return await service.rollbackDeployment(projectId, deploymentId, deployerLrn);
        } catch (err) {
          log(err);
          return false;
--- a/packages/backend/src/routes/auth.ts
+++ b/packages/backend/src/routes/auth.ts
@ -94,4 +94,13 @@ router.get('/session', (req, res) => {
  }
 });

+router.post('/logout', (req, res) => {
+  req.session.destroy((err) => {
+    if (err) {
+      return res.send({ success: false });
+    }
+    res.send({ success: true });
+  });
+});
+
 export default router;
--- a/packages/backend/src/schema.gql
+++ b/packages/backend/src/schema.gql
@ -111,6 +111,7 @@ type Deployment {
  isCurrent: Boolean!
  baseDomain: String
  status: DeploymentStatus!
+  dnsRecordData: DNSRecordAttributes
  createdAt: String!
  updatedAt: String!
  createdBy: User!
--- a/packages/backend/src/service.ts
+++ b/packages/backend/src/service.ts
@ -7,16 +7,11 @@ 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';
-import { AuctionStatus, Project } from './entity/Project';
+import { Project } from './entity/Project';
 import { Permission, ProjectMember } from './entity/ProjectMember';
 import { User } from './entity/User';
 import { Registry } from './registry';
@ -124,8 +119,7 @@ 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
@ -210,9 +204,7 @@ export class Service {
        return;
      }

-      const registryRecord = await this.laconicRegistry.getRecordById(
-        record.attributes.dns,
-      );
+      const registryRecord = await this.laconicRegistry.getRecordById(record.attributes.dns);

      if (!registryRecord) {
        log(`DNS record not found for deployment ${deployment.id}`);
@ -227,7 +219,7 @@ export class Service {
        resourceType: dnsRecord.attributes.resource_type,
        value: dnsRecord.attributes.value,
        version: dnsRecord.attributes.version,
-      };
+      }

      deployment.applicationDeploymentRecordId = record.id;
      deployment.applicationDeploymentRecordData = record.attributes;
@ -247,21 +239,18 @@ export class Service {
          relations: {
            project: true,
            deployer: true,
-          },
+          }
        });

        if (previousCanonicalDeployment) {
          // Send removal request for the previous canonical deployment and delete DB entry
          if (previousCanonicalDeployment.url !== deployment.url) {
-            await this.laconicRegistry.createApplicationDeploymentRemovalRequest(
-              {
-                deploymentId:
-                  previousCanonicalDeployment.applicationDeploymentRecordId!,
-                deployerLrn: previousCanonicalDeployment.deployer.deployerLrn,
-                auctionId: previousCanonicalDeployment.project.auctionId,
-                payment: previousCanonicalDeployment.project.txHash,
-              },
-            );
+            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);
@ -272,9 +261,7 @@ export class Service {

      // Release deployer funds on successful deployment
      if (!deployment.project.fundsReleased) {
-        const fundsReleased = await this.releaseDeployerFundsByProjectId(
-          deployment.projectId,
-        );
+        const fundsReleased = await this.releaseDeployerFundsByProjectId(deployment.projectId);

        // Return remaining amount to owner
        await this.returnUserFundsByProjectId(deployment.projectId, true);
@ -304,7 +291,7 @@ export class Service {
      const oldDeployments = projectDeployments.filter(
        (projectDeployment) =>
          projectDeployment.deployer.deployerLrn ===
-            deployment.deployer.deployerLrn &&
+          deployment.deployer.deployerLrn &&
          projectDeployment.id !== deployment.id &&
          projectDeployment.isCanonical == deployment.isCanonical,
      );
@ -369,30 +356,24 @@ export class Service {
  async checkAuctionStatus(): Promise<void> {
    const projects = await this.db.allProjectsWithoutDeployments();

-    const validAuctionIds = projects
-      .map((project) => project.auctionId)
+    const validAuctionIds = projects.map((project) => project.auctionId)
      .filter((id): id is string => Boolean(id));
-    const completedAuctionIds =
-      await this.laconicRegistry.getCompletedAuctionIds(validAuctionIds);
+    const completedAuctionIds = await this.laconicRegistry.getCompletedAuctionIds(validAuctionIds);

    const projectsToBedeployed = projects.filter((project) =>
-      completedAuctionIds.includes(project.auctionId!),
+      completedAuctionIds.includes(project.auctionId!)
    );

    for (const project of projectsToBedeployed) {
-      const deployerRecords =
-        await this.laconicRegistry.getAuctionWinningDeployerRecords(
-          project!.auctionId!,
-        );
+      const deployerRecords = await this.laconicRegistry.getAuctionWinningDeployerRecords(project!.auctionId!);

      if (!deployerRecords) {
        log(`No winning deployer for auction ${project!.auctionId}`);

        // Return all funds to the owner
-        await this.returnUserFundsByProjectId(project.id, false);
+        await this.returnUserFundsByProjectId(project.id, false)
      } else {
-        const deployers =
-          await this.saveDeployersByDeployerRecords(deployerRecords);
+        const deployers = await this.saveDeployersByDeployerRecords(deployerRecords);
        for (const deployer of deployers) {
          log(`Creating deployment for deployer ${deployer.deployerLrn}`);
          await this.createDeploymentFromAuction(project, deployer);
@ -400,10 +381,6 @@ export class Service {
          await this.updateProjectWithDeployer(project.id, deployer);
        }
      }
-
-      await this.updateProject(project.id, {
-        auctionStatus: AuctionStatus.Completed,
-      });
    }

    this.auctionStatusCheckTimeout = setTimeout(() => {
@ -508,17 +485,12 @@ export class Service {
    return dbProjects;
  }

-  async getNonCanonicalDeploymentsByProjectId(
-    projectId: string,
-  ): Promise<Deployment[]> {
-    const nonCanonicalDeployments =
-      await this.db.getNonCanonicalDeploymentsByProjectId(projectId);
+  async getNonCanonicalDeploymentsByProjectId(projectId: string): Promise<Deployment[]> {
+    const nonCanonicalDeployments = await this.db.getNonCanonicalDeploymentsByProjectId(projectId);
    return nonCanonicalDeployments;
  }

-  async getLatestDNSRecordByProjectId(
-    projectId: string,
-  ): Promise<DNSRecordAttributes | null> {
+  async getLatestDNSRecordByProjectId(projectId: string): Promise<DNSRecordAttributes | null> {
    const dnsRecord = await this.db.getLatestDNSRecordByProjectId(projectId);
    return dnsRecord;
  }
@ -672,15 +644,20 @@ export class Service {

    const octokit = await this.getOctokit(user.id);

-    const 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,
-    });
+    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;
  }

@ -688,7 +665,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(
@ -711,58 +688,34 @@ export class Service {
      deployer = data.deployer;
    }

-    const deployment = await this.createDeploymentFromData(
-      userId,
-      data,
-      deployer!.deployerLrn!,
-      applicationRecordId,
-      applicationRecordData,
-      false,
-    );
+    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) {
-      const canonicalDeployment = await this.createDeploymentFromData(
-        userId,
-        data,
-        deployer!.deployerLrn!,
-        applicationRecordId,
-        applicationRecordData,
-        true,
-      );
+      const canonicalDeployment = await this.createDeploymentFromData(userId, data, deployer!.deployerLrn!, applicationRecordId, applicationRecordData, true);
      // If a custom domain is present then use that as the DNS in the deployment request
-      const customDomain = await this.db.getOldestDomainByProjectId(
-        data.project!.id!,
-      );
+      const customDomain = await this.db.getOldestDomainByProjectId(data.project!.id!);

      // 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: customDomain?.name ?? `${canonicalDeployment.project.name}`,
-        lrn: deployer!.deployerLrn!,
-        apiUrl: deployer!.deployerApiUrl!,
-        payment: data.project.txHash,
-        auctionId: data.project.auctionId,
-        requesterAddress: address,
-        publicKey: deployer!.publicKey!,
-      });
+      const { applicationDeploymentRequestData, applicationDeploymentRequestId } =
+        await this.laconicRegistry.createApplicationDeploymentRequest({
+          deployment: canonicalDeployment,
+          appName: repo,
+          repository: repoUrl,
+          environmentVariables: environmentVariablesObj,
+          dns: customDomain?.name ?? `${canonicalDeployment.project.name}`,
+          lrn: deployer!.deployerLrn!,
+          apiUrl: deployer!.deployerApiUrl!,
+          payment: data.project.txHash,
+          auctionId: data.project.auctionId,
+          requesterAddress: address,
+          publicKey: deployer!.publicKey!
+        });

      await this.db.updateDeploymentById(canonicalDeployment.id, {
        applicationDeploymentRequestId,
@ -782,7 +735,7 @@ export class Service {
        payment: data.project.txHash,
        auctionId: data.project.auctionId,
        requesterAddress: address,
-        publicKey: deployer!.publicKey!,
+        publicKey: deployer!.publicKey!
      });

    await this.db.updateDeploymentById(deployment.id, {
@ -795,7 +748,7 @@ export class Service {

  async createDeploymentFromAuction(
    project: DeepPartial<Project>,
-    deployer: Deployer,
+    deployer: Deployer
  ): Promise<Deployment> {
    const octokit = await this.getOctokit(project.ownerId!);
    const [owner, repo] = project.repository!.split('/');
@ -821,7 +774,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 = {
@ -833,49 +786,31 @@ export class Service {
      commitMessage: latestCommit.commit.message,
    };

-    const deployment = await this.createDeploymentFromData(
-      project.ownerId!,
-      deploymentData,
-      deployerLrn,
-      applicationRecordId,
-      applicationRecordData,
-      false,
-    );
+    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) {
-      const canonicalDeployment = await this.createDeploymentFromData(
-        project.ownerId!,
-        deploymentData,
-        deployerLrn,
-        applicationRecordId,
-        applicationRecordData,
-        true,
-      );
+      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 customDomain = await this.db.getOldestDomainByProjectId(
-        project!.id!,
-      );
+      const customDomain = await this.db.getOldestDomainByProjectId(project!.id!);

      // 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: customDomain?.name ?? `${canonicalDeployment.project.name}`,
-        auctionId: project.auctionId!,
-        lrn: deployerLrn,
-        apiUrl: deployer!.deployerApiUrl!,
-        requesterAddress: address,
-        publicKey: deployer!.publicKey!,
-      });
+      const { applicationDeploymentRequestId, applicationDeploymentRequestData } =
+        await this.laconicRegistry.createApplicationDeploymentRequest({
+          deployment: canonicalDeployment,
+          appName: repo,
+          repository: repoUrl,
+          environmentVariables: environmentVariablesObj,
+          dns: customDomain?.name ?? `${canonicalDeployment.project.name}`,
+          auctionId: project.auctionId!,
+          lrn: deployerLrn,
+          apiUrl: deployer!.deployerApiUrl!,
+          requesterAddress: address,
+          publicKey: deployer!.publicKey!
+        });

      await this.db.updateDeploymentById(canonicalDeployment.id, {
        applicationDeploymentRequestId,
@ -895,7 +830,7 @@ export class Service {
        environmentVariables: environmentVariablesObj,
        dns: `${deployment.project.name}-${deployment.id}`,
        requesterAddress: address,
-        publicKey: deployer!.publicKey!,
+        publicKey: deployer!.publicKey!
      });

    await this.db.updateDeploymentById(deployment.id, {
@ -929,7 +864,7 @@ export class Service {
      deployer: Object.assign(new Deployer(), {
        deployerLrn,
      }),
-      isCanonical,
+      isCanonical
    });

    log(`Created deployment ${newDeployment.id}`);
@ -939,11 +874,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) {
@ -988,22 +923,15 @@ 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');
@ -1062,19 +990,8 @@ export class Service {
        commitHash: latestCommit.sha,
        commitMessage: latestCommit.commit.message,
      };
-
-      const { applicationDeploymentAuction } =
-        await this.laconicRegistry.createApplicationDeploymentAuction(
-          repo,
-          octokit,
-          auctionParams!,
-          deploymentData,
-        );
-
-      await this.updateProject(project.id, {
-        auctionId: applicationDeploymentAuction!.id,
-        auctionStatus: applicationDeploymentAuction!.status as AuctionStatus,
-      });
+      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!);

@ -1084,13 +1001,11 @@ export class Service {
      }

      if (deployer.minimumPayment && project.txHash) {
-        const amountToBePaid = deployer?.minimumPayment
-          .replace(/\D/g, '')
-          .toString();
+        const amountToBePaid = deployer?.minimumPayment.replace(/\D/g, '').toString();

        const txResponse = await this.laconicRegistry.sendTokensToAccount(
          deployer?.paymentAddress!,
-          amountToBePaid,
+          amountToBePaid
        );

        const txHash = txResponse.transactionHash;
@ -1108,19 +1023,12 @@ export class Service {
        domain: null,
        commitHash: latestCommit.sha,
        commitMessage: latestCommit.commit.message,
-        deployer,
+        deployer
      };

-      const newDeployment = await this.createDeployment(
-        user.id,
-        octokit,
-        deploymentData,
-      );
+      const newDeployment = await this.createDeployment(user.id, octokit, deploymentData);
      // Update project with deployer
-      await this.updateProjectWithDeployer(
-        newDeployment.projectId,
-        newDeployment.deployer,
-      );
+      await this.updateProjectWithDeployer(newDeployment.projectId, newDeployment.deployer);
    }

    await this.createRepoHook(octokit, project);
@ -1176,7 +1084,7 @@ export class Service {
      where: { repository: repository.full_name },
      relations: {
        deployers: true,
-      },
+      }
    });

    if (!projects.length) {
@ -1192,23 +1100,25 @@ export class Service {

      const deployers = project.deployers;
      if (!deployers) {
-        log(`No deployer present for project ${project.id}`);
+        log(`No deployer present for project ${project.id}`)
        return;
      }

      for (const deployer of deployers) {
        // Create deployment with branch and latest commit in GitHub data
-        await this.createDeployment(project.ownerId, octokit, {
-          project,
-          branch,
-          environment:
-            project.prodBranch === branch
-              ? Environment.Production
-              : Environment.Preview,
-          commitHash: headCommit.id,
-          commitMessage: headCommit.message,
-          deployer: deployer,
-        });
+        await this.createDeployment(project.ownerId, octokit,
+          {
+            project,
+            branch,
+            environment:
+              project.prodBranch === branch
+                ? Environment.Production
+                : Environment.Preview,
+            commitHash: headCommit.id,
+            commitMessage: headCommit.message,
+            deployer: deployer
+          },
+        );
      }
    }
  }
@ -1262,20 +1172,19 @@ export class Service {
    let newDeployment: Deployment;

    if (oldDeployment.project.auctionId) {
-      newDeployment = await this.createDeploymentFromAuction(
-        oldDeployment.project,
-        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,
-      });
+      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;
@ -1284,6 +1193,7 @@ export class Service {
  async rollbackDeployment(
    projectId: string,
    deploymentId: string,
+    deployerLrn: string,
  ): Promise<boolean> {
    // TODO: Implement transactions
    const oldCurrentDeployment = await this.db.getDeployment({
@ -1295,6 +1205,9 @@ export class Service {
        project: {
          id: projectId,
        },
+        deployer: {
+          deployerLrn
+        },
        isCurrent: true,
        isCanonical: false,
      },
@ -1314,26 +1227,22 @@ export class Service {
      { isCurrent: true },
    );

-    if (!newCurrentDeploymentUpdate || !oldCurrentDeploymentUpdate) {
+    if (!newCurrentDeploymentUpdate || !oldCurrentDeploymentUpdate){
      return false;
    }

-    const newCurrentDeployment = await this.db.getDeployment({
-      where: { id: deploymentId },
-      relations: { project: true, deployer: true },
-    });
+    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 applicationDeploymentRequestData = newCurrentDeployment.applicationDeploymentRequestData;

    const customDomain = await this.db.getOldestDomainByProjectId(projectId);

    if (customDomain && applicationDeploymentRequestData) {
-      applicationDeploymentRequestData.dns = customDomain.name;
+      applicationDeploymentRequestData.dns = customDomain.name
    }

    // Create a canonical deployment for the new current deployment
@ -1349,23 +1258,20 @@ export class Service {
    applicationDeploymentRequestData!.meta = JSON.stringify({
      ...JSON.parse(applicationDeploymentRequestData!.meta),
      note: `Updated by Snowball @ ${DateTime.utc().toFormat(
-        "EEE LLL dd HH:mm:ss 'UTC' yyyy",
-      )}`,
+        "EEE LLL dd HH:mm:ss 'UTC' yyyy"
+      )}`
    });

    const result = await this.laconicRegistry.publishRecord(
      applicationDeploymentRequestData,
    );

-    log(`Application deployment request record published: ${result.id}`);
+    log(`Application deployment request record published: ${result.id}`)

-    const updateResult = await this.db.updateDeploymentById(
-      canonicalDeployment.id,
-      {
-        applicationDeploymentRequestId: result.id,
-        applicationDeploymentRequestData,
-      },
-    );
+    const updateResult = await this.db.updateDeploymentById(canonicalDeployment.id, {
+      applicationDeploymentRequestId: result.id,
+      applicationDeploymentRequestData,
+    });

    return updateResult;
  }
@ -1388,20 +1294,18 @@ export class Service {
          where: {
            projectId: deployment.project.id,
            deployer: deployment.deployer,
-            isCanonical: true,
+            isCanonical: true
          },
          relations: {
            project: true,
            deployer: true,
          },
-        });
+        })

        // 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}`;
+          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({
@ -1418,30 +1322,24 @@ export class Service {
          }

          // 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];
+          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,
+            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,
-              },
-            );
+            await this.laconicRegistry.createApplicationDeploymentRemovalRequest({
+              deploymentId: canonicalDeployment.applicationDeploymentRecordId!,
+              deployerLrn: canonicalDeployment.deployer.deployerLrn,
+              auctionId: canonicalDeployment.project.auctionId,
+              payment: canonicalDeployment.project.txHash
+            });

          await this.db.updateDeploymentById(canonicalDeployment.id, {
            status: DeploymentStatus.Deleting,
@ -1458,7 +1356,7 @@ export class Service {
          deploymentId: deployment.applicationDeploymentRecordId,
          deployerLrn: deployment.deployer.deployerLrn,
          auctionId: deployment.project.auctionId,
-          payment: deployment.project.txHash,
+          payment: deployment.project.txHash
        });

      await this.db.updateDeploymentById(deployment.id, {
@ -1594,11 +1492,12 @@ export class Service {
    return this.db.updateUser(user, data);
  }

-  async getEnvVariables(projectId: string): Promise<{ [key: string]: string }> {
-    const environmentVariables =
-      await this.db.getEnvironmentVariablesByProjectId(projectId, {
-        environment: Environment.Production,
-      });
+  async getEnvVariables(
+    projectId: string,
+  ): Promise<{ [key: string]: string }> {
+    const environmentVariables = await this.db.getEnvironmentVariablesByProjectId(projectId, {
+      environment: Environment.Production,
+    });

    const environmentVariablesObj = environmentVariables.reduce(
      (acc, env) => {
@ -1611,7 +1510,9 @@ export class Service {
    return environmentVariablesObj;
  }

-  async getAuctionData(auctionId: string): Promise<any> {
+  async getAuctionData(
+    auctionId: string
+  ): Promise<any> {
    const auctions = await this.laconicRegistry.getAuctionData(auctionId);
    return auctions[0];
  }
@ -1620,19 +1521,16 @@ export class Service {
    const project = await this.db.getProjectById(projectId);

    if (!project || !project.auctionId) {
-      log(
-        `Project ${projectId} ${!project ? 'not found' : 'does not have an auction'}`,
-      );
+      log(`Project ${projectId} ${!project ? 'not found' : 'does not have an auction'}`);

      return false;
    }

-    const auction = await this.laconicRegistry.releaseDeployerFunds(
-      project.auctionId,
-    );
+    const auction = await this.laconicRegistry.releaseDeployerFunds(project.auctionId);

    if (auction.auction.fundsReleased) {
      log(`Funds released for auction ${project.auctionId}`);
+      await this.db.updateProjectById(projectId, { fundsReleased: true });

      return true;
    }
@ -1642,29 +1540,21 @@ export class Service {
    return false;
  }

-  async returnUserFundsByProjectId(
-    projectId: string,
-    winningDeployersPresent: boolean,
-  ) {
+  async returnUserFundsByProjectId(projectId: string, winningDeployersPresent: boolean) {
    const project = await this.db.getProjectById(projectId);

    if (!project || !project.auctionId) {
-      log(
-        `Project ${projectId} ${!project ? 'not found' : 'does not have an auction'}`,
-      );
+      log(`Project ${projectId} ${!project ? 'not found' : 'does not have an auction'}`);

      return false;
    }

    const auction = await this.getAuctionData(project.auctionId);
-    const totalAuctionPrice =
-      Number(auction.maxPrice.quantity) * auction.numProviders;
+    const totalAuctionPrice = Number(auction.maxPrice.quantity) * auction.numProviders;

    let amountToBeReturned;
    if (winningDeployersPresent) {
-      amountToBeReturned =
-        totalAuctionPrice -
-        auction.winnerAddresses.length * Number(auction.winnerPrice.quantity);
+      amountToBeReturned = totalAuctionPrice - auction.winnerAddresses.length * Number(auction.winnerPrice.quantity);
    } else {
      amountToBeReturned = totalAuctionPrice;
    }
@ -1672,7 +1562,7 @@ export class Service {
    if (amountToBeReturned !== 0) {
      await this.laconicRegistry.sendTokensToAccount(
        project.paymentAddress,
-        amountToBeReturned.toString(),
+        amountToBeReturned.toString()
      );
    }
  }
@ -1691,16 +1581,13 @@ export class Service {
  }

  async updateDeployersFromRegistry(): Promise<Deployer[]> {
-    const deployerRecords =
-      await this.laconicRegistry.getDeployerRecordsByFilter({});
+    const deployerRecords = await this.laconicRegistry.getDeployerRecordsByFilter({});
    await this.saveDeployersByDeployerRecords(deployerRecords);

    return await this.db.getDeployers();
  }

-  async saveDeployersByDeployerRecords(
-    deployerRecords: DeployerRecord[],
-  ): Promise<Deployer[]> {
+  async saveDeployersByDeployerRecords(deployerRecords: DeployerRecord[]): Promise<Deployer[]> {
    const deployers: Deployer[] = [];

    for (const record of deployerRecords) {
@ -1711,9 +1598,7 @@ export class Service {
        const minimumPayment = record.attributes.minimumPayment;
        const paymentAddress = record.attributes.paymentAddress;
        const publicKey = record.attributes.publicKey;
-        const baseDomain = deployerApiUrl.substring(
-          deployerApiUrl.indexOf('.') + 1,
-        );
+        const baseDomain = deployerApiUrl.substring(deployerApiUrl.indexOf('.') + 1);

        const deployerData = {
          deployerLrn,
@ -1722,7 +1607,7 @@ export class Service {
          baseDomain,
          minimumPayment,
          paymentAddress,
-          publicKey,
+          publicKey
        };

        // TODO: Update deployers table in a separate job
@ -1740,39 +1625,25 @@ export class Service {
    return account.address;
  }

-  async verifyTx(
-    txHash: string,
-    amountSent: string,
-    senderAddress: string,
-  ): Promise<boolean> {
+  async verifyTx(txHash: string, amountSent: string, senderAddress: string): Promise<boolean> {
    const txResponse = await this.laconicRegistry.getTxResponse(txHash);
    if (!txResponse) {
      log('Transaction response not found');
      return false;
    }

-    const transfer = txResponse.events.find(
-      (e) =>
-        e.type === 'transfer' &&
-        e.attributes.some((a) => a.key === 'msg_index'),
-    );
+    const transfer = txResponse.events.find(e => e.type === 'transfer' && e.attributes.some(a => a.key === 'msg_index'));
    if (!transfer) {
      log('No transfer event found');
      return false;
    }

-    const sender = transfer.attributes.find((a) => a.key === 'sender')?.value;
-    const recipient = transfer.attributes.find(
-      (a) => a.key === 'recipient',
-    )?.value;
-    const amount = transfer.attributes.find((a) => a.key === 'amount')?.value;
+    const sender = transfer.attributes.find(a => a.key === 'sender')?.value;
+    const recipient = transfer.attributes.find(a => a.key === 'recipient')?.value;
+    const amount = transfer.attributes.find(a => a.key === 'amount')?.value;

    const recipientAddress = await this.getAddress();

-    return (
-      amount === amountSent &&
-      sender === senderAddress &&
-      recipient === recipientAddress
-    );
+    return amount === amountSent && sender === senderAddress && recipient === recipientAddress;
  }
 }
--- a/packages/deployer/config.yml
+++ b/packages/deployer/config.yml
@ -1,8 +1,8 @@
 services:
  registry:
-    rpcEndpoint: https://laconicd-mainnet-1.laconic.com
-    gqlEndpoint: https://laconicd-mainnet-1.laconic.com/api
+    rpcEndpoint: https://laconicd-sapo.laconic.com
+    gqlEndpoint: https://laconicd-sapo.laconic.com/api
    userKey:
    bondId:
-    chainId: laconic-mainnet
+    chainId: laconic-testnet-2
    gasPrice: 0.001alnt
--- a/packages/deployer/deploy-frontend.sh
+++ b/packages/deployer/deploy-frontend.sh
@ -133,6 +133,8 @@ record:
      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 @ $CURRENT_DATE_TIME
--- a/packages/deployer/deploy-frontend.vaasl.sh
+++ b/packages/deployer/deploy-frontend.vaasl.sh
@ -127,6 +127,7 @@ record:
      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
--- a/packages/frontend/.env.example
+++ b/packages/frontend/.env.example
@ -5,6 +5,8 @@ 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=
+
 VITE_LIT_RELAY_API_KEY=

 VITE_BUGSNAG_API_KEY=
@ -12,4 +14,5 @@ VITE_BUGSNAG_API_KEY=
 VITE_PASSKEY_WALLET_RPID=
 VITE_TURNKEY_API_BASE_URL=

+VITE_LACONICD_CHAIN_ID=
 VITE_WALLET_IFRAME_URL=
--- a/packages/frontend/package.json
+++ b/packages/frontend/package.json
@ -41,12 +41,13 @@
    "@turnkey/http": "^2.10.0",
    "@turnkey/sdk-react": "^0.1.0",
    "@turnkey/webauthn-stamper": "^0.5.0",
+    "@walletconnect/ethereum-provider": "^2.16.1",
    "@web3modal/siwe": "4.0.5",
+    "@web3modal/wagmi": "4.0.5",
    "assert": "^2.1.0",
    "axios": "^1.6.7",
    "clsx": "^2.1.0",
    "date-fns": "^3.3.1",
-    "ethers": "^5.6.2",
    "downshift": "^8.3.2",
    "framer-motion": "^11.0.8",
    "gql-client": "^1.0.0",
@ -68,6 +69,7 @@
    "usehooks-ts": "^2.15.1",
    "uuid": "^9.0.1",
    "viem": "^2.7.11",
+    "wagmi": "2.5.7",
    "web-vitals": "^2.1.4"
  },
  "devDependencies": {
--- a/packages/frontend/public/android-chrome-192x192.png
+++ b/packages/frontend/public/android-chrome-192x192.png
--- a/packages/frontend/public/network.json
+++ b/packages/frontend/public/network.json
@ -1,11 +0,0 @@
-{
-  "chainId": "laconic-mainnet",
-  "networkName": "laconicd mainnet",
-  "namespace": "cosmos",
-  "rpcUrl": "https://laconicd-mainnet-1.laconic.com",
-  "blockExplorerUrl": "",
-  "nativeDenom": "alnt",
-  "addressPrefix": "laconic",
-  "coinType": 118,
-  "gasPrice": 0.001
-}
--- a/packages/frontend/src/App.tsx
+++ b/packages/frontend/src/App.tsx
@ -11,8 +11,8 @@ import ProjectSearchLayout from './layouts/ProjectSearch';
 import Index from './pages';
 import AuthPage from './pages/AuthPage';
 import { DashboardLayout } from './pages/org-slug/layout';
+import Web3Provider from 'context/Web3Provider';
 import { BASE_URL } from 'utils/constants';
-import BuyPrepaidService from './pages/BuyPrepaidService';

 const router = createBrowserRouter([
  {
@ -50,10 +50,6 @@ const router = createBrowserRouter([
    path: '/login',
    element: <AuthPage />,
  },
-  {
-    path: '/buy-prepaid-service',
-    element: <BuyPrepaidService />,
-  },
 ]);

 function App() {
@ -79,7 +75,9 @@ function App() {
  }, []);

  return (
-    <RouterProvider router={router} />
+    <Web3Provider>
+      <RouterProvider router={router} />
+    </Web3Provider>
  );
 }

--- a/packages/frontend/src/components/projects/create/AccountsDropdown.tsx
+++ b/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;
--- a/packages/frontend/src/components/projects/create/CheckBalanceIframe.tsx
+++ b/packages/frontend/src/components/projects/create/CheckBalanceIframe.tsx
@ -1,67 +0,0 @@
-import { useEffect } from 'react';
-
-import { Modal } from '@mui/material';
-
-import { VITE_WALLET_IFRAME_URL } from 'utils/constants';
-import useCheckBalance from '../../../hooks/useCheckBalance';
-import { useAddNetwork } from '../../../hooks/useAddNetwork';
-
-const CHECK_BALANCE_INTERVAL = 5000;
-const IFRAME_ID = 'checkBalanceIframe';
-
-const CheckBalanceIframe = ({
-  onBalanceChange,
-  isPollingEnabled,
-  amount,
-}: {
-  onBalanceChange: (value: boolean | undefined) => void;
-  isPollingEnabled: boolean;
-  amount: string;
-}) => {
-  const { isBalanceSufficient, checkBalance } = useCheckBalance(
-    amount,
-    IFRAME_ID,
-  );
-
-  const { isNetworkAvailable, setIframe } = useAddNetwork();
-  
-  useEffect(() => {
-    if (!isNetworkAvailable || isBalanceSufficient) {
-      return;
-    }
-
-    checkBalance();
-
-    if (!isPollingEnabled) {
-      return;
-    }
-    
-    const interval = setInterval(() => {
-      checkBalance();
-    }, CHECK_BALANCE_INTERVAL);
-
-    return () => {
-      clearInterval(interval);
-    };
-  }, [isBalanceSufficient, isPollingEnabled, checkBalance, isNetworkAvailable]);
-
-  useEffect(() => {
-    onBalanceChange(isBalanceSufficient);
-  }, [isBalanceSufficient]);
-
-  return (
-    <Modal open={false} disableEscapeKeyDown keepMounted>
-      <iframe
-        onLoad={(event) => setIframe(event.target as HTMLIFrameElement)}
-        id={IFRAME_ID}
-        src={VITE_WALLET_IFRAME_URL}
-        width="100%"
-        height="100%"
-        sandbox="allow-scripts allow-same-origin"
-        className="border rounded-md shadow-sm"
-      />
-    </Modal>
-  );
-};
-
-export default CheckBalanceIframe;
--- a/packages/frontend/src/components/projects/create/Configure.tsx
+++ b/packages/frontend/src/components/projects/create/Configure.tsx
@ -1,4 +1,4 @@
-import { useCallback, useState, useEffect, useMemo } from 'react';
+import { useCallback, useState, useEffect } from 'react';
 import { useForm, Controller } from 'react-hook-form';
 import { FormProvider, FieldValues } from 'react-hook-form';
 import { useNavigate, useSearchParams } from 'react-router-dom';
@ -8,7 +8,6 @@ import {
  AuctionParams,
  Deployer,
 } from 'gql-client';
-import { BigNumber } from 'ethers';

 import { Select, MenuItem, FormControl, FormHelperText } from '@mui/material';

@ -21,19 +20,19 @@ import { Button } from '../../shared/Button';
 import { Input } from 'components/shared/Input';
 import { useToast } from 'components/shared/Toast';
 import { useGQLClient } from '../../../context/GQLClientContext';
-import ApproveTransactionModal from './ApproveTransactionModal';
+import IFrameModal from './IFrameModal';
 import EnvironmentVariablesForm from 'pages/org-slug/projects/id/settings/EnvironmentVariablesForm';
 import { EnvironmentVariablesFormValues } from 'types/types';
 import {
+  VITE_LACONICD_CHAIN_ID,
  VITE_WALLET_IFRAME_URL,
 } from 'utils/constants';
-import CheckBalanceIframe from './CheckBalanceIframe';
-import { useAddNetwork } from '../../../hooks/useAddNetwork';
+import AccountsDropdown from './AccountsDropdown';

 type ConfigureDeploymentFormValues = {
  option: string;
  lrn?: string;
-  numProviders?: string;
+  numProviders?: number;
  maxPrice?: string;
 };

@ -47,13 +46,12 @@ const Configure = () => {
  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 [balanceMessage, setBalanceMessage] = useState<string>();
-  const [isBalanceSufficient, setIsBalanceSufficient] = useState<boolean>();

  const [searchParams] = useSearchParams();
  const templateId = searchParams.get('templateId');
@ -71,47 +69,22 @@ const Configure = () => {
  const navigate = useNavigate();
  const { toast, dismiss } = useToast();
  const client = useGQLClient();
-  const { networkData } = useAddNetwork()

  const methods = useForm<ConfigureFormValues>({
    defaultValues: {
      option: 'Auction',
      maxPrice: DEFAULT_MAX_PRICE,
      lrn: '',
-      numProviders: '1',
+      numProviders: 1,
      variables: [],
    },
  });

  const selectedOption = methods.watch('option');
-  const selectedNumProviders = methods.watch('numProviders') ?? '1';
-  const selectedMaxPrice = methods.watch('maxPrice') ?? DEFAULT_MAX_PRICE;

  const isTabletView = useMediaQuery('(min-width: 720px)'); // md:
  const buttonSize = isTabletView ? { size: 'lg' as const } : {};

-  const amountToBePaid = useMemo(() => {
-    let amount: string;
-
-    if (selectedOption === 'LRN') {
-      amount = selectedDeployer?.minimumPayment?.replace(/\D/g, '') ?? '0';
-    } else {
-      if (!selectedNumProviders || !selectedMaxPrice) {
-        return '';
-      }
-
-      const bigMaxPrice = BigNumber.from(selectedMaxPrice);
-      amount = bigMaxPrice.mul(selectedNumProviders).toString();
-    }
-
-    return amount;
-  }, [
-    selectedOption,
-    selectedDeployer?.minimumPayment,
-    selectedMaxPrice,
-    selectedNumProviders,
-  ]);
-
  const createProject = async (
    data: FieldValues,
    envVariables: AddEnvironmentVariableInput[],
@ -213,6 +186,7 @@ const Configure = () => {
          (deployer) => deployer.deployerLrn === deployerLrn,
        );

+        let amount: string;
        let senderAddress: string;
        let txHash: string | null = null;
        if (createFormData.option === 'LRN' && !deployer?.minimumPayment) {
@ -230,6 +204,16 @@ const Configure = () => {

          senderAddress = selectedAccount;

+          if (createFormData.option === 'LRN') {
+            amount = deployer?.minimumPayment!;
+          } else {
+            amount = (
+              createFormData.numProviders * createFormData.maxPrice
+            ).toString();
+          }
+
+          const amountToBePaid = amount.replace(/\D/g, '').toString();
+
          txHash = await cosmosSendTokensHandler(senderAddress, amountToBePaid);

          if (!txHash) {
@ -319,7 +303,7 @@ const Configure = () => {
        throw new Error(error);
      }
    },
-    [client, createProject, dismiss, toast, amountToBePaid],
+    [client, createProject, dismiss, toast],
  );

  const fetchDeployers = useCallback(async () => {
@ -327,6 +311,10 @@ const Configure = () => {
    setDeployers(res.deployers);
  }, [client]);

+  const onAccountChange = useCallback((account: string) => {
+    setSelectedAccount(account);
+  }, []);
+
  const onDeployerChange = useCallback(
    (selectedLrn: string) => {
      const deployer = deployers.find((d) => d.deployerLrn === selectedLrn);
@ -352,20 +340,12 @@ const Configure = () => {
        await requestTx(senderAddress, snowballAddress, amount);

        const txHash = await new Promise<string | null>((resolve, reject) => {
-          // Call cleanup method only if appropriate event type is recieved
-          const cleanup = () => {
-            setIsFrameVisible(false);
-            window.removeEventListener('message', handleTxStatus);
-          };
-
          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);
-
-              cleanup();
            } else if (event.data.type === 'ERROR') {
              console.error('Error from wallet:', event.data.message);
              reject(new Error('Transaction failed'));
@ -375,9 +355,10 @@ const Configure = () => {
                variant: 'error',
                onDismiss: dismiss,
              });
-
-              cleanup();
            }
+            setIsFrameVisible(false);
+
+            window.removeEventListener('message', handleTxStatus);
          };

          window.addEventListener('message', handleTxStatus);
@ -422,7 +403,7 @@ const Configure = () => {
    iframe.contentWindow.postMessage(
      {
        type: 'REQUEST_TX',
-        chainId: networkData?.chainId,
+        chainId: VITE_LACONICD_CHAIN_ID,
        fromAddress: sender,
        toAddress: recipient,
        amount,
@ -437,12 +418,6 @@ const Configure = () => {
    fetchDeployers();
  }, []);

-  useEffect(() => {
-    if (isBalanceSufficient) {
-      setBalanceMessage(undefined);
-    }
-  }, [isBalanceSufficient]);
-
  return (
    <div className="space-y-7 px-4 py-6">
      <div className="flex justify-between mb-6">
@ -559,7 +534,6 @@ const Configure = () => {
                        type="number"
                        value={value}
                        onChange={(e) => onChange(e)}
-                        min={1}
                      />
                    )}
                  />
@ -573,7 +547,7 @@ const Configure = () => {
                    control={methods.control}
                    rules={{ required: true }}
                    render={({ field: { value, onChange } }) => (
-                      <Input type="number" value={value} onChange={onChange} min={1} />
+                      <Input type="number" value={value} onChange={onChange} />
                    )}
                  />
                </div>
@ -605,83 +579,49 @@ const Configure = () => {
                </Button>
              </div>
            ) : (
-              <div className="flex gap-4">
-                <Button
-                  {...buttonSize}
-                  type="submit"
-                  shape="default"
-                  disabled={
-                    isLoading ||
-                    isPaymentLoading ||
-                    !selectedAccount ||
-                    !isBalanceSufficient ||
-                    amountToBePaid === '' ||
-                    selectedNumProviders === ''
-                  }
-                  rightIcon={
-                    isLoading || isPaymentLoading ? (
-                      <LoadingIcon className="animate-spin" />
-                    ) : (
-                      <ArrowRightCircleFilledIcon />
-                    )
-                  }
-                >
-                  {!isPaymentDone
-                    ? isPaymentLoading
-                      ? 'Transaction Requested'
-                      : 'Pay and Deploy'
-                    : isLoading
-                      ? 'Deploying'
-                      : 'Deploy'}
-                </Button>
-                {isAccountsDataReceived && isBalanceSufficient !== undefined ? (
-                  !selectedAccount || !isBalanceSufficient ? (
-                    <div className="flex items-center gap-4">
-                      <Button
-                        {...buttonSize}
-                        shape="default"
-                        onClick={(e: any) => {
-                          e.preventDefault();
-                          setBalanceMessage('Waiting for payment');
-                          window.open(
-                            'https://store.laconic.com',
-                            '_blank',
-                            'noopener,noreferrer',
-                          );
-                        }}
-                      >
-                        Buy prepaid service
-                      </Button>
-                      <p className="text-gray-700 dark:text-gray-300">
-                        {balanceMessage !== undefined ? (
-                          <div className="flex items-center gap-2 text-white">
-                            <LoadingIcon className="animate-spin w-5 h-5" />
-                            <p>{balanceMessage}</p>
-                          </div>
-                        ) : !selectedAccount ? (
-                          'No accounts found. Create a wallet.'
+              <>
+                <AccountsDropdown
+                  accounts={accounts}
+                  onAccountChange={onAccountChange}
+                  isDataReceived={isAccountsDataReceived}
+                />
+                {accounts.length > 0 && (
+                  <div>
+                    <Button
+                      {...buttonSize}
+                      type="submit"
+                      shape="default"
+                      disabled={
+                        isLoading || isPaymentLoading || !selectedAccount
+                      }
+                      rightIcon={
+                        isLoading || isPaymentLoading ? (
+                          <LoadingIcon className="animate-spin" />
                        ) : (
-                          'Insufficient funds.'
-                        )}
-                      </p>
-                    </div>
-                  ) : null
-                ) : null}
-              </div>
+                          <ArrowRightCircleFilledIcon />
+                        )
+                      }
+                    >
+                      {!isPaymentDone
+                        ? isPaymentLoading
+                          ? 'Transaction Requested'
+                          : 'Pay and Deploy'
+                        : isLoading
+                          ? 'Deploying'
+                          : 'Deploy'}
+                    </Button>
+                  </div>
+                )}
+              </>
            )}
          </form>
        </FormProvider>

-        <ApproveTransactionModal
-          setAccount={setSelectedAccount}
+        <IFrameModal
+          setAccounts={setAccounts}
          setIsDataReceived={setIsAccountsDataReceived}
          isVisible={isFrameVisible}
        />
-        <CheckBalanceIframe
-          onBalanceChange={setIsBalanceSufficient}
-          amount={amountToBePaid}
-          isPollingEnabled={true}
-        />
      </div>
    </div>
  );
--- a/packages/frontend/src/components/projects/create/ApproveTransactionModal.tsx
+++ b/packages/frontend/src/components/projects/create/ApproveTransactionModal.tsx
@ -3,38 +3,27 @@ import { useCallback, useEffect } from 'react';
 import { Box, Modal } from '@mui/material';

 import {
+  VITE_LACONICD_CHAIN_ID,
  VITE_WALLET_IFRAME_URL,
 } from 'utils/constants';
-import { REQUEST_WALLET_ACCOUNTS, WALLET_ACCOUNTS_DATA } from '../../../constants';
-import { useAddNetwork } from '../../../hooks/useAddNetwork';

-const ApproveTransactionModal = ({
-  setAccount,
+const IFrameModal = ({
+  setAccounts,
  setIsDataReceived,
  isVisible,
 }: {
-  setAccount: (account: string) => void;
+  setAccounts: (accounts: string[]) => void;
  setIsDataReceived: (isReceived: boolean) => void;
  isVisible: boolean;
 }) => {
-  const { setIframe, isNetworkAvailable, networkData } = useAddNetwork();
-
  useEffect(() => {
    const handleMessage = (event: MessageEvent) => {
      if (event.origin !== VITE_WALLET_IFRAME_URL) return;

-      if (event.data.type === WALLET_ACCOUNTS_DATA) {
-        setIsDataReceived(true);
-
-        if (event.data.data.length === 0) {
-          console.error(`Accounts not present for chainId: ${networkData?.chainId}`);
-          return;
-        }
-
-        setAccount(event.data.data[0]);
-      }
-
-      if (event.data.type === 'ERROR') {
+      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);
      }
    };
@ -44,14 +33,9 @@ const ApproveTransactionModal = ({
    return () => {
      window.removeEventListener('message', handleMessage);
    };
-  }, [networkData]);
+  }, []);

  const getDataFromWallet = useCallback(() => {
-    if (!networkData) {
-      console.error('networkData should not be empty');
-      return;
-    }
-
    const iframe = document.getElementById('walletIframe') as HTMLIFrameElement;

    if (!iframe.contentWindow) {
@ -61,18 +45,12 @@ const ApproveTransactionModal = ({

    iframe.contentWindow.postMessage(
      {
-        type: REQUEST_WALLET_ACCOUNTS,
-        chainId: networkData.chainId,
+        type: 'REQUEST_WALLET_ACCOUNTS',
+        chainId: VITE_LACONICD_CHAIN_ID,
      },
      VITE_WALLET_IFRAME_URL,
    );
-  }, [networkData]);
-
-  useEffect(() => {
-    if (isNetworkAvailable) {
-      getDataFromWallet();
-    }
-  }, [isNetworkAvailable, getDataFromWallet])
+  }, []);

  return (
    <Modal open={isVisible} disableEscapeKeyDown keepMounted>
@ -94,7 +72,7 @@ const ApproveTransactionModal = ({
        }}
      >
        <iframe
-          onLoad={(event) => setIframe(event.target as HTMLIFrameElement)}
+          onLoad={getDataFromWallet}
          id="walletIframe"
          src={`${VITE_WALLET_IFRAME_URL}/wallet-embed`}
          width="100%"
@ -107,4 +85,4 @@ const ApproveTransactionModal = ({
  );
 };

-export default ApproveTransactionModal;
+export default IFrameModal;
--- a/packages/frontend/src/components/projects/project/deployments/DeploymentMenu.tsx
+++ b/packages/frontend/src/components/projects/project/deployments/DeploymentMenu.tsx
@ -99,6 +99,7 @@ export const DeploymentMenu = ({
    const isRollbacked = await client.rollbackDeployment(
      project.id,
      deployment.id,
+      deployment.deployer.deployerLrn
    );
    if (isRollbacked.rollbackDeployment) {
      await onUpdate();
--- a/packages/frontend/src/components/projects/project/overview/Activity/AuctionCard.tsx
+++ b/packages/frontend/src/components/projects/project/overview/Activity/AuctionCard.tsx
@ -43,11 +43,6 @@ export const AuctionCard = ({ project }: { project: Project }) => {

  const checkAuctionStatus = useCallback(async () => {
    const result = await client.getAuctionData(project.auctionId);
-
-    if (!result) {
-      return
-    }
-
    setAuctionStatus(result.status);
    setAuctionDetails(result);
  }, [project.auctionId, project.deployers, project.fundsReleased]);
--- a/packages/frontend/src/components/projects/project/settings/DomainCard.tsx
+++ b/packages/frontend/src/components/projects/project/settings/DomainCard.tsx
@ -8,13 +8,14 @@ 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 { GearIcon } 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';
@ -44,7 +45,6 @@ interface DomainCardProps {
  onUpdate: () => Promise<void>;
 }

-
 const DomainCard = ({
  domains,
  domain,
@ -56,7 +56,9 @@ const DomainCard = ({
  const { id } = useParams();
  const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
  const [editDialogOpen, setEditDialogOpen] = useState(false);
-  const [dnsRecord, setDnsRecord] = useState<DNSRecordAttributes | null>(null);
+  const [dnsRecordsWithLRN, setDnsRecordsWithLRN] = useState<
+    { dnsRecord: DNSRecordAttributes; deployerLRN: string }[]
+  >([]);
  // const [refreshStatus, SetRefreshStatus] = useState(RefreshStatus.IDLE);

  const client = useGQLClient();
@ -94,9 +96,26 @@ const DomainCard = ({
        return;
      }

-      const dnsRecordResponse = await client.getLatestDNSRecordByProjectId(id);
+      const dnsRecordResponse = await client.getProject(id);

-      setDnsRecord(dnsRecordResponse.latestDNSRecord);
+      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();
@ -182,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>
@ -199,26 +223,49 @@ const DomainCard = ({
            </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>
-              {dnsRecord ? (
-                <tr>
-                  <td>{dnsRecord.resourceType}</td>
-                  <td>@</td>
-                  <td>{dnsRecord.value ?? 'Not Configured'}</td>
-                </tr>
-              ) : (
-                <p className={'text-red-500'}>DNS record data not available</p>
-              )}
-            </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>
      )}

--- a/packages/frontend/src/components/shared/Sidebar/Sidebar.tsx
+++ b/packages/frontend/src/components/shared/Sidebar/Sidebar.tsx
@ -1,11 +1,14 @@
 import { useCallback, useEffect, useState } from 'react';
-import { useParams } from 'react-router-dom';
+import { useNavigate, useParams } from 'react-router-dom';
 import { User } from 'gql-client';
 import { motion } from 'framer-motion';
+import { useDisconnect } from 'wagmi';

 import { useGQLClient } from 'context/GQLClientContext';
 import {
+  GlobeIcon,
  LifeBuoyIcon,
+  LogoutIcon,
  QuestionMarkRoundIcon,
 } from 'components/shared/CustomIcon';
 import { Tabs } from 'components/shared/Tabs';
@ -13,9 +16,10 @@ import { Logo } from 'components/Logo';
 import { Avatar } from 'components/shared/Avatar';
 import { formatAddress } from 'utils/format';
 import { getInitials } from 'utils/geInitials';
+import { Button } from 'components/shared/Button';
 import { cn } from 'utils/classnames';
 import { useMediaQuery } from 'usehooks-ts';
-import { SHOPIFY_APP_URL } from '../../../constants';
+import { BASE_URL } from 'utils/constants';

 interface SidebarProps {
  mobileOpen?: boolean;
@ -23,10 +27,12 @@ interface SidebarProps {

 export const Sidebar = ({ mobileOpen }: SidebarProps) => {
  const { orgSlug } = useParams();
+  const navigate = useNavigate();
  const client = useGQLClient();
  const isDesktop = useMediaQuery('(min-width: 960px)');

  const [user, setUser] = useState<User>();
+  const { disconnect } = useDisconnect();

  const fetchUser = useCallback(async () => {
    const { user } = await client.getUser();
@ -37,6 +43,16 @@ export const Sidebar = ({ mobileOpen }: SidebarProps) => {
    fetchUser();
  }, []);

+  const handleLogOut = useCallback(async () => {
+    await fetch(`${BASE_URL}/auth/logout`, {
+      method: 'POST',
+      credentials: 'include',
+    });
+    localStorage.clear();
+    disconnect();
+    navigate('/login');
+  }, [disconnect, navigate]);
+
  return (
    <motion.nav
      initial={{ x: -320 }}
@ -66,10 +82,19 @@ export const Sidebar = ({ mobileOpen }: SidebarProps) => {
          <Tabs defaultValue="Projects" orientation="vertical">
            {/* // TODO: use proper link buttons */}
            <Tabs.List>
+              <Tabs.Trigger
+                icon={<GlobeIcon />}
+                value=""
+                className="hidden lg:flex"
+              >
+                <a className="cursor-pointer font-mono" onClick={handleLogOut}>
+                  LOG OUT
+                </a>
+              </Tabs.Trigger>
              <Tabs.Trigger icon={<QuestionMarkRoundIcon />} value="">
                <a
                  className="cursor-pointer font-mono"
-                  href={`${SHOPIFY_APP_URL}/pages/instruction-faq`}
+                  href="https://store.laconic.com/pages/instruction-faq"
                >
                  DOCUMENTATION
                </a>
@ -100,6 +125,14 @@ export const Sidebar = ({ mobileOpen }: SidebarProps) => {
            </p>
          </div>
        )}
+        <Button
+          iconOnly
+          variant="ghost"
+          className="text-elements-low-em"
+          onClick={handleLogOut}
+        >
+          <LogoutIcon />
+        </Button>
      </div>
    </motion.nav>
  );
--- a/packages/frontend/src/components/shared/auth/AutoSignInIFrameModal.tsx
+++ b/packages/frontend/src/components/shared/auth/AutoSignInIFrameModal.tsx
@ -1,155 +0,0 @@
-import { useCallback, useEffect, useState } from 'react';
-import { generateNonce, SiweMessage } from 'siwe';
-import axios from 'axios';
-import { useNavigate } from 'react-router-dom';
-
-import { Box, Modal } from '@mui/material';
-
-import { BASE_URL, VITE_WALLET_IFRAME_URL } from 'utils/constants';
-import { REQUEST_CREATE_OR_GET_ACCOUNTS, WALLET_ACCOUNTS_DATA } from '../../../constants';
-
-const axiosInstance = axios.create({
-  baseURL: BASE_URL,
-  headers: {
-    'Content-Type': 'application/json',
-    'Access-Control-Allow-Origin': '*',
-  },
-  withCredentials: true,
-});
-
-const AutoSignInIFrameModal = () => {
-  const navigate = useNavigate();
-
-  const [accountAddress, setAccountAddress] = useState();
-
-  useEffect(() => {
-    const handleSignInResponse = async (event: MessageEvent) => {
-      if (event.origin !== VITE_WALLET_IFRAME_URL) return;
-
-      if (event.data.type === 'SIGN_IN_RESPONSE') {
-        try {
-          const { success } = (
-            await axiosInstance.post('/auth/validate', {
-              message: event.data.data.message,
-              signature: event.data.data.signature,
-            })
-          ).data;
-
-          if (success === true) {
-            navigate('/');
-          }
-        } catch (error) {
-          console.error('Error signing in:', error);
-        }
-      }
-    };
-
-    window.addEventListener('message', handleSignInResponse);
-
-    return () => {
-      window.removeEventListener('message', handleSignInResponse);
-    };
-  }, []);
-
-  useEffect(() => {
-    const initiateAutoSignIn = async () => {
-      if (!accountAddress) return;
-
-      const iframe = document.getElementById(
-        'autoSignInFrame',
-      ) as HTMLIFrameElement;
-
-      if (!iframe.contentWindow) {
-        console.error('Iframe not found or not loaded');
-        return;
-      }
-
-      const message = new SiweMessage({
-        version: '1',
-        domain: window.location.host,
-        uri: window.location.origin,
-        chainId: 1,
-        address: accountAddress,
-        nonce: generateNonce(),
-        // Human-readable ASCII assertion that the user will sign, and it must not contain `\n`.
-        statement: 'Sign in With Ethereum.',
-      }).prepareMessage();
-
-      iframe.contentWindow.postMessage(
-        {
-          type: 'AUTO_SIGN_IN',
-          chainId: '1',
-          message,
-        },
-        VITE_WALLET_IFRAME_URL,
-      );
-    };
-
-    initiateAutoSignIn();
-  }, [accountAddress]);
-
-  useEffect(() => {
-    const handleAccountsDataResponse = async (event: MessageEvent) => {
-      if (event.origin !== VITE_WALLET_IFRAME_URL) return;
-
-      if (event.data.type === WALLET_ACCOUNTS_DATA) {
-        setAccountAddress(event.data.data[0]);
-      }
-    };
-
-    window.addEventListener('message', handleAccountsDataResponse);
-
-    return () => {
-      window.removeEventListener('message', handleAccountsDataResponse);
-    };
-  }, []);
-
-  const getAddressFromWallet = useCallback(() => {
-    const iframe = document.getElementById(
-      'autoSignInFrame',
-    ) as HTMLIFrameElement;
-
-    if (!iframe.contentWindow) {
-      console.error('Iframe not found or not loaded');
-      return;
-    }
-
-    iframe.contentWindow.postMessage(
-      {
-        type: REQUEST_CREATE_OR_GET_ACCOUNTS,
-        chainId: '1',
-      },
-      VITE_WALLET_IFRAME_URL,
-    );
-  }, []);
-
-  return (
-    <Modal open={true} disableEscapeKeyDown keepMounted>
-      <Box
-        sx={{
-          position: 'absolute',
-          top: '50%',
-          left: '50%',
-          transform: 'translate(-50%, -50%)',
-          width: '90%',
-          maxWidth: '1200px',
-          height: '600px',
-          maxHeight: '80vh',
-          overflow: 'auto',
-          outline: 'none',
-        }}
-      >
-        <iframe
-          onLoad={getAddressFromWallet}
-          id="autoSignInFrame"
-          src={`${VITE_WALLET_IFRAME_URL}/auto-sign-in`}
-          width="100%"
-          height="100%"
-          sandbox="allow-scripts allow-same-origin"
-        ></iframe>
-      </Box>
-    </Modal>
-  );
-};
-
-export default AutoSignInIFrameModal;
--- a/packages/frontend/src/constants.ts
+++ b/packages/frontend/src/constants.ts
@ -1,16 +1,3 @@
 export const SHORT_COMMIT_HASH_LENGTH = 8;

 export const SERVER_GQL_PATH = 'graphql';
-
-export const SHOPIFY_APP_URL = 'https://store.laconic.com';
-
-// iframe request types
-export const REQUEST_CREATE_OR_GET_ACCOUNTS = 'REQUEST_CREATE_OR_GET_ACCOUNTS';
-export const REQUEST_ADD_NETWORK = 'REQUEST_ADD_NETWORK';
-export const REQUEST_WALLET_ACCOUNTS = 'REQUEST_WALLET_ACCOUNTS';
-
-// iframe response types
-export const WALLET_ACCOUNTS_DATA = 'WALLET_ACCOUNTS_DATA';
-export const NETWORK_ADDED_RESPONSE = "NETWORK_ADDED_RESPONSE";
-export const NETWORK_ALREADY_EXISTS_RESPONSE = "NETWORK_ALREADY_EXISTS_RESPONSE";
-export const NETWORK_ADD_FAILED_RESPONSE = "NETWORK_ADD_FAILED_RESPONSE";
--- a/packages/frontend/src/context/Web3Provider.tsx
+++ b/packages/frontend/src/context/Web3Provider.tsx
@ -0,0 +1,116 @@
+import { ReactNode } from 'react';
+import assert from 'assert';
+import { SiweMessage, generateNonce } from 'siwe';
+import { WagmiProvider } from 'wagmi';
+import { mainnet } from 'wagmi/chains';
+import axios from 'axios';
+
+import { createWeb3Modal } from '@web3modal/wagmi/react';
+import { defaultWagmiConfig } from '@web3modal/wagmi/react/config';
+import { createSIWEConfig } from '@web3modal/siwe';
+import type {
+  SIWECreateMessageArgs,
+  SIWEVerifyMessageArgs,
+} from '@web3modal/core';
+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: VITE_WALLET_CONNECT_ID env config is not set');
+}
+assert(BASE_URL, 'VITE_SERVER_URL is not set in env');
+
+const queryClient = new QueryClient();
+const axiosInstance = axios.create({
+  baseURL: BASE_URL,
+  headers: {
+    'Content-Type': 'application/json',
+    'Access-Control-Allow-Origin': '*',
+  },
+  withCredentials: true,
+});
+const metadata = {
+  name: 'Deploy App Auth',
+  description: '',
+  url: window.location.origin,
+  icons: ['https://avatars.githubusercontent.com/u/37784886'],
+};
+const chains = [mainnet] as const;
+const config = defaultWagmiConfig({
+  chains,
+  projectId: VITE_WALLET_CONNECT_ID,
+  metadata,
+});
+const siweConfig = createSIWEConfig({
+  createMessage: ({ nonce, address, chainId }: SIWECreateMessageArgs) =>
+    new SiweMessage({
+      version: '1',
+      domain: window.location.host,
+      uri: window.location.origin,
+      address,
+      chainId,
+      nonce,
+      // Human-readable ASCII assertion that the user will sign, and it must not contain `\n`.
+      statement: 'Sign in With Ethereum.',
+    }).prepareMessage(),
+  getNonce: async () => {
+    return generateNonce();
+  },
+  getSession: async () => {
+    try {
+      const session = (await axiosInstance.get('/auth/session')).data;
+      const { address, chainId } = session;
+      return { address, chainId };
+    } catch (err) {
+      if (window.location.pathname !== '/login') {
+        window.location.href = '/login';
+      }
+      throw new Error('Failed to get session!');
+    }
+  },
+  verifyMessage: async ({ message, signature }: SIWEVerifyMessageArgs) => {
+    try {
+      const { success } = (
+        await axiosInstance.post('/auth/validate', {
+          message,
+          signature,
+        })
+      ).data;
+      return success;
+    } catch (error) {
+      return false;
+    }
+  },
+  signOut: async () => {
+    try {
+      const { success } = (await axiosInstance.post('/auth/logout')).data;
+      return success;
+    } catch (error) {
+      return false;
+    }
+  },
+  onSignOut: () => {
+    window.location.href = '/login';
+  },
+  onSignIn: () => {
+    window.location.href = '/';
+  },
+});
+
+createWeb3Modal({
+  siweConfig,
+  wagmiConfig: config,
+  projectId: VITE_WALLET_CONNECT_ID,
+});
+export default function Web3ModalProvider({
+  children,
+}: {
+  children: ReactNode;
+}) {
+  return (
+    <WagmiProvider config={config}>
+      <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+    </WagmiProvider>
+  );
+}
--- a/packages/frontend/src/hooks/useAddNetwork.ts
+++ b/packages/frontend/src/hooks/useAddNetwork.ts
@ -1,92 +0,0 @@
-import { useState, useEffect } from 'react';
-import { VITE_WALLET_IFRAME_URL } from 'utils/constants';
-import { NETWORK_ADD_FAILED_RESPONSE, NETWORK_ADDED_RESPONSE, NETWORK_ALREADY_EXISTS_RESPONSE, REQUEST_ADD_NETWORK } from '../constants';
-
-interface NetworkData {
-  chainId: string;
-  namespace: string;
-  networkName: string;
-  rpcUrl: string;
-  coinType: string;
-  addressPrefix?: string;
-  blockExplorerUrl?: string;
-  nativeDenom?: string;
-  gasPrice?: string;
-}
-
-export const useAddNetwork = () => {
-  const [networkData, setNetworkData] = useState<NetworkData | null>(null);
-  const [iframe, setIframe] = useState<HTMLIFrameElement | null>(null);
-  const [isNetworkAvailable, setIsNetworkAvailable] = useState(false);
-
-  // useEffect to add network in embedded wallet
-  useEffect(() => {
-    if (!networkData) {
-      return;
-    }
-
-    if (!iframe?.contentWindow) {
-      return;
-    }
-
-    iframe.contentWindow.postMessage(
-      {
-        type: REQUEST_ADD_NETWORK,
-        chainId: networkData.chainId,
-        networkData,
-      },
-      VITE_WALLET_IFRAME_URL,
-    );
-  }, [networkData, iframe]);
-
-  // useEffect to listen for network add reponses
-  useEffect(() => {
-    const handleMessage = (event: MessageEvent) => {
-      if (event.origin !== VITE_WALLET_IFRAME_URL) return;
-
-      switch (event.data.type) {
-        case NETWORK_ADDED_RESPONSE:
-        case NETWORK_ALREADY_EXISTS_RESPONSE:
-          // Once network is available, set state
-          setIsNetworkAvailable(true);
-          break;
-
-        case NETWORK_ADD_FAILED_RESPONSE:
-          setIsNetworkAvailable(false);
-          console.error("Network could not be added:", event.data.message);
-          break;
-
-        default:
-          break;
-      }
-    };
-
-    window.addEventListener('message', handleMessage);
-
-    return () => {
-      window.removeEventListener('message', handleMessage);
-    };
-  }, []);
-
-  useEffect(() => {
-    const loadNetworkData = async () => {
-      try {
-        const res = await fetch('/network.json');
-        const json = await res.json();
-
-        setNetworkData(json);
-      } catch (err) {
-        console.error('Failed to load network data:', err);
-      }
-    };
-
-    loadNetworkData();
-  }, []);
-
-  return {
-    networkData,
-    isNetworkAvailable,
-    iframe,
-    setIframe
-  };
-};
--- a/packages/frontend/src/hooks/useCheckBalance.tsx
+++ b/packages/frontend/src/hooks/useCheckBalance.tsx
@ -1,50 +0,0 @@
-import { useState, useEffect, useCallback } from 'react';
-
-import { useAddNetwork } from './useAddNetwork';
-
-const useCheckBalance = (amount: string, iframeId: string) => {
-  const [isBalanceSufficient, setIsBalanceSufficient] = useState<boolean>();
-
-  const { networkData } = useAddNetwork()
-
-  const checkBalance = useCallback(() => {
-    if (!networkData) {
-      return;
-    }
-
-    const iframe = document.getElementById(iframeId) as HTMLIFrameElement;
-
-    if (!iframe || !iframe.contentWindow) {
-      console.error(`Iframe with ID "${iframeId}" not found or not loaded`);
-      return;
-    }
-
-    iframe.contentWindow.postMessage(
-      {
-        type: 'CHECK_BALANCE',
-        chainId: networkData.chainId,
-        amount,
-      },
-      import.meta.env.VITE_WALLET_IFRAME_URL
-    );
-  }, [iframeId, amount, networkData]);
-
-  useEffect(() => {
-    const handleMessage = (event: MessageEvent) => {
-      if (event.origin !== import.meta.env.VITE_WALLET_IFRAME_URL) return;
-
-      if (event.data.type !== 'IS_SUFFICIENT') return;
-
-      setIsBalanceSufficient(event.data.data);
-    };
-
-    window.addEventListener('message', handleMessage);
-    return () => {
-      window.removeEventListener('message', handleMessage);
-    };
-  }, []);
-
-  return { isBalanceSufficient, checkBalance };
-};
-
-export default useCheckBalance;
--- a/packages/frontend/src/index.tsx
+++ b/packages/frontend/src/index.tsx
@ -14,6 +14,7 @@ import { SERVER_GQL_PATH } from './constants';
 import { Toaster } from 'components/shared/Toast';
 import { LogErrorBoundary } from 'utils/log-error';
 import { BASE_URL } from 'utils/constants';
+import Web3ModalProvider from './context/Web3Provider';
 import './index.css';

 console.log(`v-0.0.9`);
@ -31,10 +32,12 @@ root.render(
  <LogErrorBoundary>
    <React.StrictMode>
      <ThemeProvider>
-        <GQLClientProvider client={gqlClient}>
-          <App />
-          <Toaster />
-        </GQLClientProvider>
+        <Web3ModalProvider>
+          <GQLClientProvider client={gqlClient}>
+            <App />
+            <Toaster />
+          </GQLClientProvider>
+        </Web3ModalProvider>
      </ThemeProvider>
    </React.StrictMode>
  </LogErrorBoundary>,
--- a/packages/frontend/src/pages/AuthPage.tsx
+++ b/packages/frontend/src/pages/AuthPage.tsx
@ -1,4 +1,4 @@
-import AutoSignInIFrameModal from 'components/shared/auth/AutoSignInIFrameModal';
+import { Login } from './auth/Login';

 const AuthPage = () => {
  return (
@ -13,7 +13,9 @@ const AuthPage = () => {
        </div>
      </div>
      <div className="pb-12 relative z-10 flex-1 flex-center">
-        <AutoSignInIFrameModal />
+        <div className="max-w-[520px] w-full dark:bg-overlay bg-white rounded-xl shadow">
+          <Login />
+        </div>
      </div>
    </div>
  );
--- a/packages/frontend/src/pages/BuyPrepaidService.tsx
+++ b/packages/frontend/src/pages/BuyPrepaidService.tsx
@ -1,38 +0,0 @@
-import { useEffect, useState } from 'react';
-import { useNavigate } from 'react-router-dom';
-import { useMediaQuery } from 'usehooks-ts';
-
-import { Button } from 'components/shared';
-import CheckBalanceIframe from 'components/projects/create/CheckBalanceIframe';
-import { SHOPIFY_APP_URL } from '../constants';
-
-const BuyPrepaidService = () => {
-  const navigate = useNavigate();
-
-  const [isBalanceSufficient, setIsBalanceSufficient] = useState<boolean>();
-
-  const isTabletView = useMediaQuery('(min-width: 720px)'); // md:
-  const buttonSize = isTabletView ? { size: 'lg' as const } : {};
-
-  useEffect(() => {
-    if (isBalanceSufficient === true) {
-      navigate('/');
-    }
-  }, [isBalanceSufficient]);
-
-  return (
-    <div className="dark:bg-background flex flex-col min-h-screen">
-      <div className="pb-12 relative z-10 flex-1 flex-center">
-        <Button {...buttonSize} shape={'default'}>
-          <a href={SHOPIFY_APP_URL} target="_blank">
-            Buy prepaid service
-          </a>
-        </Button>
-      </div>
-
-      <CheckBalanceIframe onBalanceChange={setIsBalanceSufficient} isPollingEnabled={true} amount='1'/>
-    </div>
-  );
-};
-
-export default BuyPrepaidService;
--- a/packages/frontend/src/pages/auth/Login.tsx
+++ b/packages/frontend/src/pages/auth/Login.tsx
@ -9,6 +9,12 @@ export const Login = () => {
        </div>
      </div>
      <WavyBorder className="self-stretch" variant="stroke" />
+
+      <div className="self-stretch p-4 xs:p-6 flex-col justify-center items-center gap-8 flex">
+        <div className="self-stretch flex-col justify-center  items-center gap-3 flex">
+          <w3m-button />
+        </div>
+      </div>
    </div>
  );
 };
--- a/packages/frontend/src/pages/components/modals.tsx
+++ b/packages/frontend/src/pages/components/modals.tsx
@ -13,6 +13,7 @@ import {
  AppDeploymentRecordAttributes,
  Deployment,
  DeploymentStatus,
+  DNSRecordAttributes,
  Domain,
  DomainStatus,
  Environment,
@ -50,6 +51,7 @@ const deployment: Deployment = {
  applicationDeploymentRequestId:
    'bafyreiaycvq6imoppnpwdve4smj6t6ql5svt5zl3x6rimu4qwyzgjorize',
  applicationDeploymentRecordData: {} as AppDeploymentRecordAttributes,
+  dnsRecordData: {} as DNSRecordAttributes,
 };

 const domains: Domain[] = [
--- a/packages/frontend/src/pages/org-slug/index.tsx
+++ b/packages/frontend/src/pages/org-slug/index.tsx
@ -1,20 +1,16 @@
 import { useCallback, useEffect, useState } from 'react';
-import { Link, useNavigate, useParams } from 'react-router-dom';
+import { Link, useParams } from 'react-router-dom';

 import { ProjectCard } from 'components/projects/ProjectCard';
 import { Heading, Badge, Button } from 'components/shared';
 import { PlusIcon } from 'components/shared/CustomIcon';
 import { useGQLClient } from 'context/GQLClientContext';
 import { Project } from 'gql-client';
-import CheckBalanceIframe from 'components/projects/create/CheckBalanceIframe';

 const Projects = () => {
-  const [isBalanceSufficient, setIsBalanceSufficient] = useState<boolean>();
-  const [projects, setProjects] = useState<Project[]>([]);
-
-  const navigate = useNavigate();
  const client = useGQLClient();
  const { orgSlug } = useParams();
+  const [projects, setProjects] = useState<Project[]>([]);

  const fetchProjects = useCallback(async () => {
    const { projectsInOrganization } = await client.getProjectsInOrganization(
@ -27,12 +23,6 @@ const Projects = () => {
    fetchProjects();
  }, [orgSlug]);

-  useEffect(() => {
-    if (isBalanceSufficient === false) {
-      navigate('/buy-prepaid-service');
-    }
-  }, [isBalanceSufficient]);
-
  return (
    <section className="px-4 md:px-6 py-6 flex flex-col gap-6">
      {/* Header */}
@ -59,8 +49,6 @@ const Projects = () => {
            return <ProjectCard project={project} key={key} />;
          })}
      </div>
-
-      <CheckBalanceIframe onBalanceChange={setIsBalanceSufficient} isPollingEnabled={false} amount='1' />
    </section>
  );
 };
--- a/packages/frontend/src/pages/org-slug/projects/id/Overview.tsx
+++ b/packages/frontend/src/pages/org-slug/projects/id/Overview.tsx
@ -204,7 +204,7 @@ const OverviewTabPanel = () => {
              {project.deployments &&
                project.deployments.length > 0 &&
                project.deployments.map((deployment) => (
-                  <div key={deployment.id} className="flex gap-2 items-center">
+                  <div className="flex gap-2 items-center">
                    <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">
                        {deployment.applicationDeploymentRecordData.url}
--- a/packages/frontend/src/pages/org-slug/projects/id/settings/Domains.tsx
+++ b/packages/frontend/src/pages/org-slug/projects/id/settings/Domains.tsx
@ -60,39 +60,31 @@ const Domains = () => {
  return (
    <ProjectSettingContainer
      headingText="Domains"
-      {...(!project.auctionId && {
-        button: (
-          <Button
-            as="a"
-            href="add"
-            variant="secondary"
-            leftIcon={<PlusIcon />}
-            size="md"
-          >
-            Add domain
-          </Button>
-        ),
-      })}
+      button={
+        <Button
+          as="a"
+          href="add"
+          variant="secondary"
+          leftIcon={<PlusIcon />}
+          size="md"
+        >
+          Add domain
+        </Button>
+      }
    >
-      {project.auctionId ? (
-        <p className="text-gray-500">
-          Custom domains not supported for auction driven deployments.
-        </p>
-      ) : (
-        domains.map((domain) => {
-          return (
-            <DomainCard
-              domains={domains}
-              domain={domain}
-              key={domain.id}
-              // TODO: Use github API for getting linked repository
-              branches={branches}
-              project={project}
-              onUpdate={fetchDomains}
-            />
-          );
-        })
-      )}
+      {domains.map((domain) => {
+        return (
+          <DomainCard
+            domains={domains}
+            domain={domain}
+            key={domain.id}
+            // TODO: Use github API for getting linked repository
+            branches={branches}
+            project={project}
+            onUpdate={fetchDomains}
+          />
+        );
+      })}
    </ProjectSettingContainer>
  );
 };
--- a/packages/frontend/src/pages/org-slug/projects/id/settings/domains/add/Config.tsx
+++ b/packages/frontend/src/pages/org-slug/projects/id/settings/domains/add/Config.tsx
@ -18,7 +18,9 @@ const Config = () => {
  const primaryDomainName = searchParams.get('name');
  const { toast, dismiss } = useToast();

-  const [dnsRecord, setDnsRecord] = useState<DNSRecordAttributes | null>(null);
+  const [dnsRecordsWithLRN, setDnsRecordsWithLRN] = useState<
+    { dnsRecord: DNSRecordAttributes; deployerLRN: string }[]
+  >([]);

  const handleSubmitDomain = async () => {
    if (primaryDomainName === null) {
@ -75,9 +77,26 @@ const Config = () => {
        return;
      }

-      const dnsRecordResponse = await client.getLatestDNSRecordByProjectId(id);
+      const dnsRecordResponse = await client.getProject(id);

-      setDnsRecord(dnsRecordResponse.latestDNSRecord);
+      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();
@ -86,57 +105,66 @@ const Config = () => {
  // TODO: Figure out DNS Provider if possible and update appropriatly
  return (
    <ProjectSettingContainer headingText="Setup domain name">
-      {dnsRecord ? (
+      {dnsRecordsWithLRN.length ? (
        <>
          <p className="text-blue-gray-500">
            Add the following records to your domain.
          </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>
-                  {dnsRecord.resourceType}
-                </Table.RowHeaderCell>
-                <Table.Cell>@</Table.Cell>
-                <Table.Cell>
-                  <p className={!dnsRecord.value ? 'text-red-500' : ''}>
-                    {dnsRecord.value ?? 'Not available'}
-                  </p>
-                </Table.Cell>
-              </Table.Row>
-            </Table.Body>
-          </Table>
-
-          {dnsRecord?.value && (
-            <InlineNotification
-              variant="info"
-              title={`It can take up to 48 hours for these updates to reflect
-          globally.`}
-            />
-          )}
-          <Button
-            className="w-fit"
-            disabled={!dnsRecord?.value}
-            onClick={handleSubmitDomain}
-            variant="primary"
-            shape="default"
-            rightIcon={<ArrowRightCircleIcon />}
-          >
-            FINISH
-          </Button>
+          {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"
+        rightIcon={<ArrowRightCircleIcon />}
+      >
+        FINISH
+      </Button>
    </ProjectSettingContainer>
  );
 };
--- a/packages/frontend/src/stories/MockStoriesData.ts
+++ b/packages/frontend/src/stories/MockStoriesData.ts
@ -13,6 +13,7 @@ import {
  Environment,
  Permission,
  AppDeploymentRecordAttributes,
+  DNSRecordAttributes,
 } from 'gql-client';

 export const user: User = {
@ -112,6 +113,7 @@ export const deployment0: Deployment = {
  applicationDeploymentRequestId:
    'bafyreiaycvq6imoppnpwdve4smj6t6ql5svt5zl3x6rimu4qwyzgjorize',
  applicationDeploymentRecordData: {} as AppDeploymentRecordAttributes,
+  dnsRecordData: {} as DNSRecordAttributes,
 };

 export const project: Project = {
--- a/packages/frontend/src/utils/constants.ts
+++ b/packages/frontend/src/utils/constants.ts
@ -8,6 +8,8 @@ export const VITE_GITHUB_IMAGE_UPLOAD_PWA_TEMPLATE_REPO = import.meta.env
 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;
--- a/packages/frontend/src/utils/web3modal.ts
+++ b/packages/frontend/src/utils/web3modal.ts
@ -0,0 +1,8 @@
+import { WalletConnectModal } from '@walletconnect/modal';
+
+import { VITE_WALLET_CONNECT_ID } from 'utils/constants';
+
+export const walletConnectModal = new WalletConnectModal({
+  projectId: VITE_WALLET_CONNECT_ID,
+  chains: [],
+});
--- a/packages/gql-client/src/client.ts
+++ b/packages/gql-client/src/client.ts
@ -337,13 +337,15 @@ export class GQLClient {

  async rollbackDeployment(
    projectId: string,
-    deploymentId: string
+    deploymentId: string,
+    deployerLrn: string,
  ): Promise<types.RollbackDeploymentResponse> {
    const { data } = await this.client.mutate({
      mutation: mutations.rollbackDeployment,
      variables: {
        projectId,
        deploymentId,
+        deployerLrn,
      },
    });

@ -414,25 +416,14 @@ export class GQLClient {
    return data;
  }

-  async getAuctionData(auctionId: string): Promise<types.Auction | null> {
-    const { data, errors } = await this.client.query({
+  async getAuctionData(auctionId: string): Promise<types.Auction> {
+    const { data } = await this.client.query({
      query: queries.getAuctionData,
      variables: {
        auctionId,
      },
    });

-
-    if (errors && errors.length) {
-      const isAuctionNotFound = errors.some((error) =>
-        error.message?.includes('Auction not found')
-      );
-
-      if (isAuctionNotFound) {
-        return data;
-      }
-    }
-
    return data.getAuctionData;
  }

--- a/packages/gql-client/src/mutations.ts
+++ b/packages/gql-client/src/mutations.ts
@ -95,8 +95,8 @@ export const deleteDomain = gql`
 `;

 export const rollbackDeployment = gql`
-  mutation ($projectId: String!, $deploymentId: String!) {
-    rollbackDeployment(projectId: $projectId, deploymentId: $deploymentId)
+  mutation ($projectId: String!, $deployerLrn: String!) {
+    rollbackDeployment(projectId: $projectId, deployerLrn: $deployerLrn)
  }
 `;

--- a/packages/gql-client/src/queries.ts
+++ b/packages/gql-client/src/queries.ts
@ -62,11 +62,19 @@ query ($projectId: String!) {
      }
      deployer {
        baseDomain
+        deployerLrn
      }
      createdBy {
        id
        name
      }
+      dnsRecordData {
+        name
+        value
+        request
+        resourceType
+        version
+      }
    }
  }
 }
--- a/packages/gql-client/src/types.ts
+++ b/packages/gql-client/src/types.ts
@ -112,6 +112,7 @@ export type Deployment = {
  createdBy: User;
  createdAt: string;
  updatedAt: string;
+  dnsRecordData: DNSRecordAttributes;
  applicationDeploymentRequestId: string;
 };

--- a/standards/init-commit.md
+++ b/standards/init-commit.md
@ -1,7 +0,0 @@
-# Initial Commit for QWRK UX Changes
-
-This is the first commit for QWRK UX changes to a fork of the `snowballtools-base` repository in Gitea. This commit sets the foundation for the upcoming user experience improvements and modifications.
-
- Repository: `snowballtools-base`
- Platform: Gitea
- Purpose: QWRK UX changes
--- a/yarn.lock
+++ b/yarn.lock
Author	SHA1	Message	Date
Shreerang Kale	d93afb564b	Use deployer LRN instead of ID in rollback deployment All checks were successful Lint / lint (20.x) (pull_request) Successful in 2m6s Details	2025-02-07 10:31:51 +05:30
Shreerang Kale	285d0e86bf	Add custom domain support for auctions flow	2025-02-06 10:01:39 +05:30
Shreerang Kale	13cc0f8b9b	Add UI to show multiple domains	2025-02-06 10:01:39 +05:30
Shreerang Kale	93b74074a3	Handle auction deployment when changing to production	2025-02-06 10:01:39 +05:30
Shreerang Kale	b0d3c0593a	Enable add domain button for auctions	2025-02-06 10:01:39 +05:30