From d99ed8c3e4034ee4bb9889fa038daa80b8dc7ee7 Mon Sep 17 00:00:00 2001 From: chefbc2k Date: Sun, 15 Mar 2026 03:02:05 -0500 Subject: [PATCH 1/3] add retry workflow tests --- .../workflows/register-voice-asset.test.ts | 103 ++++++++++++++- .../workflows/register-voice-asset.ts | 39 +++++- .../workflows/register-whisper-block.test.ts | 120 ++++++++++++++++++ .../src/workflows/register-whisper-block.ts | 45 +++++-- 4 files changed, 293 insertions(+), 14 deletions(-) diff --git a/packages/api/src/modules/voice-assets/workflows/register-voice-asset.test.ts b/packages/api/src/modules/voice-assets/workflows/register-voice-asset.test.ts index d14192a..4d234d9 100644 --- a/packages/api/src/modules/voice-assets/workflows/register-voice-asset.test.ts +++ b/packages/api/src/modules/voice-assets/workflows/register-voice-asset.test.ts @@ -46,6 +46,10 @@ describe("runRegisterVoiceAssetWorkflow", () => { owner: "0x0000000000000000000000000000000000000001", }, }), + getTokenId: vi.fn().mockResolvedValue({ + statusCode: 200, + body: "104", + }), updateBasicAcousticFeatures: vi.fn(), getBasicAcousticFeatures: vi.fn(), }; @@ -82,12 +86,14 @@ describe("runRegisterVoiceAssetWorkflow", () => { voiceHash: registrationBody.result, owner: "0x0000000000000000000000000000000000000001", }, + tokenId: "104", }, metadataUpdate: null, voiceHash: registrationBody.result, summary: { owner: null, hasFeatures: false, + tokenId: "104", }, }); expect(service.registerVoiceAssetForCaller).not.toHaveBeenCalled(); @@ -125,6 +131,13 @@ describe("runRegisterVoiceAssetWorkflow", () => { }, }; }), + getTokenId: vi.fn().mockImplementation(async () => { + sequence.push("read-token-id"); + return { + statusCode: 200, + body: "205", + }; + }), updateBasicAcousticFeatures: vi.fn().mockImplementation(async () => { sequence.push("update-features"); return { statusCode: 202, body: metadataBody }; @@ -156,6 +169,7 @@ describe("runRegisterVoiceAssetWorkflow", () => { "register", "wait-registration", "read-voice", + "read-token-id", "update-features", "wait-metadata", "read-features", @@ -180,6 +194,7 @@ describe("runRegisterVoiceAssetWorkflow", () => { voiceHash, owner: "0x00000000000000000000000000000000000000aa", }, + tokenId: "205", }, metadataUpdate: { submission: metadataBody, @@ -190,6 +205,7 @@ describe("runRegisterVoiceAssetWorkflow", () => { summary: { owner: "0x00000000000000000000000000000000000000aa", hasFeatures: true, + tokenId: "205", }, }); expect(service.registerVoiceAsset).not.toHaveBeenCalled(); @@ -203,6 +219,7 @@ describe("runRegisterVoiceAssetWorkflow", () => { }), registerVoiceAssetForCaller: vi.fn(), getVoiceAsset: vi.fn(), + getTokenId: vi.fn(), updateBasicAcousticFeatures: vi.fn(), getBasicAcousticFeatures: vi.fn(), }; @@ -225,15 +242,18 @@ describe("runRegisterVoiceAssetWorkflow", () => { }, txHash: "0xreceipt-registration", voiceAsset: null, + tokenId: null, }, metadataUpdate: null, voiceHash: null, summary: { owner: null, hasFeatures: true, + tokenId: null, }, }); expect(service.getVoiceAsset).not.toHaveBeenCalled(); + expect(service.getTokenId).not.toHaveBeenCalled(); expect(service.updateBasicAcousticFeatures).not.toHaveBeenCalled(); expect(service.getBasicAcousticFeatures).not.toHaveBeenCalled(); }); @@ -258,6 +278,15 @@ describe("runRegisterVoiceAssetWorkflow", () => { statusCode: 200, body: { voiceHash, owner: "0x0000000000000000000000000000000000000001" }, }), + getTokenId: vi.fn() + .mockResolvedValueOnce({ + statusCode: 404, + body: { error: "not ready" }, + }) + .mockResolvedValueOnce({ + statusCode: 200, + body: "309", + }), updateBasicAcousticFeatures: vi.fn().mockResolvedValue({ statusCode: 202, body: { txHash: "0xmeta-retry" }, @@ -284,6 +313,7 @@ describe("runRegisterVoiceAssetWorkflow", () => { }); expect(service.getVoiceAsset).toHaveBeenCalledTimes(2); + expect(service.getTokenId).toHaveBeenCalledTimes(2); expect(service.getBasicAcousticFeatures).toHaveBeenCalledTimes(2); expect(result.metadataUpdate).toMatchObject({ txHash: "0xreceipt-metadata", @@ -291,6 +321,40 @@ describe("runRegisterVoiceAssetWorkflow", () => { }); }); + it("retries after transient token-id read errors before succeeding", async () => { + const voiceHash = "0x6666666666666666666666666666666666666666666666666666666666666666"; + const service = { + registerVoiceAsset: vi.fn().mockResolvedValue({ + statusCode: 202, + body: { txHash: "0xreg-transient", result: voiceHash }, + }), + registerVoiceAssetForCaller: vi.fn(), + getVoiceAsset: vi.fn().mockResolvedValue({ + statusCode: 200, + body: { voiceHash, owner: "0x0000000000000000000000000000000000000001" }, + }), + getTokenId: vi.fn() + .mockRejectedValueOnce(new Error("rpc unavailable")) + .mockResolvedValueOnce({ + statusCode: 200, + body: 412n, + }), + updateBasicAcousticFeatures: vi.fn(), + getBasicAcousticFeatures: vi.fn(), + }; + mocks.createVoiceAssetsPrimitiveService.mockReturnValue(service); + mocks.waitForWorkflowWriteReceipt.mockResolvedValue("0xreceipt-registration"); + + const result = await runRegisterVoiceAssetWorkflow(context, auth, undefined, { + ipfsHash: "QmTransient", + royaltyRate: "100", + }); + + expect(service.getTokenId).toHaveBeenCalledTimes(2); + expect(result.registration.tokenId).toBe("412"); + expect(result.summary.tokenId).toBe("412"); + }); + it("throws when registration readback never stabilizes", async () => { const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout").mockImplementation(((callback: TimerHandler) => { if (typeof callback === "function") { @@ -311,6 +375,7 @@ describe("runRegisterVoiceAssetWorkflow", () => { statusCode: 404, body: { error: "not ready" }, }), + getTokenId: vi.fn(), updateBasicAcousticFeatures: vi.fn(), getBasicAcousticFeatures: vi.fn(), }; @@ -321,7 +386,43 @@ describe("runRegisterVoiceAssetWorkflow", () => { ipfsHash: "QmTimeout", royaltyRate: "100", })).rejects.toThrow("registerVoiceAsset.registrationRead readback timeout"); - expect(service.getVoiceAsset).toHaveBeenCalledTimes(20); + expect(service.getVoiceAsset).toHaveBeenCalledTimes(40); + setTimeoutSpy.mockRestore(); + }); + + it("surfaces transient read errors after token-id retries are exhausted", async () => { + const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout").mockImplementation(((callback: TimerHandler) => { + if (typeof callback === "function") { + callback(); + } + return 0 as ReturnType; + }) as typeof setTimeout); + const voiceHash = "0x7777777777777777777777777777777777777777777777777777777777777777"; + const service = { + registerVoiceAsset: vi.fn().mockResolvedValue({ + statusCode: 202, + body: { + txHash: "0xreg-token-timeout", + result: voiceHash, + }, + }), + registerVoiceAssetForCaller: vi.fn(), + getVoiceAsset: vi.fn().mockResolvedValue({ + statusCode: 200, + body: { voiceHash, owner: "0x0000000000000000000000000000000000000001" }, + }), + getTokenId: vi.fn().mockRejectedValue(new Error("rpc unavailable")), + updateBasicAcousticFeatures: vi.fn(), + getBasicAcousticFeatures: vi.fn(), + }; + mocks.createVoiceAssetsPrimitiveService.mockReturnValue(service); + mocks.waitForWorkflowWriteReceipt.mockResolvedValue("0xreceipt-registration"); + + await expect(runRegisterVoiceAssetWorkflow(context, auth, undefined, { + ipfsHash: "QmTokenTimeout", + royaltyRate: "100", + })).rejects.toThrow("registerVoiceAsset.tokenIdRead readback timeout after transient read errors: rpc unavailable"); + expect(service.getTokenId).toHaveBeenCalledTimes(40); setTimeoutSpy.mockRestore(); }); }); diff --git a/packages/api/src/modules/voice-assets/workflows/register-voice-asset.ts b/packages/api/src/modules/voice-assets/workflows/register-voice-asset.ts index 1e61f9a..3cf07dc 100644 --- a/packages/api/src/modules/voice-assets/workflows/register-voice-asset.ts +++ b/packages/api/src/modules/voice-assets/workflows/register-voice-asset.ts @@ -48,6 +48,19 @@ export async function runRegisterVoiceAssetWorkflow( "registerVoiceAsset.registrationRead", ) : null; + const tokenIdRead = voiceHash + ? await waitForWorkflowReadback( + () => voiceAssets.getTokenId({ + auth, + api: { executionSource: "live", gaslessMode: "none" }, + walletAddress, + wireParams: [voiceHash], + }), + (result) => result.statusCode === 200 && isNumericLike(result.body), + "registerVoiceAsset.tokenIdRead", + ) + : null; + const tokenId = numericLikeToString(tokenIdRead?.body); let metadataUpdate: import("../../../shared/route-types.js").RouteResult | null = null; let metadataUpdateTxHash: string | null = null; @@ -78,6 +91,7 @@ export async function runRegisterVoiceAssetWorkflow( submission: registration.body, txHash: registrationTxHash, voiceAsset: registrationRead?.body ?? null, + tokenId, }, metadataUpdate: metadataUpdate ? { @@ -90,6 +104,7 @@ export async function runRegisterVoiceAssetWorkflow( summary: { owner: body.owner ?? null, hasFeatures: Boolean(body.features), + tokenId, }, }; } @@ -100,13 +115,29 @@ async function waitForWorkflowReadback( label: string, ) { let lastResult: import("../../../shared/route-types.js").RouteResult | null = null; + let lastError: unknown = null; for (let attempt = 0; attempt < 40; attempt += 1) { - const result = await read(); - lastResult = result; - if (ready(result)) { - return result; + try { + const result = await read(); + lastResult = result; + if (ready(result)) { + return result; + } + } catch (error) { + lastError = error; } await new Promise((resolve) => setTimeout(resolve, 500)); } + if (lastError) { + throw new Error(`${label} readback timeout after transient read errors: ${String((lastError as Error)?.message ?? lastError)}`); + } throw new Error(`${label} readback timeout: ${JSON.stringify(lastResult?.body ?? null)}`); } + +function isNumericLike(value: unknown): boolean { + return typeof value === "string" || typeof value === "number" || typeof value === "bigint"; +} + +function numericLikeToString(value: unknown): string | null { + return isNumericLike(value) ? String(value) : null; +} diff --git a/packages/api/src/workflows/register-whisper-block.test.ts b/packages/api/src/workflows/register-whisper-block.test.ts index 3944a81..748ee2e 100644 --- a/packages/api/src/workflows/register-whisper-block.test.ts +++ b/packages/api/src/workflows/register-whisper-block.test.ts @@ -247,6 +247,85 @@ describe("runRegisterWhisperBlockWorkflow", () => { }); }); + it("normalizes event-query route results with body arrays", async () => { + const context = { + providerRouter: { + withProvider: vi.fn().mockImplementation(async (_mode: string, _label: string, work: (provider: { getTransactionReceipt: (txHash: string) => Promise }) => Promise) => work({ + getTransactionReceipt: vi.fn(async () => ({ blockNumber: 501 })), + })), + }, + } as never; + const service = { + registerVoiceFingerprint: vi.fn().mockResolvedValue({ + statusCode: 202, + body: { txHash: "0xfingerprint-write" }, + }), + verifyVoiceAuthenticity: vi.fn().mockResolvedValue({ + statusCode: 200, + body: true, + }), + voiceFingerprintUpdatedEventQuery: vi.fn().mockResolvedValue({ + statusCode: 200, + body: [{ transactionHash: "0xfingerprint-receipt" }], + }), + generateAndSetEncryptionKey: vi.fn(), + keyRotatedEventQuery: vi.fn(), + grantAccess: vi.fn(), + accessGrantedEventQuery: vi.fn(), + }; + mocks.createWhisperblockPrimitiveService.mockReturnValue(service); + mocks.waitForWorkflowWriteReceipt.mockResolvedValue("0xfingerprint-receipt"); + + const result = await runRegisterWhisperBlockWorkflow(context, auth, undefined, { + voiceHash: "0x5555555555555555555555555555555555555555555555555555555555555555", + structuredFingerprintData: "0x7777", + generateEncryptionKey: false, + }); + + expect(result.fingerprint.eventCount).toBe(1); + expect(service.voiceFingerprintUpdatedEventQuery).toHaveBeenCalledTimes(1); + }); + + it("retries transient event-query errors before confirming the fingerprint event", async () => { + const context = { + providerRouter: { + withProvider: vi.fn().mockImplementation(async (_mode: string, _label: string, work: (provider: { getTransactionReceipt: (txHash: string) => Promise }) => Promise) => work({ + getTransactionReceipt: vi.fn(async () => ({ blockNumber: 601 })), + })), + }, + } as never; + const service = { + registerVoiceFingerprint: vi.fn().mockResolvedValue({ + statusCode: 202, + body: { txHash: "0xfingerprint-write" }, + }), + verifyVoiceAuthenticity: vi.fn().mockResolvedValue({ + statusCode: 200, + body: true, + }), + voiceFingerprintUpdatedEventQuery: vi.fn() + .mockRejectedValueOnce(new Error("indexer unavailable")) + .mockResolvedValueOnce([ + { transactionHash: "0xfingerprint-receipt" }, + ]), + generateAndSetEncryptionKey: vi.fn(), + keyRotatedEventQuery: vi.fn(), + grantAccess: vi.fn(), + accessGrantedEventQuery: vi.fn(), + }; + mocks.createWhisperblockPrimitiveService.mockReturnValue(service); + mocks.waitForWorkflowWriteReceipt.mockResolvedValue("0xfingerprint-receipt"); + + const result = await runRegisterWhisperBlockWorkflow(context, auth, undefined, { + voiceHash: "0x6666666666666666666666666666666666666666666666666666666666666666", + structuredFingerprintData: "0x8888", + generateEncryptionKey: false, + }); + + expect(result.fingerprint.eventCount).toBe(1); + expect(service.voiceFingerprintUpdatedEventQuery).toHaveBeenCalledTimes(2); + }); + it("throws when authenticity verification never stabilizes", async () => { const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout").mockImplementation(((callback: TimerHandler) => { if (typeof callback === "function") { @@ -287,4 +366,45 @@ describe("runRegisterWhisperBlockWorkflow", () => { expect(service.verifyVoiceAuthenticity).toHaveBeenCalledTimes(20); setTimeoutSpy.mockRestore(); }); + + it("surfaces transient event-query errors after retries are exhausted", async () => { + const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout").mockImplementation(((callback: TimerHandler) => { + if (typeof callback === "function") { + callback(); + } + return 0 as ReturnType; + }) as typeof setTimeout); + const context = { + providerRouter: { + withProvider: vi.fn().mockImplementation(async (_mode: string, _label: string, work: (provider: { getTransactionReceipt: (txHash: string) => Promise }) => Promise) => work({ + getTransactionReceipt: vi.fn(async () => ({ blockNumber: 701 })), + })), + }, + } as never; + const service = { + registerVoiceFingerprint: vi.fn().mockResolvedValue({ + statusCode: 202, + body: { txHash: "0xfingerprint-write" }, + }), + verifyVoiceAuthenticity: vi.fn().mockResolvedValue({ + statusCode: 200, + body: true, + }), + voiceFingerprintUpdatedEventQuery: vi.fn().mockRejectedValue(new Error("indexer unavailable")), + generateAndSetEncryptionKey: vi.fn(), + keyRotatedEventQuery: vi.fn(), + grantAccess: vi.fn(), + accessGrantedEventQuery: vi.fn(), + }; + mocks.createWhisperblockPrimitiveService.mockReturnValue(service); + mocks.waitForWorkflowWriteReceipt.mockResolvedValue("0xfingerprint-receipt"); + + await expect(runRegisterWhisperBlockWorkflow(context, auth, undefined, { + voiceHash: "0x7777777777777777777777777777777777777777777777777777777777777777", + structuredFingerprintData: "0x9999", + generateEncryptionKey: false, + })).rejects.toThrow("registerWhisperBlock.voiceFingerprintUpdated event query timeout after transient read errors: indexer unavailable"); + expect(service.voiceFingerprintUpdatedEventQuery).toHaveBeenCalledTimes(20); + setTimeoutSpy.mockRestore(); + }); }); diff --git a/packages/api/src/workflows/register-whisper-block.ts b/packages/api/src/workflows/register-whisper-block.ts index ddf163b..884b00c 100644 --- a/packages/api/src/workflows/register-whisper-block.ts +++ b/packages/api/src/workflows/register-whisper-block.ts @@ -155,31 +155,47 @@ async function waitForWorkflowReadback( label: string, ) { let lastResult: RouteResult | null = null; + let lastError: unknown = null; for (let attempt = 0; attempt < 20; attempt += 1) { - const result = await read(); - lastResult = result; - if (ready(result)) { - return result; + try { + const result = await read(); + lastResult = result; + if (ready(result)) { + return result; + } + } catch (error) { + lastError = error; } await new Promise((resolve) => setTimeout(resolve, 500)); } + if (lastError) { + throw new Error(`${label} readback timeout after transient read errors: ${String((lastError as Error)?.message ?? lastError)}`); + } throw new Error(`${label} readback timeout: ${JSON.stringify(lastResult?.body ?? null)}`); } async function waitForWorkflowEventQuery( - read: () => Promise, + read: () => Promise, ready: (logs: unknown[]) => boolean, label: string, ) { let lastLogs: unknown[] = []; + let lastError: unknown = null; for (let attempt = 0; attempt < 20; attempt += 1) { - const logs = await read(); - lastLogs = logs; - if (ready(logs)) { - return logs; + try { + const logs = normalizeEventLogs(await read()); + lastLogs = logs; + if (ready(logs)) { + return logs; + } + } catch (error) { + lastError = error; } await new Promise((resolve) => setTimeout(resolve, 500)); } + if (lastError) { + throw new Error(`${label} event query timeout after transient read errors: ${String((lastError as Error)?.message ?? lastError)}`); + } throw new Error(`${label} event query timeout: ${JSON.stringify(lastLogs)}`); } @@ -194,3 +210,14 @@ function hasTransactionHash(logs: unknown[], txHash: string | null): boolean { return (entry as Record).transactionHash === txHash; }); } + +function normalizeEventLogs(value: unknown[] | RouteResult): unknown[] { + if (Array.isArray(value)) { + return value; + } + if (!value || typeof value !== "object") { + return []; + } + const body = (value as Record).body; + return Array.isArray(body) ? body : []; +} From d9c227fd93cd7188a8c079b3ede630e000922a4b Mon Sep 17 00:00:00 2001 From: chefbc2k Date: Mon, 16 Mar 2026 03:02:50 -0500 Subject: [PATCH 2/3] cover commercialization ownership gaps --- .../workflows/commercialize-voice-asset.ts | 2 + .../create-dataset-and-list-for-sale.test.ts | 126 +++++++++++++++++- .../create-dataset-and-list-for-sale.ts | 60 +++++++++ .../src/workflows/license-template.test.ts | 32 +++++ .../api/src/workflows/license-template.ts | 10 +- .../rights-aware-commercialize-voice-asset.ts | 1 + 6 files changed, 228 insertions(+), 3 deletions(-) diff --git a/packages/api/src/workflows/commercialize-voice-asset.ts b/packages/api/src/workflows/commercialize-voice-asset.ts index ea7d1c3..0b37c6d 100644 --- a/packages/api/src/workflows/commercialize-voice-asset.ts +++ b/packages/api/src/workflows/commercialize-voice-asset.ts @@ -13,6 +13,8 @@ const actorOverrideSchema = z.object({ walletAddress: z.string().regex(/^0x[a-fA-F0-9]{40}$/u).optional(), }); +// Commercialization requires the acting account to be the current on-chain owner +// of every asset being packaged. Roles/authorizations do not substitute ownership. export const commercializeVoiceAssetWorkflowSchema = z.object({ packaging: createDatasetAndListForSaleSchema, inspectListing: z.boolean().default(false), diff --git a/packages/api/src/workflows/create-dataset-and-list-for-sale.test.ts b/packages/api/src/workflows/create-dataset-and-list-for-sale.test.ts index 9bc5b72..4043dec 100644 --- a/packages/api/src/workflows/create-dataset-and-list-for-sale.test.ts +++ b/packages/api/src/workflows/create-dataset-and-list-for-sale.test.ts @@ -131,6 +131,8 @@ describe("runCreateDatasetAndListForSaleWorkflow", () => { }); expect(sequence).toEqual([ + "read-owner", + "read-owner", "create-dataset", "wait-dataset", "read-dataset", @@ -266,6 +268,125 @@ describe("runCreateDatasetAndListForSaleWorkflow", () => { expect(voiceAssets.setApprovalForAll).not.toHaveBeenCalled(); }); + it("fails early when the actor is not the current asset owner", async () => { + const context = { + addressBook: { + toJSON: () => ({ diamond: "0x0000000000000000000000000000000000000ddd" }), + }, + } as never; + mocks.resolveDatasetLicenseTemplate.mockResolvedValue({ + templateHash: `0x${"0".repeat(63)}7`, + templateId: "7", + created: false, + source: "existing-active", + template: { isActive: true, name: "Creator Template" }, + }); + const datasets = { + getDatasetsByCreator: vi.fn(), + createDataset: vi.fn(), + }; + const voiceAssets = { + ownerOf: vi.fn().mockResolvedValue({ + statusCode: 200, + body: "0x00000000000000000000000000000000000000bb", + }), + isApprovedForAll: vi.fn(), + setApprovalForAll: vi.fn(), + }; + const marketplace = { + listAsset: vi.fn(), + getListing: vi.fn(), + }; + mocks.createDatasetsPrimitiveService.mockReturnValue(datasets); + mocks.createVoiceAssetsPrimitiveService.mockReturnValue(voiceAssets); + mocks.createMarketplacePrimitiveService.mockReturnValue(marketplace); + + await expect(runCreateDatasetAndListForSaleWorkflow(context, auth, "0x00000000000000000000000000000000000000aa", { + title: "Dataset", + assetIds: ["1"], + metadataURI: "ipfs://dataset", + royaltyBps: "500", + price: "1000", + duration: "0", + })).rejects.toThrow("commercialization requires current asset ownership"); + + expect(datasets.createDataset).not.toHaveBeenCalled(); + }); + + it("reports when the actor is authorized but not the current asset owner", async () => { + const context = { + addressBook: { + toJSON: () => ({ diamond: "0x0000000000000000000000000000000000000ddd" }), + }, + } as never; + const datasets = { + getDatasetsByCreator: vi.fn(), + createDataset: vi.fn(), + }; + const voiceAssets = { + ownerOf: vi.fn().mockResolvedValue({ + statusCode: 200, + body: "0x00000000000000000000000000000000000000bb", + }), + getVoiceHashFromTokenId: vi.fn().mockResolvedValue({ + statusCode: 200, + body: `0x${"1".repeat(64)}`, + }), + isAuthorized: vi.fn().mockResolvedValue({ + statusCode: 200, + body: true, + }), + isApprovedForAll: vi.fn(), + setApprovalForAll: vi.fn(), + }; + mocks.createDatasetsPrimitiveService.mockReturnValue(datasets); + mocks.createVoiceAssetsPrimitiveService.mockReturnValue(voiceAssets); + mocks.createMarketplacePrimitiveService.mockReturnValue({ + listAsset: vi.fn(), + getListing: vi.fn(), + }); + + let thrown: unknown; + try { + await runCreateDatasetAndListForSaleWorkflow(context, auth, "0x00000000000000000000000000000000000000aa", { + title: "Dataset", + assetIds: ["1"], + metadataURI: "ipfs://dataset", + royaltyBps: "500", + price: "1000", + duration: "0", + }); + } catch (error) { + thrown = error; + } + + expect(thrown).toBeInstanceOf(Error); + expect(thrown).toMatchObject({ + statusCode: 409, + message: expect.stringContaining("actor is authorized but not owner"), + diagnostics: { + assetId: "1", + owner: "0x00000000000000000000000000000000000000bb", + actor: "0x00000000000000000000000000000000000000aa", + actorAuthorized: true, + voiceHash: `0x${"1".repeat(64)}`, + }, + }); + expect(voiceAssets.getVoiceHashFromTokenId).toHaveBeenCalledWith({ + auth, + api: { executionSource: "live", gaslessMode: "none" }, + walletAddress: "0x00000000000000000000000000000000000000aa", + wireParams: ["1"], + }); + expect(voiceAssets.isAuthorized).toHaveBeenCalledWith({ + auth, + api: { executionSource: "live", gaslessMode: "none" }, + walletAddress: "0x00000000000000000000000000000000000000aa", + wireParams: [`0x${"1".repeat(64)}`, "0x00000000000000000000000000000000000000aa"], + }); + expect(datasets.createDataset).not.toHaveBeenCalled(); + }); + it("marks non-active listings as not actively listed", async () => { const context = { addressBook: { @@ -361,7 +482,10 @@ describe("runCreateDatasetAndListForSaleWorkflow", () => { getDataset: vi.fn(), }); mocks.createVoiceAssetsPrimitiveService.mockReturnValue({ - ownerOf: vi.fn(), + ownerOf: vi.fn().mockResolvedValue({ + statusCode: 200, + body: "0x00000000000000000000000000000000000000aa", + }), isApprovedForAll: vi.fn(), setApprovalForAll: vi.fn(), }); diff --git a/packages/api/src/workflows/create-dataset-and-list-for-sale.ts b/packages/api/src/workflows/create-dataset-and-list-for-sale.ts index 141a9fa..fbe7379 100644 --- a/packages/api/src/workflows/create-dataset-and-list-for-sale.ts +++ b/packages/api/src/workflows/create-dataset-and-list-for-sale.ts @@ -3,10 +3,12 @@ import { z } from "zod"; import type { ApiExecutionContext } from "../shared/execution-context.js"; import type { RouteResult } from "../shared/route-types.js"; +import { HttpError } from "../shared/errors.js"; import { createDatasetsPrimitiveService } from "../modules/datasets/primitives/generated/index.js"; import { createMarketplacePrimitiveService } from "../modules/marketplace/primitives/generated/index.js"; import { createVoiceAssetsPrimitiveService } from "../modules/voice-assets/primitives/generated/index.js"; import { resolveDatasetLicenseTemplate } from "./license-template.js"; +import { normalizeAddress } from "./reward-campaign-helpers.js"; import { waitForWorkflowWriteReceipt } from "./wait-for-write.js"; export const createDatasetAndListForSaleSchema = z.object({ @@ -41,6 +43,64 @@ export async function runCreateDatasetAndListForSaleWorkflow( return new Wallet(privateKey, provider).getAddress(); }, ); + const normalizedSigner = normalizeAddress(signerAddress) ?? signerAddress.toLowerCase(); + + const ownershipReads = await Promise.all(body.assetIds.map(async (assetId) => { + const ownerRead = await waitForWorkflowReadback( + () => voiceAssets.ownerOf({ + auth, + api: { executionSource: "live", gaslessMode: "none" }, + walletAddress, + wireParams: [assetId], + }), + (result) => result.statusCode === 200, + `createDatasetAndListForSale.assetOwner.${assetId}`, + ); + return { assetId, owner: normalizeAddress(ownerRead.body), ownerRead: ownerRead.body }; + })); + + const ownershipMismatch = ownershipReads.find((entry) => entry.owner && entry.owner !== normalizedSigner); + if (ownershipMismatch) { + let voiceHash: string | null = null; + let actorAuthorized: boolean | null = null; + if (typeof voiceAssets.getVoiceHashFromTokenId === "function") { + const voiceHashRead = await voiceAssets.getVoiceHashFromTokenId({ + auth, + api: { executionSource: "live", gaslessMode: "none" }, + walletAddress, + wireParams: [ownershipMismatch.assetId], + }).catch(() => null); + if (voiceHashRead?.statusCode === 200 && typeof voiceHashRead.body === "string") { + voiceHash = voiceHashRead.body; + if (typeof voiceAssets.isAuthorized === "function") { + const authRead = await voiceAssets.isAuthorized({ + auth, + api: { executionSource: "live", gaslessMode: "none" }, + walletAddress, + wireParams: [voiceHash, signerAddress], + }).catch(() => null); + if (authRead?.statusCode === 200) { + actorAuthorized = authRead.body === true; + } + } + } + } + const authorizationNote = actorAuthorized === true + ? "actor is authorized but not owner" + : "actor is not current owner"; + throw new HttpError( + 409, + `commercialization requires current asset ownership; ${authorizationNote}; transfer asset ownership before commercialization`, + { + assetId: ownershipMismatch.assetId, + owner: ownershipMismatch.owner, + actor: signerAddress, + actorAuthorized, + voiceHash, + }, + ); + } + const licenseTemplate = await resolveDatasetLicenseTemplate( context, auth, diff --git a/packages/api/src/workflows/license-template.test.ts b/packages/api/src/workflows/license-template.test.ts index 3e6bb80..23e0412 100644 --- a/packages/api/src/workflows/license-template.test.ts +++ b/packages/api/src/workflows/license-template.test.ts @@ -100,6 +100,9 @@ describe("resolveDatasetLicenseTemplate", () => { }); it("creates and confirms a template when no active template exists", async () => { + const nowSpy = vi.spyOn(Date, "now") + .mockReturnValueOnce(1_700_000_000_123) + .mockReturnValueOnce(1_700_000_000_123); const licensing = { getCreatorTemplates: vi.fn().mockResolvedValue({ statusCode: 200, @@ -136,6 +139,35 @@ describe("resolveDatasetLicenseTemplate", () => { { txHash: "0xcreate", result: `0x${"0".repeat(63)}a` }, "licenseTemplate.create", ); + expect(licensing.createTemplate).toHaveBeenCalledWith({ + auth, + api: { executionSource: "live", gaslessMode: "none" }, + walletAddress: undefined, + wireParams: [{ + creator: "0x00000000000000000000000000000000000000cc", + isActive: true, + transferable: true, + createdAt: "1700000000", + updatedAt: "1700000000", + defaultDuration: "3888000", + defaultPrice: "15000", + maxUses: "12", + name: "Auto Dataset Template 1700000000123", + description: "Auto-created for dataset workflow verification", + defaultRights: ["Narration", "Ads"], + defaultRestrictions: ["no-sublicense"], + terms: { + licenseHash: `0x${"0".repeat(64)}`, + duration: "3888000", + price: "15000", + maxUses: "12", + transferable: true, + rights: ["Narration", "Ads"], + restrictions: ["no-sublicense"], + }, + }], + }); + nowSpy.mockRestore(); }); it("throws when requested template readback never stabilizes", async () => { diff --git a/packages/api/src/workflows/license-template.ts b/packages/api/src/workflows/license-template.ts index 2b9809c..9672203 100644 --- a/packages/api/src/workflows/license-template.ts +++ b/packages/api/src/workflows/license-template.ts @@ -56,7 +56,7 @@ export async function resolveDatasetLicenseTemplate( auth, api: { executionSource: "live", gaslessMode: "none" }, walletAddress, - wireParams: [buildDefaultTemplate()], + wireParams: [buildDefaultTemplate(creatorAddress)], }); await waitForWorkflowWriteReceipt(context, createTemplate.body, "licenseTemplate.create"); @@ -135,13 +135,19 @@ async function waitForTemplateReadback( throw new Error(`${label} template readback timeout: ${JSON.stringify(lastRead?.body ?? null)}`); } -function buildDefaultTemplate() { +function buildDefaultTemplate(creatorAddress: string) { const duration = String(45n * 24n * 60n * 60n); const price = "15000"; const maxUses = "12"; + const now = Math.floor(Date.now() / 1000); + const createdAt = String(now); + const updatedAt = String(now); return { + creator: creatorAddress, isActive: true, transferable: true, + createdAt, + updatedAt, defaultDuration: duration, defaultPrice: price, maxUses, diff --git a/packages/api/src/workflows/rights-aware-commercialize-voice-asset.ts b/packages/api/src/workflows/rights-aware-commercialize-voice-asset.ts index eadef57..9957846 100644 --- a/packages/api/src/workflows/rights-aware-commercialize-voice-asset.ts +++ b/packages/api/src/workflows/rights-aware-commercialize-voice-asset.ts @@ -13,6 +13,7 @@ const collaboratorRightsSetupSchema = z.object({ authorizeVoice: z.boolean().default(true), }); +// Rights setup does not override ownership requirements for commercialization. export const rightsAwareCommercializeVoiceAssetWorkflowSchema = z.object({ voiceAsset: z.object({ voiceHash: bytes32Schema, From c2f4c22a96e5d4ab9a1dcd371f35589002c26ba3 Mon Sep 17 00:00:00 2001 From: chefbc2k Date: Tue, 17 Mar 2026 00:33:38 -0500 Subject: [PATCH 3/3] docs: Add USpeaks Lite Paper and comprehensive Liquidity Bootstrapping Pool (LBP) launch materials. --- .npm/_update-notifier-last-checked | 0 .../hardhat-nodejs/analytics.json | 5 + Library/Preferences/hardhat-nodejs/vars.json | 4 + README.md | 25 + docs/LBP_Launch_Materials/LBP_FAQ.md | 168 +++ .../LBP_TOKENOMICS_MODEL.md | 229 ++++ .../USPEAKS_LITE_PAPER.md | 1100 +++++++++++++++++ .../executive_summary_lbp.md | 22 + .../funding_community_memo.md | 52 + docs/LBP_Launch_Materials/lbp_landing_page.md | 33 + ...asury_token_incentive_econ_simulation.xlsx | Bin 0 -> 13024 bytes 11 files changed, 1638 insertions(+) create mode 100644 .npm/_update-notifier-last-checked create mode 100644 Library/Application Support/hardhat-nodejs/analytics.json create mode 100644 Library/Preferences/hardhat-nodejs/vars.json create mode 100644 docs/LBP_Launch_Materials/LBP_FAQ.md create mode 100644 docs/LBP_Launch_Materials/LBP_TOKENOMICS_MODEL.md create mode 100644 docs/LBP_Launch_Materials/USPEAKS_LITE_PAPER.md create mode 100644 docs/LBP_Launch_Materials/executive_summary_lbp.md create mode 100644 docs/LBP_Launch_Materials/funding_community_memo.md create mode 100644 docs/LBP_Launch_Materials/lbp_landing_page.md create mode 100644 output/spreadsheet/treasury_token_incentive_econ_simulation.xlsx diff --git a/.npm/_update-notifier-last-checked b/.npm/_update-notifier-last-checked new file mode 100644 index 0000000..e69de29 diff --git a/Library/Application Support/hardhat-nodejs/analytics.json b/Library/Application Support/hardhat-nodejs/analytics.json new file mode 100644 index 0000000..2511e4e --- /dev/null +++ b/Library/Application Support/hardhat-nodejs/analytics.json @@ -0,0 +1,5 @@ +{ + "analytics": { + "clientId": "8f825d80-b6ec-4293-9e58-f7d4fd4540b8" + } +} diff --git a/Library/Preferences/hardhat-nodejs/vars.json b/Library/Preferences/hardhat-nodejs/vars.json new file mode 100644 index 0000000..f0eac49 --- /dev/null +++ b/Library/Preferences/hardhat-nodejs/vars.json @@ -0,0 +1,4 @@ +{ + "_format": "hh-vars-1", + "vars": {} +} diff --git a/README.md b/README.md index 54eccdf..bb2c944 100644 --- a/README.md +++ b/README.md @@ -72,6 +72,31 @@ The API no longer treats proposal submission and voting as a single happy-path w It reports which fixtures are actually ready, which are partial, and which still require upstream contract state or additional testnet funding. +## Commercialization Ownership Rule + +Business rule: a voice asset can only be commercialized by the current on-chain owner of that asset. + +Not sufficient on their own: +- collaborator role +- marketplace seller role +- per-voice authorization +- template access +- approval-style setup without ownership + +Commercialization includes: +- dataset packaging using the asset +- listing the resulting dataset/asset for sale +- collaborator-driven commercialization wrappers + +UI precondition copy: +- Only the current asset owner can commercialize this asset. +- This account is authorized, but not the owner. +- Transfer ownership first if this collaborator should commercialize. + +Validation guidance: +- Fail early in the workflow/UI when the acting user is not the owner. +- Suggested error shape: "commercialization requires current asset ownership; actor is authorized but not owner; transfer asset ownership before commercialization". + ## Scenario Adapter `scenario:api` no longer falls back to local Anvil happy paths. You must supply an explicit scenario command: diff --git a/docs/LBP_Launch_Materials/LBP_FAQ.md b/docs/LBP_Launch_Materials/LBP_FAQ.md new file mode 100644 index 0000000..756151f --- /dev/null +++ b/docs/LBP_Launch_Materials/LBP_FAQ.md @@ -0,0 +1,168 @@ +USpeaks LBP FAQ + +What is the USpeaks LBP? + +The USpeaks LBP (Liquidity Bootstrapping Pool) is the launch mechanism for the USPK token. It is designed to open early participation in the USpeaks ecosystem through a market-based price discovery process, rather than a fixed-price public sale. Balancer describes LBPs as a standard token-launch primitive for initial distribution that uses time-dependent weights to support fair price discovery. + +Why is USpeaks using an LBP instead of a traditional token sale? + +Because the goal is to launch the network with a fairer distribution model. + +A traditional fixed-price sale sets one price in advance. An LBP allows price discovery to happen in the open market as pool weights shift over time. In Balancer’s standard LBP design, the pool begins with a high project-token weight and gradually lowers that weight, creating a Dutch-auction-style launch structure. + +For USpeaks, that better matches the intent: + • broader access, + • less insider advantage, + • and a more transparent launch process. + +What is a Liquidity Bootstrapping Pool, in simple terms? + +A Liquidity Bootstrapping Pool is a token launch pool that pairs a project token with a reserve asset (often a stablecoin), then changes the token weights over time. Balancer explains that the weights are initially set heavily in favor of the project token and then gradually shift during the sale. + +In plain English: + • the market starts with a launch configuration, + • the pool changes over time, + • and participants decide when and whether to enter. + +Does the LBP have a fixed price? + +No. A standard LBP is designed for price discovery, not a permanently fixed sale price. Balancer distinguishes standard weight-shifting LBPs from fixed-price LBPs, noting that fixed-price LBPs keep a constant exchange rate, while standard token-launch LBPs are used when a project wants price discovery. + +That means the effective market price can change throughout the launch window. + +Why does the price usually start high in an LBP? + +Because that is part of how the mechanism discourages immediate rush-in behavior and allows price discovery to happen over time. + +Balancer’s documentation notes that standard LBPs start with a high project-token weight and then shift over time, creating a continuous Dutch-auction-style mechanism for initial distribution. + +For participants, the practical takeaway is: + • the earliest moment is not automatically the “best” moment, + • and the launch is meant to unfold over time, not just in the first block. + +Is the LBP meant to guarantee a “fair” outcome for everyone? + +No launch format can guarantee that every participant gets the same outcome. + +What the LBP is designed to do is support more transparent price discovery and reduce some of the distortions common in insider-heavy or fixed-price launches. Balancer explicitly frames LBPs as a tool for fair initial token distribution and price discovery, but participation outcomes still depend on market behavior. + +What is the point of the LBP in the USpeaks story? + +The LBP is not the product. + +It is the on-ramp into the USpeaks ecosystem. + +USpeaks is building infrastructure for: + • voice ownership, + • voice licensing, + • dataset access, + • creator monetization, + • and cultural preservation. + +The LBP is how the community is invited to participate in bootstrapping that network early. + +Is USPK the product? + +No. + +The product is the USpeaks voice asset economy. + +USPK is the ecosystem token used to coordinate participation across the protocol. In the USpeaks model, that includes: + • governance, + • staking, + • and ecosystem-aligned participation. + +The public message should be that the token supports the network — not that the network exists to support the token. + +What gives the USpeaks network value? + +USpeaks is designed around real protocol activity. + +The network is intended to generate activity when: + • voice assets are created, + • licenses are issued, + • datasets are assembled and accessed, + • and marketplace transactions occur. + +That means the long-term story is based on platform usage, not just launch-day attention. + +Why should the community care about this launch? + +Because the community is part of the network itself. + +USpeaks depends on: + • creators, + • dataset contributors, + • curators, + • validators, + • stakers, + • and governance participants. + +The community is not just an audience for the launch. It is part of the supply, participation, and trust layer that helps make the protocol useful. + +Why is community important to USpeaks specifically? + +Because USpeaks is building a creator- and culture-centered protocol, not just a trading asset. + +That matters for two reasons: + 1. Voice assets need active participation from real creators and contributors. + 2. USpeaks is also tied to language and cultural preservation. + +UNESCO states that at least 40% of the world’s roughly 7,000 languages are endangered, and UNESCO materials note that a language disappears on average every two weeks. + +That makes community participation especially important: the network only works if people actively contribute, preserve, license, and govern. + +Is this an investment product? + +USpeaks should not frame the LBP as a promise of returns. + +The safer and stronger framing is: + • participation, + • governance, + • staking, + • alignment, + • and ecosystem bootstrapping. + +The public-facing story should focus on network participation and protocol utility, not on promising profit or emphasizing speculative upside. + +Does participating in the LBP guarantee gains? + +No. + +Token prices are determined by market behavior, and participation in any market-based launch involves risk. A standard LBP is designed for price discovery, not guaranteed pricing outcomes. + +What should participants understand before joining? + +Participants should understand: + • the price can move during the LBP, + • the launch is a price-discovery mechanism, + • market conditions affect outcomes, + • and they should only participate if they understand the mechanics and risks. + +Is the LBP the same thing as long-term liquidity? + +Not exactly. + +The LBP is primarily a launch mechanism for initial distribution and price discovery. Balancer describes it as a primitive for initial token distribution. + +Post-launch liquidity, market depth, and ongoing trading conditions are separate from the LBP itself. + +What should the USpeaks LBP page emphasize first? + +It should lead with: + 1. the mission, + 2. the network, + 3. the economic activity, + 4. the community’s role, + 5. then token utility, + 6. then the LBP mechanics. + +That keeps the message focused on network formation, not “token sale.” + +What is the one-line summary of the USpeaks LBP? + +USpeaks is launching a community-owned voice asset economy where creators can register, license, and monetize voice assets on-chain, while the LBP gives early participants a fairer way to help bootstrap the network through open price discovery. + +--- + +**Important:** The LBP is a market-based launch mechanism for price discovery. Participation involves risk, and token prices may fluctuate during and after the launch. Nothing on this page should be interpreted as financial advice or a guarantee of future token value. diff --git a/docs/LBP_Launch_Materials/LBP_TOKENOMICS_MODEL.md b/docs/LBP_Launch_Materials/LBP_TOKENOMICS_MODEL.md new file mode 100644 index 0000000..6182e56 --- /dev/null +++ b/docs/LBP_Launch_Materials/LBP_TOKENOMICS_MODEL.md @@ -0,0 +1,229 @@ +# LBP Tokenomics Modeling Report: Speak (USPK) + +**Date:** 2026-01-11 +**Version:** 1.5 (Playbook Edition) +**Project:** USpeaks (USPK) +**Analyst:** Antigravity (Agentic AI) + +--- + +## SECTION 1 — Input Summary + +**A. Core Tokenomics** +- **Token Symbol:** USPK +- **Total Supply:** 42,000,000 +- **Allocations:** + - **Community/Ecosystem (54%):** Treasury (16%), Staking (15%), Public (14%), DEX (7%), Growth (2%). + - **Insiders (46%):** Investors (Private 12%, Union 2%), Team (Founder 12%, Exec/Board/Senior 7.75%, DevFund 0.25%), CEX (7%). +- **Vesting:** + - **Founder:** 6mo Cliff, 20yr vest. + - **Private Sale:** 0mo Cliff, 48mo vest. + - **Public:** 15% TGE, 0mo Cliff, 64mo vest (linear). + +**B. Mechanisms** +- **Staking:** Tiered APY model (15% down to 5%) based on holdings. Reward Source: Treasury (initially) -> Fees (Phase 2). +- **Buyback:** 20-40% of platform fees allocated to Buyback-and-Burn (Revenue Activated). +- **Burn:** Permanent deflation via buybacks. +- **Fees (Marketplace):** Max **8.5%** platform fee cap per sale; **91.5%** to creator/seller (before any dataset royalty). Fee config fields: `platformFee`, `unionShare` (1%), `devFund` (2.5%), `timewaveGift` (5%). Staking and buyback allocations are carved out of platform fees via config. + +**C. Market Targets** +- **Base Price Target:** $0.50 +- **Base FDV:** $21,000,000 +- **Initial Float Goal:** ~8-10% (Revised from 3.5%). + +**D. LBP Config (LBP v1 Proposal)** +- **Allocation:** 2,500,000 USPK (~6% of Supply). *Note: Remaining 3.38M Public tokens held in reserve.* +- **Quote Asset:** 250,000 USDC. +- **Duration:** 3 Days (72 Hours). +- **Weights:** Start 96:4 -> End 50:50. + +**E. External Assumptions** +- **Monthly OpEx Burn:** $50,000. +- **Base Monthly Revenue:** $75,000 (**Net Protocol Fees**, excluding creator/referral payouts). +- **Treasury Start:** $3,000,000. + +--- + +## SECTION 2 — FDV → Price Mapping + +| Scenario | FDV Target | Price / Token | Implied MC (TGE*) | Logic | +| :--- | :--- | :--- | :--- | :--- | +| **Deep Value (Bear)** | $10,500,000 | **$0.25** | $606,806 | 0.5x Base. High discount, aligns with seed valuations. | +| **Base Case** | $21,000,000 | **$0.50** | $1,213,612 | 1x Valuation. Market standard for utility/governance token. | +| **Growth (Bull)** | $63,000,000 | **$1.50** | $3,640,836 | 3x Base. Strong momentum, high initial demand. | +| **Hype / Moon** | $126,000,000 | **$3.00** | $7,281,672 | 6x Base. Top-tier launch performance. | + +*Note: Implied MC calculated using Post-LBP circulating supply (Base Case: 2,427,224 tokens).* + +--- + +## SECTION 3 — Circulating Float & MC Calculations + +Analysis of supply pressure including **LBP Sales** (Base Case: ~950k sold). + +| Milestone | Month | Base Circulating | LBP Sold | Total Float | % of Total | Market Cap ($0.50) | +| :--- | :--- | :--- | :--- | :--- | :--- | :--- | +| **TGE (Post-LBP)** | 0 | 1,477,224 | 950,000 | **2,427,224** | **5.78%** | $1,213,612 | +| **Month 1** | 1 | 2,473,254 | 950,000 | 3,423,254 | 8.15% | $1,711,627 | +| **Month 6** | 6 | 7,453,402 | 950,000 | 8,403,402 | 20.01% | $4,201,701 | +| **Month 12** | 12 | 13,553,730 | 950,000 | 14,503,730 | 34.53% | $7,251,865 | + +**Insight:** +- **Float Improvement:** Including LBP sales raises TGE float from 3.5% to ~5.8%. +- **Inflation Dampening:** The LBP sales buffer the relative impact of Month 1 vesting. Month 0->1 inflation drops from +67% (pure vesting) to +41% (combined). However, 5.8% float is still significantly below the 8-10% target. + +--- + +## SECTION 4 — LBP Valuation Dynamics (LBP v1) + +**Configuration:** 2.5M USPK / 250k USDC. Weights 96:4 -> 50:50. 72 Hours. + +### Reference Curve (No Volume) +*Deterministic price path based on weight shifting if no trading occurs.* + +| Hour | Weight (USPK:USDC) | Spot Price | Description | +| :--- | :--- | :--- | :--- | +| **0 (Start)** | 96 : 4 | **$2.40** | High start to capture hype/snipers. | +| **12** | 88.3 : 11.7 | **$0.76** | Rapid early descent. | +| **20** | 83.3 : 16.7 | **~$0.50** | **Base Target Crossed.** | +| **24** | 80.6 : 19.4 | **$0.42** | Entering value accumulation zone. | +| **36** | 73 : 27 | **$0.27** | Deep value territory. | +| **48** | 65.3 : 34.7 | **$0.19** | Oversold zone. | +| **72 (End)** | 50 : 50 | **$0.10** | **Mechanical Floor.** | + +### Scenario Bands (End State) +*Scenario end-states (not yet simulated) based on Net USDC Raised.* + +| Scenario | Net USDC Raised | Avg Price | USPK Sold | End Price (Spot) | Implied FDV | Outcome | +| :--- | :--- | :--- | :--- | :--- | :--- | :--- | +| **Bear (Low)** | +$200,000 | ~$0.35 | **~544k** | **$0.23** | $9.7M | Price finds floor above Deep Value. Minimal float added. | +| **Base (Target)** | +$600,000 | ~$0.63 | ~950k | **$0.55** | $23.1M | **Target End-State.** Hits $0.50 target. Healthy float added. | +| **Bull (High)** | +$1,200,000 | ~$1.00 | ~1.2M | **$1.10** | $46.2M | Strong demand. Price stays >$1.00. Significant liquidity built. | + +**Observation:** +The "LBP v1" config creates a much safer floor ($0.10) than the previous iteration ($0.04). The Base Case scenario ($600k raise) lands the price exactly near the $0.50 target with healthy liquidity generation. + +--- + +## SECTION 5 — Post-LBP LP & Liquidity Health Check + +**Base Case Output:** +- **Pool Assets (End):** 1.55M USPK + $850k USDC ($250k Seed + $600k Raised). +- **Total Liquidity Value (TVL):** ~$1,700,000 (at $0.55 price). + +**Liquidity Ratios (at $0.55):** +- **Market Cap:** 2.43M Circulating * $0.55 = **$1.34M**. +- **Liquidity / MC:** $1.7M / $1.34M = **127%**. + +**Slippage & Manipulation Analysis (Constant Product Proxy):** +*Note: This table assumes the **Base Case** end-state ($850k USDC reserves). Impact will be significantly higher in the Bear Case ($450k reserves).* + +| Trade Size (Buy) | Price Impact (Spot Move) | Avg Exec Price Incr. | Note | +| :--- | :--- | :--- | :--- | +| **$10,000** | +2.4% | +1.2% | Low impact for retail. | +| **$100,000** | +25% | +12% | Significant impact. | +| **$350,000** | +100% (2x) | +41% | **Doubles Price (Manipulation Threshold).** | +| **$500,000** | +152% (2.5x) | +59% | Massive slippage. | + +**Health Verdict:** +This liquidity depth is extremely healthy regarding Market Cap coverage (127%), meaning the price is stable against retail flow. However, it is **not** manipulation-proof against medium-sized whales. A ~$350k buy doubles the token price, which is a relatively low barrier for manipulation. + +--- + +## SECTION 6 — Mechanism Stress Test Projections + +### (A) Buyback Impact +*Assumption: Base Revenue ($75k/mo = **Net Protocol Fees**), 30% allocation ($22.5k/mo).* +- **Buy Pressure:** $22.5k / month constant bid. +- **Effect at $0.50:** Buys ~45,000 USPK/month. +- **Annual Burn:** ~540,000 USPK (1.2% of Total Supply). +- **Bull Case ($375k Rev):** Slashes supply by ~5-6% annually. Significant deflationary force. + +### (B) Burn Trajectory (Cumulative) +- **Year 1:** 0.5M burned. +- **Year 3:** 2.5M burned. +- **Year 5:** 5.0M burned (Total Supply reduces to 37M). +- **Impact:** Increases scarcity linearly; effectively offsets Staking emissions in Base case. + +### (C) Staking Dilution vs. Reward +- **Staking Pool:** 15% Allocation (6.3M USPK). +- **Emission:** 3-5 Year curve. +- **Annual Emission (Year 1):** ~2M USPK (+4.7% Inflation). +- **Net Flow (Year 1 Base):** +2M (Staking) - 0.5M (Burn) = **+1.5M Net Inflation**. +- **Assessment:** Inflationary in early years. Revenue must grow to increase Burn > Emission for deflation. + +--- + +## SECTION 7 — Treasury Runway Scenarios + +*Differentiation: Spendable Cash vs. Protocol Owned Liquidity (POL).* + +| Metric | Bear (Net +$200k) | Base (Net +$600k) | Bull (Net +$1.2M) | +| :--- | :--- | :--- | :--- | +| **Monthly Burn** | $50,000 | $50,000 | $50,000 | +| **Spendable Cash** | $3,000,000 | $3,000,000 | $3,000,000 | +| **POL (USDC Side)** | ~$450k | ~$850k | ~$1.45M | +| **POL (Total TVL)** | ~$900k | ~$1.70M | ~$2.90M | +| **Cash Runway** | **60 Months** (if Rev=0) | **Infinite** (Rev>$50k) | **Infinite** | + +**Conclusion:** +The project has ~5+ years of runway from **Spendable Cash** alone ($3M). The LBP Net Raise sits as **Protocol Owned Liquidity (POL)**. While this is a massive asset ($1.7M+ in Base/Bull), it supports the token price and should not be treated as burnable runway here. + +--- + +## SECTION 8 — Token Supply Curve Projection + +| Month | Total Unlocked (Vesting) | LBP Sold (Base) | Burned | Net Circulating | % of Gen. Supply | +| :--- | :--- | :--- | :--- | :--- | :--- | +| **0** | 1,477,224 | 950,000 | 0 | 2,427,224 | 5.8% | +| **12** | 13,553,730 | 950,000 | 540,000 | 13,963,730 | 33.2% | +| **24** | 19,719,460 | 950,000 | 1,100,000 | 19,569,460 | 46.6% | +| **36** | 26,630,884 | 950,000 | 1,800,000 | 25,780,884 | 61.4% | + +--- + +## SECTION 9 — Risks, Imbalances, Attack Surfaces + +1. **Inflation Shock (Month 1-6):** + - **Issue:** Supply still doubles relatively quickly in first year. + - **Mitigation:** The high liquidity ratio (127%) dampens the *price impact* of this inflation, acting as a volatility buffer. + +2. **Manipulation Risk (Revised):** + - **Issue:** With $1.7M liquidity, a $350k buy order can double the price. This is accessible to mid-sized whales. + - **Mitigation:** Monitor large buys closely. Do not rely on a single shallow liquidity band. + +3. **LBP Floor Psychology:** + - **Risk:** If net demand is <$200k, price could drift to ~$0.20 or lower. + - **Mitigation:** Marketing push must target >$500k **Net Demand** to defend the $0.50 level. + +--- + +## SECTION 10 — LBP Execution Spec + +*Operational details for LBP management.* + +**1. Target Thresholds** +* **Goal A (End-State):** By Hour 72, **End USDC Side ≥ $850k** (Implies >$600k Net USDC Raised). +* **Goal B (Path Guardrail):** From Hour 24 onwards, maintain **Spot Price ≥ $0.40**. + +**2. Liquidity Deployment** +* **Post-LBP**: Transition POL to the **Multi-Band Layout**: + * **Core (60%):** Range **$0.45 – $0.55**. (Tight stability around target). + * **Buffer (25%):** Range **$0.25 – $1.00**. (Shock absorber to prevent cascading slippage). + * **Reserve (15%):** Unpaired assets (USDC/USPK) for emergency ops + treasury flexibility. + +**3. Defense & Monitoring** +* **Defense Mechanism:** Active monitoring is not enough. Defense relies on the **Buffer Band** ($0.25-$1.00) absorbing large sells, and the **Reserve** allowing reactive deployment if walls are breached. + +--- + +## SECTION 11 — Recommendations (Revised) + +1. **Adopt "LBP v1" Config:** Use 2.5M USPK / 250k USDC. Do **NOT** use the full 5.88M Public allocation. +2. **Sequester Remaining Public Tokens:** Move the 3.38M unused Public tokens to a reserve. +3. **Aggressive Float Injection:** The current plan yields 5.8% float at TGE, which misses the 8-10% target. **Recommendation:** Implement a **Staged Community Reward** program (e.g., usage-gated claim or 30-day linear vesting) to inject an additional ~2-3% supply (840k - 1.2M tokens). This widens distribution without inviting a single dump event. +4. **Treasury Segregation:** Treat the $600k LBP Net Raise as permanent liquidity (POL). Do not budget it for operational expenses. Keep the $3M Seed funding as the sole runway source. +5. **Multi-Band Liquidity Strategy:** Do not use a single full-range position. Implement the ranges defined in the Execution Spec ($0.45-$0.55 Core / $0.25-$1.00 Buffer) to structurally mitigate whale manipulation risks. + +**Final Verdict:** +The corrected model confirms a highly stable launch setup with "LBP v1". The $0.10 floor is safe, and the $600k Net Raise target aligns perfectly with the $0.50 price goal. The strategy is now mathematically sound and operationally executable via the defined LBP Execution Spec. diff --git a/docs/LBP_Launch_Materials/USPEAKS_LITE_PAPER.md b/docs/LBP_Launch_Materials/USPEAKS_LITE_PAPER.md new file mode 100644 index 0000000..e266924 --- /dev/null +++ b/docs/LBP_Launch_Materials/USPEAKS_LITE_PAPER.md @@ -0,0 +1,1100 @@ +# USpeaks Lite Paper +## Decentralized Voice Asset Platform + +**Version:** 1.0 +**Date:** January 2026 +**Network:** Base (Ethereum L2) +**Token:** USPK + +--- + +## Table of Contents + +1. [Executive Summary](#1-executive-summary) +2. [Problem Statement](#2-problem-statement) +3. [Solution Overview](#3-solution-overview) +4. [Platform Mechanics](#4-platform-mechanics) +5. [Token Economics](#5-token-economics) +6. [Governance](#6-governance) +7. [Technical Foundation](#7-technical-foundation) +8. [Use Cases](#8-use-cases) +9. [Visualizations](#9-visualizations) +10. [Conclusion](#10-conclusion) +11. [Risks & Disclaimers](#11-risks-disclaimers) +12. [For More Information](#12-for-more-information) + +--- + +## 1. Executive Summary + +### A Decentralized Voice Asset Platform + +USpeaks is a decentralized voice asset platform designed to empower creators, preserve cultural heritage, and establish a transparent economy for digital voices through verifiable reputation and fair distribution. It combines NFT-based voice ownership, advanced vesting mechanisms, DAO governance, cultural impact measurement, and voice-specific security—all built on a modular, upgradeable architecture using the Diamond Standard (EIP-2535). + +**Mission:** Empower voice asset owners with complete control over their digital voice identity while creating sustainable economic opportunities and preserving linguistic and cultural heritage for future generations. + +### Core Value Proposition + +USpeaks addresses three critical challenges in the voice economy: + +1. **Cultural Preservation**: Economic incentives for preserving endangered languages and oral traditions +2. **Innovative Parameters**: Data-driven reputation system (Echo Score V3) replacing subjective valuation +3. **Voice Monetization**: Secure ownership with 91.5% creator payout and automated revenue distribution + +### Platform Highlights + +- **91.5% Creator Payout**: Industry-leading revenue share with transparent fee structure +- **8.5% Platform Fee**: Structured allocation supporting staking rewards, buyback & burn, DAO treasury, and platform operations +- **Staking Rewards**: 30% of platform fees fund tiered APY rewards (15% down to 5%) +- **Buyback & Burn**: 20-40% of platform fees create deflationary pressure (revenue-activated) +- **Dataset Licensing**: Separate ERC721 license tokens for dataset access control +- **Fair Launch**: Liquidity Bootstrapping Pool (LBP) ensures transparent price discovery + +### Key Metrics + +- **Token Supply**: 42,000,000 USPK +- **Base FDV Target**: $21,000,000 +- **Base Price Target**: $0.50 per USPK +- **LBP Allocation**: 2,500,000 USPK (~6% of supply) +- **LBP Target Raise**: $600,000 USDC +- **Platform Fee**: 8.5% (structured split) +- **Creator Payout**: 91.5% of sale price +- **TGE Unlock**: 3.52% of total supply (67% reduction from original plan) + +### Launch Strategy + +USpeaks launches via a **Liquidity Bootstrapping Pool (LBP)** to ensure fair price discovery without insider advantage. The 3-day LBP event (2.5M USPK / 250k USDC seed) allows market-driven price discovery, with weights shifting from 96:4 to 50:50 over 72 hours. This mechanism protects against front-running and ensures equitable token distribution. + +--- + +## 2. Problem Statement + +### Voice Market Inefficiencies + +The digital voice economy suffers from fundamental structural problems that limit creator value and cultural preservation: + +#### Fragmented Ownership Models + +- No standardized format for voice asset ownership +- Centralized platforms extract 30-50% of creator revenue +- Limited transparency in royalty distribution +- No protection against unauthorized voice cloning or deepfakes +- Fragmented licensing systems across multiple platforms + +#### Cultural Preservation Crisis + +- **3,000+ languages at risk of extinction by 2100** (UNESCO) +- Oral traditions disappearing with elder generations +- No economic incentive to preserve endangered languages +- Limited access to diverse voice datasets for AI training +- Cultural heritage lost without digital preservation mechanisms + +#### Current Market Gaps + +- **No voice-specific NFT standard**: Existing NFT platforms don't address voice-specific needs (fingerprinting, licensing, cultural metadata) +- **Missing vesting mechanisms**: Creators lack sustainable income models beyond one-time sales +- **Absence of dataset bundling**: No efficient way to create and license voice collections for research/AI +- **Lack of cultural impact measurement**: No objective metrics for valuing cultural preservation contributions +- **No decentralized governance**: Voice asset platforms remain centralized with opaque decision-making + +#### Creator Economy Challenges + +- **Revenue extraction**: Traditional platforms take 30-50% of creator earnings +- **Limited monetization options**: Creators restricted to single revenue streams +- **No long-term value accrual**: One-time sales don't build sustainable creator economies +- **Lack of ownership control**: Creators lose control after initial sale +- **No collaborative revenue sharing**: Difficult to split earnings among multiple contributors + +### The Opportunity + +The convergence of blockchain technology, NFT standards, and voice AI creates an unprecedented opportunity to build a decentralized voice asset economy that: + +- Preserves cultural heritage through economic incentives +- Empowers creators with true ownership and control +- Enables sustainable monetization through multiple revenue streams +- Provides transparent, data-driven valuation +- Supports research and AI development with ethically sourced data + +--- + +## 3. Solution Overview + +USpeaks addresses these challenges through an integrated three-pillar approach that combines cultural preservation, data-driven valuation, and sustainable monetization. + +### Pillar 1: Cultural Preservation + +**Goal**: Incentivize the preservation of linguistic diversity and support underrepresented cultures through economic mechanisms. + +**Implementation**: + +- **Geolinguistic Pools**: Language-specific token pools that reward contributions to endangered or specific languages/dialects +- **Cultural Metadata**: Rich metadata tracking (Language, Dialect, Region) to attribute voice assets correctly and track preservation metrics +- **Preservation Incentives**: Rewards based on rarity and contribution to specific cultural pools, ensuring economic value supports cultural vitality +- **Evidence System**: Validation mechanism to ensure authenticity of cultural contributions +- **Echo Score Integration**: Cultural preservation activities contribute to reputation scores, unlocking additional monetization opportunities + +**Impact**: Creates sustainable economic incentives for preserving languages and oral traditions that might otherwise disappear, while building comprehensive datasets for linguistic research. + +### Pillar 2: Innovative Parameters (Echo Score V3) + +**Goal**: Establish measurable, objective standards for voice asset value using real-world data, replacing subjective scoring with transparent, verifiable metrics. + +**Implementation**: + +- **Data-Driven Metrics**: Replaces subjective scoring with PostgreSQL-based calculations +- **Five-Dimensional Scoring**: + - **Voice Quality (15%)**: Technical metrics (sample rate, clarity, completeness, HNR, jitter, shimmer) + - **Community Engagement (30%)**: Marketplace interactions (views, likes, plays, ratings) with recency bonuses + - **Governance Engagement (20%)**: Proposal creation, success rate, and vote participation + - **Dataset Contribution (20%)**: Dataset count, asset coverage, duration, and quality multipliers + - **Marketplace Outcomes (15%)**: Sales volume, licensing activity, royalty realization +- **Cumulative Reputation System**: Unbounded point accumulation (not percentage-based) +- **Trust & Transparency**: All scores calculated via open formulas and committed on-chain by automated Oracle +- **Evidence-Based**: Cryptographic proof of contributions with hash verification + +**Impact**: Provides objective, verifiable value metrics that creators can improve through platform participation, creating a merit-based reputation system that rewards quality and engagement. + +### Pillar 3: Voice Monetization + +**Goal**: Empower creators with secure ownership, automated royalty flows, and multiple revenue streams while maintaining full control over their voice assets. + +**Implementation**: + +- **NFT-Based Ownership**: ERC721 voice assets with unique voice hashes and clear ownership rights +- **91.5% Creator Payout**: Industry-leading revenue share with transparent fee structure +- **Multiple Revenue Streams**: + - Direct asset sales + - Licensing (commercial, research, educational) + - Dataset bundling (up to 1,000 assets) + - Platform gifts (5% tracked allocation, manual claim/vesting) +- **Automated Royalty Distribution**: 2.5-10% configurable royalties with basis point precision +- **Collaborative Revenue Sharing**: Up to 10 collaborators per asset with precise revenue splits +- **Legacy Planning**: Digital inheritance with beneficiary designation, guardian approvals, and timelocks + +**Impact**: Creates sustainable monetization models that reward creators fairly while building long-term value through multiple revenue streams and platform participation. + +### Integrated Value Creation + +The three pillars work synergistically: + +- **Cultural preservation assets** earn higher Echo Scores through evidence-based contributions +- **Higher Echo Scores** unlock additional monetization opportunities and platform benefits +- **Monetization success** provides resources for further cultural preservation work +- **Platform participation** (governance, staking, dataset creation) builds reputation and value + +This creates a virtuous cycle where cultural preservation, reputation building, and monetization reinforce each other, building a sustainable ecosystem that benefits creators, researchers, and cultural preservation efforts. + +--- + +## 4. Platform Mechanics + +### Voice Asset Lifecycle + +The USpeaks platform manages the complete lifecycle of voice assets from registration through monetization, licensing, and legacy transfer. + +#### Registration & Metadata + +1. **Voice Registration**: Creator submits voice recording → `VoiceAssetFacet` mints ERC721 NFT with unique voice hash +2. **Metadata Assignment**: `VoiceMetadataFacet` stores rich classification: + - Acoustic features (pitch, tone, cadence) + - Linguistic attributes (language, dialect, region) + - Cultural context (heritage, tradition, community) + - Quality metrics (sample rate, clarity, duration) +3. **Security Setup**: `WhisperBlockFacet` implements: + - Voice fingerprinting (spectral analysis, pitch patterns) + - 256-bit encryption with automatic key rotation (90 days) + - Time-limited access controls (up to 365 days) + - Audit trails for all access + +#### Rights & Licensing + +4. **Rights Configuration**: `RightsFacet` enables: + - Up to 10 collaborators per asset + - Revenue sharing with basis point precision + - Up to 50 different usage rights per user + - Configurable expiration controls +5. **License Creation**: `VoiceLicenseFacet` supports: + - Predefined templates (commercial, research, educational) + - Custom license terms + - Pricing structures + - Usage tracking +6. **Dataset Licensing**: `VoiceDatasetLicense` contract: + - Separate ERC721 license tokens for datasets + - Mint licenses specifically for dataset access + - License metadata: datasetId, expiration, terms hash + - EIP-2981 royalty support + - Valid license checking per dataset + +#### Marketplace & Trading + +7. **Listing**: `MarketplaceFacet` creates fixed-price listings: + - Asset placed in escrow via `EscrowFacet` + - State management (Listed, InDispute, Reserved) + - Batch operations support +8. **Purchase**: Buyer purchases asset → triggers payment distribution +9. **Payment Distribution**: `PaymentFacet.distributePayment()` executes: + - Deducts 8.5% platform fee (sum of four components applied to sale price) + - DAO/Union Treasury: 1% of sale price + - Development Fund: 2.5% of sale price + - Platform Gifts: 5% of sale price (tracked, manual claim) + - Platform Operations: remainder of 8.5% + - From the total platform fees collected, allocates 30% to staking rewards + - From the total platform fees collected, allocates 20-40% to buyback & burn (if revenue targets met) + - Creator receives 91.5% immediately +10. **Transfer**: Asset ownership updated, escrow released + +### Payment Distribution Flow + +**Example: $100 USDC Sale** + +``` +Total Sale: $100.00 USDC +├── Creator Payout: $91.50 (91.5%) +└── Platform Fee: $8.50 (8.5% of sale) + ├── DAO/Union Treasury: $1.00 (1% of sale) + ├── Development Fund: $2.50 (2.5% of sale) + ├── Platform Gifts: $5.00 (5% of sale - tracked, manual claim) + ├── Staking Rewards: $2.55 (30% of $8.50 total platform fees) + ├── Buyback & Burn: $1.70-3.40 (20-40% of $8.50, if revenue targets met) + └── Platform Operations: Remainder after staking & buyback deductions +``` + +> **How to read this breakdown:** The 8.5% platform fee is the sum of four components, each calculated as a percentage of the total sale price (DAO 1% + Dev Fund 2.5% + Platform Gifts 5% + Platform Operations remainder). Staking and buyback allocations are then drawn from the combined platform fee total, reducing the Platform Operations portion. + +### Dataset Creation & Bundling + +**Capabilities**: +- Bundle up to 1,000 voice assets into cohesive datasets +- Unified licensing terms across all bundled assets +- Category system: Research, commercial, educational, custom +- Quality metrics: Audio quality ratings, duration tracking, language identification +- Access control: Public, private, or restricted access levels +- Automatic royalty distribution to all dataset contributors +- **Dataset Licensing**: Separate ERC721 license tokens for dataset access control + +**Use Cases**: +- AI training datasets for voice synthesis +- Linguistic research collections +- Cultural preservation archives +- Commercial voice libraries + +### Key Platform Numbers + +- **Platform Fee**: 8.5% maximum (structured split) +- **Creator Payout**: 91.5% of sale price +- **Staking Allocation**: 30% of total platform fees (20-40% configurable) +- **Buyback Allocation**: 20-40% of total platform fees (revenue-activated) +- **Platform Gifts**: 5% of sale price (tracked, manual claim) +- **Up to 1,000 usage refs** per license +- **Up to 20 collaborators** per asset +- **1,000 assets** per dataset +- **Configurable royalties**: 1-50% (basis points) + +--- + +## 5. Token Economics + +### Token Basics + +- **Symbol**: USPK +- **Total Supply**: 42,000,000 +- **Decimals**: 10 +- **Network**: Base (Ethereum L2) +- **Standard**: ERC20 compliant + +### Distribution Allocations + +**Community/Ecosystem (59%)**: +- Treasury: 16% (6.72M USPK) +- Staking: 15% (6.3M USPK) +- Public: 14% (5.88M USPK) +- DEX: 7% (2.94M USPK) +- Growth: 7% (2.94M USPK) + +**Insiders (41%)**: +- Private Sale: 12% (5.04M USPK) +- Union: 2% (840k USPK) +- Founder: 12% (5.04M USPK) +- Exec/Board/Senior: 7.75% (3.255M USPK) +- DevFund: 0.25% (105k USPK) +- CEX: 7% (2.94M USPK) + +### Vesting Schedules + +| Category | Allocation | Cliff | Duration | TGE Unlock | Revocable | Notes | +|---|---|---|---|---|---|---| +| **Founder** | 12% (5.04M) | 6 months | 20 years | 0.1% | No | Max unlock 65% | +| **Board** | 2% (840k) | 18 months | 36 months | 0% | Yes | — | +| **Executive** | 3% (1.26M) | 20 months | 36 months | 0% | Yes | — | +| **Senior** | 2.75% (1.155M) | 26 months | 36 months | 0% | Yes | — | +| **Private Sale** | 12% (5.04M) | 0 months | 48 months (linear) | 0.01% | Yes | — | +| **Public Sale** | 14% (5.88M) | 0 months | 64 months (linear) | **15%** | Yes | Reduced from 50% | +| **CEX Market Makers** | 7% (2.94M) | 0 months | 64 months (linear) | **20%** | Yes | Reduced from 53% | +| **DEX** | 7% (2.94M) | 0 months | 64 months | 0% | Yes | — | +| **Growth** | 7% (2.94M) | 0 months | 48 months | 0.01% | Yes | — | +| **Treasury** | 16% (6.72M) | 0 months | 52 months | 0.01% | Yes | — | +| **Union** | 2% (840k) | 0 months | 64 months | 0.01% | Yes | — | +| **Staking** | 15% (6.3M) | 0 months | 12 months | 0.01% | Yes | Per-schedule duration | +| **DevFund** | 0.25% (105k) | 0 months | 5 years | 0% | Yes | — | + +**Total TGE Unlock**: 3.52% of supply (1.48M tokens) — **67% reduction from original plan** + +This reduction significantly improves market stability by reducing immediate selling pressure while maintaining fair distribution. + +### Token Utility + +#### 1. Governance + +- **Token-Weighted Voting**: Base token balance determines voting power +- **Role Multipliers**: + - Founder: 3.0x + - Board Member: 2.0x + - Executive: 1.5x + - Standard: 1.0x +- **Time-Weighted Bonuses**: Long-term holders receive additional voting power +- **Delegation**: Delegate voting power to trusted representatives +- **Proposal Types**: Standard, Emergency, Role Change, System Upgrade, Parameter Change + +#### 2. Staking Rewards + +**Tiered APY Model**: +- Progressive decay based on stake amount +- APY ranges from 15% (lower tiers) down to 5% (higher tiers) +- Minimum stake duration required +- Withdrawal cooldown period +- Echo Score requirements for Sybil resistance + +**Reward Pool Funding**: +- **30% of platform fees** automatically allocated to staking reward pool +- Configurable range: 20-40% of platform fees +- Continuous funding from marketplace activity +- Supports sustainable long-term staking rewards + +**Staking Allocation**: 15% of total supply (6.3M USPK) with individual vesting schedules of 12 months and overall emission targeting a 3-5 year distribution curve + +**Example**: With $75k monthly platform fees (8.5% of revenue), staking receives ~$1,912/month (30% of $6,375 platform fees), providing ongoing rewards for stakers beyond the initial allocation. + +#### 3. Buyback & Burn + +**Revenue-Activated Mechanism**: +- **20-40% of platform fees** allocated to buyback mechanism +- Requires consecutive months meeting minimum revenue target +- Accumulates USDC in `buybackAccumulatorUsdc` +- Quarterly execution cadence +- Purchased USPK tokens permanently burned + +**Deflationary Pressure**: +- Year 1: ~0.5M tokens burned (if revenue targets met) +- Year 3: ~2.5M tokens burned +- Year 5: ~5.0M tokens burned +- Creates permanent scarcity as platform revenue grows + +**Activation Requirements**: +- Minimum monthly revenue threshold (configurable) +- Consecutive months meeting target (configurable) +- Governance-controlled parameters + +**Example**: With $75k monthly platform fees and 30% buyback allocation, ~$1,912/month accumulates for buybacks. When activated, this creates consistent buy pressure and permanent token removal. + +#### 4. Platform Fee Participation + +Token holders benefit from platform revenue through: +- Staking rewards (30% of platform fees) +- Buyback-driven scarcity (20-40% of platform fees) +- Governance control over fee parameters +- Value accrual as platform grows + +### Economic Mechanisms + +#### Staking Rewards Flow + +- **Initial Funding**: 6.3M USPK from allocation (15% of supply) +- **Ongoing Funding**: 30% of platform fees (USDC converted to rewards) +- **Annual Emission**: ~2M USPK in early years (+4.7% inflation) +- **Emission Curve**: 3-5 year distribution +- **Net Effect**: Inflationary in early years, transitions as buyback activates + +#### Buyback & Burn Flow + +- **Accumulation**: 20-40% of platform fees accumulate in USDC +- **Activation**: Requires consecutive months meeting revenue target +- **Execution**: Quarterly buyback via DEX, tokens burned permanently +- **Annual Burn**: ~0.5M tokens in Year 1 (if revenue targets met) +- **Net Effect**: Deflationary pressure increases as revenue grows + +#### Net Token Flow + +**Early Years (Year 1-2)**: +- Staking emissions: +2M USPK/year +- Buyback burns: -0.5M USPK/year +- **Net: +1.5M USPK/year (inflationary)** + +**Mature Years (Year 3-5)**: +- Staking emissions: Decreasing +- Buyback burns: -2.5M USPK/year +- **Net: Deflationary (as revenue grows)** + +**Long-Term (Year 5+)**: +- Staking emissions: Minimal (allocation exhausted) +- Buyback burns: -5M+ USPK/year +- **Net: Strongly deflationary** + +### LBP Launch Details + +**Configuration**: +- **Allocation**: 2,500,000 USPK (~6% of supply) +- **Quote Asset**: 250,000 USDC seed +- **Duration**: 3 days (72 hours) +- **Weights**: Start 96:4 (USPK:USDC) → End 50:50 +- **Price Target**: $0.50 base case +- **Expected Raise**: $600k net USDC (Base Case) +- **Post-LBP Float**: ~5.8% circulating supply + +**Price Discovery Curve**: +- **Hour 0**: $2.40 (high start to capture hype) +- **Hour 20**: ~$0.50 (base target crossed) +- **Hour 72**: $0.10 (mechanical floor) + +**Outcomes**: +- **Bear Case**: $200k raise, ~$0.23 end price +- **Base Case**: $600k raise, ~$0.55 end price (target) +- **Bull Case**: $1.2M raise, ~$1.10 end price + +### Revenue Model + +**Platform Fee Structure**: +- **Total Platform Fee**: 8.5% maximum +- **Fee Components** (each applied to total sale price): + - DAO/Union Treasury: 1% of sale + - Development Fund: 2.5% of sale + - Platform Gifts: 5% of sale (tracked, manual claim) + - Platform Operations: remainder of 8.5% + +**Secondary Allocations** (drawn from the combined 8.5% platform fee total): +- **Staking Rewards**: 30% of total platform fees (20-40% configurable) +- **Buyback & Burn**: 20-40% of total platform fees (revenue-activated) + +**Base Assumptions**: +- **Monthly Revenue**: $75,000 (Net Protocol Fees) +- **Treasury Start**: $3,000,000 (60+ month runway) +- **Monthly OpEx**: $50,000 + +**Revenue Projections**: +- **Base Case**: $75k/month = $900k/year platform fees +- **Growth Case**: $375k/month = $4.5M/year platform fees +- **Staking Funding**: $270k/year (Base) to $1.35M/year (Growth) +- **Buyback Funding**: $180k-$360k/year (Base) to $900k-$1.8M/year (Growth) + +--- + +## 6. Governance + +### DAO Structure + +USpeaks implements a sophisticated decentralized governance system with token-weighted voting, role-based multipliers, and comprehensive proposal management. + +### Governance Architecture + +**Core Components**: +- **Proposal System**: Create, vote, and execute on-chain proposals +- **Voting Power Calculation**: Base token balance × role multiplier × time-weight bonuses × lock duration +- **Delegation**: Delegate voting power to trusted representatives with full tracking +- **Timelock Security**: Enforced delays between approval and execution +- **Checkpointing**: Historical voting power snapshots for fair voting + +### Access Control + +**Explicit Role Assignment**: +- **No "God Mode"**: Founder/owner blanket permissions disabled for revenue-critical functions +- **Explicit Requirements**: All roles must be explicitly granted via `_requiresExplicitRoleAssignment()` check +- **Revenue-Critical Protection**: Treasury, payment, and fee management require explicit role assignment +- **Role Hierarchy**: Admin roles can grant subordinate roles, but founder cannot bypass explicit requirements + +**Role Types**: +- **FOUNDER_ROLE**: System initialization, highest permissions (but not for revenue-critical functions) +- **BOARD_MEMBER_ROLE**: Strategic governance, elevated voting power +- **EXECUTOR_ROLE**: Proposal execution, administrative functions +- **PLATFORM_ADMIN_ROLE**: Platform configuration and management +- **GOVERNANCE_ROLE**: Proposal creation and voting +- **FEE_MANAGER_ROLE**: Fee configuration (explicit assignment required) +- **TREASURY_ROLE**: Treasury management (explicit assignment required) + +### Voting Power + +**Role Multipliers**: +- **Founder**: 3.0x voting power +- **Board Member**: 2.0x voting power +- **Executive**: 1.5x voting power +- **Standard**: 1.0x base voting power + +**Additional Factors**: +- **Time-Weighted**: Long-term holders receive bonuses +- **Lock Duration**: Staking lock periods increase voting power +- **Compound Bonuses**: Multiple factors compound for committed holders + +### Proposal Types + +1. **STANDARD**: Regular governance proposals + - Typical voting period: 7 days + - Quorum: Configurable per proposal type + - Timelock: Standard delay + +2. **EMERGENCY**: Fast-track critical decisions + - Shorter voting period + - Higher quorum requirements + - Reduced timelock (but still enforced) + +3. **ROLE_CHANGE**: Modify role assignments + - Requires explicit approval + - Timelock enforced for security + +4. **SYSTEM_UPGRADE**: Protocol upgrades via Diamond cuts + - Extended review period + - Technical validation required + - Timelock for security + +5. **PARAMETER_CHANGE**: Adjust system parameters + - Fee structure changes + - Threshold adjustments + - Economic parameter modifications + +### Proposal Lifecycle + +1. **Creation**: Requires proposal threshold (minimum token balance) +2. **Voting Period**: Configurable duration per proposal type (typically 7 days) +3. **Quorum Check**: Minimum participation required (varies by proposal type) +4. **Timelock Queue**: Security delay between approval and execution (prevents rushed changes) +5. **Execution**: Automated or manual execution after timelock expires + +### Advanced Features + +- **Quadratic Voting**: Optional quadratic voting to reduce whale dominance +- **Time-Weighted Voting Power**: Bonuses for long-term token holders +- **Compound Bonuses**: Multiple factors (time, lock, role) compound +- **Custom Voting Curves**: Linear, exponential, logarithmic options +- **EIP-712 Signature-Based Delegation**: Gasless delegation via signatures +- **Quorum Requirements**: Per-proposal-type quorum thresholds +- **Execution Delays**: Timelock enforced for all governance actions + +### Democratic Transition + +The platform supports gradual transition from centralized control to full DAO governance: + +- **Initial State**: Founder/owner has elevated permissions for system setup +- **Transition Path**: Roles can be gradually transferred to governance addresses +- **Mature State**: Full DAO control over all parameters and treasury +- **Voluntary Step-Down**: Founder can renounce roles and transfer ownership to DAO + +This intentional architecture allows for secure launch with trusted operators, while enabling full decentralization as the community matures. + +--- + +## 7. Technical Foundation + +### Diamond Standard Architecture (EIP-2535) + +USpeaks is built on the Diamond Standard, providing unlimited upgradeability and modularity without the 24KB contract size limit. + +**Core Benefits**: +- **Modularity**: 25+ specialized facets for different functionality +- **Unlimited Size**: No 24KB contract size limit +- **Upgradeability**: Individual facet upgrades without full redeployment +- **Shared Storage**: All facets share unified state via Diamond Storage pattern +- **Gas Efficiency**: Optimized storage patterns and function routing + +### Core Systems + +#### Voice System (11 facets) +- `VoiceAssetFacet`: ERC721 NFT management +- `VoiceMetadataFacet`: Rich metadata storage +- `VoiceLicenseFacet`: License creation and management +- `VoiceLicenseTemplateFacet`: Predefined license templates +- `VoiceDatasetFacet`: Dataset bundling (up to 1,000 assets) +- `DatasetLicenseTemplateFacet`: Dataset license templates +- `RightsFacet`: Granular permission controls +- `LegacyFacet`: Digital inheritance planning +- `WhisperBlockFacet`: Voice security and fingerprinting +- `AuditTrailFacet`: Immutable logging +- `VoiceBundleMarketplaceFacet`: Dataset marketplace *(planned — not yet deployed)* + +#### Governance System (5+ facets) +- `GovernorFacet`: Core governance functions +- `ProposalFacet`: Proposal management +- `VotingPowerFacet`: Voting power calculation +- `DelegationFacet`: Vote delegation +- `TimelockFacet`: Execution delays + +#### Token System (5 facets) +- `TokenSupplyFacet`: ERC20 core functionality +- `BurnThresholdFacet`: Burn mechanism +- `VestingFacet`: Role-based vesting +- `MilestoneVestingFacet`: Achievement-based vesting +- `TimewaveVestingFacet`: Block-validated vesting + +#### Marketplace System (4 facets) +- `MarketplaceFacet`: Listing and purchasing +- `EscrowFacet`: Asset custody +- `PaymentFacet`: Revenue distribution, staking funding, buyback accumulation +- `DatasetLicenseFacet`: Dataset licensing + +#### Staking System (1 facet) +- `StakingFacet`: Tiered APY staking with reward pool management + +### Security Features + +#### WhisperBlock™ Security +- **Voice Fingerprinting**: Unique biometric identification using spectral analysis, pitch patterns, and cadence signatures +- **Encryption**: Minimum 256-bit key strength with configurable algorithms +- **Access Control**: Time-limited access grants (up to 365 days) with automatic expiration +- **Off-chain Entropy**: Additional randomness for enhanced key generation +- **Key Refresh**: Automatic encryption key rotation every 90 days +- **Audit Trails**: Immutable logging of all access and modifications + +#### Access Control +- **Explicit Role Assignment**: No "God mode" - all revenue-critical functions require explicit role grants +- **Role-Based Permissions**: Hierarchical permission system with term limits +- **Multi-Signature Support**: Critical roles can require multiple signatures +- **Emergency Override**: Founder can override in emergency situations (with timelock) + +#### Emergency System +- **Four-Tier States**: NORMAL → PAUSED → LOCKED_DOWN → RECOVERY +- **Asset Freezing**: Individual or batch asset freezing capabilities +- **Incident Reporting**: Structured reporting with severity levels +- **Circuit Breakers**: Automatic system pause on anomaly detection + +#### MEV Protection +- **Commit-Reveal Scheme**: High-value transactions use commit-reveal to prevent MEV attacks +- **Flashbots Integration**: Optional Flashbots relay suggestions for large transactions +- **Deadline Protection**: Stale transaction protection via deadline parameters + +### Network & Infrastructure + +**Primary Network**: Base (Ethereum L2) +- Low gas costs (~$0.01 per transaction) +- Fast transaction finality +- Ethereum security guarantees +- EVM compatibility + +**Storage**: IPFS for decentralized metadata storage + +**Oracle Services**: Price feeds for multi-currency support + +**Future Expansion**: +- L2 deployment (Arbitrum, Optimism) +- Cross-chain bridge integration +- Enhanced stablecoin support +- Fiat payment gateway integration + +### Upgradeability + +- **Diamond Cuts**: Enable protocol evolution without full redeployment +- **Community Governance**: Upgrade proposals require DAO approval +- **Timelock Delays**: Security delays for all upgrades +- **Backward Compatibility**: Maintained across upgrades + +--- + +## 8. Use Cases + +### Creator Scenarios + +#### Scenario 1: Voice Actor Monetization + +**Sarah, Professional Voice Actor** + +Sarah registers 10 voice samples on USpeaks, each with different character voices and accents. She lists commercial licenses at $500 each. + +**Results**: +- 10 sales generate $5,000 total revenue +- **Sarah receives $4,575 immediately** (91.5% of $5,000) +- Platform fee: $425 (8.5% of $5,000) + - DAO treasury: $50 (1% of sale) + - Dev fund: $125 (2.5% of sale) + - Platform gifts: $250 (5% of sale — tracked for Sarah, manual claim) + - Staking rewards: $127.50 (30% of $425 total platform fees) + - Buyback accumulation: $85 (20% of $425 total platform fees, if revenue targets met) +- Sarah's Echo Score increases through marketplace engagement +- She stakes her USPK tokens, earning tiered APY rewards (15% down to 5%) +- Platform gifts accumulate - Sarah can claim/vest them when ready (not automatic) + +**Long-Term Value**: +- Sarah builds reputation through Echo Score +- Staking rewards provide ongoing income +- Buyback-driven scarcity increases token value +- Platform gifts available for future needs + +#### Scenario 2: Endangered Language Preservation + +**Dr. Chen, Linguistic Researcher** + +Dr. Chen records 100 hours of Hokkien dialect (critically endangered language) from elderly native speakers. She creates a research dataset bundle with 1,000 voice assets. + +**Results**: +- Dataset sells to university for $50,000 +- **Dr. Chen receives $45,750 immediately** (91.5%) +- Cultural preservation bonus increases Echo Score +- Assets preserved permanently on-chain +- Future licensing revenue continues to flow +- Dataset licensing enables controlled access for research + +**Impact**: +- Language preserved for future generations +- Economic value created for speakers +- Research dataset available for academic use +- Cultural heritage protected + +### Buyer Scenarios + +#### Scenario 3: AI Training Dataset + +**TechCorp, AI Development Company** + +TechCorp needs diverse voice data for speech recognition training. They purchase a dataset bundle: 500 voices, 20 languages, commercial AI training license. + +**Results**: +- Pays $25,000 via USDC +- Receives unified license for commercial AI training +- Automated royalty distribution to all 500 creators +- Dataset license token (ERC721) provides access control +- Valid license checking ensures compliance + +**Benefits**: +- Ethically sourced training data +- Properly compensated creators +- Clear licensing terms +- Ongoing royalty payments to contributors + +#### Scenario 4: Commercial Voice Licensing + +**MediaStudio, Documentary Production** + +MediaStudio needs celebrity voice for documentary narration. They purchase a 5-year commercial license for $10,000. + +**Results**: +- Creator receives $9,150 immediately (91.5%) +- Platform fee: $850 (8.5%) +- License terms enforced on-chain +- Usage tracked automatically +- Royalty payments continue for license duration + +### Investor Scenarios + +#### Scenario 5: Token Holder Participation + +**Alex, Early Investor** + +Alex buys 10,000 USPK in LBP at $0.50 average price ($5,000 investment). He stakes tokens for 12 months. + +**Results**: +- Stakes 10,000 USPK (12% APY tier) +- Earns 1,200 USPK in staking rewards over 12 months +- Participates in governance (votes on fee structure proposal) +- Delegates voting power to trusted community member +- Benefits from buyback-driven scarcity (token value increases) + +**Value Accrual**: +- Staking rewards: 12% APY +- Governance participation: Influence over platform direction +- Buyback impact: Token scarcity increases value +- Platform growth: Revenue increases staking and buyback funding + +#### Scenario 6: Long-Term Value Accrual + +**Platform Growth Scenario** + +Platform reaches $375k monthly revenue (5x base case). Buyback mechanism fully activated. + +**Results**: +- Platform fees: $31,875/month (8.5% of $375k) +- Staking funding: $9,562/month (30% of total platform fees) +- Buyback funding: $6,375-$12,750/month (20-40% of total platform fees) +- Annual buyback: ~$76k-$153k/year +- Tokens burned: ~152k-306k USPK/year (at $0.50) +- **Net deflation**: -0.7M USPK/year (buyback exceeds staking emissions) + +**Token Holder Benefits**: +- Staking rewards increase (more funding) +- Token scarcity increases (more buybacks) +- Governance value increases (platform success) +- Long-term value accrual through multiple mechanisms + +--- + +## 9. Visualizations + +### Three-Pillar Integration + +``` +┌─────────────────────────────────────────────────────────┐ +│ USpeaks Platform │ +└─────────────────────────────────────────────────────────┘ + │ + ┌───────────────────┼───────────────────┐ + │ │ │ + ▼ ▼ ▼ +┌──────────────┐ ┌──────────────┐ ┌──────────────┐ +│ Cultural │ │ Echo Score │ │ Voice │ +│Preservation│ │ (V3) │ │ Monetization │ +│ │ │ │ │ │ +│• Geolinguistic│ │• Data-Driven│ │• 91.5% Payout│ +│ Pools │ │• 5 Dimensions│ │• Multiple │ +│• Metadata │ │• Cumulative │ │ Revenue │ +│• Incentives │ │• On-Chain │ │ Streams │ +└──────┬──────┘ └──────┬──────┘ └──────┬──────┘ + │ │ │ + └──────────────────┼──────────────────┘ + │ + ┌───────▼────────┐ + │ Integrated │ + │ Value Cycle │ + │ │ + │ Cultural → Score│ + │ Score → Revenue│ + │ Revenue → Culture│ + └─────────────────┘ +``` + +### Payment Distribution Flow + +``` +Sale: $100 USDC +│ +├─ Creator: $91.50 (91.5%) +│ +└─ Platform Fee: $8.50 (8.5%) + │ + ├─ Staking Rewards: $2.55 (30%) + │ └─→ StakingFacet.fundRewardPool() + │ + ├─ Buyback & Burn: $1.70-3.40 (20-40%) + │ └─→ buybackAccumulatorUsdc (if revenue targets met) + │ + └─ Remaining Fees: $4.25-2.55 + ├─ Platform Operations: Variable + ├─ DAO/Union Treasury: $1.00 (1%) + ├─ Development Fund: $2.50 (2.5%) + └─ Platform Gifts: $5.00 (5% - tracked, manual claim) +``` + +### Token Economics Flow + +``` +Platform Revenue + │ + ▼ +Platform Fees (8.5%) + │ + ├─→ Staking Rewards (30%) + │ └─→ Tiered APY (15%-5%) + │ └─→ Token Value ↑ + │ + ├─→ Buyback & Burn (20-40%) + │ └─→ Permanent Token Burn + │ └─→ Token Scarcity ↑ + │ + ├─→ DAO Treasury (1%) + │ └─→ Governance Proposals + │ + └─→ Platform Operations + └─→ Infrastructure & Development + └─→ Platform Growth + └─→ More Revenue + └─→ (Cycle Continues) +``` + +### Voice Asset Lifecycle + +``` +Registration + │ + ▼ +Metadata Assignment + │ + ▼ +Security Setup (WhisperBlock) + │ + ▼ +Rights Configuration + │ + ▼ +License Creation + │ + ├─→ Direct Sale ──┐ + │ │ + └─→ Dataset Bundle ─┤ + │ + ▼ + Marketplace Listing + │ + ▼ + Escrow Custody + │ + ▼ + Purchase + │ + ▼ + Payment Distribution + │ + ├─→ Creator (91.5%) + ├─→ Staking (30% of fees) + ├─→ Buyback (20-40% of fees) + └─→ Platform (remaining fees) + │ + ▼ + Asset Transfer + │ + ▼ + Legacy Planning (Optional) +``` + +### Governance Decision Flow + +``` +Proposal Creation + │ + ▼ +Voting Period (7 days) + │ + ▼ +Quorum Check + │ + ▼ +Timelock Queue (Security Delay) + │ + ▼ +Execution + │ + ├─→ Role Assignment (Explicit) + ├─→ Parameter Change + ├─→ System Upgrade + └─→ Treasury Action +``` + +### LBP Price Discovery Curve + +``` +Price ($) +│ +$2.40 ┤●───────────────── + │ \ + │ \ + │ \ +$1.00 ┤ \─────────────── + │ \ + │ \ +$0.50 ┤ \─────────────── (Target) + │ \ + │ \ +$0.25 ┤ \─────────────── + │ \ + │ \ +$0.10 ┤ \──────────── (Floor) + └───────────────────────────────→ Time + 0h 12h 24h 48h 72h +``` + +--- + +## 10. Conclusion + +### Vision Realized + +USpeaks represents a comprehensive solution for the decentralized voice economy, combining: + +- **Cultural Preservation**: Economic incentives for preserving linguistic heritage +- **Data-Driven Valuation**: Objective, transparent reputation system +- **Sustainable Monetization**: 91.5% creator payout with multiple revenue streams +- **Community Governance**: DAO structure with explicit role requirements +- **Technical Excellence**: Diamond Standard architecture with unlimited upgradeability + +### Key Differentiators + +1. **Fair Launch**: LBP ensures transparent price discovery without insider advantage +2. **Sustainable Economics**: Revenue-driven staking and buyback (not speculation-driven) +3. **Cultural Impact**: An innovative platform designed to economically incentivize language preservation +4. **Technical Excellence**: Diamond Standard architecture with rigorous testing and formal verification +5. **Community Ownership**: DAO governance from day one, gradual decentralization + +### Platform Status + +The following core systems are implemented and tested on-chain: +- Voice asset management and trading +- Dataset creation and licensing +- Governance and DAO operations +- Staking and reward distribution +- Buyback and burn mechanisms + +### Launch Strategy + +The LBP launch ensures: +- **Fair Distribution**: No insider advantage +- **Price Discovery**: Market-driven valuation +- **Liquidity Building**: Protocol-owned liquidity from day one +- **Community Participation**: Open to all participants + +### Roadmap + +*The following items are planned but not yet deployed. Timelines are estimates and subject to change based on governance decisions and market conditions.* + +**Immediate (Post-LBP)**: +- Multi-band liquidity deployment +- Staking activation +- Buyback mechanism activation (when revenue targets met) +- Community governance expansion + +**Near-Term (Months 1-6)**: +- Enhanced dataset marketplace +- Cross-chain bridge integration +- Fiat payment gateway +- Mobile wallet integration + +**Long-Term (Year 1+)**: +- Global language preservation initiative +- AI model licensing marketplace +- Voice identity verification services +- Decentralized voice storage network + +### Join the Voice Revolution + +USpeaks is building the infrastructure for the future of voice—where creators are fairly compensated, cultures are preserved, and communities govern their own platforms. + +**Participate in the LBP**: Fair launch, transparent pricing, community-driven. + +**Build on USpeaks**: Open protocol, comprehensive documentation, developer-friendly. + +**Preserve Culture**: Economic incentives for linguistic heritage preservation. + +**Govern Together**: DAO structure with explicit, transparent role requirements. + +--- + +## 11. Risks & Disclaimers + +This section outlines material risks associated with the USpeaks platform and USPK token. Participants should carefully consider these factors before engaging with the platform. + +**Forward-Looking Statements.** This document contains forward-looking statements regarding the platform's roadmap, projected revenue, token burn trajectories, and ecosystem growth. These projections are estimates based on current assumptions and are not guarantees of future performance. Actual results may differ materially. + +**No Guarantee of Token Value.** USPK is a utility token designed for platform governance, staking, and participation. Nothing in this document constitutes financial advice or a guarantee of token value appreciation. The token price is determined by market forces and may fluctuate significantly. + +**Governance-Controlled Parameters.** Fee structures, staking allocations, buyback percentages, and other economic parameters described in this document are subject to change through DAO governance proposals. Token holders should understand that these parameters may be modified by community vote. + +**Smart Contract Risk.** While USpeaks smart contracts have been designed with security best practices (explicit role assignment, MEV protection, emergency systems), all smart contracts carry inherent risks including potential vulnerabilities, upgrade risks, and interaction risks with external protocols. + +**Regulatory Uncertainty.** The regulatory landscape for digital assets, tokens, and decentralized platforms is evolving across jurisdictions. USpeaks and USPK may be subject to varying regulatory requirements depending on your jurisdiction. Platform availability and token accessibility may be restricted in certain regions. Participants are responsible for understanding and complying with the laws and regulations applicable to them. + +**Market and Liquidity Risk.** Token liquidity depends on market participation. The LBP launch mechanism is designed for fair price discovery but does not guarantee sufficient post-launch liquidity. Revenue projections assume marketplace adoption that may not materialize as expected. + +**Technical Risk.** The platform depends on the Base network (Ethereum L2), IPFS, and oracle services. Disruptions to these underlying systems could affect platform availability and functionality. + +--- + +**For More Information**: +- Technical Documentation: *Available on the USpeaks developer portal* +- Platform Overview: *See the USpeaks website* + +**Contact**: +- General inquiries: *[Contact Link / Portal]* + +--- + +*This lite paper reflects the current codebase implementation as of January 2026. All specifications are subject to governance approval and may evolve through community proposals. This document does not constitute an offer of securities or solicitation of investment in any jurisdiction.* diff --git a/docs/LBP_Launch_Materials/executive_summary_lbp.md b/docs/LBP_Launch_Materials/executive_summary_lbp.md new file mode 100644 index 0000000..3b49f04 --- /dev/null +++ b/docs/LBP_Launch_Materials/executive_summary_lbp.md @@ -0,0 +1,22 @@ +# Executive Summary (LBP-Aware) + +USpeaks is a decentralized voice asset platform designed to make voice ownable, licensable, monetizable, and preservable on-chain. + +The platform combines NFT-based voice ownership, structured licensing, dataset creation, creator-first payouts, DAO governance, and voice-specific security into a unified protocol built for the emerging voice economy. + +USpeaks exists to solve three structural problems in today’s market: +* Fragmented voice ownership and licensing, +* Extractive monetization models for creators, +* And the lack of economic incentives for cultural and linguistic preservation. + +The platform’s core value proposition is simple: voice assets should be controlled by their owners, monetized through transparent infrastructure, and preserved in a way that creates long-term value for creators and communities. + +USpeaks generates protocol activity when voice assets are registered, licensed, bundled into datasets, and transacted across the platform. That activity supports a recurring economic loop through marketplace fees, staking participation, governance, and treasury-backed ecosystem growth. + +The USPK token is designed as the coordination layer for this network. It supports governance, staking, and aligned ecosystem participation. Its role is to help organize and sustain the platform’s long-term development as protocol activity grows. + +To open the network to early participants, USpeaks is launching through a Liquidity Bootstrapping Pool (LBP) — a structure commonly used for fairer token distribution and price discovery by shifting token weights over time. This approach is intended to broaden access, reduce insider advantage, and align early participation with the growth of the ecosystem. + +Beyond monetization, USpeaks is also positioned around cultural preservation. UNESCO reports that at least 40% of the world’s languages are endangered, and one language disappears on average every two weeks. By creating economic incentives around voice and language assets, USpeaks aims to support a model where cultural preservation and creator participation reinforce each other. + +USpeaks is not simply launching a token. It is opening participation in a protocol built to turn voice into an economically useful, culturally preservable, and governable digital asset. diff --git a/docs/LBP_Launch_Materials/funding_community_memo.md b/docs/LBP_Launch_Materials/funding_community_memo.md new file mode 100644 index 0000000..86926d5 --- /dev/null +++ b/docs/LBP_Launch_Materials/funding_community_memo.md @@ -0,0 +1,52 @@ +# USpeaks Funding & Community Memo + +## Working Thesis +USpeaks is not launching a token to sell a narrative. It is opening early participation in a protocol that turns voice into an ownable, licensable, and culturally preservable digital asset. + +## What We Are Building +USpeaks is decentralized infrastructure for voice ownership, licensing, monetization, and preservation. It gives creators a way to register voice assets on-chain, manage rights, issue licenses, bundle datasets, and participate in a creator-first marketplace. + +## Why This Matters Now +Voice is becoming a major digital asset class, but the current market is fragmented. Ownership is unclear, licensing is inconsistent, and most platforms remain extractive. At the same time, cultural preservation is urgent: UNESCO reports that at least 40% of the world’s languages are endangered, and one language disappears on average every two weeks. + +## The Economic Engine +USpeaks generates protocol activity when: +* Voice assets are registered and sold, +* Licenses are issued, +* Datasets are created and licensed, +* And marketplace transactions flow through the platform. + +That activity creates recurring platform fees, which support ecosystem operations, staking rewards, treasury growth, and buyback mechanisms as defined by the protocol. + +## Why the Community is Central +The community is not separate from the product. The community helps create the product. + +Community participants include: +* Creators supplying voice assets, +* Contributors building datasets, +* Curators and validators improving quality, +* Stakers aligning with long-term protocol health, +* And governance participants shaping the network. + +The community is not just funding the platform — it is helping bootstrap the supply, participation, and trust that make the protocol valuable. + +## Why the Token Exists +USPK is the coordination layer for the ecosystem. It is designed to support: +* Governance, +* Staking, +* Ecosystem participation, +* And protocol-aligned incentive routing. + +The token is not the product itself. The product is the voice asset economy. The token helps coordinate and govern that economy. + +## Why the LBP +USpeaks is launching through an LBP because the goal is fairer price discovery and broad participation, not insider-first distribution. Balancer describes LBPs as token-launch pools that begin with a high project-token weight and shift over time to support price discovery. + +## Positioning Statement +USpeaks is building a community-owned voice asset economy where creators can register, license, and monetize voice assets on-chain, while token holders help bootstrap the network and participate in its long-term development. + +## What We Want the Audience to Understand +1. This is infrastructure, not a meme launch. +2. The network’s value comes from real platform activity. +3. The community is part of the economic engine, not just an audience. +4. The LBP is the on-ramp into that ecosystem. diff --git a/docs/LBP_Launch_Materials/lbp_landing_page.md b/docs/LBP_Launch_Materials/lbp_landing_page.md new file mode 100644 index 0000000..db75bb4 --- /dev/null +++ b/docs/LBP_Launch_Materials/lbp_landing_page.md @@ -0,0 +1,33 @@ +# Polished LBP Landing Page Section + +## Headline +Bootstrap the Voice Economy + +## Subhead +USpeaks is building the decentralized infrastructure for voice ownership, licensing, monetization, and preservation. The LBP gives the community a fair way to enter early and help launch the network through a price-discovery mechanism designed for transparent distribution. + +## Core Copy +Voice is becoming a valuable digital asset class, but ownership, licensing, and monetization remain fragmented across closed platforms. USpeaks brings that activity on-chain — making voice assets ownable, licensable, and usable in a creator-first ecosystem. + +This is not just a token launch. It is the opening phase of a network where creators, contributors, and participants help bootstrap the marketplace itself. + +As voice assets are created, licensed, bundled into datasets, and transacted across the platform, protocol activity grows. USPK exists to coordinate that ecosystem through governance, staking, and aligned participation. + +## Support Blocks + +### Ownable Voice Assets +Register, license, and manage voice assets with on-chain rights, creator-first economics, and structured licensing. + +### Real Protocol Activity +Value is generated through asset sales, license issuance, dataset access, and marketplace participation. + +### Community-Aligned Launch +The LBP is designed for transparent price discovery and broader access, helping bootstrap the network without an insider-first launch model. + +## Call to Action (CTA) + +### Community CTA +Join early, help shape the ecosystem, and participate in building a creator-owned voice platform. + +### Secondary CTA +Read the lite paper • Explore tokenomics • Learn how the LBP works diff --git a/output/spreadsheet/treasury_token_incentive_econ_simulation.xlsx b/output/spreadsheet/treasury_token_incentive_econ_simulation.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..ffa610895f897cd39032bb05ee05a5ba9618bc16 GIT binary patch literal 13024 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 literal 0 HcmV?d00001