const e = require("autobase"),
t = require("hypercore"),
r = require("deterministic-sealed-box"),
n = require("keet-identity-key"),
i = require("hypercore-crypto"),
{
contract: {
hyperschema: { encode: o, decode: c },
hyperdispatch: { encode: a },
},
} = require("../../../schema/spec"),
{ KeetContractError: u } = require("./../contract/errors"),
s = require("@holepunchto/keet-registry"),
[d, y, p, v, f, l, m] = i.namespace("@holepunchto/keet-core/invitations", 7)
function h(e, t, r) {
let i = null
try {
i = n.verify(e.proof, t, { expectedIdentity: e.memberKey })
} catch {
throw u.ABORT()
}
if (!i) throw u.ABORT()
return i.receipt
}
function K(e, t = {}) {
const { canModerate: r = !1, canAdmin: n = !1, expiration: c = 0 } = t,
a = i.randomBytes(32),
u = J(a),
s = u.publicKey,
d = o("@keet/room-keys", e)
return {
invitation: {
id: s,
metadata: { canModerate: r, canAdmin: n, expiration: c },
anchor: null,
response: { id: s, data: d, signature: i.sign(i.hash([p, d]), u.secretKey) },
},
seed: a,
}
}
function b(e, t, r) {
const c = o("@keet-private-id/contact-request-body", r),
a = n.attestData(c, t.deviceKeyPair, t.deviceProof),
u = { memberKey: t.publicKey, proof: a },
s = o("@keet-private-id/contact-request", { body: r, attestation: u })
return i.encrypt(s, e)
}
function q(t, r, n) {
const i = b(t, r, n),
o = a("@keet-private-id/add-contact-request", {
header: { timestamp: Date.now() },
blindRequest: i,
})
return e.encodeValue(o, { optimistic: !0, encrypted: !0 })
}
function k(t, { heads: r } = {}) {
const n = a("@keet/add-device", { header: { timestamp: Date.now() }, blindRequest: t })
return e.encodeValue(n, { optimistic: !0, encrypted: !0, heads: r })
}
function P(e, t, r, n, i, o) {
const { blindRequest: c } = w(e, t, r, n, i, o)
return k(c, o)
}
function g(e, t, r) {
const { blindRequest: n } = R(e, t)
return k(n, r)
}
function R(e, { device: t, member: r }) {
const n = o("@keet/device-request", { withMemberProof: { device: t, member: r } })
return { blindRequest: i.encrypt(n, e) }
}
function w(e, t, r, n, { device: c, member: a }, u) {
const s = J(n),
d = s.publicKey,
p = { deviceKey: e, identity: u?.identity, keyPair: r, device: c, member: a },
v = o("@keet/device-request-with-invitation", p),
f = i.sign(i.hash([y, v]), s.secretKey),
l = o("@keet/device-request", { withInvitation: { id: d, request: p, signature: f } })
return { blindRequest: i.encrypt(l, t) }
}
function I(e, t, n) {
const c = o("@keet/device-response", { signedKeys: n.response }),
a = i.hash([f, t])
return { blindResponse: r.encrypt(c, e, a) }
}
function x(e, { publicKey: t, deviceKeyPair: r, deviceProof: i }) {
const o = s.encodeReservation({ username: e })
return { username: e, attestation: { memberKey: t, proof: n.attestData(o, r, i) } }
}
function D({ id: e, request: t, signature: r }) {
const n = o("@keet/device-request-with-invitation", t)
return i.verify(i.hash([y, n]), r, e) ? { id: e, request: t } : null
}
function T(e, t) {
const n = r.decrypt(t, e)
return n ? c("@keet/device-request", n) : null
}
function M(e, t) {
const r = i.decrypt(t, e)
return r ? c("@keet-private-id/contact-request", r) : null
}
function C(e, t) {
const r = i.decrypt(t, e)
if (!r) return null
const n = c("@keet/device-response", r),
{
signedKeys: { id: o, data: a, signature: u },
identity: s,
} = n
return i.verify(i.hash([p, a]), u, o)
? { id: o, response: { roomKeys: c("@keet/room-keys", a), identity: s } }
: null
}
function A(e, t) {
const r = t?.deviceProof,
i = t?.privateProfileIdentity,
o = e.writerKey,
c = e.publicKey,
a = e.devicePublicKey
if (!r || !i) return null
if (!i.memberKey || !i.proof) return null
const u = n.verify(r, null, { expectedIdentity: c, expectedDevice: a }),
s = n.verify(i.proof, o, { expectedIdentity: c })
return u && s
}
function O() {
return i.encryptionKeyPair()
}
function B() {
return i.keyPair()
}
function J(e) {
return i.keyPair(i.hash([d, e]))
}
function W(e) {
return J(e).publicKey
}
function N(e) {
return t.key({ version: 2, signers: [{ publicKey: e }] })
}
function V(e) {
return { key: e, discoveryKey: i.discoveryKey(e) }
}
function E(e, t) {
return i.encryptionKeyPair(i.hash([v, e, t]))
}
function S(e) {
return i.keyPair(e)
}
function U(e) {
return i.discoveryKey(e)
}
function j(e) {
return i.discoveryKey(e)
}
function z(e, t) {
const r = E(e, t),
n = S(r.publicKey),
i = U(r.publicKey)
return { mailboxKeyPair: r, discoveryKeyPair: n, swarmTopic: j(n.publicKey), wakeupTopic: i }
}
function F(e) {
const t = S(e),
r = U(e)
return { discoveryKeyPair: t, swarmTopic: j(t.publicKey), wakeupTopic: r }
}
function G(e) {
return i.hash([l, e])
}
function H(e) {
return i.hash([m, e])
}
module.exports = {
generateIdentityPairingName: G,
generateRoomPairingName: H,
generateSwarmTopic: j,
generateWakeupTopic: U,
generateMailboxKeyPair: E,
generateDiscoveryKeyPair: S,
generateRoomCapabilities: z,
generatePairingCapabilities: F,
getWakeup: V,
getWriterKey: N,
getInvitationId: W,
createInvitation: K,
createDeviceResponse: I,
decryptDeviceRequest: T,
decryptContactRequest: M,
verifyAttestation: h,
verifyDeviceResponse: C,
verifyIdentityProofs: A,
verifyInvitationDeviceRequest: D,
createMailboxKeyPair: O,
createDiscoveryKeyPair: B,
createInvitationJoinRequest: w,
createInvitationJoinOperation: P,
createMemberProofJoinRequest: R,
createMemberProofJoinOperation: g,
createBlindContactRequest: b,
createContactRequestOperation: q,
createUsernameReservationRequest: x,
}