feat: add query wallet state endpoint See merge request atixlabs/multisig-coordination-server!3
import { FastifyRequest, Logger } from 'fastify';
import { WalletStateResponse } from '../models';
import { WalletService } from '../services/wallet-service';
import { mapToWalletCreationResponse } from '../utils/data-mapper';
import { ErrorFactory } from '../utils/errors';
import { withValidWalletInput } from './wallet-controller-helper';
export interface WalletController {
createWallet(
request: FastifyRequest<unknown, unknown, unknown, unknown, Components.RequestBodies.CreateWallet>
): Promise<Components.Responses.CreateWallet | Components.Schemas.ErrorResponse>;
getWalletState(request: FastifyRequest): Promise<WalletStateResponse>;
}
const configure = (walletService: WalletService): WalletController => ({
createWallet: async request => {
const requestBody: Components.RequestBodies.CreateWallet = request.body;
const logger = request.log;
const logger: Logger = request.log;
logger.info(`[createWallet] Request received with body ${requestBody}`);
return withValidWalletInput(logger, requestBody, async validRequestBody => {
return mapToWalletCreationResponse(walletResult);
});
},
getWalletState: async request => {
const walletState = await walletService.getWalletState(request.params.walletId);
if (!walletState) {
throw ErrorFactory.walletNotFound;
}
return walletState;
}
});
VALUES ($1, $2)
`;
const findWallet = (): string => `
SELECT * FROM wallets
WHERE id = $1
`;
const findCosigners = (): string => `
SELECT wallet_cosigners.cosigner AS pubKey,
cosigners.alias AS cosignerAlias
FROM wallet_cosigners
INNER JOIN cosigners
ON wallet_cosigners.cosigner = cosigners.pubkey
WHERE wallet_cosigners.wallet_id = $1
`;
const WalletQueries = {
createCosignersTable,
createWalletTable,
createWalletCosignersTable,
insertCosigner,
insertWallet,
insertCosignerInWallet
insertCosignerInWallet,
findWallet,
findCosigners
};
export default WalletQueries;
import { Logger } from 'fastify';
import { Pool } from 'pg';
import { Wallet, PubKey, CoSigner, WalletId, WalletState } from '../models';
import { Pool, QueryResultRow } from 'pg';
import { Wallet, CoSigner, WalletId } from '../models';
import WalletQueries from './queries/wallet-queries';
import uuid from 'uuid';
import { mapToWallet } from '../utils/data-mapper';
export interface WalletRepository {
createWallet(walletName: string, m: number, n: number, cosigner: CoSigner): Promise<WalletId>;
findWallet(walletId: string): Promise<Wallet | undefined>;
findCosigners(walletId: string): Promise<CoSigner[]>;
countPendingTransactions(walletId: string): Promise<number | undefined>;
}
const prepareDB = (
await readyDatabaseInstance.query(WalletQueries.insertCosignerInWallet(), [walletId, cosigner.pubKey]);
return walletId;
}
},
findWallet: async walletId => {
const result: QueryResultRow = await databaseInstance.query(WalletQueries.findWallet(), [walletId]);
return result.rowCount === 1 ? mapToWallet(result.rows[0]) : undefined;
},
findCosigners: async walletId => {
const result = await databaseInstance.query(WalletQueries.findCosigners(), [walletId]);
const cosigners: CoSigner[] = [];
if (result.rowCount > 0) {
result.rows.forEach(value => {
const { pubkey, cosigneralias } = value;
cosigners.push({ pubKey: pubkey, cosignerAlias: cosigneralias });
});
}
return cosigners;
},
countPendingTransactions: async walletId => 0 // @todo implement
}));
export interface Wallet {
walletId: WalletId;
walletState: WalletState;
walletName: string;
m: number;
n: number;
createDate: string;
pendingTxs: number;
cosigners: CoSigner[];
initiator: PubKey;
}
export interface Transaction {
creationDate: string;
updateDate: string;
}
export type WalletStateResponse = Wallet & {
walletState: WalletState;
pendingTxs: number;
};
},
"Wallet": {
"type": "object",
"required": ["walletId", "walletState", "cosigners", "pendingTxs", "creationDate"],
"required": ["walletId", "walletState", "cosigners", "pendingTxs", "createDate"],
"properties": {
"walletId": {
"$ref": "#/components/schemas/WalletId"
"pendingTxs": {
"type": "integer"
},
"creationDate": {
"createDate": {
"type": "string",
"format": "date"
}
import { WalletRepository } from '../db/wallet-repository';
import { CoSigner, WalletId } from '../models';
import { CoSigner, Wallet, WalletId, WalletState, WalletStateResponse } from '../models';
export interface WalletService {
createWallet(walletName: string, m: number, n: number, cosigner: CoSigner): Promise<WalletId>;
getWalletState(walletId: string): Promise<WalletStateResponse | undefined>;
}
const hasExpired = (createDate: string) => false; // @todo implement
const mapToWalletState = (countCosigners: number, m: number, date: string) => {
if (countCosigners === m) {
return 'Ready';
} else if (hasExpired(date)) {
return 'Expired';
}
return 'WaitingForCosigners';
};
const getWalletState = (wallet: Wallet, countCosigners: number) =>
mapToWalletState(countCosigners, wallet.m, wallet.createDate);
const configure = (repository: WalletRepository): WalletService => ({
async createWallet(walletName, m, n, cosigner) {
return await repository.createWallet(walletName, m, n, cosigner);
createWallet: async (walletName, m, n, cosigner) => await repository.createWallet(walletName, m, n, cosigner),
getWalletState: async walletId => {
const wallet: Wallet | undefined = await repository.findWallet(walletId);
if (wallet) {
const cosigners: CoSigner[] = await repository.findCosigners(walletId);
const walletState: WalletState = getWalletState(wallet, cosigners.length);
const pendingTxs = await repository.countPendingTransactions(walletId);
return {
...wallet,
walletState,
pendingTxs: pendingTxs ? pendingTxs : 0,
cosigners
};
}
return wallet;
}
});
import { QueryResultRow } from 'pg';
import { Wallet } from '../models';
/* eslint-disable camelcase */
export const mapToWalletCreationResponse = (result: string): Components.Responses.CreateWallet => ({
walletId: result
});
export const mapToWallet = (result: QueryResultRow): Wallet => {
const { id, wallet_name, n, m, create_date, initiator } = result;
return {
walletId: id,
walletName: wallet_name,
n,
m,
createDate: create_date,
initiator
};
};
import { num } from 'envalid';
import ApiError from '../api-error';
export interface CustomError {
const invalidWalletN = buildApiError(Errors.INVALID_WALLET_INPUT_N);
const invalidWalletName = buildApiError(Errors.WALLET_NAME_EMPTY);
const invalidPubKey = buildApiError(Errors.INVALID_PUBKEY);
const walletNotFound = buildApiError(Errors.WALLET_NOT_FOUND);
export const ErrorFactory = {
invalidPubKey,
invalidWalletName,
invalidWalletMAndN,
invalidWalletM,
invalidWalletN
invalidWalletN,
walletNotFound
};
walletState: WalletState;
cosigners: CoSigner[];
pendingTxs: number;
creationDate: string; // date
createDate: string; // date
}
export interface WalletCreation {
walletName: string;
import { FastifyInstance } from 'fastify';
import StatusCodes from 'http-status-codes';
import * as Repositories from '../../../src/server/db/repositories';
import * as Services from '../../../src/server/services/services';
import createPool from '../../../src/server/db/connection';
};
export const setupServer = (database: Pool): FastifyInstance => {
// let repositories;
const repositories = Repositories.configure(database);
const services = Services.configure(repositories);
return buildServer(services, process.env.LOGGER_LEVEL);
/* eslint-disable no-magic-numbers */
import { FastifyInstance } from 'fastify';
import StatusCodes from 'http-status-codes';
import { Pool } from 'pg';
import { setupDatabase, setupServer } from '../utils/test-utils';
describe('/wallets/{walletId} endpoint', () => {
let database: Pool;
let server: FastifyInstance;
beforeAll(async () => {
database = setupDatabase(false);
server = setupServer(database);
});
afterAll(async () => {
await database.end();
});
test('should return the wallet state', async () => {
const walletInitiator = {
cosignerAlias: 'someAlias',
pubKey: 'someValidKey'
};
const response = await server.inject({
method: 'post',
url: '/wallets',
payload: {
walletName: 'someName',
m: 2,
n: 3,
cosigner: walletInitiator
}
});
expect(response.statusCode).toEqual(StatusCodes.OK);
expect(response.json()).toHaveProperty('walletId');
const walletId: string = response.json().walletId;
const walletState = await server.inject({
method: 'get',
url: `/wallets/${walletId}`,
payload: {}
});
expect(walletState.statusCode).toEqual(StatusCodes.OK);
expect(walletState.json()).toHaveProperty('walletState');
expect(walletState.json().walletState).toBe('WaitingForCosigners');
expect(walletState.json()).toHaveProperty('pendingTxs');
expect(walletState.json()).toHaveProperty('cosigners');
expect(walletState.json().cosigners).toStrictEqual([walletInitiator]);
});
test('should return the wallet not found', async () => {
const walletInitiator = {
cosignerAlias: 'someAlias',
pubKey: 'someValidKey'
};
const response = await server.inject({
method: 'post',
url: '/wallets',
payload: {
walletName: 'someName',
m: 2,
n: 3,
cosigner: walletInitiator
}
});
expect(response.statusCode).toEqual(StatusCodes.OK);
expect(response.json()).toHaveProperty('walletId');
const walletId = 'someInvalidId';
const walletState = await server.inject({
method: 'get',
url: `/wallets/${walletId}`,
payload: {}
});
expect(walletState.statusCode).toEqual(StatusCodes.NOT_FOUND);
});
});
import { WalletRepository } from '../../../src/server/db/wallet-repository';
import { Wallet } from '../../../src/server/models';
import configure, { WalletService } from '../../../src/server/services/wallet-service';
describe('Wallet Service', () => {
let walletService: WalletService;
const mockCosigner: Components.Schemas.CoSigner = {
cosignerAlias: 'someAlias',
pubKey: 'someValidKey'
};
const mockWallet: Wallet = {
walletId: 'someId',
walletName: 'someName',
initiator: mockCosigner.pubKey,
createDate: new Date().toString(),
m: 2,
n: 3
};
const mockRepository: WalletRepository = {
async createWallet(walletName, m, n, cosigner) {
return Promise.resolve('someId');
}
createWallet: async () => 'someId',
findWallet: async () => mockWallet,
findCosigners: async () => [mockCosigner],
countPendingTransactions: async () => 0
};
beforeAll(() => {
describe('Wallet creation', () => {
it('Return someId', async () => {
const cosigner: Components.Schemas.CoSigner = {
cosignerAlias: 'someAlias',
pubKey: 'someKey'
};
const m = 2;
const n = 3;
expect(await walletService.createWallet('someName', m, n, cosigner)).toBe('someId');
expect(await walletService.createWallet('someName', m, n, mockCosigner)).toBe('someId');
});
it('Get wallet state', async () => {
const walletState = await walletService.getWalletState('someId');
expect(walletState?.initiator).toBe(mockCosigner.pubKey);
expect(walletState?.walletId).toBe('someId');
expect(walletState?.walletState).toBe('WaitingForCosigners');
});
});
});
Merge release/3.2.0-FC1 into master
Merge release/3.2.0-FC1 into develop
In response to review feedback: https://github.com/input-output-hk/cardano-wallet/pull/2451#discussion_r561029734
In response to review feedback: https://github.com/input-output-hk/cardano-wallet/pull/2451#discussion_r560856424
