@helia/ipns 9.2.1-ae98a4f4 → 9.2.1-ed6c3b79

package/dist/src/validator.js

@@ -0,0 +1,58 @@
+import NanoDate from 'timestamp-nano';
+import { InvalidEmbeddedPublicKeyError, RecordExpiredError, SignatureVerificationError, UnsupportedValidityError } from "./errors.js";
+import { IpnsEntry } from "./pb/ipns.js";
+import { ipnsRecordDataForV2Sig } from "./utils.js";
+/**
+ * Validate the given IPNS record against the given routing key.
+ *
+ * @see https://specs.ipfs.tech/ipns/ipns-record/#routing-record for the binary
+ * format of the routing key
+ */
+export async function ipnsValidator(record, options) {
+    if (record.publicKey == null) {
+        throw new InvalidEmbeddedPublicKeyError('The record had no public key associated with it');
+    }
+    // Validate Signature V2
+    let isValid;
+    try {
+        const dataForSignature = ipnsRecordDataForV2Sig(record.data);
+        isValid = await record.publicKey.verify(dataForSignature, record.signatureV2, options);
+    }
+    catch {
+        isValid = false;
+    }
+    if (!isValid) {
+        throw new SignatureVerificationError('Record signature verification failed');
+    }
+    // Validate according to the validity type
+    if (record.validityType === IpnsEntry.ValidityType.EOL) {
+        if (NanoDate.fromString(record.validity).toDate().getTime() < Date.now()) {
+            throw new RecordExpiredError('record has expired');
+        }
+    }
+    else if (record.validityType != null) {
+        throw new UnsupportedValidityError('The validity type is unsupported');
+    }
+}
+/**
+ * Returns the number of milliseconds until the record expires.
+ * If the record is already expired, returns 0.
+ *
+ * @param record - The IPNS record to validate.
+ * @returns The number of milliseconds until the record expires, or 0 if the record is already expired.
+ */
+export function validFor(record) {
+    if (record.validityType !== IpnsEntry.ValidityType.EOL) {
+        throw new UnsupportedValidityError();
+    }
+    if (record.validity == null) {
+        throw new UnsupportedValidityError();
+    }
+    const validUntil = NanoDate.fromString(record.validity).toDate().getTime();
+    const now = Date.now();
+    if (validUntil < now) {
+        return 0;
+    }
+    return validUntil - now;
+}
+//# sourceMappingURL=validator.js.map

package/dist/src/validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.js","sourceRoot":"","sources":["../../src/validator.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,gBAAgB,CAAA;AACrC,OAAO,EAAE,6BAA6B,EAAE,kBAAkB,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AACrI,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAInD;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAE,MAAkB,EAAE,OAAsB;IAC7E,IAAI,MAAM,CAAC,SAAS,IAAI,IAAI,EAAE,CAAC;QAC7B,MAAM,IAAI,6BAA6B,CAAC,iDAAiD,CAAC,CAAA;IAC5F,CAAC;IAED,wBAAwB;IACxB,IAAI,OAAO,CAAA;IAEX,IAAI,CAAC;QACH,MAAM,gBAAgB,GAAG,sBAAsB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;QAC5D,OAAO,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAA;IACxF,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,GAAG,KAAK,CAAA;IACjB,CAAC;IAED,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,0BAA0B,CAAC,sCAAsC,CAAC,CAAA;IAC9E,CAAC;IAED,0CAA0C;IAC1C,IAAI,MAAM,CAAC,YAAY,KAAK,SAAS,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC;QACvD,IAAI,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;YACzE,MAAM,IAAI,kBAAkB,CAAC,oBAAoB,CAAC,CAAA;QACpD,CAAC;IACH,CAAC;SAAM,IAAI,MAAM,CAAC,YAAY,IAAI,IAAI,EAAE,CAAC;QACvC,MAAM,IAAI,wBAAwB,CAAC,kCAAkC,CAAC,CAAA;IACxE,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CAAE,MAAkB;IAC1C,IAAI,MAAM,CAAC,YAAY,KAAK,SAAS,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC;QACvD,MAAM,IAAI,wBAAwB,EAAE,CAAA;IACtC,CAAC;IAED,IAAI,MAAM,CAAC,QAAQ,IAAI,IAAI,EAAE,CAAC;QAC5B,MAAM,IAAI,wBAAwB,EAAE,CAAA;IACtC,CAAC;IAED,MAAM,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,CAAA;IAC1E,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;IAEtB,IAAI,UAAU,GAAG,GAAG,EAAE,CAAC;QACrB,OAAO,CAAC,CAAA;IACV,CAAC;IAED,OAAO,UAAU,GAAG,GAAG,CAAA;AACzB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helia/ipns",
-  "version": "9.2.1-ae98a4f4",
+  "version": "9.2.1-ed6c3b79",
   "description": "An implementation of IPNS for Helia",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/ipfs/helia/tree/main/packages/ipns#readme",
