Skip to content

Commit dd308f0

Browse files
achingbrainachingbrain
authoredApr 13, 2022
feat: convert to typescript (#154)
* Upgrades aegir to the latest version * Switches protobufjs for protons BREAKING CHANGE: this module is now ESM-only
·
v10.0.2v1.0.0
1 parent 8f2bd28 commit dd308f0

26 files changed

+1273
-1600
lines changed
 

‎.aegir.cjs ‎.aegir.js

+1-5
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,7 @@
1-
'use strict'
21

32
/** @type {import('aegir').PartialOptions} */
4-
module.exports = {
3+
export default {
54
build: {
65
bundlesizeMax: '143KB'
7-
},
8-
ts: {
9-
copyTo: './dist/types'
106
}
117
}

‎.github/dependabot.yml

+1-1
Original file line numberDiff line numberDiff line change
@@ -4,5 +4,5 @@ updates:
44
directory: "/"
55
schedule:
66
interval: daily
7-
time: "11:00"
7+
time: "10:00"
88
open-pull-requests-limit: 10

‎.github/workflows/automerge.yml

+8
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,8 @@
1+
name: Automerge
2+
on: [ pull_request ]
3+
4+
jobs:
5+
automerge:
6+
uses: protocol/.github/.github/workflows/automerge.yml@master
7+
with:
8+
job: 'automerge'

‎.github/workflows/js-test-and-release.yml

+152
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,152 @@
1+
name: test & maybe release
2+
on:
3+
push:
4+
branches:
5+
- master # with #262 - ${{{ github.default_branch }}}
6+
pull_request:
7+
branches:
8+
- master # with #262 - ${{{ github.default_branch }}}
9+
10+
jobs:
11+
12+
check:
13+
runs-on: ubuntu-latest
14+
steps:
15+
- uses: actions/checkout@v2
16+
- uses: actions/setup-node@v2
17+
with:
18+
node-version: lts/*
19+
- uses: ipfs/aegir/actions/cache-node-modules@master
20+
- run: npm run --if-present lint
21+
- run: npm run --if-present dep-check
22+
23+
test-node:
24+
needs: check
25+
runs-on: ${{ matrix.os }}
26+
strategy:
27+
matrix:
28+
os: [windows-latest, ubuntu-latest, macos-latest]
29+
node: [16]
30+
fail-fast: true
31+
steps:
32+
- uses: actions/checkout@v2
33+
- uses: actions/setup-node@v2
34+
with:
35+
node-version: ${{ matrix.node }}
36+
- uses: ipfs/aegir/actions/cache-node-modules@master
37+
- run: npm run --if-present test:node
38+
- uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
39+
with:
40+
directory: ./.nyc_output
41+
flags: node
42+
43+
test-chrome:
44+
needs: check
45+
runs-on: ubuntu-latest
46+
steps:
47+
- uses: actions/checkout@v2
48+
- uses: actions/setup-node@v2
49+
with:
50+
node-version: lts/*
51+
- uses: ipfs/aegir/actions/cache-node-modules@master
52+
- run: npm run --if-present test:chrome
53+
- uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
54+
with:
55+
directory: ./.nyc_output
56+
flags: chrome
57+
58+
test-chrome-webworker:
59+
needs: check
60+
runs-on: ubuntu-latest
61+
steps:
62+
- uses: actions/checkout@v2
63+
- uses: actions/setup-node@v2
64+
with:
65+
node-version: lts/*
66+
- uses: ipfs/aegir/actions/cache-node-modules@master
67+
- run: npm run --if-present test:chrome-webworker
68+
- uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
69+
with:
70+
directory: ./.nyc_output
71+
flags: chrome-webworker
72+
73+
test-firefox:
74+
needs: check
75+
runs-on: ubuntu-latest
76+
steps:
77+
- uses: actions/checkout@v2
78+
- uses: actions/setup-node@v2
79+
with:
80+
node-version: lts/*
81+
- uses: ipfs/aegir/actions/cache-node-modules@master
82+
- run: npm run --if-present test:firefox
83+
- uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
84+
with:
85+
directory: ./.nyc_output
86+
flags: firefox
87+
88+
test-firefox-webworker:
89+
needs: check
90+
runs-on: ubuntu-latest
91+
steps:
92+
- uses: actions/checkout@v2
93+
- uses: actions/setup-node@v2
94+
with:
95+
node-version: lts/*
96+
- uses: ipfs/aegir/actions/cache-node-modules@master
97+
- run: npm run --if-present test:firefox-webworker
98+
- uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
99+
with:
100+
directory: ./.nyc_output
101+
flags: firefox-webworker
102+
103+
test-electron-main:
104+
needs: check
105+
runs-on: ubuntu-latest
106+
steps:
107+
- uses: actions/checkout@v2
108+
- uses: actions/setup-node@v2
109+
with:
110+
node-version: lts/*
111+
- uses: ipfs/aegir/actions/cache-node-modules@master
112+
- run: npx xvfb-maybe npm run --if-present test:electron-main
113+
- uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
114+
with:
115+
directory: ./.nyc_output
116+
flags: electron-main
117+
118+
test-electron-renderer:
119+
needs: check
120+
runs-on: ubuntu-latest
121+
steps:
122+
- uses: actions/checkout@v2
123+
- uses: actions/setup-node@v2
124+
with:
125+
node-version: lts/*
126+
- uses: ipfs/aegir/actions/cache-node-modules@master
127+
- run: npx xvfb-maybe npm run --if-present test:electron-renderer
128+
- uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
129+
with:
130+
directory: ./.nyc_output
131+
flags: electron-renderer
132+
133+
release:
134+
needs: [test-node, test-chrome, test-chrome-webworker, test-firefox, test-firefox-webworker, test-electron-main, test-electron-renderer]
135+
runs-on: ubuntu-latest
136+
if: github.event_name == 'push' && github.ref == 'refs/heads/master' # with #262 - 'refs/heads/${{{ github.default_branch }}}'
137+
steps:
138+
- uses: actions/checkout@v2
139+
with:
140+
fetch-depth: 0
141+
- uses: actions/setup-node@v2
142+
with:
143+
node-version: lts/*
144+
- uses: ipfs/aegir/actions/cache-node-modules@master
145+
- uses: ipfs/aegir/actions/docker-login@master
146+
with:
147+
docker-token: ${{ secrets.DOCKER_TOKEN }}
148+
docker-username: ${{ secrets.DOCKER_USERNAME }}
149+
- run: npm run --if-present release
150+
env:
151+
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
152+
NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

‎.github/workflows/main.yml

-76
This file was deleted.

‎LICENSE

+3-20
Original file line numberDiff line numberDiff line change
@@ -1,21 +1,4 @@
1-
The MIT License (MIT)
1+
This project is dual licensed under MIT and Apache-2.0.
22

3-
Copyright (c) 2018 Protocol Labs, Inc.
4-
5-
Permission is hereby granted, free of charge, to any person obtaining a copy
6-
of this software and associated documentation files (the "Software"), to deal
7-
in the Software without restriction, including without limitation the rights
8-
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9-
copies of the Software, and to permit persons to whom the Software is
10-
furnished to do so, subject to the following conditions:
11-
12-
The above copyright notice and this permission notice shall be included in
13-
all copies or substantial portions of the Software.
14-
15-
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16-
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17-
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18-
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19-
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20-
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21-
THE SOFTWARE.
3+
MIT: https://www.opensource.org/licenses/mit
4+
Apache-2.0: https://www.apache.org/licenses/license-2.0

‎LICENSE-APACHE

+5
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,5 @@
1+
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
2+
3+
http://www.apache.org/licenses/LICENSE-2.0
4+
5+
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

‎LICENSE-MIT

+19
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
The MIT License (MIT)
2+
3+
Permission is hereby granted, free of charge, to any person obtaining a copy
4+
of this software and associated documentation files (the "Software"), to deal
5+
in the Software without restriction, including without limitation the rights
6+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7+
copies of the Software, and to permit persons to whom the Software is
8+
furnished to do so, subject to the following conditions:
9+
10+
The above copyright notice and this permission notice shall be included in
11+
all copies or substantial portions of the Software.
12+
13+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19+
THE SOFTWARE.

‎package.json

+150-50
Original file line numberDiff line numberDiff line change
@@ -2,14 +2,59 @@
22
"name": "ipns",
33
"version": "0.16.0",
44
"description": "ipns record definitions",
5-
"leadMaintainer": "Vasco Santos <vasco.santos@moxy.studio>",
6-
"main": "src/index.js",
7-
"types": "types/src/index.d.ts",
5+
"author": "Vasco Santos <vasco.santos@moxy.studio>",
6+
"license": "Apache-2.0 OR MIT",
7+
"homepage": "https://github.com/ipfs/js-ipns#readme",
8+
"repository": {
9+
"type": "git",
10+
"url": "git+https://github.com/ipfs/js-ipns.git"
11+
},
12+
"bugs": {
13+
"url": "https://github.com/ipfs/js-ipns/issues"
14+
},
15+
"keywords": [
16+
"ipfs",
17+
"ipns"
18+
],
19+
"engines": {
20+
"node": ">=16.0.0",
21+
"npm": ">=7.0.0"
22+
},
823
"type": "module",
24+
"types": "./dist/src/index.d.ts",
25+
"typesVersions": {
26+
"*": {
27+
"*": [
28+
"*",
29+
"dist/*",
30+
"dist/src/*",
31+
"dist/src/*/index"
32+
],
33+
"src/*": [
34+
"*",
35+
"dist/*",
36+
"dist/src/*",
37+
"dist/src/*/index"
38+
]
39+
}
40+
},
941
"files": [
10-
"*",
42+
"src",
43+
"dist/src",
44+
"!dist/test",
1145
"!**/*.tsbuildinfo"
1246
],
47+
"exports": {
48+
".": {
49+
"import": "./dist/src/index.js"
50+
},
51+
"./selector": {
52+
"import": "./dist/src/selector.js"
53+
},
54+
"./validator": {
55+
"import": "./dist/src/validator.js"
56+
}
57+
},
1358
"eslintConfig": {
1459
"extends": "ipfs",
1560
"parserOptions": {
@@ -19,68 +64,123 @@
1964
"src/pb/ipns.d.ts"
2065
]
2166
},
67+
"release": {
68+
"branches": [
69+
"master"
70+
],
71+
"plugins": [
72+
[
73+
"@semantic-release/commit-analyzer",
74+
{
75+
"preset": "conventionalcommits",
76+
"releaseRules": [
77+
{
78+
"breaking": true,
79+
"release": "major"
80+
},
81+
{
82+
"revert": true,
83+
"release": "patch"
84+
},
85+
{
86+
"type": "feat",
87+
"release": "minor"
88+
},
89+
{
90+
"type": "fix",
91+
"release": "patch"
92+
},
93+
{
94+
"type": "chore",
95+
"release": "patch"
96+
},
97+
{
98+
"type": "docs",
99+
"release": "patch"
100+
},
101+
{
102+
"type": "test",
103+
"release": "patch"
104+
},
105+
{
106+
"scope": "no-release",
107+
"release": false
108+
}
109+
]
110+
}
111+
],
112+
[
113+
"@semantic-release/release-notes-generator",
114+
{
115+
"preset": "conventionalcommits",
116+
"presetConfig": {
117+
"types": [
118+
{
119+
"type": "feat",
120+
"section": "Features"
121+
},
122+
{
123+
"type": "fix",
124+
"section": "Bug Fixes"
125+
},
126+
{
127+
"type": "chore",
128+
"section": "Trivial Changes"
129+
},
130+
{
131+
"type": "docs",
132+
"section": "Trivial Changes"
133+
},
134+
{
135+
"type": "test",
136+
"section": "Tests"
137+
}
138+
]
139+
}
140+
}
141+
],
142+
"@semantic-release/changelog",
143+
"@semantic-release/npm",
144+
"@semantic-release/github",
145+
"@semantic-release/git"
146+
]
147+
},
22148
"scripts": {
23-
"generate": "run-s generate:*",
24-
"generate:proto": "pbjs -t static-module -w es6 -r ipfs-ipns --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/pb/ipns.js src/pb/ipns.proto",
25-
"generate:proto-types": "pbts -o src/pb/ipns.d.ts src/pb/ipns.js",
149+
"clean": "aegir clean",
150+
"lint": "aegir lint",
151+
"dep-check": "aegir dep-check",
26152
"build": "aegir build",
27-
"clean": "rimraf dist types",
28-
"lint": "aegir ts -p check && aegir lint",
29-
"release": "aegir release --target node",
30-
"release-minor": "aegir release --type minor --target node",
31-
"release-major": "aegir release --type major --target node",
32-
"pretest": "aegir build --esm-tests",
33153
"test": "aegir test",
34-
"dep-check": "aegir dep-check -i rimraf"
154+
"test:node": "aegir test -t node --cov",
155+
"test:chrome": "aegir test -t browser --cov",
156+
"test:chrome-webworker": "aegir test -t webworker",
157+
"test:firefox": "aegir test -t browser -- --browser firefox",
158+
"test:firefox-webworker": "aegir test -t webworker -- --browser firefox",
159+
"test:electron-main": "aegir test -t electron-main",
160+
"release": "aegir release",
161+
"generate": "protons src/pb/ipns.proto"
35162
},
36-
"repository": {
37-
"type": "git",
38-
"url": "git+https://github.com/ipfs/js-ipns.git"
39-
},
40-
"keywords": [
41-
"ipfs",
42-
"ipns"
43-
],
44-
"author": "Vasco Santos <vasco.santos@moxy.studio>",
45-
"license": "MIT",
46-
"bugs": {
47-
"url": "https://github.com/ipfs/js-ipns/issues"
48-
},
49-
"homepage": "https://github.com/ipfs/js-ipns#readme",
50163
"dependencies": {
164+
"@libp2p/crypto": "^0.22.10",
165+
"@libp2p/interfaces": "^1.3.20",
166+
"@libp2p/logger": "^1.1.3",
167+
"@libp2p/peer-id": "^1.1.9",
51168
"cborg": "^1.3.3",
52169
"debug": "^4.2.0",
53170
"err-code": "^3.0.1",
54171
"interface-datastore": "^6.0.2",
55-
"libp2p-crypto": "^0.21.0",
56-
"long": "^4.0.0",
57172
"multiformats": "^9.4.5",
58-
"peer-id": "^0.16.0",
59-
"protobufjs": "^6.10.2",
173+
"protons-runtime": "^1.0.3",
60174
"timestamp-nano": "^1.0.0",
61175
"uint8arrays": "^3.0.0"
62176
},
63177
"devDependencies": {
178+
"@libp2p/peer-id-factory": "^1.0.9",
64179
"@types/debug": "^4.1.5",
65-
"aegir": "^36.0.2",
180+
"aegir": "^37.0.11",
66181
"npm-run-all": "^4.1.5",
182+
"protons": "3.0.3",
67183
"rimraf": "^3.0.2",
68184
"util": "^0.12.3"
69-
},
70-
"contributors": [
71-
"Vasco Santos <vasco.santos@moxy.studio>",
72-
"achingbrain <alex@achingbrain.net>",
73-
"Jacob Heun <jacobheun@gmail.com>",
74-
"Hugo Dias <hugomrdias@gmail.com>",
75-
"Hector Sanjuan <code@hector.link>",
76-
"dirkmc <dirkmdev@gmail.com>",
77-
"Alan Shaw <alan.shaw@protocol.ai>",
78-
"swedneck <40505480+swedneck@users.noreply.github.com>",
79-
"Bryan Stenson <bryan.stenson@gmail.com>",
80-
"Diogo Silva <fsdiogo@gmail.com>",
81-
"Esteban Ordano <eordano@gmail.com>",
82-
"Juhamatti Niemelä <iiska@iki.fi>",
83-
"Rob Brackett <rob@robbrackett.com>",
84-
"Steven Allen <steven@stebalien.com>"
85-
]
185+
}
86186
}

