8126186552

Committed 02 Mar 2024 11:44PM UTC coverage: 79.451% (+0.03%) from 79.421%

Build # 8126186552

Build Type

push

github

Committed by

vgrichina

Commit Message

Extract viewAccessKey method

Run Details

392 of 584 branches covered (67.12%)

Branch coverage included in aggregate %.

22 of 24 new or added lines in 2 files covered. (91.67%)

1 existing line in 1 file now uncovered.

1402 of 1674 relevant lines covered (83.75%)

15879.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.55

/app.js

// NOTE: Needs --experimental-wasm-bigint on older Node versions

const Koa = require('koa');
const app = new Koa();
const Router = require('koa-router');
const router = new Router();
const getRawBody = require('raw-body');
const cors = require('@koa/cors');

const resolveBlockHeightUtil = require('./resolve-block-height');
const isJSON = require('./utils/is-json');
const { runContract, getWasmModule } = require('./run-contract');
const { viewAccessKey } = require('./utils/view-access-key');
const storage = require('./storage');
const { accountKey } = require('./storage-keys');
const { deserialize } = require('borsh');
const bs58 = require('bs58');
const { BORSH_SCHEMA, Account } = require('./data-model');

const parseQueryArgs = async (ctx, next) => {
    // TODO: Refactor/merge with web4?
    const {
        query
    } = ctx;

    const tryParse = key => {
        try {
            return JSON.parse(query[key]);
        } catch (e) {
            ctx.throw(400, `Problem parsing JSON for ${key} field: ${e}`);
        }
    }

    ctx.methodArgs = Object.keys(query)
        .map(key => key.endsWith('.json')
            ? { [key.replace(/\.json$/, '')]: tryParse(key) }
            : { [key] : query[key] })
        .reduce((a, b) => ({...a, ...b}), {});

    await next();
}

const parseBodyArgs = async (ctx, next) => {
    ctx.methodArgs = await getRawBody(ctx.req);

    await next();
}

const resolveBlockHeight = async (ctx, next) => {
    // TODO: Evaluate some alternate scheme, e.g. use URL prefix like /height/<block_height>/account/
    const { near_block_height: blockHeight } = ctx.query;

    ctx.blockHeight = await resolveBlockHeightUtil(blockHeight);

    await next();
}

const runViewMethod = async ctx => {
    const { accountId, methodName } = ctx.params;
    const { blockHeight } = ctx;

    try {
        const { result, logs } = await runContract(accountId, methodName, ctx.methodArgs, blockHeight);
        // TODO: return logs somehow (in headers? if requested?)
        const resultBuffer = Buffer.from(result);
        if (isJSON(resultBuffer)) {
            ctx.type = 'json';
        }
        ctx.body = resultBuffer;
    } catch (e) {
        const message = e.toString();
        if (/TypeError.* is not a function/.test(message)) {
            ctx.throw(404, `method ${methodName} not found`);
        }

        if (['codeNotFound', 'accountNotFound'].includes(e.code)) {
            ctx.throw(404, message);
        }

        console.log('Unexpected error', e);

        ctx.throw(400, message);
    }
}

router.get('/account/:accountId/view/:methodName', resolveBlockHeight, parseQueryArgs, runViewMethod);
router.post('/account/:accountId/view/:methodName', resolveBlockHeight, parseBodyArgs, runViewMethod);

const MAX_LIMIT = 100;
router.get('/account/:accountId/data/:keyPattern', async ctx => {
    const { encoding = 'utf8', iterator = "0", limit = "10"} = ctx.query;
    const { accountId, keyPattern } = ctx.params;
    const debug = require('debug')(`data:${accountId}`);

    const latestBlockHeight = await storage.getLatestBlockHeight();
    debug('latestBlockHeight', latestBlockHeight);

    const { data, iterator: newIterator } = await storage.scanDataKeys(accountId, latestBlockHeight, keyPattern, iterator, Math.min(MAX_LIMIT, parseInt(limit)));
    ctx.body = {
        data: data
            .filter(([_, value]) => value !== null)
            .map(([key, value]) => [Buffer.from(key).toString(encoding), Buffer.from(value).toString(encoding)]),
        iterator: newIterator
    };
});