@@ -66,7 +66,7 @@
     "doc-check": "aegir doc-check",
     "build": "aegir build",
     "docs": "aegir docs",
-    "generate": "protons ./src/pb/metadata.proto",
+    "generate": "protons ./src/pb/*.proto",
     "test": "aegir test",
     "test:chrome": "aegir test -t browser --cov",
     "test:chrome-webworker": "aegir test -t webworker",
@@ -76,34 +76,35 @@
     "test:electron-main": "aegir test -t electron-main"
   },
   "dependencies": {
-    "@helia/interface": "6.2.1-ae98a4f4",
-    "@libp2p/crypto": "^5.1.15",
-    "@libp2p/fetch": "^4.1.0",
-    "@libp2p/interface": "^3.2.0",
-    "@libp2p/kad-dht": "^16.2.0",
-    "@libp2p/keychain": "^6.0.12",
-    "@libp2p/logger": "^6.2.4",
-    "@libp2p/peer-collections": "^7.0.15",
-    "@libp2p/utils": "^7.0.15",
+    "@helia/interface": "6.2.1-ed6c3b79",
+    "@libp2p/fetch": "^4.1.6",
+    "@libp2p/interface": "^3.2.3",
+    "@libp2p/kad-dht": "^16.3.2",
+    "@libp2p/logger": "^6.2.8",
+    "@libp2p/peer-collections": "^7.0.21",
+    "@libp2p/utils": "^7.2.2",
+    "abort-error": "^1.0.2",
     "any-signal": "^4.2.0",
+    "cborg": "^5.1.1",
     "delay": "^7.0.0",
-    "interface-datastore": "^9.0.3",
-    "ipns": "^10.1.3",
-    "multiformats": "^13.4.2",
+    "interface-datastore": "^10.0.1",
+    "multiformats": "^14.0.0",
     "progress-events": "^1.1.0",
-    "protons-runtime": "^6.0.1",
+    "protons-runtime": "^7.0.0",
     "race-signal": "^2.0.0",
-    "uint8arraylist": "^2.4.8",
-    "uint8arrays": "^5.1.0"
+    "timestamp-nano": "^1.0.1",
+    "uint8arraylist": "^3.0.2",
+    "uint8arrays": "^6.1.1"
   },
   "devDependencies": {
-    "@libp2p/crypto": "^5.1.15",
-    "@libp2p/peer-id": "^6.0.6",
-    "aegir": "^48.0.4",
-    "datastore-core": "^11.0.3",
+    "@ipshipyard/crypto": "^1.1.0",
+    "@ipshipyard/keychain": "^1.0.2",
+    "aegir": "^48.0.11",
+    "datastore-core": "^12.0.1",
     "it-drain": "^3.0.12",
-    "protons": "^8.1.1",
-    "sinon": "^21.1.0",
+    "it-last": "^3.0.11",
+    "protons": "^9.0.1",
+    "sinon": "^22.0.0",
     "sinon-ts": "^2.0.0"
   },
   "browser": {

package/src/errors.ts

@@ -1,49 +1,64 @@
 export class RecordsFailedValidationError extends Error {
   static name = 'RecordsFailedValidationError'
-
-  constructor (message = 'Records failed validation') {
-    super(message)
-    this.name = 'RecordsFailedValidationError'
-  }
+  name = 'RecordsFailedValidationError'
 }
 
 export class UnsupportedMultibasePrefixError extends Error {
   static name = 'UnsupportedMultibasePrefixError'
-
-  constructor (message = 'Unsupported multibase prefix') {
-    super(message)
-    this.name = 'UnsupportedMultibasePrefixError'
-  }
+  name = 'UnsupportedMultibasePrefixError'
 }
 
 export class UnsupportedMultihashCodecError extends Error {
   static name = 'UnsupportedMultihashCodecError'
-
-  constructor (message = 'Unsupported multihash codec') {
-    super(message)
-    this.name = 'UnsupportedMultihashCodecError'
-  }
+  name = 'UnsupportedMultihashCodecError'
 }
 
 export class InvalidValueError extends Error {
   static name = 'InvalidValueError'
-
-  constructor (message = 'Invalid value') {
-    super(message)
-    this.name = 'InvalidValueError'
-  }
+  name = 'InvalidValueError'
 }
 
 export class InvalidTopicError extends Error {
   static name = 'InvalidTopicError'
-
-  constructor (message = 'Invalid topic') {
-    super(message)
-    this.name = 'InvalidTopicError'
-  }
+  name = 'InvalidTopicError'
 }
 
 export class RecordNotFoundError extends Error {
   static name = 'RecordNotFoundError'
   name = 'RecordNotFoundError'
 }
+
+export class SignatureCreationError extends Error {
+  static name = 'SignatureCreationError'
+  name = 'SignatureCreationError'
+}
+
+export class SignatureVerificationError extends Error {
+  static name = 'SignatureVerificationError'
+  name = 'SignatureVerificationError'
+}
+
+export class RecordExpiredError extends Error {
+  static name = 'RecordExpiredError'
+  name = 'RecordExpiredError'
+}
+
+export class UnsupportedValidityError extends Error {
+  static name = 'UnsupportedValidityError'
+  name = 'UnsupportedValidityError'
+}
+
+export class RecordTooLargeError extends Error {
+  static name = 'RecordTooLargeError'
+  name = 'RecordTooLargeError'
+}
+
+export class InvalidRecordDataError extends Error {
+  static name = 'InvalidRecordDataError'
+  name = 'InvalidRecordDataError'
+}
+
+export class InvalidEmbeddedPublicKeyError extends Error {
+  static name = 'InvalidEmbeddedPublicKeyError'
+  name = 'InvalidEmbeddedPublicKeyError'
+}

package/src/index.ts

@@ -23,9 +23,9 @@
  * const { publicKey } = await name.publish('key-1', cid)
  *
  * // resolve the name
- * const result = await name.resolve(publicKey)
- *
- * console.info(result.cid, result.path)
+ * for await (const result of name.resolve(publicKey)) {
+ *   console.info(result.record.value) // /ipfs/QmFoo
+ * }
  * ```
  *
  * @example Publishing a recursive record
@@ -53,8 +53,9 @@
  * const { publicKey: recursivePublicKey } = await name.publish('key-2', publicKey)
  *
  * // resolve the name recursively - it resolves until a CID is found
- * const result = await name.resolve(recursivePublicKey)
- * console.info(result.cid.toString() === cid.toString()) // true
+ * for await (const result of name.resolve(recursivePublicKey)) {
+ *   console.info(result.record.value) // /ipfs/QmFoo../foo.txt
+ * }
  * ```
  *
  * @example Publishing a record with a path
@@ -82,9 +83,9 @@
  * const { publicKey } = await name.publish('key-1', `/ipfs/${finalDirCid}/foo.txt`)
  *
  * // resolve the name
- * const result = await name.resolve(publicKey)
- *
- * console.info(result.cid, result.path) // QmFoo.. 'foo.txt'
+ * for await (const result of name.resolve(publicKey)) {
+ *   console.info(result.record.value) // /ipfs/QmFoo../foo.txt
+ * }
  * ```
  *
  * @example Using custom PubSub router
@@ -104,29 +105,30 @@
  * may fail to be published with "Insufficient peers" errors.
  *
  * ```TypeScript
- * import { createHelia, libp2pDefaults } from 'helia'
  * import { ipns } from '@helia/ipns'
  * import { pubsub } from '@helia/ipns/routing'
+ * import { withLibp2p, libp2pDefaults } from '@helia/libp2p'
  * import { unixfs } from '@helia/unixfs'
- * import { floodsub } from '@libp2p/floodsub'
  * import { generateKeyPair } from '@libp2p/crypto/keys'
+ * import { floodsub } from '@libp2p/floodsub'
+ * import { createHelia } from 'helia'
+ * import type { Helia } from '@helia/interface'
  * import type { PubSub } from '@helia/ipns/routing'
+ * import type { DefaultLibp2pServices } from '@helia/libp2p'
+ * import type { FloodSub } from '@libp2p/floodsub'
  * import type { Libp2p } from '@libp2p/interface'
- * import type { DefaultLibp2pServices } from 'helia'
  *
- * const libp2pOptions = libp2pDefaults()
+ * const libp2pOptions = libp2pDefaults() as any
  * libp2pOptions.services.pubsub = floodsub()
  *
- * const helia = await createHelia<Libp2p<DefaultLibp2pServices & { pubsub: PubSub }>>({
- *   libp2p: libp2pOptions
- * })
+ * const helia = await withLibp2p<Helia, { pubsub: FloodSub }>(createHelia(), libp2pOptions).start()
+ *
  * const name = ipns(helia, {
  *  routers: [
  *    pubsub(helia)
  *  ]
  * })
  *
- *
  * // store some data to publish
  * const fs = unixfs(helia)
  * const cid = await fs.addBytes(Uint8Array.from([0, 1, 2, 3, 4]))
@@ -135,51 +137,12 @@
  * const { publicKey } = await name.publish('key-1', cid)
  *
  * // resolve the name
- * const result = await name.resolve(publicKey)
- * ```
- *
- * @example Republishing an existing IPNS record
- *
- * It is sometimes useful to be able to republish an existing IPNS record
- * without needing the private key. This allows you to extend the availability
- * of a record that was created elsewhere.
- *
- * ```TypeScript
- * import { createHelia } from 'helia'
- * import { ipns, ipnsValidator } from '@helia/ipns'
- * import { delegatedRoutingV1HttpApiClient } from '@helia/delegated-routing-v1-http-api-client'
- * import { CID } from 'multiformats/cid'
- * import { multihashToIPNSRoutingKey, marshalIPNSRecord } from 'ipns'
- * import { defaultLogger } from '@libp2p/logger'
- *
- * const helia = await createHelia()
- * const name = ipns(helia)
- *
- * const ipnsName = 'k51qzi5uqu5dktsyfv7xz8h631pri4ct7osmb43nibxiojpttxzoft6hdyyzg4'
- * const parsedCid: CID<unknown, 114, 0 | 18, 1> = CID.parse(ipnsName)
- * const delegatedClient = delegatedRoutingV1HttpApiClient({
- *   url: 'https://delegated-ipfs.dev'
- * })({
- *   logger: defaultLogger()
- * })
- * const record = await delegatedClient.getIPNS(parsedCid)
- *
- * const routingKey = multihashToIPNSRoutingKey(parsedCid.multihash)
- * const marshaledRecord = marshalIPNSRecord(record)
- *
- * // validate that they key corresponds to the record
- * await ipnsValidator(routingKey, marshaledRecord)
- *
- * // publish record to routing
- * await Promise.all(
- *   name.routers.map(async r => {
- *     await r.put(routingKey, marshaledRecord)
- *   })
- * )
+ * for await (const result of name.resolve(publicKey)) {
+ *   console.info(result.record.value)
+ * }
  * ```
  */
 
-import { ipnsValidator } from 'ipns/validator'
 import { CID } from 'multiformats/cid'
 import { IPNSResolver as IPNSResolverClass } from './ipns/resolver.ts'
 import { IPNS as IPNSClass } from './ipns.ts'
@@ -187,12 +150,12 @@ import { localStore } from './local-store.ts'
 import { helia } from './routing/index.ts'
 import { localStoreRouting } from './routing/local-store.ts'
 import type { IPNSResolverComponents } from './ipns/resolver.ts'
+import type { IPNSRecord } from './records.ts'
 import type { IPNSRouting, IPNSRoutingProgressEvents } from './routing/index.ts'
-import type { Routing, HeliaEvents } from '@helia/interface'
-import type { AbortOptions, ComponentLogger, Libp2p, PeerId, PublicKey, TypedEventEmitter } from '@libp2p/interface'
-import type { Keychain } from '@libp2p/keychain'
+import type { Routing, HeliaEvents, Keychain, PublicKey } from '@helia/interface'
+import type { ComponentLogger, TypedEventEmitter } from '@libp2p/interface'
+import type { AbortOptions } from 'abort-error'
 import type { Datastore } from 'interface-datastore'
-import type { IPNSRecord } from 'ipns'
 import type { MultihashDigest } from 'multiformats/hashes/interface'
 import type { ProgressEvent, ProgressOptions } from 'progress-events'
 
@@ -214,23 +177,31 @@ export type DatastoreProgressEvents =
 
 export interface PublishOptions extends AbortOptions, ProgressOptions<PublishProgressEvents | IPNSRoutingProgressEvents> {
   /**
-   * Time duration of the signature validity in ms (default: 48hrs)
+   * Time duration of the signature validity in ms
+   *
+   * @default 172_800_000
    */
   lifetime?: number
 
   /**
-   * Only publish to a local datastore (default: false)
+   * Only publish to a local datastore
+   *
+   * @default false
    */
   offline?: boolean
 
   /**
    * By default a IPNS V1 and a V2 signature is added to every record. Pass
-   * false here to only add a V2 signature. (default: true)
+   * false here to only add a V2 signature.
+   *
+   * @default true
    */
   v1Compatible?: boolean
 
   /**
-   * The TTL of the record in ms (default: 5 minutes)
+   * The TTL of the record in ms
+   *
+   * @default 300_000
    */
   ttl?: number
 }
@@ -257,32 +228,25 @@ export interface ResolveOptions extends AbortOptions, ProgressOptions<ResolvePro
 }
 
 export interface ResolveResult {
-  /**
-   * The CID that was resolved
-   */
-  cid: CID
-
-  /**
-   * Any path component that was part of the resolved record
-   */
-  path?: string
-}
-
-export interface IPNSResolveResult extends ResolveResult {
   /**
    * The resolved record
    */
   record: IPNSRecord
 }
 
-export interface IPNSPublishResult {
+export interface PublishResult {
   /**
    * The published record
    */
   record: IPNSRecord
 
   /**
-   * The public key that was used to publish the record
+   * The IPNS name that can be used to resolve this record
+   */
+  name: string
+
+  /**
+   * The public key that was used to sign and publish the record
    */
   publicKey: PublicKey
 }
@@ -295,7 +259,7 @@ export interface IPNSResolver {
    * Ed25519, secp256k1 or RSA PeerId and recursively resolves the IPNS record
    * corresponding to that key until a value is found.
    */
-  resolve(key: CID<unknown, 0x72, 0x00 | 0x12, 1> | PublicKey | MultihashDigest<0x00 | 0x12> | PeerId, options?: ResolveOptions): Promise<IPNSResolveResult>
+  resolve(key: CID<unknown, 0x72> | MultihashDigest, options?: ResolveOptions): AsyncGenerator<ResolveResult>
 }
 
 export interface IPNS {
@@ -308,12 +272,14 @@ export interface IPNS {
    * Creates and publishes an IPNS record that will resolve the passed value
    * signed by a key stored in the libp2p keychain under the passed key name.
    *
+   * If the key does not exist, a new Ed25519 key will be created. To use a
+   * different key types, ensure the key is created and stored in the keychain
+   * before invoking this method.
+   *
    * It is possible to create a recursive IPNS record by passing:
    *
-   * - A PeerId,
-   * - A PublicKey
-   * - A CID with the libp2p-key codec and Identity or SHA256 hash algorithms
-   * - A Multihash with the Identity or SHA256 hash algorithms
+   * - A CID with the libp2p-key codec
+   * - A Multihash
    * - A string IPNS key (e.g. `/ipns/Qmfoo`)
    *
    * @example
@@ -332,38 +298,36 @@ export interface IPNS {
    * console.info(result) // { answer: ... }
    * ```
    */
-  publish(keyName: string, value: CID | PublicKey | MultihashDigest<0x00 | 0x12> | PeerId | string, options?: PublishOptions): Promise<IPNSPublishResult>
+  publish(keyName: string, value: CID | PublicKey | MultihashDigest | string, options?: PublishOptions): Promise<PublishResult>
 
   /**
-   * Accepts a libp2p public key, a CID with the libp2p-key codec and either the
-   * identity hash (for Ed25519 and secp256k1 public keys) or a SHA256 hash (for
-   * RSA public keys), or the multihash of a libp2p-key encoded CID, or a
-   * Ed25519, secp256k1 or RSA PeerId and recursively resolves the IPNS record
-   * corresponding to that key until a value is found.
+   * Accepts a multihash of a public key, a libp2p-key CID containing the
+   * multihash of a public key, or an IPNS name in it's string representation
+   * and recursively resolves IPNS records until a non-recursive record is found
+   * (e.g. the value can be parsed as a string that does not start with
+   * `/ipns/`).
    */
-  resolve(key: CID<unknown, 0x72, 0x00 | 0x12, 1> | PublicKey | MultihashDigest<0x00 | 0x12> | PeerId, options?: ResolveOptions): Promise<IPNSResolveResult>
+  resolve(name: CID<unknown, 0x72> | PublicKey | MultihashDigest | string, options?: ResolveOptions): AsyncGenerator<ResolveResult>
 
   /**
    * Stop republishing of an IPNS record
    *
-   * This will delete the last signed IPNS record from the datastore, but the
-   * key will remain in the keychain.
+   * This will delete the last signed IPNS record from the datastore.
    *
    * Note that the record may still be resolved by other peers until it expires
-   * or is no longer valid.
+   * or is otherwise no longer valid.
    */
   unpublish(keyName: string, options?: AbortOptions): Promise<void>
 }
 
 export type { IPNSRouting } from './routing/index.ts'