‎src/errors.js ‎src/errors.ts

+1
Original file line numberDiff line numberDiff line change
@@ -9,3 +9,4 @@ export const ERR_PUBLIC_KEY_FROM_ID = 'ERR_PUBLIC_KEY_FROM_ID'
99
export const ERR_UNDEFINED_PARAMETER = 'ERR_UNDEFINED_PARAMETER'
1010
export const ERR_INVALID_RECORD_DATA = 'ERR_INVALID_RECORD_DATA'
1111
export const ERR_INVALID_EMBEDDED_KEY = 'ERR_INVALID_EMBEDDED_KEY'
12+
export const ERR_MISSING_PRIVATE_KEY = 'ERR_MISSING_PRIVATE_KEY'

‎src/index.js

-505
This file was deleted.

‎src/index.ts

+158
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,158 @@
1+
import NanoDate from 'timestamp-nano'
2+
import { Key } from 'interface-datastore/key'
3+
import { unmarshalPrivateKey } from '@libp2p/crypto/keys'
4+
import errCode from 'err-code'
5+
import { base32upper } from 'multiformats/bases/base32'
6+
import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
7+
import { logger } from '@libp2p/logger'
8+
import { createCborData, ipnsEntryDataForV1Sig, ipnsEntryDataForV2Sig } from './utils.js'
9+
import * as ERRORS from './errors.js'
10+
import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
11+
import * as Digest from 'multiformats/hashes/digest'
12+
import { identity } from 'multiformats/hashes/identity'
13+
import { IpnsEntry } from './pb/ipns.js'
14+
import type { PrivateKey } from '@libp2p/interfaces/keys'
15+
import type { PeerId } from '@libp2p/interfaces/peer-id'
16+
17+
const log = logger('ipns')
18+
const ID_MULTIHASH_CODE = identity.code
19+
20+
export const namespace = '/ipns/'
21+
export const namespaceLength = namespace.length
22+
23+
export interface IPNSEntry {
24+
value: Uint8Array
25+
signature: Uint8Array // signature of the record
26+
validityType: IpnsEntry.ValidityType // Type of validation being used
27+
validity: Uint8Array // expiration datetime for the record in RFC3339 format
28+
sequence: bigint // number representing the version of the record
29+
ttl?: bigint // ttl in nanoseconds
30+
pubKey?: Uint8Array // the public portion of the key that signed this record (only present if it was not embedded in the IPNS key)
31+
signatureV2?: Uint8Array // the v2 signature of the record
32+
data?: Uint8Array // extensible data
33+
}
34+
35+
export interface IPNSEntryData {
36+
Value: Uint8Array
37+
Validity: Uint8Array
38+
ValidityType: IpnsEntry.ValidityType
39+
Sequence: bigint
40+
TTL: bigint
41+
}
42+
43+
export interface IDKeys {
44+
routingPubKey: Key
45+
pkKey: Key
46+
routingKey: Key
47+
ipnsKey: Key
48+
}
49+
50+
/**
51+
* Creates a new ipns entry and signs it with the given private key.
52+
* The ipns entry validity should follow the [RFC3339]{@link https://www.ietf.org/rfc/rfc3339.txt} with nanoseconds precision.
53+
* Note: This function does not embed the public key. If you want to do that, use `EmbedPublicKey`.
54+
*
55+
* @param {PeerId} peerId - peer id containing private key for signing the record.
56+
* @param {Uint8Array} value - value to be stored in the record.
57+
* @param {number | bigint} seq - number representing the current version of the record.
58+
* @param {number} lifetime - lifetime of the record (in milliseconds).
59+
*/
60+
export const create = async (peerId: PeerId, value: Uint8Array, seq: number | bigint, lifetime: number): Promise<IPNSEntry> => {
61+
// Validity in ISOString with nanoseconds precision and validity type EOL
62+
const expirationDate = new NanoDate(Date.now() + Number(lifetime))
63+
const validityType = IpnsEntry.ValidityType.EOL
64+
const [ms, ns] = lifetime.toString().split('.')
65+
const lifetimeNs = (BigInt(ms) * BigInt(100000)) + BigInt(ns ?? '0')
66+
67+
return await _create(peerId, value, seq, validityType, expirationDate, lifetimeNs)
68+
}
69+
70+
/**
71+
* Same as create(), but instead of generating a new Date, it receives the intended expiration time
72+
* WARNING: nano precision is not standard, make sure the value in seconds is 9 orders of magnitude lesser than the one provided.
73+
*
74+
* @param {PeerId} peerId - PeerId containing private key for signing the record.
75+
* @param {Uint8Array} value - value to be stored in the record.
76+
* @param {number | bigint} seq - number representing the current version of the record.
77+
* @param {string} expiration - expiration datetime for record in the [RFC3339]{@link https://www.ietf.org/rfc/rfc3339.txt} with nanoseconds precision.
78+
*/
79+
export const createWithExpiration = async (peerId: PeerId, value: Uint8Array, seq: number | bigint, expiration: string): Promise<IPNSEntry> => {
80+
const expirationDate = NanoDate.fromString(expiration)
81+
const validityType = IpnsEntry.ValidityType.EOL
82+
83+
const ttlMs = expirationDate.toDate().getTime() - Date.now()
84+
const ttlNs = (BigInt(ttlMs) * BigInt(100000)) + BigInt(expirationDate.getNano())
85+
86+
return await _create(peerId, value, seq, validityType, expirationDate, ttlNs)
87+
}
88+
89+
const _create = async (peerId: PeerId, value: Uint8Array, seq: number | bigint, validityType: IpnsEntry.ValidityType, expirationDate: NanoDate, ttl: bigint): Promise<IPNSEntry> => {
90+
seq = BigInt(seq)
91+
const isoValidity = uint8ArrayFromString(expirationDate.toString())
92+
93+
if (peerId.privateKey == null) {
94+
throw errCode(new Error('Missing private key'), ERRORS.ERR_MISSING_PRIVATE_KEY)
95+
}
96+
97+
const privateKey = await unmarshalPrivateKey(peerId.privateKey)
98+
const signatureV1 = await sign(privateKey, value, validityType, isoValidity)
99+
const data = createCborData(value, isoValidity, validityType, seq, ttl)
100+
const sigData = ipnsEntryDataForV2Sig(data)
101+
const signatureV2 = await privateKey.sign(sigData)
102+
103+
const entry: IPNSEntry = {
104+
value,
105+
signature: signatureV1,
106+
validityType: validityType,
107+
validity: isoValidity,
108+
sequence: seq,
109+
ttl,
110+
signatureV2,
111+
data
112+
}
113+
114+
// if we cannot derive the public key from the PeerId (e.g. RSA PeerIDs),
115+
// we have to embed it in the IPNS record
116+
if (peerId.publicKey != null) {
117+
const digest = Digest.decode(peerId.toBytes())
118+
119+
if (digest.code !== ID_MULTIHASH_CODE || !uint8ArrayEquals(peerId.publicKey, digest.digest)) {
120+
entry.pubKey = peerId.publicKey
121+
}
122+
}
123+
124+
log('ipns entry for %b created', value)
125+
return entry
126+
}
127+
128+
/**
129+
* rawStdEncoding with RFC4648
130+
*/
131+
const rawStdEncoding = (key: Uint8Array): string => base32upper.encode(key).slice(1)
132+
133+
/**
134+
* Get key for storing the record locally.
135+
* Format: /ipns/${base32(<HASH>)}
136+
*
137+
* @param {Uint8Array} key - peer identifier object.
138+
*/
139+
export const getLocalKey = (key: Uint8Array): Key => new Key(`/ipns/${rawStdEncoding(key)}`)
140+
141+
export { unmarshal } from './utils.js'
142+
export { marshal } from './utils.js'
143+
export { peerIdToRoutingKey } from './utils.js'
144+
export { peerIdFromRoutingKey } from './utils.js'
145+
146+
/**
147+
* Sign ipns record data
148+
*/
149+
const sign = async (privateKey: PrivateKey, value: Uint8Array, validityType: IpnsEntry.ValidityType, validity: Uint8Array) => {
150+
try {
151+
const dataForSignature = ipnsEntryDataForV1Sig(value, validityType, validity)
152+
153+
return await privateKey.sign(dataForSignature)
154+
} catch (error: any) {
155+
log.error('record signature creation failed', error)
156+
throw errCode(new Error('record signature creation failed'), ERRORS.ERR_SIGNATURE_CREATION)
157+
}
158+
}