router.get('/account/:accountId', resolveBlockHeight, async ctx => {
    const { accountId } = ctx.params;

    // TODO: Refactor with JSON-RPC version?
    const data = await storage.getLatestData(accountKey(accountId), ctx.blockHeight);
    if (!data) {
        ctx.throw(404);
    }

    const { amount, locked, code_hash, storage_usage } = deserialize(BORSH_SCHEMA, Account, data);
    ctx.body = {
        amount: amount.toString(),
        locked: locked.toString(),
        code_hash: bs58.encode(code_hash),
        storage_usage: parseInt(storage_usage.toString()),
    };
});

router.get('/account/:accountId/contract', resolveBlockHeight, async ctx => {
    const { accountId } = ctx.params;

    const accountData = await storage.getLatestData(accountKey(accountId), ctx.blockHeight);
    if (!accountData) {
        ctx.throw(404);
    }

    const { code_hash } = deserialize(BORSH_SCHEMA, Account, accountData);
    const data = await storage.getBlob(Buffer.from(code_hash));

    ctx.type = 'wasm';
    ctx.res.setHeader('Content-Disposition', `attachment; filename="${accountId}.wasm"`);
    ctx.body = data;
});

router.get('/account/:accountId/contract/methods', resolveBlockHeight, async ctx => {
    const { accountId } = ctx.params;

    const wasmModule = await getWasmModule(accountId, ctx.blockHeight);
    ctx.body = WebAssembly.Module.exports(wasmModule).filter(({ kind }) => kind === 'function').map(({ name }) => name).sort();
});

router.get('/account/:accountId/key/:publicKey', resolveBlockHeight, async ctx => {
    const { accountId, publicKey } = ctx.params;

    const accessKey = await viewAccessKey({ accountId, publicKey, blockHeight: ctx.blockHeight });
    if (!accessKey) {
        ctx.throw(404);
    }

    ctx.body = accessKey;
});

const MAX_BLOCK_LAG_TIME_MS = 60_000;
router.get('/healthz', async ctx => {
    const latestBlockHeight = await storage.getLatestBlockHeight();
    const latestBlockTimestamp = (await storage.getBlockTimestamp(latestBlockHeight)) / 1000000;

    // NOTE: fast-near node considered unhealthy if it's out of sync
    if (!latestBlockHeight || !latestBlockTimestamp || Date.now() - latestBlockTimestamp > MAX_BLOCK_LAG_TIME_MS) {
        ctx.throw(500, 'unhealthy (out of sync)');
    }

    ctx.status = 204; // No Content
});

const { parseJsonBody, withJsonRpcCache, proxyJson, handleJsonRpc } = require('./json-rpc');
router.post('/', parseJsonBody, withJsonRpcCache, handleJsonRpc);
router.get('/(status|metrics|health)', proxyJson);

app
    .use(async (ctx, next) => {
        console.log(ctx.method, ctx.path);
        await next();
    })
    .use(cors({ credentials: true }))
    .use(router.routes())
    .use(router.allowedMethods());

module.exports = app;