-
-export type { IPNSRecord } from 'ipns'
+export type { IPNSRecord } from './records.ts'
 
 export interface IPNSComponents {
   datastore: Datastore
   routing: Routing
   logger: ComponentLogger
-  libp2p: Libp2p<{ keychain: Keychain }>
+  keychain: Keychain
   events: TypedEventEmitter<HeliaEvents> // Helia event bus
 }
 
@@ -414,5 +378,4 @@ export function ipnsResolver (components: IPNSResolverComponents, options: IPNSR
   })
 }
 
-export { ipnsValidator, type IPNSRoutingProgressEvents }
-export { ipnsSelector } from 'ipns/selector'
+export type { IPNSRoutingProgressEvents }

package/src/ipns/publisher.ts

@@ -1,21 +1,19 @@
-import { generateKeyPair } from '@libp2p/crypto/keys'
-import { isPeerId } from '@libp2p/interface'
-import { createIPNSRecord, marshalIPNSRecord, multihashToIPNSRoutingKey, unmarshalIPNSRecord } from 'ipns'
-import { CID } from 'multiformats/cid'
+import { base36 } from 'multiformats/bases/base36'
 import { CustomProgressEvent } from 'progress-events'
 import { DEFAULT_LIFETIME_MS, DEFAULT_TTL_NS } from '../constants.ts'
-import type { IPNSPublishResult, PublishOptions } from '../index.ts'
+import { createIPNSRecord } from '../records.ts'
+import { marshalIPNSRecord, multihashToIPNSRoutingKey, unmarshalIPNSRecord } from '../utils.ts'
+import type { PublishResult, PublishOptions } from '../index.ts'
 import type { LocalStore } from '../local-store.ts'
 import type { IPNSRouting } from '../routing/index.ts'
-import type { AbortOptions, ComponentLogger, Libp2p, PeerId, PrivateKey, PublicKey } from '@libp2p/interface'
-import type { Keychain } from '@libp2p/keychain'
+import type { Keychain, PrivateKey } from '@helia/interface'
+import type { AbortOptions, ComponentLogger } from '@libp2p/interface'
 import type { Datastore } from 'interface-datastore'
-import type { MultihashDigest } from 'multiformats/hashes/interface'
 
 export interface IPNSPublisherComponents {
   datastore: Datastore
   logger: ComponentLogger
-  libp2p: Libp2p<{ keychain: Keychain }>
+  keychain: Keychain
 }
 
 export interface IPNSPublisherInit {
@@ -29,32 +27,29 @@ export class IPNSPublisher {
   private readonly keychain: Keychain
 
   constructor (components: IPNSPublisherComponents, init: IPNSPublisherInit) {
-    this.keychain = components.libp2p.services.keychain
+    this.keychain = components.keychain
     this.localStore = init.localStore
     this.routers = init.routers
   }
 
-  async publish (keyName: string, value: CID | PublicKey | MultihashDigest<0x00 | 0x12> | PeerId | string, options: PublishOptions = {}): Promise<IPNSPublishResult> {
+  async publish (keyName: string, value: string, options: PublishOptions = {}): Promise<PublishResult> {
     try {
-      const privKey = await this.#loadOrCreateKey(keyName)
+      const key = await this.#loadOrCreateKey(keyName, options)
+      const digest = key.publicKey.toMultihash()
+      const routingKey = multihashToIPNSRoutingKey(digest)
       let sequenceNumber = 1n
-      const routingKey = multihashToIPNSRoutingKey(privKey.publicKey.toMultihash())
 
       if (await this.localStore.has(routingKey, options)) {
         // if we have published under this key before, increment the sequence number
         const { record } = await this.localStore.get(routingKey, options)
-        const existingRecord = unmarshalIPNSRecord(record)
+        const existingRecord = await unmarshalIPNSRecord(routingKey, record, this.keychain, options)
         sequenceNumber = existingRecord.sequence + 1n
       }
 
-      if (isPeerId(value)) {
-        value = value.toCID()
-      }
-
       // convert ttl from milliseconds to nanoseconds as createIPNSRecord expects
       const ttlNs = options.ttl != null ? BigInt(options.ttl) * 1_000_000n : DEFAULT_TTL_NS
       const lifetime = options.lifetime ?? DEFAULT_LIFETIME_MS
-      const record = await createIPNSRecord(privKey, value, sequenceNumber, lifetime, { ...options, ttlNs })
+      const record = await createIPNSRecord(key, value, sequenceNumber, lifetime, { ...options, ttlNs })
       const marshaledRecord = marshalIPNSRecord(record)
 
       if (options.offline === true) {
@@ -68,8 +63,12 @@ export class IPNSPublisher {
       }
 
       return {
-        record,
-        publicKey: privKey.publicKey
+        record: {
+          ...record,
+          publicKey: key.publicKey
+        },
+        name: `/ipns/${key.publicKey.toCID().toString(base36)}`,
+        publicKey: key.publicKey
       }
     } catch (err: any) {
       options.onProgress?.(new CustomProgressEvent<Error>('ipns:publish:error', err))
@@ -77,20 +76,26 @@ export class IPNSPublisher {
     }
   }
 
-  async #loadOrCreateKey (keyName: string): Promise<PrivateKey> {
+  /**
+   * Create the private key if it is not in the keychain already, defaulting to
+   * Ed25519 keys
+   */
+  async #loadOrCreateKey (keyName: string, options?: AbortOptions): Promise<PrivateKey> {
     try {
-      return await this.keychain.exportKey(keyName)
+      return await this.keychain.exportKey(keyName, options)
     } catch (err: any) {
-      // If no named key found in keychain, generate and import
-      const privKey = await generateKeyPair('Ed25519')
-      await this.keychain.importKey(keyName, privKey)
-      return privKey
+      if (err.name === 'NotFoundError') {
+        // create a new key
+        return this.keychain.generateKey(keyName, options)
+      } else {
+        throw err
+      }
     }
   }
 
   async unpublish (keyName: string, options?: AbortOptions): Promise<void> {
-    const { publicKey } = await this.keychain.exportKey(keyName)
-    const digest = publicKey.toMultihash()
+    const key = await this.keychain.exportKey(keyName, options)
+    const digest = key.publicKey.toMultihash()
     const routingKey = multihashToIPNSRoutingKey(digest)
     await this.localStore.delete(routingKey, options)
   }