‎src/pb/ipns.d.ts

-115
This file was deleted.

‎src/pb/ipns.js

-407
This file was deleted.

‎src/pb/ipns.proto

+12
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,28 @@
11
// https://github.com/ipfs/go-ipns/blob/master/pb/ipns.proto
22

3+
syntax = "proto3";
4+
35
message IpnsEntry {
46
enum ValidityType {
57
EOL = 0; // setting an EOL says "this record is valid until..."
68
}
79

10+
// value to be stored in the record
811
optional bytes value = 1;
12+
13+
// signature of the record
914
optional bytes signature = 2;
1015

16+
// Type of validation being used
1117
optional ValidityType validityType = 3;
18+
19+
// expiration datetime for the record in RFC3339 format
1220
optional bytes validity = 4;
1321

22+
// number representing the version of the record
1423
optional uint64 sequence = 5;
1524

25+
// ttl in nanoseconds
1626
optional uint64 ttl = 6;
1727

1828
// in order for nodes to properly validate a record upon receipt, they need the public
@@ -21,7 +31,9 @@ message IpnsEntry {
2131
// peerID, making this field unnecessary.
2232
optional bytes pubKey = 7;
2333

34+
// the v2 signature of the record
2435
optional bytes signatureV2 = 8;
2536

37+
// extensible data
2638
optional bytes data = 9;
2739
}

‎src/pb/ipns.ts

+51
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,51 @@
1+
/* eslint-disable import/export */
2+
/* eslint-disable @typescript-eslint/no-namespace */
3+
4+
import { enumeration, encodeMessage, decodeMessage, message, bytes, uint64 } from 'protons-runtime'
5+
import type { Codec } from 'protons-runtime'
6+
7+
export interface IpnsEntry {
8+
value?: Uint8Array
9+
signature?: Uint8Array
10+
validityType?: IpnsEntry.ValidityType
11+
validity?: Uint8Array
12+
sequence?: bigint
13+
ttl?: bigint
14+
pubKey?: Uint8Array
15+
signatureV2?: Uint8Array
16+
data?: Uint8Array
17+
}
18+
19+
export namespace IpnsEntry {
20+
export enum ValidityType {
21+
EOL = 'EOL'
22+
}
23+
24+
export namespace ValidityType {
25+
export const codec = () => {
26+
return enumeration<typeof ValidityType>(ValidityType)
27+
}
28+
}
29+
30+
export const codec = (): Codec<IpnsEntry> => {
31+
return message<IpnsEntry>({
32+
1: { name: 'value', codec: bytes, optional: true },
33+
2: { name: 'signature', codec: bytes, optional: true },
34+
3: { name: 'validityType', codec: IpnsEntry.ValidityType.codec(), optional: true },
35+
4: { name: 'validity', codec: bytes, optional: true },
36+
5: { name: 'sequence', codec: uint64, optional: true },
37+
6: { name: 'ttl', codec: uint64, optional: true },
38+
7: { name: 'pubKey', codec: bytes, optional: true },
39+
8: { name: 'signatureV2', codec: bytes, optional: true },
40+
9: { name: 'data', codec: bytes, optional: true }
41+
})
42+
}
43+
44+
export const encode = (obj: IpnsEntry): Uint8Array => {
45+
return encodeMessage(obj, IpnsEntry.codec())
46+
}
47+
48+
export const decode = (buf: Uint8Array): IpnsEntry => {
49+
return decodeMessage(buf, IpnsEntry.codec())
50+
}
51+
}

‎src/selector.ts

+49
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
1+
import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
2+
import { IpnsEntry } from './pb/ipns.js'
3+
import { parseRFC3339 } from './utils.js'
4+
import type { SelectFn } from '@libp2p/interfaces/dht'
5+
6+
export const ipnsSelector: SelectFn = (key, data) => {
7+
const entries = data.map((buf, index) => ({
8+
entry: IpnsEntry.decode(buf),
9+
index
10+
}))
11+
12+
entries.sort((a, b) => {
13+
// having a newer signature version is better than an older signature version
14+
if (a.entry.signatureV2 != null && b.entry.signatureV2 == null) {
15+
return -1
16+
} else if (a.entry.signatureV2 == null && b.entry.signatureV2 != null) {
17+
return 1
18+
}
19+
20+
const aSeq = a.entry.sequence ?? 0n
21+
const bSeq = b.entry.sequence ?? 0n
22+
23+
// choose later sequence number
24+
if (aSeq > bSeq) {
25+
return -1
26+
} else if (aSeq < bSeq) {
27+
return 1
28+
}
29+
30+
const aValidty = a.entry.validity ?? new Uint8Array(0)
31+
const bValidty = b.entry.validity ?? new Uint8Array(0)
32+
33+
// choose longer lived record if sequence numbers the same
34+
const entryAValidityDate = parseRFC3339(uint8ArrayToString(aValidty))
35+
const entryBValidityDate = parseRFC3339(uint8ArrayToString(bValidty))
36+
37+
if (entryAValidityDate.getTime() > entryBValidityDate.getTime()) {
38+
return -1
39+
}
40+
41+
if (entryAValidityDate.getTime() < entryBValidityDate.getTime()) {
42+
return 1
43+
}
44+
45+
return 0
46+
})
47+
48+
return entries[0].index
49+
}

‎src/types.ts

-14
This file was deleted.

‎src/utils.js

-51
This file was deleted.

‎src/utils.ts

+190
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,190 @@
1+
import errCode from 'err-code'
2+
import type { PeerId } from '@libp2p/interfaces/peer-id'
3+
import type { IPNSEntry, IPNSEntryData } from './index.js'
4+
import * as ERRORS from './errors.js'
5+
import { unmarshalPublicKey } from '@libp2p/crypto/keys'
6+
import { peerIdFromBytes, peerIdFromKeys } from '@libp2p/peer-id'
7+
import { logger } from '@libp2p/logger'
8+
import { IpnsEntry } from './pb/ipns.js'
9+
import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
10+
import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
11+
import * as cborg from 'cborg'
12+
13+
const log = logger('ipns:utils')
14+
const IPNS_PREFIX = uint8ArrayFromString('/ipns/')
15+
16+
/**
17+
* Convert a JavaScript date into an `RFC3339Nano` formatted
18+
* string
19+
*/
20+
export function toRFC3339 (time: Date) {
21+
const year = time.getUTCFullYear()
22+
const month = String(time.getUTCMonth() + 1).padStart(2, '0')
23+
const day = String(time.getUTCDate()).padStart(2, '0')
24+
const hour = String(time.getUTCHours()).padStart(2, '0')
25+
const minute = String(time.getUTCMinutes()).padStart(2, '0')
26+
const seconds = String(time.getUTCSeconds()).padStart(2, '0')
27+
const milliseconds = time.getUTCMilliseconds()
28+
const nanoseconds = milliseconds * 1000 * 1000
29+
30+
return `${year}-${month}-${day}T${hour}:${minute}:${seconds}.${nanoseconds}Z`
31+
}
32+
33+
/**
34+
* Parses a date string formatted as `RFC3339Nano` into a
35+
* JavaScript Date object
36+
*/
37+
export function parseRFC3339 (time: string) {
38+
const rfc3339Matcher = new RegExp(
39+
// 2006-01-02T
40+
'(\\d{4})-(\\d{2})-(\\d{2})T' +
41+
// 15:04:05
42+
'(\\d{2}):(\\d{2}):(\\d{2})' +
43+
// .999999999Z
44+
'\\.(\\d+)Z'
45+
)
46+
const m = String(time).trim().match(rfc3339Matcher)
47+
48+
if (m == null) {
49+
throw new Error('Invalid format')
50+
}
51+
52+
const year = parseInt(m[1], 10)
53+
const month = parseInt(m[2], 10) - 1
54+
const date = parseInt(m[3], 10)
55+
const hour = parseInt(m[4], 10)
56+
const minute = parseInt(m[5], 10)
57+
const second = parseInt(m[6], 10)
58+
const millisecond = parseInt(m[7].slice(0, -6), 10)
59+
60+
return new Date(Date.UTC(year, month, date, hour, minute, second, millisecond))
61+
}
62+
63+
/**
64+
* Extracts a public key from the passed PeerId, falling
65+
* back to the pubKey embedded in the ipns record
66+
*/
67+
export const extractPublicKey = async (peerId: PeerId, entry: IpnsEntry) => {
68+
if (entry == null || peerId == null) {
69+
const error = new Error('one or more of the provided parameters are not defined')
70+
71+
log.error(error)
72+
throw errCode(error, ERRORS.ERR_UNDEFINED_PARAMETER)
73+
}
74+
75+
let pubKey
76+
77+
if (entry.pubKey != null) {
78+
try {
79+
pubKey = unmarshalPublicKey(entry.pubKey)
80+
} catch (err) {
81+
log.error(err)
82+
throw err
83+
}
84+
85+
const otherId = await peerIdFromKeys(entry.pubKey)
86+
87+
if (!otherId.equals(peerId)) {
88+
throw errCode(new Error('Embedded public key did not match PeerID'), ERRORS.ERR_INVALID_EMBEDDED_KEY)
89+
}
90+
} else if (peerId.publicKey != null) {
91+
pubKey = unmarshalPublicKey(peerId.publicKey)
92+
}
93+
94+
if (pubKey != null) {
95+
return pubKey
96+
}
97+
98+
throw errCode(new Error('no public key is available'), ERRORS.ERR_UNDEFINED_PARAMETER)
99+
}
100+
101+
/**
102+
* Utility for creating the record data for being signed
103+
*/
104+
export const ipnsEntryDataForV1Sig = (value: Uint8Array, validityType: IpnsEntry.ValidityType, validity: Uint8Array): Uint8Array => {
105+
const validityTypeBuffer = uint8ArrayFromString(validityType)
106+
107+
return uint8ArrayConcat([value, validity, validityTypeBuffer])
108+
}
109+
110+
/**
111+
* Utility for creating the record data for being signed
112+
*/
113+
export const ipnsEntryDataForV2Sig = (data: Uint8Array): Uint8Array => {
114+
const entryData = uint8ArrayFromString('ipns-signature:')
115+
116+
return uint8ArrayConcat([entryData, data])
117+
}
118+
119+
export const marshal = (obj: IPNSEntry): Uint8Array => {
120+
return IpnsEntry.encode(obj)
121+
}
122+
123+
export const unmarshal = (buf: Uint8Array): IPNSEntry => {
124+
const message = IpnsEntry.decode(buf)
125+
126+
return {
127+
value: message.value ?? new Uint8Array(0),
128+
signature: message.signature ?? new Uint8Array(0),
129+
validityType: message.validityType ?? IpnsEntry.ValidityType.EOL,
130+
validity: message.validity ?? new Uint8Array(0),
131+
sequence: message.sequence ?? 0n,
132+
pubKey: message.pubKey,
133+
ttl: message.ttl ?? undefined,
134+
signatureV2: message.signatureV2,
135+
data: message.data
136+
}
137+
}
138+
139+
export const peerIdToRoutingKey = (peerId: PeerId): Uint8Array => {
140+
return uint8ArrayConcat([
141+
IPNS_PREFIX,
142+
peerId.toBytes()
143+
])
144+
}
145+
146+
export const peerIdFromRoutingKey = (key: Uint8Array): PeerId => {
147+
return peerIdFromBytes(key.slice(IPNS_PREFIX.length))
148+
}
149+
150+
export const createCborData = (value: Uint8Array, validity: Uint8Array, validityType: string, sequence: bigint, ttl: bigint): Uint8Array => {
151+
let ValidityType
152+
153+
if (validityType === IpnsEntry.ValidityType.EOL) {
154+
ValidityType = 0
155+
} else {
156+
throw errCode(new Error('Unknown validity type'), ERRORS.ERR_UNRECOGNIZED_VALIDITY)
157+
}
158+
159+
const data = {
160+
Value: value,
161+
Validity: validity,
162+
ValidityType,
163+
Sequence: sequence,
164+
TTL: ttl
165+
}
166+
167+
return cborg.encode(data)
168+
}
169+
170+
export const parseCborData = (buf: Uint8Array): IPNSEntryData => {
171+
const data = cborg.decode(buf)
172+
173+
if (data.ValidityType === 0) {
174+
data.ValidityType = IpnsEntry.ValidityType.EOL
175+
} else {
176+
throw errCode(new Error('Unknown validity type'), ERRORS.ERR_UNRECOGNIZED_VALIDITY)
177+
}
178+
179+
if (Number.isInteger(data.Sequence)) {
180+
// sequence must be a BigInt, but DAG-CBOR doesn't preserve this for Numbers within the safe-integer range
181+
data.Sequence = BigInt(data.Sequence)
182+
}
183+
184+
if (Number.isInteger(data.TTL)) {
185+
// ttl must be a BigInt, but DAG-CBOR doesn't preserve this for Numbers within the safe-integer range
186+
data.TTL = BigInt(data.TTL)
187+
}
188+
189+
return data
190+
}

‎src/validator.ts

+106
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,106 @@
1+
import errCode from 'err-code'
2+
import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
3+
import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
4+
import { IpnsEntry } from './pb/ipns.js'
5+
import { parseRFC3339, extractPublicKey, ipnsEntryDataForV1Sig, ipnsEntryDataForV2Sig, unmarshal, peerIdFromRoutingKey, parseCborData } from './utils.js'
6+
import * as ERRORS from './errors.js'
7+
import type { IPNSEntry } from './index.js'
8+
import type { PublicKey } from '@libp2p/interfaces/keys'
9+
import type { ValidateFn } from '@libp2p/interfaces/dht'
10+
import { logger } from '@libp2p/logger'
11+
12+
const log = logger('ipns:validator')
13+
14+
/**
15+
* Validates the given ipns entry against the given public key
16+
*/
17+
export const validate = async (publicKey: PublicKey, entry: IPNSEntry) => {
18+
const { value, validityType, validity } = entry
19+
20+
let dataForSignature: Uint8Array
21+
let signature: Uint8Array
22+
23+
// Check v2 signature if it's available, otherwise use the v1 signature
24+
if ((entry.signatureV2 != null) && (entry.data != null)) {
25+
signature = entry.signatureV2
26+
dataForSignature = ipnsEntryDataForV2Sig(entry.data)
27+
28+
validateCborDataMatchesPbData(entry)
29+
} else {
30+
signature = entry.signature ?? new Uint8Array(0)
31+
dataForSignature = ipnsEntryDataForV1Sig(value, validityType, validity)
32+
}
33+
34+
// Validate Signature
35+
let isValid
36+
try {
37+
isValid = await publicKey.verify(dataForSignature, signature)
38+
} catch (err) {
39+
isValid = false
40+
}
41+
if (!isValid) {
42+
log.error('record signature verification failed')
43+
throw errCode(new Error('record signature verification failed'), ERRORS.ERR_SIGNATURE_VERIFICATION)
44+
}
45+
46+
// Validate according to the validity type
47+
if (validity != null && validityType === IpnsEntry.ValidityType.EOL) {
48+
let validityDate
49+
50+
try {
51+
validityDate = parseRFC3339(uint8ArrayToString(validity))
52+
} catch (e) {
53+
log.error('unrecognized validity format (not an rfc3339 format)')
54+
throw errCode(new Error('unrecognized validity format (not an rfc3339 format)'), ERRORS.ERR_UNRECOGNIZED_FORMAT)
55+
}
56+
57+
if (validityDate.getTime() < Date.now()) {
58+
log.error('record has expired')
59+
throw errCode(new Error('record has expired'), ERRORS.ERR_IPNS_EXPIRED_RECORD)
60+
}
61+
} else if (validityType != null) {
62+
log.error('unrecognized validity type')
63+
throw errCode(new Error('unrecognized validity type'), ERRORS.ERR_UNRECOGNIZED_VALIDITY)
64+
}
65+
66+
log('ipns entry for %b is valid', value)
67+
}
68+
69+
const validateCborDataMatchesPbData = (entry: IPNSEntry) => {
70+
if (entry.data == null) {
71+
throw errCode(new Error('Record data is missing'), ERRORS.ERR_INVALID_RECORD_DATA)
72+
}
73+
74+
const data = parseCborData(entry.data)
75+
76+
if (!uint8ArrayEquals(data.Value, entry.value)) {
77+
throw errCode(new Error('Field "value" did not match between protobuf and CBOR'), ERRORS.ERR_SIGNATURE_VERIFICATION)
78+
}
79+
80+
if (!uint8ArrayEquals(data.Validity, entry.validity)) {
81+
throw errCode(new Error('Field "validity" did not match between protobuf and CBOR'), ERRORS.ERR_SIGNATURE_VERIFICATION)
82+
}
83+
84+
if (data.ValidityType !== entry.validityType) {
85+
throw errCode(new Error('Field "validityType" did not match between protobuf and CBOR'), ERRORS.ERR_SIGNATURE_VERIFICATION)
86+
}
87+
88+
if (data.Sequence !== entry.sequence) {
89+
throw errCode(new Error('Field "sequence" did not match between protobuf and CBOR'), ERRORS.ERR_SIGNATURE_VERIFICATION)
90+
}
91+
92+
if (data.TTL !== entry.ttl) {
93+
throw errCode(new Error('Field "ttl" did not match between protobuf and CBOR'), ERRORS.ERR_SIGNATURE_VERIFICATION)
94+
}
95+
}
96+
97+
export const ipnsValidator: ValidateFn = async (key, marshalledData) => {
98+
const peerId = peerIdFromRoutingKey(key)
99+
const receivedEntry = unmarshal(marshalledData)
100+
101+
// extract public key
102+
const pubKey = await extractPublicKey(peerId, receivedEntry)
103+
104+
// Record validation
105+
await validate(pubKey, receivedEntry)
106+
}

‎test/index.spec.js

-352
This file was deleted.

‎test/index.spec.ts

+202
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,202 @@
1+
/* eslint-env mocha */
2+
3+
import { expect } from 'aegir/chai'
4+
import { base58btc } from 'multiformats/bases/base58'
5+
import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
6+
import { peerIdFromKeys, peerIdFromString } from '@libp2p/peer-id'
7+
import { generateKeyPair } from '@libp2p/crypto/keys'
8+
import { randomBytes } from '@libp2p/crypto'
9+
import * as ipns from '../src/index.js'
10+
import * as ERRORS from '../src/errors.js'
11+
import type { PeerId } from '@libp2p/interfaces/peer-id'
12+
import { unmarshal, marshal, extractPublicKey, peerIdToRoutingKey } from '../src/utils.js'
13+
import { ipnsValidator } from '../src/validator.js'
14+
import { createEd25519PeerId } from '@libp2p/peer-id-factory'
15+
16+
describe('ipns', function () {
17+
this.timeout(20 * 1000)
18+
19+
const cid = uint8ArrayFromString('QmWEekX7EZLUd9VXRNMRXW3LXe4F6x7mB8oPxY5XLptrBq')
20+
let peerId: PeerId
21+
22+
before(async () => {
23+
const rsa = await generateKeyPair('RSA', 2048)
24+
peerId = await peerIdFromKeys(rsa.public.bytes, rsa.bytes)
25+
})
26+
27+
it('should create an ipns record correctly', async () => {
28+
const sequence = 0
29+
const validity = 1000000
30+
31+
const entry = await ipns.create(peerId, cid, sequence, validity)
32+
expect(entry).to.deep.include({
33+
value: cid,
34+
sequence: BigInt(sequence)
35+
})
36+
expect(entry).to.have.property('validity')
37+
expect(entry).to.have.property('signature')
38+
expect(entry).to.have.property('validityType')
39+
expect(entry).to.have.property('signatureV2')
40+
expect(entry).to.have.property('data')
41+
})
42+
43+
it('should be able to create a record with a fixed expiration', async () => {
44+
const sequence = 0
45+
// 2033-05-18T03:33:20.000000000Z
46+
const expiration = '2033-05-18T03:33:20.000000000Z'
47+
48+
const entry = await ipns.createWithExpiration(peerId, cid, sequence, expiration)
49+
50+
await ipnsValidator(peerIdToRoutingKey(peerId), marshal(entry))
51+
expect(entry).to.have.property('validity')
52+
expect(entry.validity).to.equalBytes(uint8ArrayFromString('2033-05-18T03:33:20.000000000Z'))
53+
})
54+
55+
it('should create an ipns record and validate it correctly', async () => {
56+
const sequence = 0
57+
const validity = 1000000
58+
59+
const entry = await ipns.create(peerId, cid, sequence, validity)
60+
await ipnsValidator(peerIdToRoutingKey(peerId), marshal(entry))
61+
})
62+
63+
it('should validate a v1 message', async () => {
64+
const sequence = 0
65+
const validity = 1000000
66+
67+
const entry = await ipns.create(peerId, cid, sequence, validity)
68+
69+
// extra fields added for v2 sigs
70+
delete entry.data
71+
delete entry.signatureV2
72+
73+
await ipnsValidator(peerIdToRoutingKey(peerId), marshal(entry))
74+
})
75+
76+
it('should fail to validate a bad record', async () => {
77+
const sequence = 0
78+
const validity = 1000000
79+
80+
const entry = await ipns.create(peerId, cid, sequence, validity)
81+
82+
// corrupt the record by changing the value to random bytes
83+
entry.value = randomBytes(46)
84+
85+
await expect(ipnsValidator(peerIdToRoutingKey(peerId), marshal(entry))).to.eventually.be.rejected().with.property('code', ERRORS.ERR_SIGNATURE_VERIFICATION)
86+
})
87+
88+
it('should create an ipns record with a validity of 1 nanosecond correctly and it should not be valid 1ms later', async () => {
89+
const sequence = 0
90+
const validity = 0.00001
91+
92+
const entry = await ipns.create(peerId, cid, sequence, validity)
93+
94+
await new Promise(resolve => setTimeout(resolve, 1))
95+
96+
await expect(ipnsValidator(peerIdToRoutingKey(peerId), marshal(entry))).to.eventually.be.rejected().with.property('code', ERRORS.ERR_IPNS_EXPIRED_RECORD)
97+
})
98+
99+
it('should create an ipns record, marshal and unmarshal it, as well as validate it correctly', async () => {
100+
const sequence = 0
101+
const validity = 1000000
102+
103+
const entryDataCreated = await ipns.create(peerId, cid, sequence, validity)
104+
105+
const marshalledData = marshal(entryDataCreated)
106+
const unmarshalledData = unmarshal(marshalledData)
107+
108+
expect(entryDataCreated.value).to.equalBytes(unmarshalledData.value)
109+
expect(entryDataCreated.validity).to.equalBytes(unmarshalledData.validity)
110+
expect(entryDataCreated.validityType).to.equal(unmarshalledData.validityType)
111+
expect(entryDataCreated.signature).to.equalBytes(unmarshalledData.signature)
112+
expect(entryDataCreated.sequence).to.equal(unmarshalledData.sequence)
113+
expect(entryDataCreated.ttl).to.equal(unmarshalledData.ttl)
114+
115+
if (unmarshalledData.signatureV2 == null) {
116+
throw new Error('No v2 sig found')
117+
}
118+
119+
expect(entryDataCreated.signatureV2).to.equalBytes(unmarshalledData.signatureV2)
120+
121+
if (unmarshalledData.data == null) {
122+
throw new Error('No v2 data found')
123+
}
124+
125+
expect(entryDataCreated.data).to.equalBytes(unmarshalledData.data)
126+
127+
await ipnsValidator(peerIdToRoutingKey(peerId), marshal(unmarshalledData))
128+
})
129+
130+
it('should get datastore key correctly', () => {
131+
const datastoreKey = ipns.getLocalKey(base58btc.decode(`z${peerId.toString()}`))
132+
133+
expect(datastoreKey).to.exist()
134+
expect(datastoreKey.toString()).to.startWith('/ipns/CIQ')
135+
})
136+
137+
it('should be able to turn routing key back into id', () => {
138+
const keys = [
139+
'QmQd5Enz5tzP8u5wHur8ADuJMbcNhEf86CkWkqRzoWUhst',
140+
'QmW6mcoqDKJRch2oph2FmvZhPLJn6wPU648Vv9iMyMtmtG'
141+
]
142+
143+
keys.forEach(key => {
144+
const routingKey = ipns.peerIdToRoutingKey(peerIdFromString(key))
145+
const id = ipns.peerIdFromRoutingKey(routingKey)
146+
147+
expect(id.toString()).to.equal(key)
148+
})
149+
})
150+
151+
it('should be able to embed a public key in an ipns record', async () => {
152+
const sequence = 0
153+
const validity = 1000000
154+
155+
const entry = await ipns.create(peerId, cid, sequence, validity)
156+
157+
expect(entry).to.deep.include({
158+
pubKey: peerId.publicKey
159+
})
160+
})
161+
162+
// It should have a public key embedded for newer ed25519 keys
163+
// https://github.com/ipfs/go-ipns/blob/d51115b4b14ed7fcca5472aadff0fee6772aca8c/ipns.go#L81
164+
// https://github.com/ipfs/go-ipns/blob/d51115b4b14ed7fcca5472aadff0fee6772aca8c/ipns_test.go
165+
// https://github.com/libp2p/go-libp2p-peer/blob/7f219a1e70011a258c5d3e502aef6896c60d03ce/peer.go#L80
166+
// IDFromEd25519PublicKey is not currently implement on js-libp2p-peer
167+
// https://github.com/libp2p/go-libp2p-peer/pull/30
168+
it('should be able to extract a public key directly from the peer', async () => {
169+
const sequence = 0
170+
const validity = 1000000
171+
172+
const ed25519 = await createEd25519PeerId()
173+
const entry = await ipns.create(ed25519, cid, sequence, validity)
174+
175+
expect(entry).to.not.have.property('pubKey') // ed25519 keys should not be embedded
176+
})
177+
178+
it('validator with no valid public key should error', async () => {
179+
const sequence = 0
180+
const validity = 1000000
181+
182+
const entry = await ipns.create(peerId, cid, sequence, validity)
183+
delete entry.pubKey
184+
185+
const marshalledData = marshal(entry)
186+
const key = peerIdToRoutingKey(peerId)
187+
188+
await expect(ipnsValidator(key, marshalledData)).to.eventually.be.rejected().with.property('code', ERRORS.ERR_UNDEFINED_PARAMETER)
189+
})
190+
191+
it('should be able to export a previously embedded public key from an ipns record', async () => {
192+
const sequence = 0
193+
const validity = 1000000
194+
195+
const entry = await ipns.create(peerId, cid, sequence, validity)
196+
197+
const publicKey = await extractPublicKey(peerId, entry)
198+
expect(publicKey).to.deep.include({
199+
bytes: peerId.publicKey
200+
})
201+
})
202+
})

‎test/selector.spec.ts

+81
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,81 @@
1+
/* eslint-env mocha */
2+
3+
import { expect } from 'aegir/chai'
4+
import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
5+
import { peerIdFromKeys } from '@libp2p/peer-id'
6+
import { generateKeyPair } from '@libp2p/crypto/keys'
7+
import * as ipns from '../src/index.js'
8+
import { marshal, peerIdToRoutingKey } from '../src/utils.js'
9+
import { ipnsSelector } from '../src/selector.js'
10+
import type { PeerId } from '@libp2p/interfaces/peer-id'
11+
12+
describe('selector', function () {
13+
this.timeout(20 * 1000)
14+
15+
const cid = uint8ArrayFromString('QmWEekX7EZLUd9VXRNMRXW3LXe4F6x7mB8oPxY5XLptrBq')
16+
let peerId: PeerId
17+
18+
before(async () => {
19+
const rsa = await generateKeyPair('RSA', 2048)
20+
peerId = await peerIdFromKeys(rsa.public.bytes, rsa.bytes)
21+
})
22+
23+
it('should use validator.select to select the record with the highest sequence number', async () => {
24+
const sequence = 0
25+
const lifetime = 1000000
26+
27+
const entry = await ipns.create(peerId, cid, sequence, lifetime)
28+
const newEntry = await ipns.create(peerId, cid, (sequence + 1), lifetime)
29+
30+
const marshalledData = marshal(entry)
31+
const marshalledNewData = marshal(newEntry)
32+
33+
const key = peerIdToRoutingKey(peerId)
34+
35+
let valid = ipnsSelector(key, [marshalledNewData, marshalledData])
36+
expect(valid).to.equal(0) // new data is the selected one
37+
38+
valid = ipnsSelector(key, [marshalledData, marshalledNewData])
39+
expect(valid).to.equal(1) // new data is the selected one
40+
})
41+
42+
it('should use validator.select to select the record with the longest validity', async () => {
43+
const sequence = 0
44+
const lifetime = 1000000
45+
46+
const entry = await ipns.create(peerId, cid, sequence, lifetime)
47+
const newEntry = await ipns.create(peerId, cid, sequence, (lifetime + 1))
48+
49+
const marshalledData = marshal(entry)
50+
const marshalledNewData = marshal(newEntry)
51+
52+
const key = peerIdToRoutingKey(peerId)
53+
54+
let valid = ipnsSelector(key, [marshalledNewData, marshalledData])
55+
expect(valid).to.equal(0) // new data is the selected one
56+
57+
valid = ipnsSelector(key, [marshalledData, marshalledNewData])
58+
expect(valid).to.equal(1) // new data is the selected one
59+
})
60+
61+
it('should use validator.select to select an older record with a v2 sig when the newer record only uses v1', async () => {
62+
const sequence = 0
63+
const lifetime = 1000000
64+
65+
const entry = await ipns.create(peerId, cid, sequence, lifetime)
66+
67+
const newEntry = await ipns.create(peerId, cid, sequence + 1, lifetime)
68+
delete newEntry.signatureV2
69+
70+
const marshalledData = marshal(entry)
71+
const marshalledNewData = marshal(newEntry)
72+
73+
const key = peerIdToRoutingKey(peerId)
74+
75+
let valid = ipnsSelector(key, [marshalledNewData, marshalledData])
76+
expect(valid).to.equal(1) // old data is the selected one
77+
78+
valid = ipnsSelector(key, [marshalledData, marshalledNewData])
79+
expect(valid).to.equal(0) // old data is the selected one
80+
})
81+
})

‎test/validator.spec.ts

+83
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,83 @@
1+
/* eslint-env mocha */
2+
3+
import { expect } from 'aegir/chai'
4+
import { base58btc } from 'multiformats/bases/base58'
5+
import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
6+
import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
7+
import { peerIdFromKeys } from '@libp2p/peer-id'
8+
import { generateKeyPair } from '@libp2p/crypto/keys'
9+
import { randomBytes } from '@libp2p/crypto'
10+
import * as ipns from '../src/index.js'
11+
import * as ERRORS from '../src/errors.js'
12+
import type { PeerId } from '@libp2p/interfaces/peer-id'
13+
import { marshal, peerIdToRoutingKey } from '../src/utils.js'
14+
import { ipnsValidator } from '../src/validator.js'
15+
16+
describe('validator', function () {
17+
this.timeout(20 * 1000)
18+
19+
const cid = uint8ArrayFromString('QmWEekX7EZLUd9VXRNMRXW3LXe4F6x7mB8oPxY5XLptrBq')
20+
let peerId1: PeerId
21+
let peerId2: PeerId
22+
23+
before(async () => {
24+
const rsa = await generateKeyPair('RSA', 2048)
25+
peerId1 = await peerIdFromKeys(rsa.public.bytes, rsa.bytes)
26+
27+
const rsa2 = await generateKeyPair('RSA', 2048)
28+
peerId2 = await peerIdFromKeys(rsa2.public.bytes, rsa2.bytes)
29+
})
30+
31+
it('should validate a record', async () => {
32+
const sequence = 0
33+
const validity = 1000000
34+
35+
const entry = await ipns.create(peerId1, cid, sequence, validity)
36+
const marshalledData = marshal(entry)
37+
38+
const keyBytes = base58btc.decode(`z${peerId1.toString()}`)
39+
const key = uint8ArrayConcat([uint8ArrayFromString('/ipns/'), keyBytes])
40+
41+
await ipnsValidator(key, marshalledData)
42+
})
43+
44+
it('should use validator.validate to verify that a record is not valid', async () => {
45+
const sequence = 0
46+
const validity = 1000000
47+
48+
const entry = await ipns.create(peerId1, cid, sequence, validity)
49+
50+
// corrupt the record by changing the value to random bytes
51+
entry.value = randomBytes(entry.value.length)
52+
const marshalledData = marshal(entry)
53+
54+
const key = peerIdToRoutingKey(peerId1)
55+
56+
await expect(ipnsValidator(key, marshalledData)).to.eventually.be.rejected().with.property('code', ERRORS.ERR_SIGNATURE_VERIFICATION)
57+
})
58+
59+
it('should use validator.validate to verify that a record is not valid when it is passed with the wrong IPNS key', async () => {
60+
const sequence = 0
61+
const validity = 1000000
62+
63+
const entry = await ipns.create(peerId1, cid, sequence, validity)
64+
const marshalledData = marshal(entry)
65+
66+
const key = peerIdToRoutingKey(peerId2)
67+
68+
await expect(ipnsValidator(key, marshalledData)).to.eventually.be.rejected().with.property('code', ERRORS.ERR_INVALID_EMBEDDED_KEY)
69+
})
70+
71+
it('should use validator.validate to verify that a record is not valid when the wrong key is embedded', async () => {
72+
const sequence = 0
73+
const validity = 1000000
74+
75+
const entry = await ipns.create(peerId1, cid, sequence, validity)
76+
entry.pubKey = peerId2.publicKey
77+
const marshalledData = marshal(entry)
78+
79+
const key = peerIdToRoutingKey(peerId1)
80+
81+
await expect(ipnsValidator(key, marshalledData)).to.eventually.be.rejected().with.property('code', ERRORS.ERR_INVALID_EMBEDDED_KEY)
82+
})
83+
})

‎tsconfig.json

+1-4
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,10 @@
11
{
22
"extends": "aegir/src/config/tsconfig.aegir.json",
33
"compilerOptions": {
4-
"outDir": "types"
4+
"outDir": "dist"
55
},
66
"include": [
77
"src",
88
"test"
9-
],
10-
"exclude": [
11-
"src/pb/ipns.js"
129
]
1310
}

0 commit comments

Comments
 (0)
Please sign in to comment.