1	// NOTE: Needs --experimental-wasm-bigint on older Node versions
2
3	const Koa = require('koa');	5✔
4	const app = new Koa();	5✔
5	const Router = require('koa-router');	5✔
6	const router = new Router();	5✔
7	const getRawBody = require('raw-body');	5✔
8	const cors = require('@koa/cors');	5✔
9
10	const resolveBlockHeightUtil = require('./resolve-block-height');	5✔
11	const isJSON = require('./utils/is-json');	5✔
12	const { runContract, getWasmModule } = require('./run-contract');	5✔
13	const { viewAccessKey } = require('./utils/view-access-key');	5✔
14	const storage = require('./storage');	5✔
15	const { accountKey } = require('./storage-keys');	5✔
16	const { deserialize } = require('borsh');	5✔
17	const bs58 = require('bs58');	5✔
18	const { BORSH_SCHEMA, Account } = require('./data-model');	5✔
19
20	const parseQueryArgs = async (ctx, next) => {	5✔
21	// TODO: Refactor/merge with web4?
22	const {
23	query
24	} = ctx;	30✔
25
26	const tryParse = key => {	30✔
27	try {	4✔
28	return JSON.parse(query[key]);	4✔
29	} catch (e) {
30	ctx.throw(400, `Problem parsing JSON for ${key} field: ${e}`);	×
31	}
32	}
33
34	ctx.methodArgs = Object.keys(query)	30✔
35	.map(key => key.endsWith('.json')	4!
36	? { [key.replace(/\.json$/, '')]: tryParse(key) }
37	: { [key] : query[key] })
38	.reduce((a, b) => ({...a, ...b}), {});	4✔
39
40	await next();	30✔
41	}
42
43	const parseBodyArgs = async (ctx, next) => {	5✔
44	ctx.methodArgs = await getRawBody(ctx.req);	24✔
45
46	await next();	24✔
47	}
48
49	const resolveBlockHeight = async (ctx, next) => {	5✔
50	// TODO: Evaluate some alternate scheme, e.g. use URL prefix like /height/<block_height>/account/
51	const { near_block_height: blockHeight } = ctx.query;	64✔
52
53	ctx.blockHeight = await resolveBlockHeightUtil(blockHeight);	64✔
54
55	await next();	64✔
56	}
57
58	const runViewMethod = async ctx => {	5✔
59	const { accountId, methodName } = ctx.params;	54✔
60	const { blockHeight } = ctx;	54✔
61
62	try {	54✔
63	const { result, logs } = await runContract(accountId, methodName, ctx.methodArgs, blockHeight);	54✔
64	// TODO: return logs somehow (in headers? if requested?)
65	const resultBuffer = Buffer.from(result);	24✔
66	if (isJSON(resultBuffer)) {	24✔
67	ctx.type = 'json';	10✔
68	}
69	ctx.body = resultBuffer;	24✔
70	} catch (e) {
71	const message = e.toString();	30✔
72	if (/TypeError.* is not a function/.test(message)) {	30✔
73	ctx.throw(404, `method ${methodName} not found`);	2✔
74	}
75
76	if (['codeNotFound', 'accountNotFound'].includes(e.code)) {	28✔
77	ctx.throw(404, message);	20✔
78	}
79
80	console.log('Unexpected error', e);	8✔
81
82	ctx.throw(400, message);	8✔
83	}
84	}
85
86	router.get('/account/:accountId/view/:methodName', resolveBlockHeight, parseQueryArgs, runViewMethod);	5✔
87	router.post('/account/:accountId/view/:methodName', resolveBlockHeight, parseBodyArgs, runViewMethod);	5✔
88
89	const MAX_LIMIT = 100;	5✔
90	router.get('/account/:accountId/data/:keyPattern', async ctx => {	5✔
91	const { encoding = 'utf8', iterator = "0", limit = "10"} = ctx.query;	6✔
92	const { accountId, keyPattern } = ctx.params;	6✔
93	const debug = require('debug')(`data:${accountId}`);	6✔
94
95	const latestBlockHeight = await storage.getLatestBlockHeight();	6✔
96	debug('latestBlockHeight', latestBlockHeight);	6✔
97
98	const { data, iterator: newIterator } = await storage.scanDataKeys(accountId, latestBlockHeight, keyPattern, iterator, Math.min(MAX_LIMIT, parseInt(limit)));	6✔
99	ctx.body = {	6✔
100	data: data
101	.filter(([_, value]) => value !== null)	3,027✔
102	.map(([key, value]) => [Buffer.from(key).toString(encoding), Buffer.from(value).toString(encoding)]),	2,018✔
103	iterator: newIterator
104	};
105	});
106
107	router.get('/account/:accountId', resolveBlockHeight, async ctx => {	5✔
108	const { accountId } = ctx.params;	2✔
109
110	// TODO: Refactor with JSON-RPC version?
111	const data = await storage.getLatestData(accountKey(accountId), ctx.blockHeight);	2✔
112	if (!data) {	2!
113	ctx.throw(404);	×
114	}
115
116	const { amount, locked, code_hash, storage_usage } = deserialize(BORSH_SCHEMA, Account, data);	2✔
117	ctx.body = {	2✔
118	amount: amount.toString(),
119	locked: locked.toString(),
120	code_hash: bs58.encode(code_hash),
121	storage_usage: parseInt(storage_usage.toString()),
122	};
123	});
124
125	router.get('/account/:accountId/contract', resolveBlockHeight, async ctx => {	5✔
126	const { accountId } = ctx.params;	2✔
127
128	const accountData = await storage.getLatestData(accountKey(accountId), ctx.blockHeight);	2✔
129	if (!accountData) {	2!
130	ctx.throw(404);	×
131	}
132
133	const { code_hash } = deserialize(BORSH_SCHEMA, Account, accountData);	2✔
134	const data = await storage.getBlob(Buffer.from(code_hash));	2✔
135
136	ctx.type = 'wasm';	2✔
137	ctx.res.setHeader('Content-Disposition', `attachment; filename="${accountId}.wasm"`);	2✔
138	ctx.body = data;	2✔
139	});
140
141	router.get('/account/:accountId/contract/methods', resolveBlockHeight, async ctx => {	5✔
142	const { accountId } = ctx.params;	2✔
143
144	const wasmModule = await getWasmModule(accountId, ctx.blockHeight);	2✔
145	ctx.body = WebAssembly.Module.exports(wasmModule).filter(({ kind }) => kind === 'function').map(({ name }) => name).sort();	82✔
146	});
147
148	router.get('/account/:accountId/key/:publicKey', resolveBlockHeight, async ctx => {	5✔
149	const { accountId, publicKey } = ctx.params;	4✔
150
151	const accessKey = await viewAccessKey({ accountId, publicKey, blockHeight: ctx.blockHeight });	4✔
152	if (!accessKey) {	4!
UNCOV 153	ctx.throw(404);	×
154	}
155
156	ctx.body = accessKey;	4✔
157	});
158
159	const MAX_BLOCK_LAG_TIME_MS = 60_000;	5✔
160	router.get('/healthz', async ctx => {	5✔
161	const latestBlockHeight = await storage.getLatestBlockHeight();	4✔
162	const latestBlockTimestamp = (await storage.getBlockTimestamp(latestBlockHeight)) / 1000000;	4✔
163
164	// NOTE: fast-near node considered unhealthy if it's out of sync
165	if (!latestBlockHeight \|\| !latestBlockTimestamp \|\| Date.now() - latestBlockTimestamp > MAX_BLOCK_LAG_TIME_MS) {	4✔
166	ctx.throw(500, 'unhealthy (out of sync)');	2✔
167	}
168
169	ctx.status = 204; // No Content	2✔
170	});
171
172	const { parseJsonBody, withJsonRpcCache, proxyJson, handleJsonRpc } = require('./json-rpc');	5✔
173	router.post('/', parseJsonBody, withJsonRpcCache, handleJsonRpc);	5✔
174	router.get('/(status\|metrics\|health)', proxyJson);	5✔
175
176	app	5✔
177	.use(async (ctx, next) => {
178	console.log(ctx.method, ctx.path);	83✔
179	await next();	83✔
180	})
181	.use(cors({ credentials: true }))
182	.use(router.routes())
183	.use(router.allowedMethods());
184
185	module.exports = app;	5✔

vgrichina / fast-near / 8126186552

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous