deep-stack/snowballtools-base
3
0
Fork 0
forked from cerc-io/snowballtools-base
Code Pull Requests Actions Activity

Skip check in intervals for projects with completed auction and no winning deployers (#60)

Browse Source 
Part of https://www.notion.so/Laconic-Mainnet-Plan-1eca6b22d47280569cd0d1e6d711d949

- Contains formatting changes from prettier

Reviewed-on: cerc-io/snowballtools-base#60
Co-authored-by: Nabarun <nabarun@deepstacksoft.com>
Co-committed-by: Nabarun <nabarun@deepstacksoft.com>
This commit is contained in:
Nabarun 2025-07-07 08:51:54 +00:00 committed by nabarun
parent dd1d747b60
commit 095cf0df34
4 changed files with 589 additions and 361 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

210
packages/backend/src/database.ts
View File

@ -5,7 +5,7 @@ import {
FindOneOptions, FindOneOptions,
FindOptionsWhere, FindOptionsWhere,
IsNull, IsNull,
Not Not,
} from 'typeorm'; } from 'typeorm';
import path from 'path'; import path from 'path';
import debug from 'debug'; import debug from 'debug';
@ -16,7 +16,7 @@ import { lowercase, numbers } from 'nanoid-dictionary';
import { DatabaseConfig } from './config'; import { DatabaseConfig } from './config';
import { User } from './entity/User'; import { User } from './entity/User';
import { Organization } from './entity/Organization'; import { Organization } from './entity/Organization';
import { Project } from './entity/Project'; import { AuctionStatus, Project } from './entity/Project';
import { Deployment, DeploymentStatus } from './entity/Deployment'; import { Deployment, DeploymentStatus } from './entity/Deployment';
import { ProjectMember } from './entity/ProjectMember'; import { ProjectMember } from './entity/ProjectMember';
import { EnvironmentVariable } from './entity/EnvironmentVariable'; import { EnvironmentVariable } from './entity/EnvironmentVariable';
@ -42,7 +42,7 @@ export class Database {
database: dbPath, database: dbPath,
entities: [path.join(__dirname, '/entity/*')], entities: [path.join(__dirname, '/entity/*')],
synchronize: true, synchronize: true,
logging: false logging: false,
}); });
} }
@ -54,21 +54,24 @@ export class Database {
// Load an organization if none exist // Load an organization if none exist
if (!organizations.length) { if (!organizations.length) {
const orgEntities = await getEntities(path.resolve(__dirname, ORGANIZATION_DATA_PATH)); const orgEntities = await getEntities(
organizations = await loadAndSaveData(Organization, this.dataSource, [orgEntities[0]]); path.resolve(__dirname, ORGANIZATION_DATA_PATH),
);
organizations = await loadAndSaveData(Organization, this.dataSource, [
orgEntities[0],
]);
} }
// Hotfix for updating old DB data // Hotfix for updating old DB data
if (organizations[0].slug === 'snowball-tools-1') { 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( await this.updateOrganization(organizations[0].id, {
organizations[0].id, slug: orgEntity.slug as string,
{ name: orgEntity.name as string,
slug: orgEntity.slug as string, });
name: orgEntity.name as string
}
)
} }
} }
@ -95,7 +98,7 @@ export class Database {
} }
async getOrganizations( async getOrganizations(
options: FindManyOptions<Organization> options: FindManyOptions<Organization>,
): Promise<Organization[]> { ): Promise<Organization[]> {
const organizationRepository = this.dataSource.getRepository(Organization); const organizationRepository = this.dataSource.getRepository(Organization);
const organizations = await organizationRepository.find(options); const organizations = await organizationRepository.find(options);
@ -104,7 +107,7 @@ export class Database {
} }
async getOrganization( async getOrganization(
options: FindOneOptions<Organization> options: FindOneOptions<Organization>,
): Promise<Organization | null> { ): Promise<Organization | null> {
const organizationRepository = this.dataSource.getRepository(Organization); const organizationRepository = this.dataSource.getRepository(Organization);
const organization = await organizationRepository.findOne(options); const organization = await organizationRepository.findOne(options);
@ -119,25 +122,34 @@ export class Database {
where: { where: {
userOrganizations: { userOrganizations: {
member: { member: {
id: userId id: userId,
} },
} },
} },
}); });
return userOrgs; return userOrgs;
} }
async addUserOrganization(data: DeepPartial<UserOrganization>): Promise<UserOrganization> { async addUserOrganization(
const userOrganizationRepository = this.dataSource.getRepository(UserOrganization); data: DeepPartial<UserOrganization>,
): Promise<UserOrganization> {
const userOrganizationRepository =
this.dataSource.getRepository(UserOrganization);
const newUserOrganization = await userOrganizationRepository.save(data); const newUserOrganization = await userOrganizationRepository.save(data);
return newUserOrganization; 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 organizationRepository = this.dataSource.getRepository(Organization);
const updateResult = await organizationRepository.update({ id: organizationId }, data); const updateResult = await organizationRepository.update(
{ id: organizationId },
data,
);
assert(updateResult.affected); assert(updateResult.affected);
return updateResult.affected > 0; return updateResult.affected > 0;
@ -158,7 +170,7 @@ export class Database {
.leftJoinAndSelect( .leftJoinAndSelect(
'project.deployments', 'project.deployments',
'deployments', 'deployments',
'deployments.isCurrent = true AND deployments.isCanonical = true' 'deployments.isCurrent = true AND deployments.isCanonical = true',
) )
.leftJoinAndSelect('deployments.createdBy', 'user') .leftJoinAndSelect('deployments.createdBy', 'user')
.leftJoinAndSelect('deployments.deployer', 'deployer') .leftJoinAndSelect('deployments.deployer', 'deployer')
@ -166,7 +178,7 @@ export class Database {
.leftJoinAndSelect('project.deployers', 'deployers') .leftJoinAndSelect('project.deployers', 'deployers')
.leftJoinAndSelect('project.organization', 'organization') .leftJoinAndSelect('project.organization', 'organization')
.where('project.id = :projectId', { .where('project.id = :projectId', {
projectId projectId,
}) })
.getOne(); .getOne();
@ -174,26 +186,28 @@ export class Database {
} }
async allProjectsWithoutDeployments(): Promise<Project[]> { async allProjectsWithoutDeployments(): Promise<Project[]> {
// Fetch all projects with auction not completed and wihout any deployments
const allProjects = await this.getProjects({ const allProjects = await this.getProjects({
where: { where: {
auctionId: Not(IsNull()), auctionId: Not(IsNull()),
auctionStatus: Not(AuctionStatus.Completed),
}, },
relations: ['deployments'], relations: ['deployments'],
withDeleted: true, withDeleted: true,
}); });
const projects = allProjects.filter(project => { const activeProjectsWithoutDeployments = allProjects.filter((project) => {
if (project.deletedAt !== null) return false; if (project.deletedAt !== null) return false;
return project.deployments.length === 0; return project.deployments.length === 0;
}); });
return projects; return activeProjectsWithoutDeployments;
} }
async getProjectsInOrganization( async getProjectsInOrganization(
userId: string, userId: string,
organizationSlug: string organizationSlug: string,
): Promise<Project[]> { ): Promise<Project[]> {
const projectRepository = this.dataSource.getRepository(Project); const projectRepository = this.dataSource.getRepository(Project);
@ -202,7 +216,7 @@ export class Database {
.leftJoinAndSelect( .leftJoinAndSelect(
'project.deployments', 'project.deployments',
'deployments', 'deployments',
'deployments.isCurrent = true AND deployments.isCanonical = true' 'deployments.isCurrent = true AND deployments.isCanonical = true',
) )
.leftJoin('project.projectMembers', 'projectMembers') .leftJoin('project.projectMembers', 'projectMembers')
.leftJoin('project.organization', 'organization') .leftJoin('project.organization', 'organization')
@ -210,8 +224,8 @@ export class Database {
'(project.ownerId = :userId OR projectMembers.userId = :userId) AND organization.slug = :organizationSlug', '(project.ownerId = :userId OR projectMembers.userId = :userId) AND organization.slug = :organizationSlug',
{ {
userId, userId,
organizationSlug organizationSlug,
} },
) )
.getMany(); .getMany();
@ -222,7 +236,7 @@ export class Database {
* Get deployments with specified filter * Get deployments with specified filter
*/ */
async getDeployments( async getDeployments(
options: FindManyOptions<Deployment> options: FindManyOptions<Deployment>,
): Promise<Deployment[]> { ): Promise<Deployment[]> {
const deploymentRepository = this.dataSource.getRepository(Deployment); const deploymentRepository = this.dataSource.getRepository(Deployment);
const deployments = await deploymentRepository.find(options); const deployments = await deploymentRepository.find(options);
@ -239,16 +253,18 @@ export class Database {
}, },
where: { where: {
project: { project: {
id: projectId id: projectId,
} },
}, },
order: { order: {
createdAt: 'DESC' createdAt: 'DESC',
} },
}); });
} }
async getNonCanonicalDeploymentsByProjectId(projectId: string): Promise<Deployment[]> { async getNonCanonicalDeploymentsByProjectId(
projectId: string,
): Promise<Deployment[]> {
return this.getDeployments({ return this.getDeployments({
relations: { relations: {
project: true, project: true,
@ -257,18 +273,18 @@ export class Database {
}, },
where: { where: {
project: { project: {
id: projectId id: projectId,
}, },
isCanonical: false isCanonical: false,
}, },
order: { order: {
createdAt: 'DESC' createdAt: 'DESC',
} },
}); });
} }
async getDeployment( async getDeployment(
options: FindOneOptions<Deployment> options: FindOneOptions<Deployment>,
): Promise<Deployment | null> { ): Promise<Deployment | null> {
const deploymentRepository = this.dataSource.getRepository(Deployment); const deploymentRepository = this.dataSource.getRepository(Deployment);
const deployment = await deploymentRepository.findOne(options); const deployment = await deploymentRepository.findOne(options);
@ -290,7 +306,7 @@ export class Database {
const updatedData = { const updatedData = {
...data, ...data,
id id,
}; };
const deployment = await deploymentRepository.save(updatedData); const deployment = await deploymentRepository.save(updatedData);
@ -298,7 +314,7 @@ export class Database {
} }
async getProjectMembersByProjectId( async getProjectMembersByProjectId(
projectId: string projectId: string,
): Promise<ProjectMember[]> { ): Promise<ProjectMember[]> {
const projectMemberRepository = const projectMemberRepository =
this.dataSource.getRepository(ProjectMember); this.dataSource.getRepository(ProjectMember);
@ -306,13 +322,13 @@ export class Database {
const projectMembers = await projectMemberRepository.find({ const projectMembers = await projectMemberRepository.find({
relations: { relations: {
project: true, project: true,
member: true member: true,
}, },
where: { where: {
project: { project: {
id: projectId id: projectId,
} },
} },
}); });
return projectMembers; return projectMembers;
@ -320,7 +336,7 @@ export class Database {
async getEnvironmentVariablesByProjectId( async getEnvironmentVariablesByProjectId(
projectId: string, projectId: string,
filter?: FindOptionsWhere<EnvironmentVariable> filter?: FindOptionsWhere<EnvironmentVariable>,
): Promise<EnvironmentVariable[]> { ): Promise<EnvironmentVariable[]> {
const environmentVariableRepository = const environmentVariableRepository =
this.dataSource.getRepository(EnvironmentVariable); this.dataSource.getRepository(EnvironmentVariable);
@ -328,10 +344,10 @@ export class Database {
const environmentVariables = await environmentVariableRepository.find({ const environmentVariables = await environmentVariableRepository.find({
where: { where: {
project: { project: {
id: projectId id: projectId,
}, },
...filter ...filter,
} },
}); });
return environmentVariables; return environmentVariables;
@ -342,7 +358,7 @@ export class Database {
this.dataSource.getRepository(ProjectMember); this.dataSource.getRepository(ProjectMember);
const deleteResult = await projectMemberRepository.delete({ const deleteResult = await projectMemberRepository.delete({
id: projectMemberId id: projectMemberId,
}); });
if (deleteResult.affected) { if (deleteResult.affected) {
@ -354,20 +370,20 @@ export class Database {
async updateProjectMemberById( async updateProjectMemberById(
projectMemberId: string, projectMemberId: string,
data: DeepPartial<ProjectMember> data: DeepPartial<ProjectMember>,
): Promise<boolean> { ): Promise<boolean> {
const projectMemberRepository = const projectMemberRepository =
this.dataSource.getRepository(ProjectMember); this.dataSource.getRepository(ProjectMember);
const updateResult = await projectMemberRepository.update( const updateResult = await projectMemberRepository.update(
{ id: projectMemberId }, { id: projectMemberId },
data data,
); );
return Boolean(updateResult.affected); return Boolean(updateResult.affected);
} }
async addProjectMember( async addProjectMember(
data: DeepPartial<ProjectMember> data: DeepPartial<ProjectMember>,
): Promise<ProjectMember> { ): Promise<ProjectMember> {
const projectMemberRepository = const projectMemberRepository =
this.dataSource.getRepository(ProjectMember); this.dataSource.getRepository(ProjectMember);
@ -377,7 +393,7 @@ export class Database {
} }
async addEnvironmentVariables( async addEnvironmentVariables(
data: DeepPartial<EnvironmentVariable>[] data: DeepPartial<EnvironmentVariable>[],
): Promise<EnvironmentVariable[]> { ): Promise<EnvironmentVariable[]> {
const environmentVariableRepository = const environmentVariableRepository =
this.dataSource.getRepository(EnvironmentVariable); this.dataSource.getRepository(EnvironmentVariable);
@ -389,25 +405,25 @@ export class Database {
async updateEnvironmentVariable( async updateEnvironmentVariable(
environmentVariableId: string, environmentVariableId: string,
data: DeepPartial<EnvironmentVariable> data: DeepPartial<EnvironmentVariable>,
): Promise<boolean> { ): Promise<boolean> {
const environmentVariableRepository = const environmentVariableRepository =
this.dataSource.getRepository(EnvironmentVariable); this.dataSource.getRepository(EnvironmentVariable);
const updateResult = await environmentVariableRepository.update( const updateResult = await environmentVariableRepository.update(
{ id: environmentVariableId }, { id: environmentVariableId },
data data,
); );
return Boolean(updateResult.affected); return Boolean(updateResult.affected);
} }
async deleteEnvironmentVariable( async deleteEnvironmentVariable(
environmentVariableId: string environmentVariableId: string,
): Promise<boolean> { ): Promise<boolean> {
const environmentVariableRepository = const environmentVariableRepository =
this.dataSource.getRepository(EnvironmentVariable); this.dataSource.getRepository(EnvironmentVariable);
const deleteResult = await environmentVariableRepository.delete({ const deleteResult = await environmentVariableRepository.delete({
id: environmentVariableId id: environmentVariableId,
}); });
if (deleteResult.affected) { if (deleteResult.affected) {
@ -424,13 +440,13 @@ export class Database {
const projectMemberWithProject = await projectMemberRepository.find({ const projectMemberWithProject = await projectMemberRepository.find({
relations: { relations: {
project: { project: {
owner: true owner: true,
}, },
member: true member: true,
}, },
where: { where: {
id: projectMemberId id: projectMemberId,
} },
}); });
if (projectMemberWithProject.length === 0) { if (projectMemberWithProject.length === 0) {
@ -442,7 +458,7 @@ export class Database {
async getProjectsBySearchText( async getProjectsBySearchText(
userId: string, userId: string,
searchText: string searchText: string,
): Promise<Project[]> { ): Promise<Project[]> {
const projectRepository = this.dataSource.getRepository(Project); const projectRepository = this.dataSource.getRepository(Project);
@ -454,8 +470,8 @@ export class Database {
'(project.owner = :userId OR projectMembers.member.id = :userId) AND project.name LIKE :searchText', '(project.owner = :userId OR projectMembers.member.id = :userId) AND project.name LIKE :searchText',
{ {
userId, userId,
searchText: `%${searchText}%` searchText: `%${searchText}%`,
} },
) )
.getMany(); .getMany();
@ -464,14 +480,14 @@ export class Database {
async updateDeploymentById( async updateDeploymentById(
deploymentId: string, deploymentId: string,
data: DeepPartial<Deployment> data: DeepPartial<Deployment>,
): Promise<boolean> { ): Promise<boolean> {
return this.updateDeployment({ id: deploymentId }, data); return this.updateDeployment({ id: deploymentId }, data);
} }
async updateDeployment( async updateDeployment(
criteria: FindOptionsWhere<Deployment>, criteria: FindOptionsWhere<Deployment>,
data: DeepPartial<Deployment> data: DeepPartial<Deployment>,
): Promise<boolean> { ): Promise<boolean> {
const deploymentRepository = this.dataSource.getRepository(Deployment); const deploymentRepository = this.dataSource.getRepository(Deployment);
const updateResult = await deploymentRepository.update(criteria, data); const updateResult = await deploymentRepository.update(criteria, data);
@ -481,7 +497,7 @@ export class Database {
async updateDeploymentsByProjectIds( async updateDeploymentsByProjectIds(
projectIds: string[], projectIds: string[],
data: DeepPartial<Deployment> data: DeepPartial<Deployment>,
): Promise<boolean> { ): Promise<boolean> {
const deploymentRepository = this.dataSource.getRepository(Deployment); const deploymentRepository = this.dataSource.getRepository(Deployment);
@ -499,8 +515,8 @@ export class Database {
const deploymentRepository = this.dataSource.getRepository(Deployment); const deploymentRepository = this.dataSource.getRepository(Deployment);
const deployment = await deploymentRepository.findOneOrFail({ const deployment = await deploymentRepository.findOneOrFail({
where: { where: {
id: deploymentId id: deploymentId,
} },
}); });
const deleteResult = await deploymentRepository.softRemove(deployment); const deleteResult = await deploymentRepository.softRemove(deployment);
@ -508,7 +524,11 @@ export class Database {
return Boolean(deleteResult); 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); const projectRepository = this.dataSource.getRepository(Project);
// TODO: Check if organization exists // TODO: Check if organization exists
@ -521,7 +541,7 @@ export class Database {
newProject.owner = user; newProject.owner = user;
newProject.organization = Object.assign(new Organization(), { newProject.organization = Object.assign(new Organization(), {
id: organizationId id: organizationId,
}); });
return projectRepository.save(newProject); return projectRepository.save(newProject);
@ -535,12 +555,12 @@ export class Database {
async updateProjectById( async updateProjectById(
projectId: string, projectId: string,
data: DeepPartial<Project> data: DeepPartial<Project>,
): Promise<boolean> { ): Promise<boolean> {
const projectRepository = this.dataSource.getRepository(Project); const projectRepository = this.dataSource.getRepository(Project);
const updateResult = await projectRepository.update( const updateResult = await projectRepository.update(
{ id: projectId }, { id: projectId },
data data,
); );
return Boolean(updateResult.affected); return Boolean(updateResult.affected);
@ -550,11 +570,11 @@ export class Database {
const projectRepository = this.dataSource.getRepository(Project); const projectRepository = this.dataSource.getRepository(Project);
const project = await projectRepository.findOneOrFail({ const project = await projectRepository.findOneOrFail({
where: { where: {
id: projectId id: projectId,
}, },
relations: { relations: {
projectMembers: true projectMembers: true,
} },
}); });
const deleteResult = await projectRepository.softRemove(project); const deleteResult = await projectRepository.softRemove(project);
@ -590,7 +610,7 @@ export class Database {
async updateDomainById( async updateDomainById(
domainId: string, domainId: string,
data: DeepPartial<Domain> data: DeepPartial<Domain>,
): Promise<boolean> { ): Promise<boolean> {
const domainRepository = this.dataSource.getRepository(Domain); const domainRepository = this.dataSource.getRepository(Domain);
const updateResult = await domainRepository.update({ id: domainId }, data); const updateResult = await domainRepository.update({ id: domainId }, data);
@ -600,39 +620,37 @@ export class Database {
async getDomainsByProjectId( async getDomainsByProjectId(
projectId: string, projectId: string,
filter?: FindOptionsWhere<Domain> filter?: FindOptionsWhere<Domain>,
): Promise<Domain[]> { ): Promise<Domain[]> {
const domainRepository = this.dataSource.getRepository(Domain); const domainRepository = this.dataSource.getRepository(Domain);
const domains = await domainRepository.find({ const domains = await domainRepository.find({
relations: { relations: {
redirectTo: true redirectTo: true,
}, },
where: { where: {
project: { project: {
id: projectId id: projectId,
}, },
...filter ...filter,
} },
}); });
return domains; return domains;
} }
async getOldestDomainByProjectId( async getOldestDomainByProjectId(projectId: string): Promise<Domain | null> {
projectId: string,
): Promise<Domain | null> {
const domainRepository = this.dataSource.getRepository(Domain); const domainRepository = this.dataSource.getRepository(Domain);
const domain = await domainRepository.findOne({ const domain = await domainRepository.findOne({
where: { where: {
project: { project: {
id: projectId id: projectId,
}, },
}, },
order: { order: {
createdAt: 'ASC' createdAt: 'ASC',
} },
}); });
return domain; return domain;
@ -651,8 +669,8 @@ export class Database {
status: DeploymentStatus.Ready, status: DeploymentStatus.Ready,
}, },
order: { order: {
createdAt: 'DESC' createdAt: 'DESC',
} },
}); });
if (deployment === null) { if (deployment === null) {
@ -677,7 +695,9 @@ export class Database {
async getDeployerByLRN(deployerLrn: string): Promise<Deployer | null> { async getDeployerByLRN(deployerLrn: string): Promise<Deployer | null> {
const deployerRepository = this.dataSource.getRepository(Deployer); const deployerRepository = this.dataSource.getRepository(Deployer);
const deployer = await deployerRepository.findOne({ where: { deployerLrn } }); const deployer = await deployerRepository.findOne({
where: { deployerLrn },
});
return deployer; return deployer;
} }

25
packages/backend/src/entity/Project.ts
View File

@ -9,7 +9,7 @@ import {
OneToMany, OneToMany,
DeleteDateColumn, DeleteDateColumn,
JoinTable, JoinTable,
ManyToMany ManyToMany,
} from 'typeorm'; } from 'typeorm';
import { User } from './User'; import { User } from './User';
@ -18,6 +18,12 @@ import { ProjectMember } from './ProjectMember';
import { Deployment } from './Deployment'; import { Deployment } from './Deployment';
import { Deployer } from './Deployer'; import { Deployer } from './Deployer';
export enum AuctionStatus {
Commit = 'commit',
Reveal = 'reveal',
Completed = 'completed',
}
@Entity() @Entity()
export class Project { export class Project {
@PrimaryGeneratedColumn('uuid') @PrimaryGeneratedColumn('uuid')
@ -49,16 +55,23 @@ export class Project {
@Column('text', { default: '' }) @Column('text', { default: '' })
description!: string; description!: string;
@Column('varchar', { nullable: true })
auctionId!: string | null;
// Tx hash for sending coins from snowball to deployer // Tx hash for sending coins from snowball to deployer
@Column('varchar', { nullable: true }) @Column('varchar', { nullable: true })
txHash!: string | null; txHash!: string | null;
@ManyToMany(() => Deployer, (deployer) => (deployer.projects)) @ManyToMany(() => Deployer, (deployer) => deployer.projects)
@JoinTable() @JoinTable()
deployers!: Deployer[] 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;
@Column('boolean', { default: false, nullable: true }) @Column('boolean', { default: false, nullable: true })
fundsReleased!: boolean; fundsReleased!: boolean;

253
packages/backend/src/registry.ts
View File

@ -6,7 +6,13 @@ import { inc as semverInc } from 'semver';
import { DeepPartial } from 'typeorm'; import { DeepPartial } from 'typeorm';
import * as openpgp from 'openpgp'; 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 { DeliverTxResponse, IndexedTx } from '@cosmjs/stargate';
import { RegistryConfig } from './config'; import { RegistryConfig } from './config';
@ -14,17 +20,30 @@ import {
ApplicationRecord, ApplicationRecord,
Deployment, Deployment,
ApplicationDeploymentRequest, ApplicationDeploymentRequest,
ApplicationDeploymentRemovalRequest ApplicationDeploymentRemovalRequest,
} from './entity/Deployment'; } from './entity/Deployment';
import { AppDeploymentRecord, AppDeploymentRemovalRecord, AuctionParams, DeployerRecord, RegistryRecord } from './types'; import {
import { getConfig, getRepoDetails, registryTransactionWithRetry, sleep } from './utils'; 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';
const log = debug('snowball:registry'); const log = debug('snowball:registry');
const APP_RECORD_TYPE = 'ApplicationRecord'; const APP_RECORD_TYPE = 'ApplicationRecord';
const APP_DEPLOYMENT_AUCTION_RECORD_TYPE = 'ApplicationDeploymentAuction'; const APP_DEPLOYMENT_AUCTION_RECORD_TYPE = 'ApplicationDeploymentAuction';
const APP_DEPLOYMENT_REQUEST_TYPE = 'ApplicationDeploymentRequest'; 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_RECORD_TYPE = 'ApplicationDeploymentRecord';
const APP_DEPLOYMENT_REMOVAL_RECORD_TYPE = 'ApplicationDeploymentRemovalRecord'; const APP_DEPLOYMENT_REMOVAL_RECORD_TYPE = 'ApplicationDeploymentRemovalRecord';
const WEBAPP_DEPLOYER_RECORD_TYPE = 'WebappDeployer'; const WEBAPP_DEPLOYER_RECORD_TYPE = 'WebappDeployer';
@ -43,7 +62,7 @@ export class Registry {
this.registry = new LaconicRegistry( this.registry = new LaconicRegistry(
registryConfig.gqlEndpoint, registryConfig.gqlEndpoint,
registryConfig.restEndpoint, registryConfig.restEndpoint,
{ chainId: registryConfig.chainId, gasPrice } { chainId: registryConfig.chainId, gasPrice },
); );
} }
@ -53,7 +72,7 @@ export class Registry {
commitHash, commitHash,
appType, appType,
}: { }: {
octokit: Octokit octokit: Octokit;
repository: string; repository: string;
commitHash: string; commitHash: string;
appType: string; appType: string;
@ -61,29 +80,33 @@ export class Registry {
applicationRecordId: string; applicationRecordId: string;
applicationRecordData: ApplicationRecord; 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 // 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 // Reference: https://git.vdb.to/cerc-io/test-progressive-web-app/src/branch/main/scripts/publish-app-record.sh
// Fetch previous records // Fetch previous records
const records = await this.registry.queryRecords( const records = await this.registry.queryRecords(
{ {
type: APP_RECORD_TYPE, type: APP_RECORD_TYPE,
name: packageJSON.name name: packageJSON.name,
}, },
true true,
); );
// Get next version of record // Get next version of record
const bondRecords = records.filter( const bondRecords = records.filter(
(record: any) => record.bondId === this.registryConfig.bondId (record: any) => record.bondId === this.registryConfig.bondId,
); );
const [latestBondRecord] = bondRecords.sort( const [latestBondRecord] = bondRecords.sort(
(a: any, b: any) => (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( const nextVersion = semverInc(
latestBondRecord?.attributes.version ?? '0.0.0', latestBondRecord?.attributes.version ?? '0.0.0',
'patch' 'patch',
); );
assert(nextVersion, 'Application record version not valid'); assert(nextVersion, 'Application record version not valid');
@ -103,9 +126,9 @@ export class Registry {
author: author:
typeof packageJSON.author === 'object' typeof packageJSON.author === 'object'
? JSON.stringify(packageJSON.author) ? 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); const result = await this.publishRecord(applicationRecord);
@ -117,18 +140,9 @@ export class Registry {
const lrn = this.getLrn(repo); const lrn = this.getLrn(repo);
log(`Setting name: ${lrn} for record ID: ${result.id}`); 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,
await sleep(SLEEP_DURATION); this.registryConfig.fee.fees,
await registryTransactionWithRetry(() =>
this.registry.setName(
{
cid: result.id,
lrn
},
this.registryConfig.privateKey,
fee
)
); );
await sleep(SLEEP_DURATION); await sleep(SLEEP_DURATION);
@ -136,11 +150,11 @@ export class Registry {
this.registry.setName( this.registry.setName(
{ {
cid: result.id, cid: result.id,
lrn: `${lrn}@${applicationRecord.app_version}` lrn,
}, },
this.registryConfig.privateKey, this.registryConfig.privateKey,
fee fee,
) ),
); );
await sleep(SLEEP_DURATION); await sleep(SLEEP_DURATION);
@ -148,16 +162,28 @@ export class Registry {
this.registry.setName( this.registry.setName(
{ {
cid: result.id, cid: result.id,
lrn: `${lrn}@${applicationRecord.repository_ref}` lrn: `${lrn}@${applicationRecord.app_version}`,
}, },
this.registryConfig.privateKey, this.registryConfig.privateKey,
fee fee,
) ),
);
await sleep(SLEEP_DURATION);
await registryTransactionWithRetry(() =>
this.registry.setName(
{
cid: result.id,
lrn: `${lrn}@${applicationRecord.repository_ref}`,
},
this.registryConfig.privateKey,
fee,
),
); );
return { return {
applicationRecordId: result.id, applicationRecordId: result.id,
applicationRecordData: applicationRecord applicationRecordData: applicationRecord,
}; };
} }
@ -167,7 +193,7 @@ export class Registry {
auctionParams: AuctionParams, auctionParams: AuctionParams,
data: DeepPartial<Deployment>, data: DeepPartial<Deployment>,
): Promise<{ ): Promise<{
applicationDeploymentAuctionId: string; applicationDeploymentAuction: MsgCreateAuctionResponse['auction'];
}> { }> {
assert(data.project?.repository, 'Project repository not found'); assert(data.project?.repository, 'Project repository not found');
@ -182,8 +208,11 @@ export class Registry {
const config = await getConfig(); const config = await getConfig();
const auctionConfig = config.auction; const auctionConfig = config.auction;
const fee = parseGasAndFees(this.registryConfig.fee.gas, this.registryConfig.fee.fees); const fee = parseGasAndFees(
const auctionResult = await registryTransactionWithRetry(() => this.registryConfig.fee.gas,
this.registryConfig.fee.fees,
);
const auctionResult = (await registryTransactionWithRetry(() =>
this.registry.createProviderAuction( this.registry.createProviderAuction(
{ {
commitFee: auctionConfig.commitFee, commitFee: auctionConfig.commitFee,
@ -195,9 +224,9 @@ export class Registry {
numProviders: auctionParams.numProviders, numProviders: auctionParams.numProviders,
}, },
this.registryConfig.privateKey, this.registryConfig.privateKey,
fee fee,
) ),
); )) as MsgCreateAuctionResponse;
if (!auctionResult.auction) { if (!auctionResult.auction) {
throw new Error('Error creating auction'); throw new Error('Error creating auction');
@ -217,22 +246,22 @@ export class Registry {
log('Application deployment auction data:', applicationDeploymentAuction); log('Application deployment auction data:', applicationDeploymentAuction);
return { return {
applicationDeploymentAuctionId: auctionResult.auction.id, applicationDeploymentAuction: auctionResult.auction!,
}; };
} }
async createApplicationDeploymentRequest(data: { async createApplicationDeploymentRequest(data: {
deployment: Deployment, deployment: Deployment;
appName: string, appName: string;
repository: string, repository: string;
auctionId?: string | null, auctionId?: string | null;
lrn: string, lrn: string;
apiUrl: string, apiUrl: string;
environmentVariables: { [key: string]: string }, environmentVariables: { [key: string]: string };
dns: string, dns: string;
requesterAddress: string, requesterAddress: string;
publicKey: string, publicKey: string;
payment?: string | null payment?: string | null;
}): Promise<{ }): Promise<{
applicationDeploymentRequestId: string; applicationDeploymentRequestId: string;
applicationDeploymentRequestData: ApplicationDeploymentRequest; applicationDeploymentRequestData: ApplicationDeploymentRequest;
@ -267,10 +296,10 @@ export class Registry {
config: JSON.stringify(hash ? { ref: hash } : {}), config: JSON.stringify(hash ? { ref: hash } : {}),
meta: JSON.stringify({ meta: JSON.stringify({
note: `Added by Snowball @ ${DateTime.utc().toFormat( 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: data.repository,
repository_ref: data.deployment.commitHash repository_ref: data.deployment.commitHash,
}), }),
deployer: data.lrn, deployer: data.lrn,
...(data.auctionId && { auction: data.auctionId }), ...(data.auctionId && { auction: data.auctionId }),
@ -286,12 +315,12 @@ export class Registry {
return { return {
applicationDeploymentRequestId: result.id, applicationDeploymentRequestId: result.id,
applicationDeploymentRequestData: applicationDeploymentRequest applicationDeploymentRequestData: applicationDeploymentRequest,
}; };
} }
async getAuctionWinningDeployerRecords( async getAuctionWinningDeployerRecords(
auctionId: string auctionId: string,
): Promise<DeployerRecord[]> { ): Promise<DeployerRecord[]> {
const records = await this.registry.getAuctionsByIds([auctionId]); const records = await this.registry.getAuctionsByIds([auctionId]);
const auctionResult = records[0]; const auctionResult = records[0];
@ -304,7 +333,7 @@ export class Registry {
paymentAddress: auctionWinner, paymentAddress: auctionWinner,
}); });
const newRecords = records.filter(record => { const newRecords = records.filter((record) => {
return record.names !== null && record.names.length > 0; return record.names !== null && record.names.length > 0;
}); });
@ -319,18 +348,19 @@ export class Registry {
return deployerRecords; return deployerRecords;
} }
async releaseDeployerFunds( async releaseDeployerFunds(auctionId: string): Promise<any> {
auctionId: string const fee = parseGasAndFees(
): Promise<any> { this.registryConfig.fee.gas,
const fee = parseGasAndFees(this.registryConfig.fee.gas, this.registryConfig.fee.fees); this.registryConfig.fee.fees,
);
const auction = await registryTransactionWithRetry(() => const auction = await registryTransactionWithRetry(() =>
this.registry.releaseFunds( this.registry.releaseFunds(
{ {
auctionId auctionId,
}, },
this.registryConfig.privateKey, this.registryConfig.privateKey,
fee fee,
) ),
); );
return auction; return auction;
@ -340,49 +370,54 @@ export class Registry {
* Fetch ApplicationDeploymentRecords for deployments * Fetch ApplicationDeploymentRecords for deployments
*/ */
async getDeploymentRecords( async getDeploymentRecords(
deployments: Deployment[] deployments: Deployment[],
): Promise<AppDeploymentRecord[]> { ): Promise<AppDeploymentRecord[]> {
// Fetch ApplicationDeploymentRecords for corresponding ApplicationRecord set in deployments // Fetch ApplicationDeploymentRecords for corresponding ApplicationRecord set in deployments
// TODO: Implement Laconicd GQL query to filter records by multiple values for an attribute // TODO: Implement Laconicd GQL query to filter records by multiple values for an attribute
const records = await this.registry.queryRecords( const records = await this.registry.queryRecords(
{ {
type: APP_DEPLOYMENT_RECORD_TYPE type: APP_DEPLOYMENT_RECORD_TYPE,
}, },
true true,
); );
// Filter records with ApplicationDeploymentRequestId ID // Filter records with ApplicationDeploymentRequestId ID
return records.filter((record: AppDeploymentRecord) => return records.filter((record: AppDeploymentRecord) =>
deployments.some( deployments.some(
(deployment) => (deployment) =>
deployment.applicationDeploymentRequestId === record.attributes.request deployment.applicationDeploymentRequestId ===
) record.attributes.request,
),
); );
} }
/** /**
* Fetch WebappDeployer Records by filter * 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( return this.registry.queryRecords(
{ {
type: WEBAPP_DEPLOYER_RECORD_TYPE, type: WEBAPP_DEPLOYER_RECORD_TYPE,
...filter ...filter,
}, },
true true,
); );
} }
/** /**
* Fetch ApplicationDeploymentRecords by filter * Fetch ApplicationDeploymentRecords by filter
*/ */
async getDeploymentRecordsByFilter(filter: { [key: string]: any }): Promise<AppDeploymentRecord[]> { async getDeploymentRecordsByFilter(filter: {
[key: string]: any;
}): Promise<AppDeploymentRecord[]> {
return this.registry.queryRecords( return this.registry.queryRecords(
{ {
type: APP_DEPLOYMENT_RECORD_TYPE, type: APP_DEPLOYMENT_RECORD_TYPE,
...filter ...filter,
}, },
true true,
); );
} }
@ -390,29 +425,31 @@ export class Registry {
* Fetch ApplicationDeploymentRemovalRecords for deployments * Fetch ApplicationDeploymentRemovalRecords for deployments
*/ */
async getDeploymentRemovalRecords( async getDeploymentRemovalRecords(
deployments: Deployment[] deployments: Deployment[],
): Promise<AppDeploymentRemovalRecord[]> { ): Promise<AppDeploymentRemovalRecord[]> {
// Fetch ApplicationDeploymentRemovalRecords for corresponding ApplicationDeploymentRecord set in deployments // Fetch ApplicationDeploymentRemovalRecords for corresponding ApplicationDeploymentRecord set in deployments
const records = await this.registry.queryRecords( 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 // Filter records with ApplicationDeploymentRecord and ApplicationDeploymentRemovalRequest IDs
return records.filter((record: AppDeploymentRemovalRecord) => return records.filter((record: AppDeploymentRemovalRecord) =>
deployments.some( deployments.some(
(deployment) => (deployment) =>
deployment.applicationDeploymentRemovalRequestId === record.attributes.request && deployment.applicationDeploymentRemovalRequestId ===
deployment.applicationDeploymentRecordId === record.attributes.deployment record.attributes.request &&
) deployment.applicationDeploymentRecordId ===
record.attributes.deployment,
),
); );
} }
/** /**
* Fetch record by Id * Fetch record by Id
*/ */
async getRecordById(id: string): Promise<RegistryRecord | null> { async getRecordById(id: string): Promise<RegistryRecord | null> {
const [record] = await this.registry.getRecordsByIds([id]); const [record] = await this.registry.getRecordsByIds([id]);
return record ?? null; return record ?? null;
@ -440,12 +477,18 @@ export class Registry {
applicationDeploymentRemovalRequest, applicationDeploymentRemovalRequest,
); );
log(`Application deployment removal request record published: ${result.id}`); log(
log('Application deployment removal request data:', applicationDeploymentRemovalRequest); `Application deployment removal request record published: ${result.id}`,
);
log(
'Application deployment removal request data:',
applicationDeploymentRemovalRequest,
);
return { return {
applicationDeploymentRemovalRequestId: result.id, applicationDeploymentRemovalRequestId: result.id,
applicationDeploymentRemovalRequestData: applicationDeploymentRemovalRequest applicationDeploymentRemovalRequestData:
applicationDeploymentRemovalRequest,
}; };
} }
@ -457,8 +500,11 @@ export class Registry {
const auctions = await this.registry.getAuctionsByIds(auctionIds); const auctions = await this.registry.getAuctionsByIds(auctionIds);
const completedAuctions = auctions const completedAuctions = auctions
.filter((auction: { id: string, status: string }) => auction.status === 'completed') .filter(
.map((auction: { id: string, status: string }) => auction.id); (auction: { id: string; status: string }) =>
auction.status === 'completed',
)
.map((auction: { id: string; status: string }) => auction.id);
return completedAuctions; return completedAuctions;
} }
@ -492,27 +538,38 @@ export class Registry {
return this.registry.getAuctionsByIds([auctionId]); return this.registry.getAuctionsByIds([auctionId]);
} }
async sendTokensToAccount(receiverAddress: string, amount: string): Promise<DeliverTxResponse> { async sendTokensToAccount(
const fee = parseGasAndFees(this.registryConfig.fee.gas, this.registryConfig.fee.fees); receiverAddress: string,
amount: string,
): Promise<DeliverTxResponse> {
const fee = parseGasAndFees(
this.registryConfig.fee.gas,
this.registryConfig.fee.fees,
);
const account = await this.getAccount(); const account = await this.getAccount();
const laconicClient = await this.registry.getLaconicClient(account); const laconicClient = await this.registry.getLaconicClient(account);
const txResponse: DeliverTxResponse = const txResponse: DeliverTxResponse = await registryTransactionWithRetry(
await registryTransactionWithRetry(() => () =>
laconicClient.sendTokens(account.address, receiverAddress, laconicClient.sendTokens(
account.address,
receiverAddress,
[ [
{ {
denom: 'alnt', denom: 'alnt',
amount amount,
} },
], ],
fee || DEFAULT_GAS_ESTIMATION_MULTIPLIER) fee || DEFAULT_GAS_ESTIMATION_MULTIPLIER,
); ),
);
return txResponse; return txResponse;
} }
async getAccount(): Promise<Account> { 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(); await account.init();
return account; return account;

462
packages/backend/src/service.ts
View File

@ -7,11 +7,16 @@ import { DateTime } from 'luxon';
import { OAuthApp } from '@octokit/oauth-app'; import { OAuthApp } from '@octokit/oauth-app';
import { Database } from './database'; 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 { Domain } from './entity/Domain';
import { EnvironmentVariable } from './entity/EnvironmentVariable'; import { EnvironmentVariable } from './entity/EnvironmentVariable';
import { Organization } from './entity/Organization'; import { Organization } from './entity/Organization';
import { Project } from './entity/Project'; import { AuctionStatus, Project } from './entity/Project';
import { Permission, ProjectMember } from './entity/ProjectMember'; import { Permission, ProjectMember } from './entity/ProjectMember';
import { User } from './entity/User'; import { User } from './entity/User';
import { Registry } from './registry'; import { Registry } from './registry';
@ -119,7 +124,8 @@ export class Service {
} }
// Fetch ApplicationDeploymentRecord for deployments // Fetch ApplicationDeploymentRecord for deployments
const records = await this.laconicRegistry.getDeploymentRecords(deployments); const records =
await this.laconicRegistry.getDeploymentRecords(deployments);
log(`Found ${records.length} ApplicationDeploymentRecords`); log(`Found ${records.length} ApplicationDeploymentRecords`);
// Update deployments for which ApplicationDeploymentRecords were returned // Update deployments for which ApplicationDeploymentRecords were returned
@ -204,7 +210,9 @@ export class Service {
return; return;
} }
const registryRecord = await this.laconicRegistry.getRecordById(record.attributes.dns); const registryRecord = await this.laconicRegistry.getRecordById(
record.attributes.dns,
);
if (!registryRecord) { if (!registryRecord) {
log(`DNS record not found for deployment ${deployment.id}`); log(`DNS record not found for deployment ${deployment.id}`);
@ -219,7 +227,7 @@ export class Service {
resourceType: dnsRecord.attributes.resource_type, resourceType: dnsRecord.attributes.resource_type,
value: dnsRecord.attributes.value, value: dnsRecord.attributes.value,
version: dnsRecord.attributes.version, version: dnsRecord.attributes.version,
} };
deployment.applicationDeploymentRecordId = record.id; deployment.applicationDeploymentRecordId = record.id;
deployment.applicationDeploymentRecordData = record.attributes; deployment.applicationDeploymentRecordData = record.attributes;
@ -239,18 +247,21 @@ export class Service {
relations: { relations: {
project: true, project: true,
deployer: true, deployer: true,
} },
}); });
if (previousCanonicalDeployment) { if (previousCanonicalDeployment) {
// Send removal request for the previous canonical deployment and delete DB entry // Send removal request for the previous canonical deployment and delete DB entry
if (previousCanonicalDeployment.url !== deployment.url) { if (previousCanonicalDeployment.url !== deployment.url) {
await this.laconicRegistry.createApplicationDeploymentRemovalRequest({ await this.laconicRegistry.createApplicationDeploymentRemovalRequest(
deploymentId: previousCanonicalDeployment.applicationDeploymentRecordId!, {
deployerLrn: previousCanonicalDeployment.deployer.deployerLrn, deploymentId:
auctionId: previousCanonicalDeployment.project.auctionId, previousCanonicalDeployment.applicationDeploymentRecordId!,
payment: previousCanonicalDeployment.project.txHash deployerLrn: previousCanonicalDeployment.deployer.deployerLrn,
}); auctionId: previousCanonicalDeployment.project.auctionId,
payment: previousCanonicalDeployment.project.txHash,
},
);
} }
await this.db.deleteDeploymentById(previousCanonicalDeployment.id); await this.db.deleteDeploymentById(previousCanonicalDeployment.id);
@ -261,7 +272,9 @@ export class Service {
// Release deployer funds on successful deployment // Release deployer funds on successful deployment
if (!deployment.project.fundsReleased) { if (!deployment.project.fundsReleased) {
const fundsReleased = await this.releaseDeployerFundsByProjectId(deployment.projectId); const fundsReleased = await this.releaseDeployerFundsByProjectId(
deployment.projectId,
);
// Return remaining amount to owner // Return remaining amount to owner
await this.returnUserFundsByProjectId(deployment.projectId, true); await this.returnUserFundsByProjectId(deployment.projectId, true);
@ -291,7 +304,7 @@ export class Service {
const oldDeployments = projectDeployments.filter( const oldDeployments = projectDeployments.filter(
(projectDeployment) => (projectDeployment) =>
projectDeployment.deployer.deployerLrn === projectDeployment.deployer.deployerLrn ===
deployment.deployer.deployerLrn && deployment.deployer.deployerLrn &&
projectDeployment.id !== deployment.id && projectDeployment.id !== deployment.id &&
projectDeployment.isCanonical == deployment.isCanonical, projectDeployment.isCanonical == deployment.isCanonical,
); );
@ -356,24 +369,30 @@ export class Service {
async checkAuctionStatus(): Promise<void> { async checkAuctionStatus(): Promise<void> {
const projects = await this.db.allProjectsWithoutDeployments(); 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)); .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) => const projectsToBedeployed = projects.filter((project) =>
completedAuctionIds.includes(project.auctionId!) completedAuctionIds.includes(project.auctionId!),
); );
for (const project of projectsToBedeployed) { for (const project of projectsToBedeployed) {
const deployerRecords = await this.laconicRegistry.getAuctionWinningDeployerRecords(project!.auctionId!); const deployerRecords =
await this.laconicRegistry.getAuctionWinningDeployerRecords(
project!.auctionId!,
);
if (!deployerRecords) { if (!deployerRecords) {
log(`No winning deployer for auction ${project!.auctionId}`); log(`No winning deployer for auction ${project!.auctionId}`);
// Return all funds to the owner // Return all funds to the owner
await this.returnUserFundsByProjectId(project.id, false) await this.returnUserFundsByProjectId(project.id, false);
} else { } else {
const deployers = await this.saveDeployersByDeployerRecords(deployerRecords); const deployers =
await this.saveDeployersByDeployerRecords(deployerRecords);
for (const deployer of deployers) { for (const deployer of deployers) {
log(`Creating deployment for deployer ${deployer.deployerLrn}`); log(`Creating deployment for deployer ${deployer.deployerLrn}`);
await this.createDeploymentFromAuction(project, deployer); await this.createDeploymentFromAuction(project, deployer);
@ -381,6 +400,10 @@ export class Service {
await this.updateProjectWithDeployer(project.id, deployer); await this.updateProjectWithDeployer(project.id, deployer);
} }
} }
await this.updateProject(project.id, {
auctionStatus: AuctionStatus.Completed,
});
} }
this.auctionStatusCheckTimeout = setTimeout(() => { this.auctionStatusCheckTimeout = setTimeout(() => {
@ -485,12 +508,17 @@ export class Service {
return dbProjects; return dbProjects;
} }
async getNonCanonicalDeploymentsByProjectId(projectId: string): Promise<Deployment[]> { async getNonCanonicalDeploymentsByProjectId(
const nonCanonicalDeployments = await this.db.getNonCanonicalDeploymentsByProjectId(projectId); projectId: string,
): Promise<Deployment[]> {
const nonCanonicalDeployments =
await this.db.getNonCanonicalDeploymentsByProjectId(projectId);
return nonCanonicalDeployments; return nonCanonicalDeployments;
} }
async getLatestDNSRecordByProjectId(projectId: string): Promise<DNSRecordAttributes | null> { async getLatestDNSRecordByProjectId(
projectId: string,
): Promise<DNSRecordAttributes | null> {
const dnsRecord = await this.db.getLatestDNSRecordByProjectId(projectId); const dnsRecord = await this.db.getLatestDNSRecordByProjectId(projectId);
return dnsRecord; return dnsRecord;
} }
@ -650,7 +678,7 @@ export class Service {
environment: Environment.Production, environment: Environment.Production,
commitHash: oldDeployment.commitHash, commitHash: oldDeployment.commitHash,
commitMessage: oldDeployment.commitMessage, commitMessage: oldDeployment.commitMessage,
deployer: oldDeployment.deployer deployer: oldDeployment.deployer,
}); });
return newDeployment; return newDeployment;
@ -660,7 +688,7 @@ export class Service {
userId: string, userId: string,
octokit: Octokit, octokit: Octokit,
data: DeepPartial<Deployment>, data: DeepPartial<Deployment>,
deployerLrn?: string deployerLrn?: string,
): Promise<Deployment> { ): Promise<Deployment> {
assert(data.project?.repository, 'Project repository not found'); assert(data.project?.repository, 'Project repository not found');
log( log(
@ -683,34 +711,58 @@ export class Service {
deployer = data.deployer; 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 address = await this.getAddress();
const { repo, repoUrl } = await getRepoDetails(octokit, data.project.repository, data.commitHash); const { repo, repoUrl } = await getRepoDetails(
const environmentVariablesObj = await this.getEnvVariables(data.project!.id!); octokit,
data.project.repository,
data.commitHash,
);
const environmentVariablesObj = await this.getEnvVariables(
data.project!.id!,
);
// To set project DNS // To set project DNS
if (data.environment === Environment.Production) { 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 // 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 // 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 // So publish project canonical deployment first so that ApplicationDeploymentRecord for the same is available when deleting deployment later
const { applicationDeploymentRequestData, applicationDeploymentRequestId } = const {
await this.laconicRegistry.createApplicationDeploymentRequest({ applicationDeploymentRequestData,
deployment: canonicalDeployment, applicationDeploymentRequestId,
appName: repo, } = await this.laconicRegistry.createApplicationDeploymentRequest({
repository: repoUrl, deployment: canonicalDeployment,
environmentVariables: environmentVariablesObj, appName: repo,
dns: customDomain?.name ?? `${canonicalDeployment.project.name}`, repository: repoUrl,
lrn: deployer!.deployerLrn!, environmentVariables: environmentVariablesObj,
apiUrl: deployer!.deployerApiUrl!, dns: customDomain?.name ?? `${canonicalDeployment.project.name}`,
payment: data.project.txHash, lrn: deployer!.deployerLrn!,
auctionId: data.project.auctionId, apiUrl: deployer!.deployerApiUrl!,
requesterAddress: address, payment: data.project.txHash,
publicKey: deployer!.publicKey! auctionId: data.project.auctionId,
}); requesterAddress: address,
publicKey: deployer!.publicKey!,
});
await this.db.updateDeploymentById(canonicalDeployment.id, { await this.db.updateDeploymentById(canonicalDeployment.id, {
applicationDeploymentRequestId, applicationDeploymentRequestId,
@ -730,7 +782,7 @@ export class Service {
payment: data.project.txHash, payment: data.project.txHash,
auctionId: data.project.auctionId, auctionId: data.project.auctionId,
requesterAddress: address, requesterAddress: address,
publicKey: deployer!.publicKey! publicKey: deployer!.publicKey!,
}); });
await this.db.updateDeploymentById(deployment.id, { await this.db.updateDeploymentById(deployment.id, {
@ -743,7 +795,7 @@ export class Service {
async createDeploymentFromAuction( async createDeploymentFromAuction(
project: DeepPartial<Project>, project: DeepPartial<Project>,
deployer: Deployer deployer: Deployer,
): Promise<Deployment> { ): Promise<Deployment> {
const octokit = await this.getOctokit(project.ownerId!); const octokit = await this.getOctokit(project.ownerId!);
const [owner, repo] = project.repository!.split('/'); const [owner, repo] = project.repository!.split('/');
@ -769,7 +821,7 @@ export class Service {
const applicationRecordId = record.id; const applicationRecordId = record.id;
const applicationRecordData = record.attributes; const applicationRecordData = record.attributes;
const deployerLrn = deployer!.deployerLrn const deployerLrn = deployer!.deployerLrn;
// Create deployment with prod branch and latest commit // Create deployment with prod branch and latest commit
const deploymentData = { const deploymentData = {
@ -781,31 +833,49 @@ export class Service {
commitMessage: latestCommit.commit.message, 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 address = await this.getAddress();
const environmentVariablesObj = await this.getEnvVariables(project!.id!); const environmentVariablesObj = await this.getEnvVariables(project!.id!);
// To set project DNS // To set project DNS
if (deploymentData.environment === Environment.Production) { 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 // 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 // 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 // So publish project canonical deployment first so that ApplicationDeploymentRecord for the same is available when deleting deployment later
const { applicationDeploymentRequestId, applicationDeploymentRequestData } = const {
await this.laconicRegistry.createApplicationDeploymentRequest({ applicationDeploymentRequestId,
deployment: canonicalDeployment, applicationDeploymentRequestData,
appName: repo, } = await this.laconicRegistry.createApplicationDeploymentRequest({
repository: repoUrl, deployment: canonicalDeployment,
environmentVariables: environmentVariablesObj, appName: repo,
dns: customDomain?.name ?? `${canonicalDeployment.project.name}`, repository: repoUrl,
auctionId: project.auctionId!, environmentVariables: environmentVariablesObj,
lrn: deployerLrn, dns: customDomain?.name ?? `${canonicalDeployment.project.name}`,
apiUrl: deployer!.deployerApiUrl!, auctionId: project.auctionId!,
requesterAddress: address, lrn: deployerLrn,
publicKey: deployer!.publicKey! apiUrl: deployer!.deployerApiUrl!,
}); requesterAddress: address,
publicKey: deployer!.publicKey!,
});
await this.db.updateDeploymentById(canonicalDeployment.id, { await this.db.updateDeploymentById(canonicalDeployment.id, {
applicationDeploymentRequestId, applicationDeploymentRequestId,
@ -825,7 +895,7 @@ export class Service {
environmentVariables: environmentVariablesObj, environmentVariables: environmentVariablesObj,
dns: `${deployment.project.name}-${deployment.id}`, dns: `${deployment.project.name}-${deployment.id}`,
requesterAddress: address, requesterAddress: address,
publicKey: deployer!.publicKey! publicKey: deployer!.publicKey!,
}); });
await this.db.updateDeploymentById(deployment.id, { await this.db.updateDeploymentById(deployment.id, {
@ -859,7 +929,7 @@ export class Service {
deployer: Object.assign(new Deployer(), { deployer: Object.assign(new Deployer(), {
deployerLrn, deployerLrn,
}), }),
isCanonical isCanonical,
}); });
log(`Created deployment ${newDeployment.id}`); log(`Created deployment ${newDeployment.id}`);
@ -869,11 +939,11 @@ export class Service {
async updateProjectWithDeployer( async updateProjectWithDeployer(
projectId: string, projectId: string,
deployer: Deployer deployer: Deployer,
): Promise<Deployer> { ): Promise<Deployer> {
const deploymentProject = await this.db.getProjects({ const deploymentProject = await this.db.getProjects({
where: { id: projectId }, where: { id: projectId },
relations: ['deployers'] relations: ['deployers'],
}); });
if (!deploymentProject[0].deployers) { if (!deploymentProject[0].deployers) {
@ -918,15 +988,22 @@ export class Service {
const prodBranch = createdTemplateRepo.data.default_branch ?? 'main'; const prodBranch = createdTemplateRepo.data.default_branch ?? 'main';
const project = await this.addProject(user, organizationSlug, { const project = await this.addProject(
name: `${gitRepo.data.owner!.login}-${gitRepo.data.name}`, user,
prodBranch, organizationSlug,
repository: gitRepo.data.full_name, {
// TODO: Set selected template name: `${gitRepo.data.owner!.login}-${gitRepo.data.name}`,
template: 'webapp', prodBranch,
paymentAddress: data.paymentAddress, repository: gitRepo.data.full_name,
txHash: data.txHash // TODO: Set selected template
}, lrn, auctionParams, environmentVariables); template: 'webapp',
paymentAddress: data.paymentAddress,
txHash: data.txHash,
},
lrn,
auctionParams,
environmentVariables,
);
if (!project || !project.id) { if (!project || !project.id) {
throw new Error('Failed to create project from template'); throw new Error('Failed to create project from template');
@ -985,8 +1062,19 @@ export class Service {
commitHash: latestCommit.sha, commitHash: latestCommit.sha,
commitMessage: latestCommit.commit.message, commitMessage: latestCommit.commit.message,
}; };
const { applicationDeploymentAuctionId } = await this.laconicRegistry.createApplicationDeploymentAuction(repo, octokit, auctionParams!, deploymentData);
await this.updateProject(project.id, { auctionId: applicationDeploymentAuctionId }); const { applicationDeploymentAuction } =
await this.laconicRegistry.createApplicationDeploymentAuction(
repo,
octokit,
auctionParams!,
deploymentData,
);
await this.updateProject(project.id, {
auctionId: applicationDeploymentAuction!.id,
auctionStatus: applicationDeploymentAuction!.status as AuctionStatus,
});
} else { } else {
const deployer = await this.db.getDeployerByLRN(lrn!); const deployer = await this.db.getDeployerByLRN(lrn!);
@ -996,11 +1084,13 @@ export class Service {
} }
if (deployer.minimumPayment && project.txHash) { 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( const txResponse = await this.laconicRegistry.sendTokensToAccount(
deployer?.paymentAddress!, deployer?.paymentAddress!,
amountToBePaid amountToBePaid,
); );
const txHash = txResponse.transactionHash; const txHash = txResponse.transactionHash;
@ -1018,12 +1108,19 @@ export class Service {
domain: null, domain: null,
commitHash: latestCommit.sha, commitHash: latestCommit.sha,
commitMessage: latestCommit.commit.message, 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 // Update project with deployer
await this.updateProjectWithDeployer(newDeployment.projectId, newDeployment.deployer); await this.updateProjectWithDeployer(
newDeployment.projectId,
newDeployment.deployer,
);
} }
await this.createRepoHook(octokit, project); await this.createRepoHook(octokit, project);
@ -1079,7 +1176,7 @@ export class Service {
where: { repository: repository.full_name }, where: { repository: repository.full_name },
relations: { relations: {
deployers: true, deployers: true,
} },
}); });
if (!projects.length) { if (!projects.length) {
@ -1095,25 +1192,23 @@ export class Service {
const deployers = project.deployers; const deployers = project.deployers;
if (!deployers) { if (!deployers) {
log(`No deployer present for project ${project.id}`) log(`No deployer present for project ${project.id}`);
return; return;
} }
for (const deployer of deployers) { for (const deployer of deployers) {
// Create deployment with branch and latest commit in GitHub data // Create deployment with branch and latest commit in GitHub data
await this.createDeployment(project.ownerId, octokit, await this.createDeployment(project.ownerId, octokit, {
{ project,
project, branch,
branch, environment:
environment: project.prodBranch === branch
project.prodBranch === branch ? Environment.Production
? Environment.Production : Environment.Preview,
: Environment.Preview, commitHash: headCommit.id,
commitHash: headCommit.id, commitMessage: headCommit.message,
commitMessage: headCommit.message, deployer: deployer,
deployer: deployer });
},
);
} }
} }
} }
@ -1167,19 +1262,20 @@ export class Service {
let newDeployment: Deployment; let newDeployment: Deployment;
if (oldDeployment.project.auctionId) { if (oldDeployment.project.auctionId) {
newDeployment = await this.createDeploymentFromAuction(oldDeployment.project, oldDeployment.deployer); newDeployment = await this.createDeploymentFromAuction(
} else { oldDeployment.project,
newDeployment = await this.createDeployment(user.id, octokit, oldDeployment.deployer,
{
project: oldDeployment.project,
// TODO: Put isCurrent field in project
branch: oldDeployment.branch,
environment: Environment.Production,
commitHash: oldDeployment.commitHash,
commitMessage: oldDeployment.commitMessage,
deployer: oldDeployment.deployer
}
); );
} else {
newDeployment = await this.createDeployment(user.id, octokit, {
project: oldDeployment.project,
// TODO: Put isCurrent field in project
branch: oldDeployment.branch,
environment: Environment.Production,
commitHash: oldDeployment.commitHash,
commitMessage: oldDeployment.commitMessage,
deployer: oldDeployment.deployer,
});
} }
return newDeployment; return newDeployment;
@ -1218,22 +1314,26 @@ export class Service {
{ isCurrent: true }, { isCurrent: true },
); );
if (!newCurrentDeploymentUpdate || !oldCurrentDeploymentUpdate){ if (!newCurrentDeploymentUpdate || !oldCurrentDeploymentUpdate) {
return false; 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) { if (!newCurrentDeployment) {
throw new Error(`Deployment with Id ${deploymentId} not found`); throw new Error(`Deployment with Id ${deploymentId} not found`);
} }
const applicationDeploymentRequestData = newCurrentDeployment.applicationDeploymentRequestData; const applicationDeploymentRequestData =
newCurrentDeployment.applicationDeploymentRequestData;
const customDomain = await this.db.getOldestDomainByProjectId(projectId); const customDomain = await this.db.getOldestDomainByProjectId(projectId);
if (customDomain && applicationDeploymentRequestData) { if (customDomain && applicationDeploymentRequestData) {
applicationDeploymentRequestData.dns = customDomain.name applicationDeploymentRequestData.dns = customDomain.name;
} }
// Create a canonical deployment for the new current deployment // Create a canonical deployment for the new current deployment
@ -1249,20 +1349,23 @@ export class Service {
applicationDeploymentRequestData!.meta = JSON.stringify({ applicationDeploymentRequestData!.meta = JSON.stringify({
...JSON.parse(applicationDeploymentRequestData!.meta), ...JSON.parse(applicationDeploymentRequestData!.meta),
note: `Updated by Snowball @ ${DateTime.utc().toFormat( 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( const result = await this.laconicRegistry.publishRecord(
applicationDeploymentRequestData, 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, { const updateResult = await this.db.updateDeploymentById(
applicationDeploymentRequestId: result.id, canonicalDeployment.id,
applicationDeploymentRequestData, {
}); applicationDeploymentRequestId: result.id,
applicationDeploymentRequestData,
},
);
return updateResult; return updateResult;
} }
@ -1285,18 +1388,20 @@ export class Service {
where: { where: {
projectId: deployment.project.id, projectId: deployment.project.id,
deployer: deployment.deployer, deployer: deployment.deployer,
isCanonical: true isCanonical: true,
}, },
relations: { relations: {
project: true, project: true,
deployer: true, deployer: true,
}, },
}) });
// If the canonical deployment is not present then query the chain for the deployment record for backward compatibility // If the canonical deployment is not present then query the chain for the deployment record for backward compatibility
if (!canonicalDeployment) { if (!canonicalDeployment) {
log(`Canonical deployment for deployment with id ${deployment.id} not found, querying the chain..`); log(
const currentDeploymentURL = `https://${(deployment.project.name).toLowerCase()}.${deployment.deployer.baseDomain}`; `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 = const deploymentRecords =
await this.laconicRegistry.getDeploymentRecordsByFilter({ await this.laconicRegistry.getDeploymentRecordsByFilter({
@ -1313,24 +1418,30 @@ export class Service {
} }
// Multiple records are fetched, take the latest record // Multiple records are fetched, take the latest record
const latestRecord = deploymentRecords const latestRecord = deploymentRecords.sort(
.sort((a, b) => new Date(b.createTime).getTime() - new Date(a.createTime).getTime())[0]; (a, b) =>
new Date(b.createTime).getTime() -
new Date(a.createTime).getTime(),
)[0];
await this.laconicRegistry.createApplicationDeploymentRemovalRequest({ await this.laconicRegistry.createApplicationDeploymentRemovalRequest({
deploymentId: latestRecord.id, deploymentId: latestRecord.id,
deployerLrn: deployment.deployer.deployerLrn, deployerLrn: deployment.deployer.deployerLrn,
auctionId: deployment.project.auctionId, auctionId: deployment.project.auctionId,
payment: deployment.project.txHash payment: deployment.project.txHash,
}); });
} else { } else {
// If canonical deployment is found in the DB, then send the removal request with that deployment record Id // If canonical deployment is found in the DB, then send the removal request with that deployment record Id
const result = const result =
await this.laconicRegistry.createApplicationDeploymentRemovalRequest({ await this.laconicRegistry.createApplicationDeploymentRemovalRequest(
deploymentId: canonicalDeployment.applicationDeploymentRecordId!, {
deployerLrn: canonicalDeployment.deployer.deployerLrn, deploymentId:
auctionId: canonicalDeployment.project.auctionId, canonicalDeployment.applicationDeploymentRecordId!,
payment: canonicalDeployment.project.txHash deployerLrn: canonicalDeployment.deployer.deployerLrn,
}); auctionId: canonicalDeployment.project.auctionId,
payment: canonicalDeployment.project.txHash,
},
);
await this.db.updateDeploymentById(canonicalDeployment.id, { await this.db.updateDeploymentById(canonicalDeployment.id, {
status: DeploymentStatus.Deleting, status: DeploymentStatus.Deleting,
@ -1347,7 +1458,7 @@ export class Service {
deploymentId: deployment.applicationDeploymentRecordId, deploymentId: deployment.applicationDeploymentRecordId,
deployerLrn: deployment.deployer.deployerLrn, deployerLrn: deployment.deployer.deployerLrn,
auctionId: deployment.project.auctionId, auctionId: deployment.project.auctionId,
payment: deployment.project.txHash payment: deployment.project.txHash,
}); });
await this.db.updateDeploymentById(deployment.id, { await this.db.updateDeploymentById(deployment.id, {
@ -1483,12 +1594,11 @@ export class Service {
return this.db.updateUser(user, data); return this.db.updateUser(user, data);
} }
async getEnvVariables( async getEnvVariables(projectId: string): Promise<{ [key: string]: string }> {
projectId: string, const environmentVariables =
): Promise<{ [key: string]: string }> { await this.db.getEnvironmentVariablesByProjectId(projectId, {
const environmentVariables = await this.db.getEnvironmentVariablesByProjectId(projectId, { environment: Environment.Production,
environment: Environment.Production, });
});
const environmentVariablesObj = environmentVariables.reduce( const environmentVariablesObj = environmentVariables.reduce(
(acc, env) => { (acc, env) => {
@ -1501,9 +1611,7 @@ export class Service {
return environmentVariablesObj; return environmentVariablesObj;
} }
async getAuctionData( async getAuctionData(auctionId: string): Promise<any> {
auctionId: string
): Promise<any> {
const auctions = await this.laconicRegistry.getAuctionData(auctionId); const auctions = await this.laconicRegistry.getAuctionData(auctionId);
return auctions[0]; return auctions[0];
} }
@ -1512,16 +1620,19 @@ export class Service {
const project = await this.db.getProjectById(projectId); const project = await this.db.getProjectById(projectId);
if (!project || !project.auctionId) { 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; return false;
} }
const auction = await this.laconicRegistry.releaseDeployerFunds(project.auctionId); const auction = await this.laconicRegistry.releaseDeployerFunds(
project.auctionId,
);
if (auction.auction.fundsReleased) { if (auction.auction.fundsReleased) {
log(`Funds released for auction ${project.auctionId}`); log(`Funds released for auction ${project.auctionId}`);
await this.db.updateProjectById(projectId, { fundsReleased: true });
return true; return true;
} }
@ -1531,21 +1642,29 @@ export class Service {
return false; return false;
} }
async returnUserFundsByProjectId(projectId: string, winningDeployersPresent: boolean) { async returnUserFundsByProjectId(
projectId: string,
winningDeployersPresent: boolean,
) {
const project = await this.db.getProjectById(projectId); const project = await this.db.getProjectById(projectId);
if (!project || !project.auctionId) { 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; return false;
} }
const auction = await this.getAuctionData(project.auctionId); 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; let amountToBeReturned;
if (winningDeployersPresent) { if (winningDeployersPresent) {
amountToBeReturned = totalAuctionPrice - auction.winnerAddresses.length * Number(auction.winnerPrice.quantity); amountToBeReturned =
totalAuctionPrice -
auction.winnerAddresses.length * Number(auction.winnerPrice.quantity);
} else { } else {
amountToBeReturned = totalAuctionPrice; amountToBeReturned = totalAuctionPrice;
} }
@ -1553,7 +1672,7 @@ export class Service {
if (amountToBeReturned !== 0) { if (amountToBeReturned !== 0) {
await this.laconicRegistry.sendTokensToAccount( await this.laconicRegistry.sendTokensToAccount(
project.paymentAddress, project.paymentAddress,
amountToBeReturned.toString() amountToBeReturned.toString(),
); );
} }
} }
@ -1572,13 +1691,16 @@ export class Service {
} }
async updateDeployersFromRegistry(): Promise<Deployer[]> { async updateDeployersFromRegistry(): Promise<Deployer[]> {
const deployerRecords = await this.laconicRegistry.getDeployerRecordsByFilter({}); const deployerRecords =
await this.laconicRegistry.getDeployerRecordsByFilter({});
await this.saveDeployersByDeployerRecords(deployerRecords); await this.saveDeployersByDeployerRecords(deployerRecords);
return await this.db.getDeployers(); return await this.db.getDeployers();
} }
async saveDeployersByDeployerRecords(deployerRecords: DeployerRecord[]): Promise<Deployer[]> { async saveDeployersByDeployerRecords(
deployerRecords: DeployerRecord[],
): Promise<Deployer[]> {
const deployers: Deployer[] = []; const deployers: Deployer[] = [];
for (const record of deployerRecords) { for (const record of deployerRecords) {
@ -1589,7 +1711,9 @@ export class Service {
const minimumPayment = record.attributes.minimumPayment; const minimumPayment = record.attributes.minimumPayment;
const paymentAddress = record.attributes.paymentAddress; const paymentAddress = record.attributes.paymentAddress;
const publicKey = record.attributes.publicKey; const publicKey = record.attributes.publicKey;
const baseDomain = deployerApiUrl.substring(deployerApiUrl.indexOf('.') + 1); const baseDomain = deployerApiUrl.substring(
deployerApiUrl.indexOf('.') + 1,
);
const deployerData = { const deployerData = {
deployerLrn, deployerLrn,
@ -1598,7 +1722,7 @@ export class Service {
baseDomain, baseDomain,
minimumPayment, minimumPayment,
paymentAddress, paymentAddress,
publicKey publicKey,
}; };
// TODO: Update deployers table in a separate job // TODO: Update deployers table in a separate job
@ -1616,25 +1740,39 @@ export class Service {
return account.address; 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); const txResponse = await this.laconicRegistry.getTxResponse(txHash);
if (!txResponse) { if (!txResponse) {
log('Transaction response not found'); log('Transaction response not found');
return false; 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) { if (!transfer) {
log('No transfer event found'); log('No transfer event found');
return false; return false;
} }
const sender = transfer.attributes.find(a => a.key === 'sender')?.value; const sender = transfer.attributes.find((a) => a.key === 'sender')?.value;
const recipient = transfer.attributes.find(a => a.key === 'recipient')?.value; const recipient = transfer.attributes.find(
const amount = transfer.attributes.find(a => a.key === 'amount')?.value; (a) => a.key === 'recipient',
)?.value;
const amount = transfer.attributes.find((a) => a.key === 'amount')?.value;
const recipientAddress = await this.getAddress(); const recipientAddress = await this.getAddress();
return amount === amountSent && sender === senderAddress && recipient === recipientAddress; return (
amount === amountSent &&
sender === senderAddress &&
recipient === recipientAddress
);
} }
} }