From 6c8159c5f7c1af0b10f9395967c931f2285dbd0f346805eacc1c955cbc08ce30 Mon Sep 17 00:00:00 2001 From: AidarKC Date: Fri, 23 Oct 2026 12:18:27 +0300 Subject: [PATCH 01/82] =?UTF-8?q?=D0=94=D0=BE=D1=80=D0=B0=D0=B1=D0=BE?= =?UTF-8?q?=D1=82=D0=BA=D0=B0=20=D0=BB=D0=BE=D0=B3=D0=B8=D0=BD=D0=B0=20?= =?UTF-8?q?=D0=B8=20=D1=82=D0=B5=D0=BC=D1=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- VERSION.properties | 2 +- shine-UI/js/services/theme-service.js | 20 ++++++++++++++++ shine-UI/tests/tg-midnight-theme.test.mjs | 28 +++++++++++++++++++++++ 3 files changed, 49 insertions(+), 1 deletion(-) create mode 100644 shine-UI/tests/tg-midnight-theme.test.mjs diff --git a/VERSION.properties b/VERSION.properties index 164d6982..90187fe1 100644 --- a/VERSION.properties +++ b/VERSION.properties @@ -1,2 +1,2 @@ -client.version=1.20.0 +client.version=1.20.1 server.version=1.16.0 diff --git a/shine-UI/js/services/theme-service.js b/shine-UI/js/services/theme-service.js index ee8027f3..64251680 100644 --- a/shine-UI/js/services/theme-service.js +++ b/shine-UI/js/services/theme-service.js @@ -48,6 +48,26 @@ export const PALETTE_PRESETS = { 'reaction-active': '#5d4fc4', danger: '#b3304a', success: '#2d7552', warning: '#8a5a0e', info: '#2f5f9e', }, }, + // TG · Midnight — спокойная тёмно-синяя палитра по мотивам Telegram Android. + // Только цвета: никаких изменений в навигации, компонентах и логике сообщений. + // Светлый вариант нужен, чтобы «Авто» работало по существующим правилам. + tg_midnight: { + label: 'TG · Midnight', + dark: { + background: '#151e27', surface: '#1d2733', 'surface-selected': '#2c4358', 'surface-raised': '#263646', + 'text-primary': '#f0f3f7', 'text-secondary': '#8494a5', + 'border-subtle': '#293643', 'border-control': '#547086', + accent: '#2596e8', 'on-accent': '#ffffff', action: '#69b9f0', 'bubble-out': '#456f69', + 'reaction-active': '#69b9f0', danger: '#f06e7a', success: '#7ad4ad', warning: '#f1bc74', info: '#73bff1', + }, + light: { + background: '#f1f5f9', surface: '#ffffff', 'surface-selected': '#dceefa', 'surface-raised': '#e9f2f9', + 'text-primary': '#192a39', 'text-secondary': '#667e90', + 'border-subtle': '#dae4ec', 'border-control': '#91aabc', + accent: '#248ed0', 'on-accent': '#ffffff', action: '#167fbf', 'bubble-out': '#d9f0e9', + 'reaction-active': '#248ed0', danger: '#c33c51', success: '#267f59', warning: '#976315', info: '#297eb7', + }, + }, club: { label: 'Индиго', dark: { diff --git a/shine-UI/tests/tg-midnight-theme.test.mjs b/shine-UI/tests/tg-midnight-theme.test.mjs new file mode 100644 index 00000000..0255e06e --- /dev/null +++ b/shine-UI/tests/tg-midnight-theme.test.mjs @@ -0,0 +1,28 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { + PALETTE_PRESETS, PALETTE_ROLES, resolvePalette, +} from '../js/services/theme-service.js'; + +const settings = (preset) => ({ preset, custom: { dark: {}, light: {} } }); + +test('новая палитра доступна в настройках, а стандартная сохранена', () => { + assert.equal(PALETTE_PRESETS.tg_midnight.label, 'TG · Midnight'); + assert.equal(PALETTE_PRESETS.aurora.label, 'Сияние'); +}); + +test('каждая роль в тёмном и светлом TG содержит корректный HEX', () => { + for (const mode of ['dark', 'light']) { + const result = resolvePalette(mode, settings('tg_midnight')); + for (const { id } of PALETTE_ROLES) { + assert.match(result[id], /^#[0-9a-f]{6}$/i, `${mode}/${id}`); + } + } +}); + +test('у тёмной темы синий акцент и отдельный цвет исходящего сообщения', () => { + const c = resolvePalette('dark', settings('tg_midnight')); + assert.equal(c.background, '#151e27'); + assert.equal(c.accent, '#2596e8'); + assert.equal(c['bubble-out'], '#456f69'); +}); From cab26bbf417e9295d300581004d0509d0b9e5b2ea7e494df4d1e9f1e738a99c9 Mon Sep 17 00:00:00 2001 From: AidarKC Date: Fri, 23 Oct 2026 19:21:52 +0300 Subject: [PATCH 02/82] =?UTF-8?q?=D0=A0=D0=B5=D0=B3=D0=B8=D1=81=D1=82?= =?UTF-8?q?=D1=80=D0=B0=D1=86=D0=B8=D1=8F=20V2:=20=D0=BD=D0=B5=20=D0=BF?= =?UTF-8?q?=D1=80=D0=BE=D0=B2=D0=B5=D1=80=D0=B5=D0=BD=D0=BE=20end-to-end?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../archive/ArweaveBlockSyncService.java | 99 ++- .../FreeRegistrationApiBootstrap.java | 116 +++ .../FreeRegistrationCertificateV1.java | 114 +++ .../registration/FreeRegistrationIssuer.java | 67 ++ .../FreeRegistrationPublisher.java | 35 + .../FreeRegistrationWorkflow.java | 138 ++++ .../registration/LocalRegistrarSigner.java | 43 ++ .../archive/registration/RegistrarSigner.java | 8 + .../VerifiedFreeRegistrationImporter.java | 155 ++++ .../src/test/fixtures/reg-v1-example.hex | 1 + .../FreeRegistrationCertificateV1Check.java | 42 + .../FreeRegistrationWorkflowLocalCheck.java | 47 ++ .../java/shine/db/DatabaseInitializer.java | 16 +- .../java/shine/db/dao/CurrentUsersDAO.java | 2 +- .../shine/db/dao/RegistrationIdentityDAO.java | 58 ++ .../db/dao/UserAccessServersCurrentDAO.java | 24 +- .../java/shine/db/sql/CurrentUsersSql.java | 2 +- .../main/resources/postgres/migration_v33.sql | 213 ++++++ .../main/resources/postgres/migration_v34.sql | 12 + .../ws_protocol/JSON/JsonHandlerRegistry.java | 18 + .../JSON/JsonInboundProcessor.java | 16 +- .../auth/SolanaUserPdaImportService.java | 5 + .../keyRotation/KeyRotationApiSupport.java | 17 + .../Net_KeyRotationAbort_Handler.java | 2 + .../Net_KeyRotationAddBlock_Handler.java | 2 + .../Net_KeyRotationContinue_Handler.java | 2 + .../Net_KeyRotationFinishChain_Handler.java | 2 + .../Net_KeyRotationRotatePda_Handler.java | 2 + .../Net_KeyRotationStart_Handler.java | 2 + .../Net_KeyRotationStatus_Handler.java | 2 + .../Net_Registration_Handler.java | 47 ++ .../Net_Registration_Request.java | 28 + .../Net_Registration_Response.java | 12 + .../registration/RegistrationApiBridge.java | 15 + .../main/java/sync/codec/ShineUsersCodec.java | 58 ++ .../sync/service/SolanaUsersSyncService.java | 43 +- .../postgres/PostgresStorageRepository.java | 49 ++ .../main/java/sync/util/SolanaPdaUtil.java | 21 + .../sync/codec/NamespaceV2VectorCheck.java | 35 + .../src/main/java/server/ws/WsServer.java | 4 +- VERSION.properties | 4 +- deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md | 5 + docs/API/01_User_Registration_API.md | 8 + docs/API/09_Operations_Index.md | 12 + docs/Blockchain/CHANGELOG.md | 6 + docs/Blockchain/README.md | 7 + .../Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md | 7 + docs/registration-v2/IMPLEMENTATION_STATUS.md | 85 +++ .../MASTER_PLAN_V2_2026-10-23.md | 720 ++++++++++++++++++ docs/registration-v2/PATCH_STAGES_11_12_13.md | 42 + docs/registration-v2/PATCH_STAGES_1_2_3.md | 31 + docs/registration-v2/PATCH_STAGES_4_5_6_7.md | 40 + docs/registration-v2/PATCH_STAGES_8_9_10.md | 28 + .../REGISTRAR_CONFIGURATION.md | 15 + .../ROADMAP_ORIGINAL_2026-10-23.md | 251 ++++++ docs/registration-v2/SERVER_PDA_V2_SETUP.md | 12 + docs/registration-v2/SOURCE_BASELINE.md | 81 ++ docs/registration-v2/SQL_DEPENDENCIES.md | 76 ++ docs/registration-v2/VALIDATION_STAGE_13.md | 22 + ...WS_REGISTRATION_V2_PROPOSED_NOT_ENABLED.md | 22 + .../SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md | 35 + shine-UI/js/app.js | 6 +- shine-UI/js/pages/devnet-topup-view.js | 211 +---- shine-UI/js/pages/register-view.js | 485 ++---------- shine-UI/js/pages/registration-email-view.js | 60 ++ .../js/pages/registration-payment-view.js | 52 +- .../js/pages/registration-upgrade-view.js | 64 ++ shine-UI/js/pages/settings-view.js | 14 + shine-UI/js/pages/topup-view.js | 48 +- shine-UI/js/router.js | 2 + shine-UI/js/services/registration-v2-api.js | 24 + .../js/services/shine-namespace-service.js | 112 +++ .../js/services/shine-user-pda-service.js | 80 +- .../js/services/solana-register-service.js | 100 +-- shine-UI/js/state.js | 6 + shine-UI/server-ui/create-server-pda.html | 11 +- .../server-ui/js/create-server-pda-page.js | 10 +- shine-UI/server-ui/js/server-ui-shared.js | 13 +- shine-UI/server-ui/update-server-pda.html | 2 +- .../registration-api-v2-contract.test.mjs | 42 + .../tests/registration-namespace-v2.test.mjs | 52 ++ shine-UI/tests/server-pda-v2-ui.test.mjs | 21 + .../formats/shine-namespace-pda-format-v1.md | 41 + .../formats/shine-user-pda-format-v.1.2.md | 7 + .../shine/doc/programs/shine_users.md | 72 +- .../shine/programs/shine_users/src/lib.rs | 399 +++++----- .../programs/shine_users/src/settings.rs | 14 +- .../registration-v2/create-namespace.mjs | 82 ++ .../registration-v2/decode-namespace.mjs | 36 + .../shine/tests/fixtures/registration-v2.json | 100 +++ .../tests/fixtures/registration-v2.properties | 32 + .../java/RegistrationV2VectorsCheck.java | 75 ++ .../tests/registration-v2-decoder.test.mjs | 32 + .../tests/registration-v2-vectors.test.mjs | 110 +++ .../shine/tests/registration_v2_vectors.rs | 59 ++ 95 files changed, 4469 insertions(+), 1088 deletions(-) create mode 100644 SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationApiBootstrap.java create mode 100644 SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationCertificateV1.java create mode 100644 SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationIssuer.java create mode 100644 SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationPublisher.java create mode 100644 SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationWorkflow.java create mode 100644 SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/LocalRegistrarSigner.java create mode 100644 SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/RegistrarSigner.java create mode 100644 SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/VerifiedFreeRegistrationImporter.java create mode 100644 SHiNE-server/shine-server-archive/src/test/fixtures/reg-v1-example.hex create mode 100644 SHiNE-server/shine-server-archive/src/test/java/server/archive/FreeRegistrationCertificateV1Check.java create mode 100644 SHiNE-server/shine-server-archive/src/test/java/server/archive/FreeRegistrationWorkflowLocalCheck.java create mode 100644 SHiNE-server/shine-server-db/src/main/java/shine/db/dao/RegistrationIdentityDAO.java create mode 100644 SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v33.sql create mode 100644 SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v34.sql create mode 100644 SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/registration/Net_Registration_Handler.java create mode 100644 SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/registration/Net_Registration_Request.java create mode 100644 SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/registration/Net_Registration_Response.java create mode 100644 SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/registration/RegistrationApiBridge.java create mode 100644 SHiNE-server/shine-server-solana-users-sync/src/test/java/sync/codec/NamespaceV2VectorCheck.java create mode 100644 docs/registration-v2/IMPLEMENTATION_STATUS.md create mode 100644 docs/registration-v2/MASTER_PLAN_V2_2026-10-23.md create mode 100644 docs/registration-v2/PATCH_STAGES_11_12_13.md create mode 100644 docs/registration-v2/PATCH_STAGES_1_2_3.md create mode 100644 docs/registration-v2/PATCH_STAGES_4_5_6_7.md create mode 100644 docs/registration-v2/PATCH_STAGES_8_9_10.md create mode 100644 docs/registration-v2/REGISTRAR_CONFIGURATION.md create mode 100644 docs/registration-v2/ROADMAP_ORIGINAL_2026-10-23.md create mode 100644 docs/registration-v2/SERVER_PDA_V2_SETUP.md create mode 100644 docs/registration-v2/SOURCE_BASELINE.md create mode 100644 docs/registration-v2/SQL_DEPENDENCIES.md create mode 100644 docs/registration-v2/VALIDATION_STAGE_13.md create mode 100644 docs/registration-v2/WS_REGISTRATION_V2_PROPOSED_NOT_ENABLED.md create mode 100644 docs/Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md create mode 100644 shine-UI/js/pages/registration-email-view.js create mode 100644 shine-UI/js/pages/registration-upgrade-view.js create mode 100644 shine-UI/js/services/registration-v2-api.js create mode 100644 shine-UI/js/services/shine-namespace-service.js create mode 100644 shine-UI/tests/registration-api-v2-contract.test.mjs create mode 100644 shine-UI/tests/registration-namespace-v2.test.mjs create mode 100644 shine-UI/tests/server-pda-v2-ui.test.mjs create mode 100644 shine-solana/shine/doc/formats/shine-namespace-pda-format-v1.md create mode 100644 shine-solana/shine/scripts/registration-v2/create-namespace.mjs create mode 100644 shine-solana/shine/scripts/registration-v2/decode-namespace.mjs create mode 100644 shine-solana/shine/tests/fixtures/registration-v2.json create mode 100644 shine-solana/shine/tests/fixtures/registration-v2.properties create mode 100644 shine-solana/shine/tests/java/RegistrationV2VectorsCheck.java create mode 100644 shine-solana/shine/tests/registration-v2-decoder.test.mjs create mode 100644 shine-solana/shine/tests/registration-v2-vectors.test.mjs create mode 100644 shine-solana/shine/tests/registration_v2_vectors.rs diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java index d43253be..f2e869a1 100644 --- a/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java @@ -2,6 +2,7 @@ package server.archive; import blockchain.Ans104DataItem; import blockchain.BchBlockEntry; +import server.archive.registration.VerifiedFreeRegistrationImporter; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import org.slf4j.Logger; @@ -50,6 +51,7 @@ public final class ArweaveBlockSyncService { .connectTimeout(Duration.ofSeconds(20)) .followRedirects(HttpClient.Redirect.NORMAL) .build(); + private final VerifiedFreeRegistrationImporter registrationImporter = new VerifiedFreeRegistrationImporter(); private final ArweaveBlockImportDAO importDAO = ArweaveBlockImportDAO.getInstance(); private final BlocksDAO blocksDAO = BlocksDAO.getInstance(); private final SolanaUserPdaCurrentDAO usersDAO = SolanaUserPdaCurrentDAO.getInstance(); @@ -68,6 +70,7 @@ public final class ArweaveBlockSyncService { public void runCycle() throws Exception { recoverInterruptedCanonicalRebuilds(); discover(); + discoverFreeRegistrations(); drainQueue(); } @@ -116,6 +119,12 @@ public final class ArweaveBlockSyncService { try { DownloadedDataItem downloaded = downloadSignedDataItem(dataItemId); + if (isRegistrationItem(downloaded.rawDataItem())) { + registrationImporter.importSigned(downloaded.rawDataItem(), + VerifiedFreeRegistrationImporter.Provenance.ARWEAVE_CONFIRMED); + unresolvedDownloads.remove(dataItemId); + continue; // Не парсить регистрацию как BchBlockEntry. + } unresolvedDownloads.remove(dataItemId); if (importDAO.enqueueIfMissing(id32, downloaded.rootTxId(), height, downloaded.rawDataItem(), System.currentTimeMillis())) discovered++; } catch (RetryableDataItemDownloadException e) { @@ -172,6 +181,18 @@ public final class ArweaveBlockSyncService { continue; } + if (isRegistrationItem(downloaded.rawDataItem())) { + try { + registrationImporter.importSigned(downloaded.rawDataItem(), + VerifiedFreeRegistrationImporter.Provenance.ARWEAVE_CONFIRMED); + unresolvedDownloads.remove(pending.dataItemId()); + } catch (Exception e) { + unresolvedDownloads.remove(pending.dataItemId()); + unresolvedDownloads.put(pending.dataItemId(), pending); + log.debug("Registration {} awaits namespace/DB sync or retry: {}", pending.dataItemId(), e.getMessage()); + } + continue; + } if (importDAO.enqueueIfMissing(pending.id32(), downloaded.rootTxId(), pending.height(), downloaded.rawDataItem(), System.currentTimeMillis())) { queued++; @@ -474,10 +495,84 @@ public final class ArweaveBlockSyncService { }finally{BlockchainResyncGuard.end(activeName);} } + + /** Независимый GraphQL курсор для t=reg: не смешивается с блоковой очередью. */ + private void discoverFreeRegistrations() throws Exception { + long stored; + try (Connection c = DbController.getInstance().getConnection(); + PreparedStatement ps = c.prepareStatement( + "SELECT last_block_height FROM free_registration_arweave_sync_state WHERE id=1"); + ResultSet rs = ps.executeQuery()) { + stored = rs.next() ? rs.getLong(1) : 0; + } + long minHeight = Math.max(cfg.syncStartBlockHeight(), stored); + long high = minHeight; + long retryFrom = Long.MAX_VALUE; + String cursor = null; + int count = 0; + do { + JsonNode response = graphQlPage(minHeight, cursor, true); + if (response.has("errors")) throw new IOException("Registration GraphQL errors: " + response.path("errors")); + JsonNode txs = response.path("data").path("transactions"); + JsonNode edges = txs.path("edges"); + if (!edges.isArray()) throw new IOException("Registration GraphQL returned no edges"); + String next = null; + for (JsonNode edge : edges) { + next = edge.path("cursor").asText(null); + JsonNode node = edge.path("node"); + String id = node.path("id").asText("").trim(); + long height = node.path("block").path("height").asLong(-1); + if (id.isBlank() || height < 0) continue; // мгновенный Turbo-импорт не зависит от height + high = Math.max(high, height); + try { + byte[] idBytes = B64URL.decode(id); + if (idBytes.length != 32) throw new IllegalArgumentException("Malformed id"); + DownloadedDataItem item = downloadSignedDataItem(id); + if (!isRegistrationItem(item.rawDataItem())) + throw new IllegalArgumentException("GraphQL registration tag is not present in signed bytes"); + registrationImporter.importSigned(item.rawDataItem(), + VerifiedFreeRegistrationImporter.Provenance.ARWEAVE_CONFIRMED); + count++; + } catch (RetryableDataItemDownloadException e) { + retryFrom = Math.min(retryFrom, height); + log.debug("Registration DataItem {} is not downloadable yet", id); + } catch (IllegalArgumentException e) { + log.warn("Rejecting invalid registration DataItem {}: {}", id, e.getMessage()); + } catch (Exception e) { + retryFrom = Math.min(retryFrom, height); + log.warn("Registration DataItem {} import deferred: {}", id, e.getMessage()); + } + } + cursor = txs.path("pageInfo").path("hasNextPage").asBoolean(false) ? next : null; + if (txs.path("pageInfo").path("hasNextPage").asBoolean(false) && (cursor == null || cursor.isBlank())) + throw new IOException("Registration GraphQL cursor missing"); + } while (cursor != null); + long checkpoint = retryFrom == Long.MAX_VALUE ? high : Math.min(high, retryFrom); + try (Connection c = DbController.getInstance().getConnection(); + PreparedStatement ps = c.prepareStatement(""" + UPDATE free_registration_arweave_sync_state + SET last_block_height=?, updated_at_ms=? WHERE id=1 + """)) { + ps.setLong(1, checkpoint); ps.setLong(2, System.currentTimeMillis()); ps.executeUpdate(); + } + if (count > 0) log.info("Registration discovery verified {} DataItems; checkpoint={}", count, checkpoint); + } + + private static boolean isRegistrationItem(byte[] raw) { + Ans104DataItem item = new Ans104DataItem(raw); + return item.tags().contains(new Ans104DataItem.Tag("t", "reg")); + } + private JsonNode graphQlPage(long minHeight, String cursor) throws Exception { + return graphQlPage(minHeight, cursor, false); + } + + private JsonNode graphQlPage(long minHeight, String cursor, boolean registrationsOnly) throws Exception { String after = cursor == null ? "null" : "\"" + escapeGraphQl(cursor) + "\""; - String query = "query { transactions(tags:[{name:\"" + ArweaveBlocksConfig.TEST_TAG_NAME + "\",values:[\"" - + ArweaveBlocksConfig.TEST_TAG_VALUE + "\"]}], block:{min:" + minHeight + "}, first:" + String tagFilter = "{name:\"" + ArweaveBlocksConfig.TEST_TAG_NAME + "\",values:[\"" + + ArweaveBlocksConfig.TEST_TAG_VALUE + "\"]}" + + (registrationsOnly ? ",{name:\"t\",values:[\"reg\"]}" : ""); + String query = "query { transactions(tags:[" + tagFilter + "], block:{min:" + minHeight + "}, first:" + cfg.syncPageSize() + ", after:" + after + ", sort:HEIGHT_ASC) { pageInfo { hasNextPage } edges { cursor node { id block { height } } } } }"; String body = MAPPER.writeValueAsString(Map.of("query", query)); diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationApiBootstrap.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationApiBootstrap.java new file mode 100644 index 00000000..39f01ca2 --- /dev/null +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationApiBootstrap.java @@ -0,0 +1,116 @@ +package server.archive.registration; + +import server.archive.ArweaveBlocksConfig; +import server.archive.TurboDataItemUploader; +import server.logic.ws_protocol.JSON.handlers.registration.RegistrationApiBridge; +import server.logic.ws_protocol.JSON.handlers.registration.Net_Registration_Request; +import shine.db.DbController; +import utils.config.AppConfig; + +import javax.sql.DataSource; +import java.io.PrintWriter; +import java.sql.Connection; +import java.sql.SQLException; +import java.sql.SQLFeatureNotSupportedException; +import java.util.Base64; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.logging.Logger; + +/** Единственная точка подключения API без циклической зависимости Gradle-модулей. */ +public final class FreeRegistrationApiBootstrap { + private static volatile FreeRegistrationWorkflow workflow; + private static volatile LocalRegistrarSigner signer; + private FreeRegistrationApiBootstrap() {} + + public static synchronized void startOrThrow() throws Exception { + if (workflow != null) return; + AppConfig cfg=AppConfig.getInstance(); + LocalRegistrarSigner newSigner=null; + FreeRegistrationIssuer issuer=null; + FreeRegistrationPublisher publisher=null; + if (cfg.getBoolean("freeRegistration.enabled",false)) { + // Не выводить seed/path в журнал ни при успешном старте, ни при ошибке. + ArweaveBlocksConfig transport=ArweaveBlocksConfig.load(); + if(transport.publishMode()!=ArweaveBlocksConfig.PublishMode.TURBO) + throw new IllegalStateException("Free registration requires Turbo transport"); + newSigner=LocalRegistrarSigner.fromConfig(cfg); + issuer=new FreeRegistrationIssuer(dbSource(),newSigner); + publisher=new FreeRegistrationPublisher(issuer,new TurboDataItemUploader(transport),new VerifiedFreeRegistrationImporter()); + } + FreeRegistrationWorkflow newWorkflow=new FreeRegistrationWorkflow(issuer,publisher); + RegistrationApiBridge.install((op,req)->dispatch(newWorkflow,op,req)); + signer=newSigner; workflow=newWorkflow; + } + public static synchronized void close() { + RegistrationApiBridge.uninstall(); + workflow=null; + if(signer!=null) signer.close(); + signer=null; + } + public static Map dispatch(FreeRegistrationWorkflow w, String op,Net_Registration_Request req) throws Exception { + Map out=new LinkedHashMap<>(); + switch(op) { + case "GetNamespaces" -> { + out.put("namespaces",w.listNamespaces().stream().map(ns->Map.of( + "name",ns.namespace(), "type",ns.type(), "minLocalLength",ns.minLoginLength(), + "registrationFeeLamports",ns.priceLamports(), "defaultServerLogin",ns.serverLogin()==null?"":ns.serverLogin() + )).toList()); + } + case "CheckRegistrationLogin" -> { + var info=w.checkLogin(req.getFullLogin()); + out.put("loginAvailable",info.loginAvailable()); + out.put("namespaceType",info.namespaceType()); + out.put("minLocalLength",info.minLocalLength()); + out.put("registrationFeeLamports",info.registrationFeeLamports()); + } + case "CheckRegistrationEmail" -> out.put("emailAvailable",w.checkEmail(req.getEmail()).emailAvailable()); + case "StartFreeRegistration" -> { + var state=w.start(req.getFullLogin(),decodeKey(req.getRootPublicKeyB64()), + decodeKey(req.getBlockchainPublicKeyB64()),decodeKey(req.getClientPublicKeyB64()),req.getEmail()); + out.put("challengeId",state.challengeId()); out.put("expiresAtMs",state.expiresAtMs()); + } + case "ConfirmFreeRegistration" -> { + var value=w.confirm(req.getChallengeId(),req.getCode()); + out.put("fullLogin",value.fullLogin());out.put("dataItemId",value.dataItemId()); + out.put("publicationStatus",value.state());out.put("chainConfirmed",false); + } + case "GetRegistrationStatus" -> { + var value=w.getStatus(req.getFullLogin()); + out.put("registrationStatus",value.status()); + out.put("dataItemId",value.dataItemId()==null?"":value.dataItemId()); + out.put("publicationStatus",value.publicationStatus()==null?"":value.publicationStatus()); + // Публичная историческая часть сертификата для бесплатного → Solana upgrade. + if("FREE_CERT".equals(value.status())) { + out.put("innerSignature64B64",value.innerSignature64B64()==null?"":value.innerSignature64B64()); + out.put("rootPublicKey",value.rootPublicKey()==null?"":value.rootPublicKey()); + out.put("blockchainPublicKey",value.blockchainPublicKey()==null?"":value.blockchainPublicKey()); + out.put("clientPublicKey",value.clientPublicKey()==null?"":value.clientPublicKey()); + out.put("defaultServerLogin",value.defaultServerLogin()==null?"":value.defaultServerLogin()); + } + } + default -> throw new IllegalArgumentException("Unknown registration operation"); + } + return out; + } + private static byte[] decodeKey(String base64) { + if(base64==null || base64.length()>64)throw new IllegalArgumentException("Invalid public key"); + byte[] decoded=Base64.getDecoder().decode(base64); + if(decoded.length!=32)throw new IllegalArgumentException("Invalid public key length"); + return decoded; + } + private static DataSource dbSource() { + return new DataSource() { + @Override public Connection getConnection() throws SQLException {return DbController.getInstance().getConnection();} + @Override public Connection getConnection(String u,String p) throws SQLException {throw new SQLFeatureNotSupportedException();} + @Override public PrintWriter getLogWriter(){return null;} + @Override public void setLogWriter(PrintWriter p){} + @Override public void setLoginTimeout(int t){} + @Override public int getLoginTimeout(){return 0;} + @Override public Logger getParentLogger(){return Logger.getGlobal();} + @Override public T unwrap(Class type) throws SQLException {throw new SQLFeatureNotSupportedException();} + @Override public boolean isWrapperFor(Class type){return false;} + }; + } +} diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationCertificateV1.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationCertificateV1.java new file mode 100644 index 00000000..31587542 --- /dev/null +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationCertificateV1.java @@ -0,0 +1,114 @@ +package server.archive.registration; + +import blockchain.Ans104DataItem; +import utils.crypto.Ed25519Util; + +import java.io.ByteArrayOutputStream; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.text.Normalizer; +import java.util.Arrays; +import java.util.Base64; +import java.util.List; +import java.util.Locale; + +/** Строгое формирование и проверка двух подписей нового независимого DataItem `t=reg`. */ +public final class FreeRegistrationCertificateV1 { + private static final byte[] DOMAIN = "SHiNE_FREE_REG_V1\0".getBytes(StandardCharsets.UTF_8); + private static final List TAGS = List.of( + new Ans104DataItem.Tag("App", "test5591"), + new Ans104DataItem.Tag("t", "reg"), + new Ans104DataItem.Tag("Protocol", "SHiNE-Free-Registration-V1")); + + public record Verified(String login, byte[] rootKey, byte[] blockchainKey, + byte[] clientKey, byte[] innerSignature, + byte[] emailSha256, byte[] owner32, String idBase64Url) {} + + private FreeRegistrationCertificateV1() {} + + public static String validateLogin(String login) { + if (login == null || !login.matches("[a-z0-9_]+@[a-z0-9_]+") || login.length() > 30) + throw new IllegalArgumentException("Full login must be lowercase ASCII, <= 30 bytes"); + return login; + } + + public static byte[] identityFields(String login, byte[] root32, byte[] blockchain32, byte[] client32) { + byte[] name = validateLogin(login).getBytes(StandardCharsets.UTF_8); + require32(root32); require32(blockchain32); require32(client32); + ByteArrayOutputStream out = new ByteArrayOutputStream(); + out.write(1); out.write(0); out.write(name.length); out.writeBytes(name); + out.writeBytes(root32); out.writeBytes(blockchain32); out.writeBytes(client32); + return out.toByteArray(); + } + + public static byte[] innerMessage(byte[] identity) { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + out.writeBytes(DOMAIN); out.writeBytes(identity); + return out.toByteArray(); + } + + public static String normalizeEmail(String email) { + if (email == null) throw new IllegalArgumentException("Email is required"); + String value = Normalizer.normalize(email.strip(), Normalizer.Form.NFC).toLowerCase(Locale.ROOT); + if (value.isBlank() || value.indexOf('@') < 1 || value.contains(" ")) + throw new IllegalArgumentException("Invalid email"); + return value; + } + + public static byte[] emailHash(String email) { + return sha256(normalizeEmail(email).getBytes(StandardCharsets.UTF_8)); + } + + public static byte[] issue(String login, byte[] root32, byte[] blockchain32, + byte[] client32, String email, RegistrarSigner signer) { + byte[] fields = identityFields(login, root32, blockchain32, client32); + byte[] inner = signer.sign(innerMessage(fields)); + if (inner.length != 64) throw new IllegalStateException("Invalid inner signature length"); + ByteArrayOutputStream payload = new ByteArrayOutputStream(); + payload.writeBytes(fields); + payload.writeBytes(inner); + payload.writeBytes(emailHash(email)); + byte[] data = payload.toByteArray(); + byte[] owner = signer.publicKey32(); + require32(owner); + byte[] outer = signer.sign(Ans104DataItem.buildSigningMessage(owner, TAGS, data)); + byte[] raw = Ans104DataItem.serializeEd25519(outer, owner, TAGS, data); + verify(raw, owner); + return raw; + } + + public static Verified verify(byte[] signedDataItem, byte[] registrarPublicKey32) { + require32(registrarPublicKey32); + Ans104DataItem item = new Ans104DataItem(signedDataItem); + if (!item.ownerEquals(registrarPublicKey32) || !item.verifySignature()) + throw new IllegalArgumentException("Invalid outer ANS-104 registrar signature"); + if (!item.tags().equals(TAGS) || item.target().length != 0 || item.anchor().length != 0) + throw new IllegalArgumentException("Unexpected registration tags/target/anchor"); + byte[] data = item.data(); + if (data.length < 3 + 96 + 64 + 32 || data[0] != 1 || data[1] != 0) + throw new IllegalArgumentException("Invalid certificate version/length"); + int len = data[2] & 0xff; + if (data.length != 3 + len + 96 + 64 + 32) + throw new IllegalArgumentException("Invalid certificate byte length"); + String login = validateLogin(new String(data, 3, len, StandardCharsets.UTF_8)); + int offset = 3 + len; + byte[] root = Arrays.copyOfRange(data, offset, offset+32); offset += 32; + byte[] blockchain = Arrays.copyOfRange(data, offset, offset+32); offset += 32; + byte[] client = Arrays.copyOfRange(data, offset, offset+32); offset += 32; + byte[] innerSig = Arrays.copyOfRange(data, offset, offset+64); offset += 64; + byte[] emailSha = Arrays.copyOfRange(data, offset, offset+32); + byte[] fields = Arrays.copyOfRange(data, 0, 3 + len + 96); + if (!Ed25519Util.verify(innerMessage(fields), innerSig, registrarPublicKey32)) + throw new IllegalArgumentException("Invalid inner certificate signature"); + return new Verified(login, root, blockchain, client, innerSig, emailSha, + item.owner32(), Base64.getUrlEncoder().withoutPadding().encodeToString(item.id32())); + } + + private static void require32(byte[] key) { + if (key == null || key.length != 32) throw new IllegalArgumentException("Expected 32-byte public key"); + } + private static byte[] sha256(byte[] data) { + try { return MessageDigest.getInstance("SHA-256").digest(data); } + catch (Exception e) { throw new IllegalStateException("SHA-256 unavailable", e); } + } +} diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationIssuer.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationIssuer.java new file mode 100644 index 00000000..9dd2a56f --- /dev/null +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationIssuer.java @@ -0,0 +1,67 @@ +package server.archive.registration; + +import sync.util.Base58Util; + +import javax.sql.DataSource; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.util.Arrays; + +/** Выдача (без публикации). Stage 8 публикует через Turbo и импортирует тот же raw DataItem. */ +public final class FreeRegistrationIssuer { + private final DataSource db; + private final RegistrarSigner signer; + + public FreeRegistrationIssuer(DataSource db, RegistrarSigner signer) { + this.db = java.util.Objects.requireNonNull(db); + this.signer = java.util.Objects.requireNonNull(signer); + } + + /** Код 1111 учебный: не подтверждает владение email. */ + public synchronized byte[] issue(String fullLogin, byte[] root32, byte[] blockchain32, + byte[] client32, String email, String code) throws Exception { + FreeRegistrationCertificateV1.validateLogin(fullLogin); + if (!"1111".equals(code)) throw new IllegalArgumentException("Invalid demo email code"); + String namespace = fullLogin.substring(fullLogin.indexOf('@') + 1); + byte[] expectedEmail = FreeRegistrationCertificateV1.emailHash(email); + try (Connection conn = db.getConnection()) { + conn.setReadOnly(true); + String sql = """ + SELECT namespace_type, min_localpart_len, registrar_pubkey, default_server_login + FROM shine_namespace_current WHERE namespace = ? + """; + try (PreparedStatement statement = conn.prepareStatement(sql)) { + statement.setString(1, namespace); + try (ResultSet rs = statement.executeQuery()) { + if (!rs.next() || rs.getInt("namespace_type") != 2 || + fullLogin.indexOf('@') < rs.getInt("min_localpart_len")) + throw new IllegalArgumentException("Free namespace is unavailable"); + byte[] nsPub = Base58Util.decode(rs.getString("registrar_pubkey")); + if (!Arrays.equals(nsPub, signer.publicKey32())) + throw new IllegalStateException("Registrar public key does not match on-chain namespace"); + String server = rs.getString("default_server_login"); + if (server == null || server.isBlank()) + throw new IllegalStateException("Free namespace server is not configured"); + } + } + try (PreparedStatement ps = conn.prepareStatement( + "SELECT 1 FROM user_identity_current WHERE normalized_login = ?")) { + ps.setString(1, fullLogin); + try (ResultSet rs = ps.executeQuery()) { + if (rs.next()) throw new IllegalArgumentException("Login is already registered"); + } + } + try (PreparedStatement ps = conn.prepareStatement( + "SELECT 1 FROM free_registration_certificate WHERE email_sha256 = ?")) { + ps.setBytes(1, expectedEmail); + try (ResultSet rs = ps.executeQuery()) { + if (rs.next()) throw new IllegalArgumentException("Email hash already registered"); + } + } + } + // Это только подписанный артефакт, не активная регистрация. Перед Turbo + // и локальным импортом обязательно повторять уникальность в транзакции БД. + return FreeRegistrationCertificateV1.issue(fullLogin, root32, blockchain32, client32, email, signer); + } +} diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationPublisher.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationPublisher.java new file mode 100644 index 00000000..975996c5 --- /dev/null +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationPublisher.java @@ -0,0 +1,35 @@ +package server.archive.registration; + +import server.archive.TurboDataItemUploader; +import blockchain.Ans104DataItem; + +/** Отдельный транспорт регистрации. Публикация не является пользовательским AddBlock. */ +public final class FreeRegistrationPublisher { + private final FreeRegistrationIssuer issuer; + private final TurboDataItemUploader uploader; + private final VerifiedFreeRegistrationImporter importer; + + public FreeRegistrationPublisher(FreeRegistrationIssuer issuer, TurboDataItemUploader uploader, + VerifiedFreeRegistrationImporter importer) { + this.issuer = java.util.Objects.requireNonNull(issuer); + this.uploader = java.util.Objects.requireNonNull(uploader); + this.importer = java.util.Objects.requireNonNull(importer); + } + /** Для повтора ПОСЛЕ потери ACK передавайте точно те же signedBytes. */ + public VerifiedFreeRegistrationImporter.ImportResult publishSigned(byte[] signedBytes) throws Exception { + Ans104DataItem parsed = new Ans104DataItem(signedBytes); + importer.validateForUpload(signedBytes); // строго до HTTP/Turbo списания кредитов + // Импорт на этой точке вызовет полную проверку обеих подписей и namespace + // ПОСЛЕ успешного ACK Turbo, а не до окончательного подтверждения Arweave. + TurboDataItemUploader.UploadResult acknowledged = uploader.upload(signedBytes, parsed.id32()); + String expectedId = java.util.Base64.getUrlEncoder().withoutPadding().encodeToString(parsed.id32()); + if (!expectedId.equals(acknowledged.dataItemId())) + throw new IllegalStateException("Unexpected Turbo DataItem id"); + return importer.importSigned(signedBytes, VerifiedFreeRegistrationImporter.Provenance.TURBO_ACCEPTED); + } + public VerifiedFreeRegistrationImporter.ImportResult register(String fullLogin, byte[] root, byte[] blockchain, + byte[] client, String email, String demoCode) throws Exception { + byte[] signed = issuer.issue(fullLogin, root, blockchain, client, email, demoCode); + return publishSigned(signed); + } +} diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationWorkflow.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationWorkflow.java new file mode 100644 index 00000000..c39ac9ea --- /dev/null +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationWorkflow.java @@ -0,0 +1,138 @@ +package server.archive.registration; + +import shine.db.DbController; +import java.security.SecureRandom; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.time.Duration; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +/** Внутренний state machine публичных операций регистрации v2. */ +public final class FreeRegistrationWorkflow { + public record NamespaceInfo(String namespace, int type, int minLoginLength, String priceLamports, String serverLogin) {} + public record Availability(boolean nameFree, boolean emailHashFree) {} + public record LoginCheck(boolean loginAvailable, int namespaceType, int minLocalLength, String registrationFeeLamports) {} + public record EmailCheck(boolean emailAvailable) {} + public record Started(String challengeId, long expiresAtMs) {} + public record Completed(String fullLogin, String dataItemId, String state, boolean alreadyImported) {} + public record State(String status, String dataItemId, String publicationStatus, String innerSignature64B64, + String rootPublicKey, String blockchainPublicKey, String clientPublicKey, + String defaultServerLogin) {} + + private record Draft(String login, byte[] root, byte[] blockchain, byte[] client, String email, + long expiresAtMs, byte[] signedBytes) {} + private final Map pending = new ConcurrentHashMap<>(); + private static final long TTL_MS = Duration.ofMinutes(15).toMillis(); + private static final int MAX_PENDING = 512; + private static final SecureRandom RANDOM = new SecureRandom(); + private final FreeRegistrationIssuer issuer; + private final FreeRegistrationPublisher publisher; + + public FreeRegistrationWorkflow(FreeRegistrationIssuer issuer, FreeRegistrationPublisher publisher) { + if ((issuer == null) != (publisher == null)) throw new IllegalArgumentException("Signer/publisher mismatch"); + this.issuer = issuer; + this.publisher = publisher; + } + public List listNamespaces() throws Exception { + List result = new ArrayList<>(); + try (Connection c = DbController.getInstance().getConnection(); + PreparedStatement ps = c.prepareStatement(""" + SELECT namespace,namespace_type,min_localpart_len,registration_fee_lamports,default_server_login + FROM shine_namespace_current ORDER BY namespace + """); ResultSet rs = ps.executeQuery()) { + while (rs.next()) result.add(new NamespaceInfo(rs.getString(1),rs.getInt(2),rs.getInt(3), + rs.getString(4),rs.getString(5))); + } + return List.copyOf(result); + } + public LoginCheck checkLogin(String login) throws Exception { + FreeRegistrationCertificateV1.validateLogin(login); + String namespace=login.substring(login.indexOf('@')+1); + try (Connection c=DbController.getInstance().getConnection()) { + int type, minimum; String fee; + try (PreparedStatement p=c.prepareStatement("SELECT namespace_type,min_localpart_len,registration_fee_lamports FROM shine_namespace_current WHERE namespace=?")) { + p.setString(1,namespace); + try (ResultSet rs=p.executeQuery()) { + if (!rs.next()) throw new IllegalArgumentException("Namespace is unavailable"); + type=rs.getInt(1); minimum=rs.getInt(2); fee=rs.getString(3); + if (login.indexOf('@') < minimum) throw new IllegalArgumentException("Login shorter than namespace minimum"); + } + } + try (PreparedStatement p=c.prepareStatement("SELECT 1 FROM user_identity_current WHERE normalized_login=?")) { + p.setString(1, login); + try (ResultSet rs=p.executeQuery()) { return new LoginCheck(!rs.next(),type,minimum,fee); } + } + } + } + public EmailCheck checkEmail(String email) throws Exception { + byte[] hash=FreeRegistrationCertificateV1.emailHash(email); + try (Connection c=DbController.getInstance().getConnection(); + PreparedStatement p=c.prepareStatement("SELECT 1 FROM free_registration_certificate WHERE email_sha256=?")) { + p.setBytes(1,hash); + try(ResultSet rs=p.executeQuery()) { return new EmailCheck(!rs.next()); } + } + } + /** Устаревший внутренний helper: внешний API использует две отдельные операции. */ + public Availability availability(String login,String email) throws Exception { + return new Availability(checkLogin(login).loginAvailable(),checkEmail(email).emailAvailable()); + } + public Started start(String login, byte[] root, byte[] blockchain, byte[] client, String email) throws Exception { + if (issuer == null || publisher == null) throw new IllegalStateException("Free registration is disabled"); + FreeRegistrationCertificateV1.identityFields(login,root,blockchain,client); + LoginCheck checked = checkLogin(login); + if (checked.namespaceType()!=2 || !checked.loginAvailable()) throw new IllegalStateException("Login is unavailable"); + if (!checkEmail(email).emailAvailable()) throw new IllegalStateException("Email is unavailable"); + String cleanEmail=FreeRegistrationCertificateV1.normalizeEmail(email); + pending.entrySet().removeIf(e->e.getValue().expiresAtMs < System.currentTimeMillis()); + if (pending.size() >= MAX_PENDING) throw new IllegalStateException("Too many pending registrations"); + byte[] id=new byte[32]; RANDOM.nextBytes(id); + String challenge=Base64.getUrlEncoder().withoutPadding().encodeToString(id); + long expires=System.currentTimeMillis()+TTL_MS; + pending.put(challenge,new Draft(login,root.clone(),blockchain.clone(),client.clone(),cleanEmail,expires,null)); + return new Started(challenge,expires); + } + public synchronized Completed confirm(String challenge, String demoCode) throws Exception { + if (publisher == null) throw new IllegalStateException("Free registration disabled"); + Draft d=pending.get(challenge); + if (d==null || d.expiresAtMs < System.currentTimeMillis()) { + pending.remove(challenge); throw new IllegalArgumentException("Registration challenge missing or expired"); + } + if (!"1111".equals(demoCode)) throw new IllegalArgumentException("Invalid demo code"); + // При ошибке Turbo сохраняем единожды подписанные bytes и повторно отправляем ТОТ ЖЕ DataItem. + byte[] signed=d.signedBytes; + if(signed==null) { + signed=issuer.issue(d.login,d.root,d.blockchain,d.client,d.email,demoCode); + pending.put(challenge,new Draft(d.login,d.root,d.blockchain,d.client,d.email,d.expiresAtMs,signed)); + } + VerifiedFreeRegistrationImporter.ImportResult result=publisher.publishSigned(signed); + // Сохраняем draft до TTL, чтобы потерянный WS-ответ не вынуждал выпускать другой сертификат. + pending.put(challenge,new Draft(d.login,d.root,d.blockchain,d.client,d.email,d.expiresAtMs,signed)); + return new Completed(result.login(),result.dataItemId(),"TURBO_ACCEPTED",result.alreadyImported()); + } + public State getStatus(String login) throws Exception { + FreeRegistrationCertificateV1.validateLogin(login); + try (Connection c=DbController.getInstance().getConnection(); + PreparedStatement p=c.prepareStatement(""" + SELECT i.registration_status,i.free_data_item_id,f.publication_status,f.inner_signature, + i.root_key,i.blockchain_key,i.client_key,n.default_server_login + FROM user_identity_current i + LEFT JOIN free_registration_certificate f ON f.data_item_id=i.free_data_item_id + LEFT JOIN shine_namespace_current n ON n.namespace=i.namespace + WHERE i.normalized_login=? + """)) { + p.setString(1,login); + try (ResultSet r=p.executeQuery()) { + return r.next()?new State(r.getString(1),r.getString(2),r.getString(3), + r.getBytes(4)==null?null:Base64.getEncoder().encodeToString(r.getBytes(4)), + r.getString(5),r.getString(6),r.getString(7),r.getString(8)) + :new State("NOT_FOUND",null,null,null,null,null,null,null); + } + } + } +} diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/LocalRegistrarSigner.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/LocalRegistrarSigner.java new file mode 100644 index 00000000..3e9d68fc --- /dev/null +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/LocalRegistrarSigner.java @@ -0,0 +1,43 @@ +package server.archive.registration; + +import utils.crypto.Ed25519Util; +import utils.config.AppConfig; + +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Arrays; +import java.util.Base64; + +/** Временный signer. Файл вне Git: одно значение Base64 от 32-байтного Ed25519 seed. */ +public final class LocalRegistrarSigner implements RegistrarSigner { + private final byte[] seed32; + private final byte[] publicKey32; + private boolean closed; + + public LocalRegistrarSigner(byte[] seed) { + if (seed == null || seed.length != 32) throw new IllegalArgumentException("Registrar seed must be 32 bytes"); + this.seed32 = seed.clone(); + this.publicKey32 = Ed25519Util.derivePublicKey(seed32); + } + + public static LocalRegistrarSigner fromConfig(AppConfig config) throws Exception { + if (!config.getBoolean("freeRegistration.enabled", false)) + throw new IllegalStateException("Free registration is disabled"); + String path = config.getStringOrEmpty("freeRegistration.registrarSeedFile"); + if (path.isEmpty()) throw new IllegalStateException("Registrar key path is not configured"); + byte[] seed = Base64.getDecoder().decode(Files.readString(Path.of(path), StandardCharsets.UTF_8).trim()); + try { return new LocalRegistrarSigner(seed); } + finally { Arrays.fill(seed, (byte) 0); } + } + + @Override public synchronized byte[] publicKey32() { return publicKey32.clone(); } + @Override public synchronized byte[] sign(byte[] message) { + if (closed) throw new IllegalStateException("Signer closed"); + return Ed25519Util.sign(message, seed32); + } + @Override public synchronized void close() { + Arrays.fill(seed32, (byte) 0); + closed = true; + } +} diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/RegistrarSigner.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/RegistrarSigner.java new file mode 100644 index 00000000..9444ef46 --- /dev/null +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/RegistrarSigner.java @@ -0,0 +1,8 @@ +package server.archive.registration; + +/** Интерфейс приватного регистратора: private key не передаётся в бизнес-логику. */ +public interface RegistrarSigner extends AutoCloseable { + byte[] publicKey32(); + byte[] sign(byte[] message); + @Override default void close() {} +} diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/VerifiedFreeRegistrationImporter.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/VerifiedFreeRegistrationImporter.java new file mode 100644 index 00000000..4d6e5152 --- /dev/null +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/VerifiedFreeRegistrationImporter.java @@ -0,0 +1,155 @@ +package server.archive.registration; + +import shine.db.DbController; +import sync.util.Base58Util; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.Arrays; + +/** Только верифицированный сертификат. Локальная БД — проекция Arweave/Solana. */ +public final class VerifiedFreeRegistrationImporter { + public enum Provenance { TURBO_ACCEPTED, ARWEAVE_CONFIRMED } + public record ImportResult(String login, String dataItemId, boolean alreadyImported, Provenance provenance) {} + + /** Предварительная проверка ДО Turbo: не расходовать кредиты на чужую/битую запись. */ + public FreeRegistrationCertificateV1.Verified validateForUpload(byte[] raw) throws Exception { + if (raw == null || raw.length < 200 || raw.length > 16_384) + throw new IllegalArgumentException("Invalid registration size"); + blockchain.Ans104DataItem item = new blockchain.Ans104DataItem(raw); + String login = extractCanonicalLogin(item); + try (Connection c = DbController.getInstance().getConnection()) { + String namespace = login.substring(login.indexOf('@') + 1); + var cert = FreeRegistrationCertificateV1.verify(raw, readRegistrar(c, namespace, login)); + try (PreparedStatement ps = c.prepareStatement( + "SELECT free_data_item_id FROM user_identity_current WHERE normalized_login=?")) { + ps.setString(1, login); + try (ResultSet rs = ps.executeQuery()) { + if (rs.next() && !cert.idBase64Url().equals(rs.getString(1))) + throw new IllegalArgumentException("Login is already registered"); + } + } + try (PreparedStatement ps = c.prepareStatement( + "SELECT data_item_id FROM free_registration_certificate WHERE email_sha256=?")) { + ps.setBytes(1, cert.emailSha256()); + try (ResultSet rs = ps.executeQuery()) { + if (rs.next() && !cert.idBase64Url().equals(rs.getString(1))) + throw new IllegalArgumentException("Email hash belongs to another account"); + } + } + return cert; + } + } + + /** Единая точка импорта: один и тот же raw ANS-104 из Turbo и Arweave. */ + public ImportResult importSigned(byte[] raw, Provenance provenance) throws Exception { + if (raw == null || raw.length > 16_384 || raw.length < 200) + throw new IllegalArgumentException("Invalid registration data item size"); + // Сначала разбираем/проверяем структурный контейнер, затем сверяем owner с on-chain namespace. + blockchain.Ans104DataItem item = new blockchain.Ans104DataItem(raw); + String login = extractCanonicalLogin(item); + String namespace = login.substring(login.indexOf('@') + 1); + try (Connection c = DbController.getInstance().getConnection()) { + boolean oldAutoCommit = c.getAutoCommit(); + c.setAutoCommit(false); + try { + byte[] registrar = readRegistrar(c, namespace, login); + FreeRegistrationCertificateV1.Verified cert = FreeRegistrationCertificateV1.verify(raw, registrar); + String id = cert.idBase64Url(); + String publication = provenance == Provenance.ARWEAVE_CONFIRMED ? "ARWEAVE_CONFIRMED" : "TURBO_ACCEPTED"; + long now = System.currentTimeMillis(); + // Защита от коллизий и двойного импорта: имя и email захвачены индексами UNIQUE. + try (PreparedStatement check = c.prepareStatement(""" + SELECT f.raw_signed_data_item, f.publication_status, u.root_key, u.client_key, + u.blockchain_key FROM free_registration_certificate f + JOIN user_identity_current u ON u.login=f.login + WHERE f.data_item_id=? FOR UPDATE OF f + """)) { + check.setString(1, id); + try (ResultSet r = check.executeQuery()) { + if (r.next()) { + if (!Arrays.equals(raw, r.getBytes(1))) + throw new SQLException("DataItem id collision with different raw bytes"); + if (!r.getString(3).equals(Base58Util.encode(cert.rootKey())) || + !r.getString(4).equals(Base58Util.encode(cert.clientKey())) || + !r.getString(5).equals(Base58Util.encode(cert.blockchainKey()))) + throw new SQLException("Accepted identity keys conflict with certificate"); + if (provenance == Provenance.ARWEAVE_CONFIRMED) { + try (PreparedStatement up = c.prepareStatement(""" + UPDATE free_registration_certificate SET publication_status='ARWEAVE_CONFIRMED',last_seen_at_ms=? + WHERE data_item_id=? + """)) { + up.setLong(1, now); up.setString(2, id); up.executeUpdate(); + } + } + c.commit(); + return new ImportResult(login, id, true, provenance); + } + } + } + try (PreparedStatement insert = c.prepareStatement(""" + INSERT INTO user_identity_current ( + login, normalized_login, namespace, registration_source, registration_status, + solana_pda_address, free_data_item_id, root_key, client_key, blockchain_key, + blockchain_name, is_server, registered_at_ms, updated_at_ms) + VALUES (?, ?, ?, 'ARWEAVE', 'FREE_CERT', NULL, ?, ?, ?, ?, ?, false, ?, ?) + """)) { + insert.setString(1, login); insert.setString(2, login); insert.setString(3, namespace); + insert.setString(4, id); insert.setString(5, Base58Util.encode(cert.rootKey())); + insert.setString(6, Base58Util.encode(cert.clientKey())); + insert.setString(7, Base58Util.encode(cert.blockchainKey())); + insert.setString(8, login + "-001"); insert.setLong(9, now); insert.setLong(10, now); + insert.executeUpdate(); + } + try (PreparedStatement insert = c.prepareStatement(""" + INSERT INTO free_registration_certificate ( + data_item_id, login, namespace, email_sha256, inner_signature, + raw_signed_data_item, publication_status, registered_at_ms, last_seen_at_ms) + VALUES (?,?,?,?,?,?,?,?,?) + """)) { + insert.setString(1, id); insert.setString(2, login); insert.setString(3, namespace); + insert.setBytes(4, cert.emailSha256()); insert.setBytes(5, cert.innerSignature()); + insert.setBytes(6, raw); insert.setString(7, publication); + insert.setLong(8, now); insert.setLong(9, now); insert.executeUpdate(); + } + c.commit(); + return new ImportResult(login, id, false, provenance); + } catch (Exception e) { + c.rollback(); throw e; + } finally { c.setAutoCommit(oldAutoCommit); } + } + } + + private static String extractCanonicalLogin(blockchain.Ans104DataItem item) { + boolean marker = item.tags().contains(new blockchain.Ans104DataItem.Tag("t", "reg")); + if (!marker) throw new IllegalArgumentException("Not a registration DataItem"); + byte[] bytes = item.data(); + if (bytes.length < 3 || bytes[0] != 1 || bytes[1] != 0) throw new IllegalArgumentException("Bad certificate header"); + int len = bytes[2] & 0xff; + if (len < 3 || len > 30 || bytes.length < 3 + len + 96 + 64 + 32) + throw new IllegalArgumentException("Invalid certificate login length"); + return FreeRegistrationCertificateV1.validateLogin( + new String(bytes, 3, len, java.nio.charset.StandardCharsets.UTF_8)); + } + + private static byte[] readRegistrar(Connection c, String namespace, String login) throws Exception { + try (PreparedStatement ps = c.prepareStatement(""" + SELECT registrar_pubkey, min_localpart_len, default_server_login + FROM shine_namespace_current WHERE namespace=? AND namespace_type=2 + """)) { + ps.setString(1, namespace); + try (ResultSet rs = ps.executeQuery()) { + if (!rs.next()) throw new IllegalStateException("Unknown/free namespace not yet synchronized"); + if (login.indexOf('@') < rs.getInt("min_localpart_len")) + throw new IllegalArgumentException("Login shorter than namespace minimum"); + if (rs.getString("default_server_login") == null || rs.getString("default_server_login").isBlank()) + throw new IllegalArgumentException("Namespace has no access server"); + byte[] key = Base58Util.decode(rs.getString("registrar_pubkey")); + if (key.length != 32) throw new IllegalArgumentException("Invalid registrar pubkey"); + return key; + } + } + } +} diff --git a/SHiNE-server/shine-server-archive/src/test/fixtures/reg-v1-example.hex b/SHiNE-server/shine-server-archive/src/test/fixtures/reg-v1-example.hex new file mode 100644 index 00000000..35ac50b0 --- /dev/null +++ b/SHiNE-server/shine-server-archive/src/test/fixtures/reg-v1-example.hex @@ -0,0 +1 @@ +0200a9de19b3551ace117973b80d632503bf2a55f0aa2490deb1474a280b675fa01bb2ccb5890faadcb213d3882fb21a7af13702526a569f7807b1c8b6963c0be402174553b456dddfc6908ecab1c101fe6ab21e2baa0617795b7d43a63482993fd500000300000000000000390000000000000006064170701074657374353539310274067265671050726f746f636f6c345348694e452d467265652d526567697374726174696f6e2d563100010008626f62406672656503a107bff3ce10be1d70dd18e74bc09967e4d6309ba50d5f1ddc8664125531b829acbae141bccaf0b22e1a94d34d0bc7361e526d0bfe12c89794bc9322966dd72543b92ff1095511476adc8369db6ddc933665a11978dda1404ee1066ca9559de2edfcd8b1b7a1823f56b827ddfa8a3682793e036141b526467ae346e220d08757d0a878a2f722562e6d3132ef9df04b1ab9e2f65d72bb0f48c17b7ada3e5a0acbc605c49fd774ff4d9ea789d8f6bffa719e9774cb86f62d11fd244121150956 diff --git a/SHiNE-server/shine-server-archive/src/test/java/server/archive/FreeRegistrationCertificateV1Check.java b/SHiNE-server/shine-server-archive/src/test/java/server/archive/FreeRegistrationCertificateV1Check.java new file mode 100644 index 00000000..ddc3afed --- /dev/null +++ b/SHiNE-server/shine-server-archive/src/test/java/server/archive/FreeRegistrationCertificateV1Check.java @@ -0,0 +1,42 @@ +package server.archive; + +import server.archive.registration.*; +import utils.crypto.Ed25519Util; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Arrays; +import java.util.HexFormat; + +/** Запуск: java ... server.archive.FreeRegistrationCertificateV1Check file.hex */ +public final class FreeRegistrationCertificateV1Check { + static final HexFormat HEX = HexFormat.of(); + public static void main(String[] args) throws Exception { + byte[] raw = HEX.parseHex(Files.readString(Path.of(args[0])).trim()); + byte[] pub = HEX.parseHex("174553b456dddfc6908ecab1c101fe6ab21e2baa0617795b7d43a63482993fd5"); + var result = FreeRegistrationCertificateV1.verify(raw, pub); + if (!"bob@free".equals(result.login()) || !result.idBase64Url().equals( + java.util.Base64.getUrlEncoder().withoutPadding().encodeToString( + HEX.parseHex("45ef42eda7c7e76d222ecce8a7678edb923ae63f8419ea0899701551c2466770")))) + throw new AssertionError("Wrong fixture identity / DataItem id"); + byte[] corrupted = raw.clone(); corrupted[corrupted.length-1] ^= 1; + try { FreeRegistrationCertificateV1.verify(corrupted, pub); throw new AssertionError("Email bit flip accepted"); } + catch (IllegalArgumentException expected) {} + corrupted = raw.clone(); corrupted[corrupted.length-40] ^= 1; + try { FreeRegistrationCertificateV1.verify(corrupted, pub); throw new AssertionError("Inner signature tampering accepted"); } + catch (IllegalArgumentException expected) {} + + byte[] seed = Ed25519Util.generatePrivateKeyFromString("TEST-only-reg-v1-check"); + try (var signer = new LocalRegistrarSigner(seed)) { + byte[] cert = FreeRegistrationCertificateV1.issue("bob@free", + HEX.parseHex("03a107bff3ce10be1d70dd18e74bc09967e4d6309ba50d5f1ddc8664125531b8"), + HEX.parseHex("29acbae141bccaf0b22e1a94d34d0bc7361e526d0bfe12c89794bc9322966dd7"), + HEX.parseHex("2543b92ff1095511476adc8369db6ddc933665a11978dda1404ee1066ca9559d"), + " Alice.Example+Tag@Example.COM ", signer); + var verified = FreeRegistrationCertificateV1.verify(cert, signer.publicKey32()); + if (!Arrays.equals(verified.emailSha256(), + HEX.parseHex("cbc605c49fd774ff4d9ea789d8f6bffa719e9774cb86f62d11fd244121150956"))) + throw new AssertionError("Email normalization differs"); + } + System.out.println("PASS: Java registrar fixture, inner+outer Ed25519, email normalization, tamper rejection"); + } +} diff --git a/SHiNE-server/shine-server-archive/src/test/java/server/archive/FreeRegistrationWorkflowLocalCheck.java b/SHiNE-server/shine-server-archive/src/test/java/server/archive/FreeRegistrationWorkflowLocalCheck.java new file mode 100644 index 00000000..9f691198 --- /dev/null +++ b/SHiNE-server/shine-server-archive/src/test/java/server/archive/FreeRegistrationWorkflowLocalCheck.java @@ -0,0 +1,47 @@ +package server.archive; + +import server.archive.registration.*; +import javax.sql.DataSource; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.HexFormat; + +/** Только проверки без БД/сети; полное E2E требует PostgreSQL и Turbo. */ +public final class FreeRegistrationWorkflowLocalCheck { + public static void main(String[] args) throws Exception { + var signer = new RegistrarSigner() { + public byte[] publicKey32() { return new byte[32]; } + public byte[] sign(byte[] message) { return new byte[64]; } + }; + DataSource noDb = new DataSource() { + public java.sql.Connection getConnection() throws java.sql.SQLException { throw new java.sql.SQLException("No database in local test"); } + public java.sql.Connection getConnection(String u, String p) throws java.sql.SQLException { return getConnection(); } + public java.io.PrintWriter getLogWriter() {return null;} + public void setLogWriter(java.io.PrintWriter x) {} + public void setLoginTimeout(int x) {} + public int getLoginTimeout() {return 0;} + public java.util.logging.Logger getParentLogger() {return java.util.logging.Logger.getAnonymousLogger();} + public T unwrap(Class iface) throws java.sql.SQLException {throw new java.sql.SQLException("unsupported");} + public boolean isWrapperFor(Class iface) {return false;} + }; + var issuer = new FreeRegistrationIssuer(noDb, signer); + var importer = new VerifiedFreeRegistrationImporter(); + var workflow = new FreeRegistrationWorkflow(issuer, + new FreeRegistrationPublisher(issuer, new TurboDataItemUploader(), importer)); + byte[] k1 = new byte[32], k2 = new byte[32], k3 = new byte[32]; + k1[0] = 1; k2[0] = 2; k3[0] = 3; + var start = workflow.start("bob@free", k1, k2, k3, "hello@example.org"); + if (start.challengeId().isBlank() || start.expiresAtMs() <= System.currentTimeMillis()) + throw new AssertionError("Cannot start a bounded challenge"); + try { workflow.confirm(start.challengeId(), "wrong"); throw new AssertionError("Bad demo code accepted"); } + catch (IllegalArgumentException expected) { } + try { workflow.confirm("unknown", "1111"); throw new AssertionError("Missing challenge accepted"); } + catch (IllegalArgumentException expected) { } + try { workflow.start("BOB@free", k1, k2, k3, "hello@example.org"); throw new AssertionError("Invalid login accepted"); } + catch (IllegalArgumentException expected) { } + try { importer.importSigned(new byte[]{1,2,3}, VerifiedFreeRegistrationImporter.Provenance.TURBO_ACCEPTED); + throw new AssertionError("Invalid bytes accepted"); } + catch (IllegalArgumentException expected) { } + System.out.println("PASS: workflow nonce/code checks + reject invalid signed bytes"); + } +} diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java index a4ba68b7..718d4636 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java @@ -23,9 +23,13 @@ public final class DatabaseInitializer { public static final int SCHEMA_VERSION_1 = 1; public static final int SCHEMA_VERSION_31 = 31; public static final int SCHEMA_VERSION_32 = 32; + public static final int SCHEMA_VERSION_33 = 33; + public static final int SCHEMA_VERSION_34 = 34; public static final String POSTGRES_SCHEMA_RESOURCE = "postgres/schema_v1.sql"; public static final String POSTGRES_MIGRATION_V31_RESOURCE = "postgres/migration_v31.sql"; public static final String POSTGRES_MIGRATION_V32_RESOURCE = "postgres/migration_v32.sql"; + public static final String POSTGRES_MIGRATION_V33_RESOURCE = "postgres/migration_v33.sql"; + public static final String POSTGRES_MIGRATION_V34_RESOURCE = "postgres/migration_v34.sql"; private DatabaseInitializer() {} @@ -125,9 +129,17 @@ public final class DatabaseInitializer { runSqlScript(conn, POSTGRES_MIGRATION_V32_RESOURCE); currentVersion = readCurrentSchemaVersion(conn); } - if (currentVersion != SCHEMA_VERSION_32) { + if (currentVersion == SCHEMA_VERSION_32) { + runSqlScript(conn, POSTGRES_MIGRATION_V33_RESOURCE); + currentVersion = readCurrentSchemaVersion(conn); + } + if (currentVersion == SCHEMA_VERSION_33) { + runSqlScript(conn, POSTGRES_MIGRATION_V34_RESOURCE); + currentVersion = readCurrentSchemaVersion(conn); + } + if (currentVersion != SCHEMA_VERSION_34) { throw new SQLException( - "Unsupported SHiNE DB v2 schema version: expected 32, found " + currentVersion); + "Unsupported SHiNE DB v2 schema version: expected 34, found " + currentVersion); } } } diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/CurrentUsersDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/CurrentUsersDAO.java index bc670f19..b5b1e426 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/CurrentUsersDAO.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/CurrentUsersDAO.java @@ -213,7 +213,7 @@ public final class CurrentUsersDAO { String sql = """ SELECT su.login, coalesce(up.first_name, '') AS first_name, coalesce(up.last_name, '') AS last_name, coalesce(up.ava_ar, '') AS ava_ar - FROM solana_user_pda_current su + FROM user_identity_current su LEFT JOIN user_profile_state up ON lower(up.login) = lower(su.login) WHERE (? IS NULL OR su.is_server = ?) AND ( diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/RegistrationIdentityDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/RegistrationIdentityDAO.java new file mode 100644 index 00000000..83c83a39 --- /dev/null +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/RegistrationIdentityDAO.java @@ -0,0 +1,58 @@ +package shine.db.dao; + +import shine.db.DbController; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; + +/** Единая авторитетная проекция: FREE_CERT не притворяется Solana PDA. */ +public final class RegistrationIdentityDAO { + public record ResolvedIdentity(String fullLogin, String rootKey, String blockchainKey, + String clientKey, String registrationSource, String registrationStatus, + String namespace, String accessServerLogin, boolean hasSolanaPda) { + public boolean isFree() { return "FREE_CERT".equals(registrationStatus); } + } + private static final RegistrationIdentityDAO INSTANCE = new RegistrationIdentityDAO(); + public static RegistrationIdentityDAO getInstance() { return INSTANCE; } + private RegistrationIdentityDAO() {} + + public ResolvedIdentity get(String login) throws SQLException { + try (Connection c = DbController.getInstance().getConnection()) { return get(c, login); } + } + public ResolvedIdentity get(Connection c, String login) throws SQLException { + if (login == null || login.isBlank()) return null; + try (PreparedStatement ps = c.prepareStatement(""" + SELECT i.login, i.root_key, i.blockchain_key, i.client_key, + i.registration_source, i.registration_status, i.namespace, + i.solana_pda_address, n.default_server_login, + s.server_login AS actual_access_server + FROM user_identity_current i + LEFT JOIN shine_namespace_current n ON n.namespace=i.namespace + LEFT JOIN user_access_servers_current s ON s.user_login=i.login + WHERE i.normalized_login=LOWER(BTRIM(?)) + ORDER BY s.server_login ASC + LIMIT 1 + """)) { + ps.setString(1, login); + try (ResultSet rs = ps.executeQuery()) { + if (!rs.next()) return null; + boolean hasPda = rs.getString("solana_pda_address") != null; + String status = rs.getString("registration_status"); + String server = "FREE_CERT".equals(status) ? rs.getString("default_server_login") + : rs.getString("actual_access_server"); + if ("FREE_CERT".equals(status) && hasPda) + throw new SQLException("Inconsistent free user: Solana PDA must be absent"); + if (!"FREE_CERT".equals(status) && !hasPda) + throw new SQLException("Inconsistent paid user: Solana PDA is missing"); + return new ResolvedIdentity(rs.getString("login"), rs.getString("root_key"), + rs.getString("blockchain_key"), rs.getString("client_key"), + rs.getString("registration_source"), status, rs.getString("namespace"), server, hasPda); + } + } + } + public boolean isFreeCertificate(String login) throws SQLException { + ResolvedIdentity identity = get(login); + return identity != null && identity.isFree(); + } +} diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/UserAccessServersCurrentDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/UserAccessServersCurrentDAO.java index 8b8fc312..8a552938 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/UserAccessServersCurrentDAO.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/UserAccessServersCurrentDAO.java @@ -46,26 +46,28 @@ public final class UserAccessServersCurrentDAO { public UserAccessServerRouteEntry findPrimaryByUserLogin(String userLogin) throws SQLException { String sql = """ SELECT - u.login AS user_login, + i.login AS user_login, s.login AS server_login, s.server_address AS server_url, s.client_key AS server_client_key - FROM solana_user_pda_current u + FROM user_identity_current i + LEFT JOIN solana_user_pda_current u ON u.login = i.login + LEFT JOIN shine_namespace_current ns ON ns.namespace = i.namespace CROSS JOIN LATERAL ( - SELECT BTRIM(a.login_value) AS server_login - FROM jsonb_array_elements_text( - CASE - WHEN BTRIM(COALESCE(u.access_servers_json, '')) = '' THEN '[]'::jsonb - ELSE u.access_servers_json::jsonb - END - ) WITH ORDINALITY AS a(login_value, ord) - WHERE a.ord = 1 + SELECT CASE WHEN i.registration_status = 'FREE_CERT' + THEN ns.default_server_login + ELSE (SELECT BTRIM(a.login_value) + FROM jsonb_array_elements_text( + COALESCE(NULLIF(u.access_servers_json, ''), '[]')::jsonb) + WITH ORDINALITY AS a(login_value, ord) + WHERE a.ord = 1) + END AS server_login ) primary_access JOIN solana_user_pda_current s ON s.normalized_login = LOWER(primary_access.server_login) AND s.is_server = TRUE AND BTRIM(COALESCE(s.server_address, '')) <> '' - WHERE u.normalized_login = LOWER(BTRIM(?)) + WHERE i.normalized_login = LOWER(BTRIM(?)) LIMIT 1 """; try (Connection c = db.getConnection(); diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/sql/CurrentUsersSql.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/sql/CurrentUsersSql.java index 8fc33d91..dd4a2e66 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/sql/CurrentUsersSql.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/sql/CurrentUsersSql.java @@ -18,7 +18,7 @@ public final class CurrentUsersSql { current_users.blockchain_key AS blockchain_key, current_users.client_key AS client_key, current_users.is_server AS is_server - FROM solana_user_pda_current current_users + FROM user_identity_current current_users ) %s """.formatted(alias); } diff --git a/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v33.sql b/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v33.sql new file mode 100644 index 00000000..f0ddcc24 --- /dev/null +++ b/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v33.sql @@ -0,0 +1,213 @@ +-- SHiNE DB v33: общий индекс идентичностей, namespace и сертификаты. +-- ТОЛЬКО dev/test до проверки всей серверной авторизации. +BEGIN; + +CREATE TABLE user_identity_current ( + login TEXT PRIMARY KEY, + normalized_login TEXT NOT NULL UNIQUE, + namespace TEXT, + registration_source TEXT NOT NULL CHECK (registration_source IN ('SOLANA', 'ARWEAVE')), + registration_status TEXT NOT NULL CHECK (registration_status IN ('PAID_DIRECT', 'FREE_CERT', 'PAID_UPGRADED')), + solana_pda_address TEXT UNIQUE, + free_data_item_id TEXT UNIQUE, + root_key TEXT NOT NULL, + client_key TEXT NOT NULL, + blockchain_key TEXT NOT NULL, + blockchain_name TEXT NOT NULL, + is_server BOOLEAN NOT NULL DEFAULT FALSE, + registered_at_ms BIGINT NOT NULL, + updated_at_ms BIGINT NOT NULL, + CHECK ((registration_status = 'FREE_CERT' AND solana_pda_address IS NULL AND free_data_item_id IS NOT NULL) + OR (registration_status <> 'FREE_CERT' AND solana_pda_address IS NOT NULL)) +); +CREATE INDEX idx_user_identity_namespace ON user_identity_current(namespace); + +INSERT INTO user_identity_current ( + login, normalized_login, namespace, registration_source, registration_status, + solana_pda_address, root_key, client_key, blockchain_key, blockchain_name, + is_server, registered_at_ms, updated_at_ms +) +SELECT login, normalized_login, + CASE WHEN position('@' in login) > 0 THEN split_part(login, '@', 2) ELSE NULL END, + 'SOLANA', 'PAID_DIRECT', pda_address, root_key, client_key, blockchain_key, + blockchain_name, is_server, created_at_ms, updated_at_ms +FROM solana_user_pda_current +ON CONFLICT (login) DO NOTHING; + +CREATE TABLE shine_namespace_current ( + namespace TEXT PRIMARY KEY, + pda_address TEXT NOT NULL UNIQUE, + namespace_type SMALLINT NOT NULL CHECK(namespace_type IN (1,2)), + min_localpart_len SMALLINT NOT NULL CHECK (min_localpart_len BETWEEN 1 AND 30), + registration_fee_lamports NUMERIC(20,0) NOT NULL CHECK (registration_fee_lamports >= 0), + registrar_pubkey TEXT, + default_server_login TEXT, + slot BIGINT NOT NULL, + last_tx_signature TEXT NOT NULL DEFAULT '', + raw_data_base64 TEXT NOT NULL, + CHECK ((namespace_type = 1 AND registrar_pubkey IS NULL AND default_server_login IS NULL) + OR (namespace_type = 2 AND registrar_pubkey IS NOT NULL AND default_server_login IS NOT NULL)) +); + +CREATE TABLE free_registration_certificate ( + data_item_id TEXT PRIMARY KEY, + login TEXT NOT NULL UNIQUE REFERENCES user_identity_current(login), + namespace TEXT NOT NULL REFERENCES shine_namespace_current(namespace), + email_sha256 BYTEA NOT NULL UNIQUE CHECK (octet_length(email_sha256) = 32), + inner_signature BYTEA NOT NULL CHECK (octet_length(inner_signature) = 64), + raw_signed_data_item BYTEA NOT NULL, + publication_status TEXT NOT NULL CHECK (publication_status IN ('TURBO_ACCEPTED','ARWEAVE_SEEN','ARWEAVE_CONFIRMED')), + registered_at_ms BIGINT NOT NULL, + last_seen_at_ms BIGINT NOT NULL +); +CREATE INDEX idx_free_registration_namespace ON free_registration_certificate(namespace); + +-- Существующие объекты (в том числе десятки FK) должны ссылаться на логическую +-- идентичность, иначе бесплатный пользователь не сможет иметь профиль/связи/каналы. +-- Воссоздаём существующие FK с теми же ON DELETE/UPDATE и deferrable-настройками. +DO $$ +DECLARE + item RECORD; + definition TEXT; +BEGIN + FOR item IN SELECT c.conname, c.conrelid::regclass AS child_table, + pg_get_constraintdef(c.oid) AS definition + FROM pg_constraint c + WHERE c.contype = 'f' AND c.confrelid = 'solana_user_pda_current'::regclass + LOOP + definition := replace(item.definition, + 'REFERENCES solana_user_pda_current(', 'REFERENCES user_identity_current('); + IF definition = item.definition THEN + RAISE EXCEPTION 'Unexpected FK expression: %', item.definition; + END IF; + EXECUTE format('ALTER TABLE %s DROP CONSTRAINT %I', item.child_table, item.conname); + EXECUTE format('ALTER TABLE %s ADD CONSTRAINT %I %s', item.child_table, item.conname, definition); + END LOOP; +END $$; + +-- Любое поступившее из Solana состояние дополняет существующую идентичность. +-- Бесплатный → платный допускается ТОЛЬКО при совпадении всех публичных ключей; +-- старые on-chain key rotations разрешены, если статус уже платный. +CREATE OR REPLACE FUNCTION shine_sync_identity_from_solana() +RETURNS TRIGGER LANGUAGE plpgsql AS $$ +DECLARE old_user user_identity_current%ROWTYPE; +BEGIN + -- Если PostgreSQL получил старую запись из replay, она не должна затереть + -- уже принятую более новую логическую идентичность в BEFORE INSERT. + IF TG_OP = 'INSERT' AND EXISTS ( + SELECT 1 FROM solana_user_pda_current prior + WHERE prior.pda_address = NEW.pda_address AND prior.record_number > NEW.record_number + ) THEN + RETURN NEW; + END IF; + SELECT * INTO old_user FROM user_identity_current + WHERE normalized_login = NEW.normalized_login FOR UPDATE; + IF FOUND AND old_user.registration_status = 'FREE_CERT' AND + (old_user.root_key <> NEW.root_key OR old_user.client_key <> NEW.client_key OR old_user.blockchain_key <> NEW.blockchain_key) THEN + RAISE EXCEPTION 'Free certificate keys differ from Solana upgrade for %', NEW.login; + END IF; + IF FOUND AND old_user.solana_pda_address IS NOT NULL AND old_user.solana_pda_address <> NEW.pda_address THEN + RAISE EXCEPTION 'Duplicate on-chain identity for %', NEW.login; + END IF; + INSERT INTO user_identity_current ( + login, normalized_login, namespace, registration_source, registration_status, + solana_pda_address, free_data_item_id, root_key, client_key, blockchain_key, + blockchain_name, is_server, registered_at_ms, updated_at_ms) + VALUES (NEW.login, NEW.normalized_login, + CASE WHEN position('@' in NEW.login) > 0 THEN split_part(NEW.login,'@',2) ELSE NULL END, + 'SOLANA', CASE WHEN old_user.free_data_item_id IS NOT NULL THEN 'PAID_UPGRADED' ELSE 'PAID_DIRECT' END, + NEW.pda_address, old_user.free_data_item_id, NEW.root_key, NEW.client_key, + NEW.blockchain_key, NEW.blockchain_name, NEW.is_server, + COALESCE(old_user.registered_at_ms, NEW.created_at_ms), NEW.updated_at_ms) + ON CONFLICT (login) DO UPDATE SET + registration_source='SOLANA', + registration_status=EXCLUDED.registration_status, + solana_pda_address=EXCLUDED.solana_pda_address, + root_key=EXCLUDED.root_key, client_key=EXCLUDED.client_key, + blockchain_key=EXCLUDED.blockchain_key, blockchain_name=EXCLUDED.blockchain_name, + is_server=EXCLUDED.is_server, updated_at_ms=EXCLUDED.updated_at_ms; + RETURN NEW; +END $$; +CREATE TRIGGER trg_sync_identity_from_solana +BEFORE INSERT OR UPDATE ON solana_user_pda_current +FOR EACH ROW EXECUTE FUNCTION shine_sync_identity_from_solana(); + +-- Free namespace: сервер доступа задаётся namespace, а не клиентским полем. +-- Реальный сервер должен иметь on-chain PDA и открытый адрес. +CREATE OR REPLACE FUNCTION shine_refresh_user_access_servers_for_user(p_user_login TEXT) +RETURNS VOID LANGUAGE plpgsql AS $$ +BEGIN + IF p_user_login IS NULL OR btrim(p_user_login) = '' THEN RETURN; END IF; + DELETE FROM user_access_servers_current WHERE lower(user_login) = lower(p_user_login); + INSERT INTO user_access_servers_current ( + user_login, server_login, server_url, server_client_key, user_record_number, + user_updated_at_ms, server_record_number, server_updated_at_ms, refreshed_at_ms) + SELECT i.login, srv.login, srv.server_address, srv.client_key, + COALESCE(u.record_number, 0), i.updated_at_ms, + srv.record_number, srv.updated_at_ms, + CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT) + FROM user_identity_current i + LEFT JOIN solana_user_pda_current u ON u.login = i.login + LEFT JOIN shine_namespace_current ns ON ns.namespace = i.namespace + CROSS JOIN LATERAL ( + SELECT CASE WHEN i.registration_status = 'FREE_CERT' THEN ns.default_server_login + ELSE (SELECT value FROM jsonb_array_elements_text( + COALESCE(NULLIF(u.access_servers_json, ''), '[]')::jsonb) + WITH ORDINALITY AS a(value, position) WHERE position=1) END AS login + ) effective + JOIN solana_user_pda_current srv + ON lower(srv.login) = lower(effective.login) AND srv.is_server = true + AND btrim(coalesce(srv.server_address, '')) <> '' + WHERE lower(i.login) = lower(p_user_login) + ON CONFLICT (user_login, server_login) DO UPDATE SET + server_url=EXCLUDED.server_url, server_client_key=EXCLUDED.server_client_key, + user_record_number=EXCLUDED.user_record_number, + user_updated_at_ms=EXCLUDED.user_updated_at_ms, + server_record_number=EXCLUDED.server_record_number, + server_updated_at_ms=EXCLUDED.server_updated_at_ms, + refreshed_at_ms=EXCLUDED.refreshed_at_ms; +END $$; + +CREATE OR REPLACE FUNCTION shine_refresh_user_access_servers_for_server(p_server_login TEXT) +RETURNS VOID LANGUAGE plpgsql AS $$ +DECLARE u RECORD; +BEGIN + IF p_server_login IS NULL OR btrim(p_server_login) = '' THEN RETURN; END IF; + DELETE FROM user_access_servers_current WHERE lower(server_login) = lower(p_server_login); + FOR u IN + SELECT i.login FROM user_identity_current i + LEFT JOIN solana_user_pda_current p ON p.login=i.login + LEFT JOIN shine_namespace_current ns ON ns.namespace=i.namespace + WHERE lower(p_server_login) = lower( + CASE WHEN i.registration_status='FREE_CERT' THEN ns.default_server_login + ELSE (SELECT value FROM jsonb_array_elements_text( + COALESCE(NULLIF(p.access_servers_json,''),'[]')::jsonb) + WITH ORDINALITY AS a(value, position) WHERE position=1) END) + LOOP PERFORM shine_refresh_user_access_servers_for_user(u.login); END LOOP; +END $$; + +CREATE OR REPLACE FUNCTION shine_refresh_user_access_servers_all() +RETURNS VOID LANGUAGE plpgsql AS $$ +DECLARE u RECORD; +BEGIN + TRUNCATE TABLE user_access_servers_current; + FOR u IN SELECT login FROM user_identity_current LOOP + PERFORM shine_refresh_user_access_servers_for_user(u.login); + END LOOP; +END $$; + +CREATE OR REPLACE FUNCTION shine_refresh_free_routing_from_identity() +RETURNS TRIGGER LANGUAGE plpgsql AS $$ +BEGIN + IF NEW.registration_status = 'FREE_CERT' THEN + PERFORM shine_refresh_user_access_servers_for_user(NEW.login); + END IF; + RETURN NEW; +END $$; +CREATE TRIGGER trg_refresh_free_routing_from_identity +AFTER INSERT OR UPDATE ON user_identity_current +FOR EACH ROW EXECUTE FUNCTION shine_refresh_free_routing_from_identity(); + +UPDATE db_schema_version SET schema_version=33, + updated_at_ms=CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT) WHERE id=1; +COMMIT; diff --git a/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v34.sql b/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v34.sql new file mode 100644 index 00000000..ee130707 --- /dev/null +++ b/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v34.sql @@ -0,0 +1,12 @@ +-- SHiNE v34. Отдельный checkpoint Arweave сертификатов, не смешивать с блоками. +BEGIN; +CREATE TABLE IF NOT EXISTS free_registration_arweave_sync_state ( + id SMALLINT PRIMARY KEY CHECK (id=1), + last_block_height BIGINT NOT NULL DEFAULT 0 CHECK (last_block_height>=0), + updated_at_ms BIGINT NOT NULL DEFAULT 0 +); +INSERT INTO free_registration_arweave_sync_state (id,last_block_height,updated_at_ms) +VALUES (1,0,0) ON CONFLICT (id) DO NOTHING; +UPDATE db_schema_version SET schema_version=34, + updated_at_ms=CAST(EXTRACT(EPOCH FROM clock_timestamp())*1000 AS BIGINT) WHERE id=1; +COMMIT; diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonHandlerRegistry.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonHandlerRegistry.java index 9a361510..e99b4153 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonHandlerRegistry.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonHandlerRegistry.java @@ -169,6 +169,8 @@ import server.logic.ws_protocol.JSON.handlers.system.entyties.Net_ListBlockchain import server.logic.ws_protocol.JSON.handlers.system.entyties.Net_Ping_Request; import server.logic.ws_protocol.JSON.handlers.system.entyties.Net_ServerHello_Request; +import server.logic.ws_protocol.JSON.handlers.registration.Net_Registration_Handler; +import server.logic.ws_protocol.JSON.handlers.registration.Net_Registration_Request; import java.util.Map; /** @@ -186,6 +188,14 @@ public final class JsonHandlerRegistry { Map.entry("SearchUsers", new Net_SearchUsers_Handler()), Map.entry("SearchChannels", new Net_SearchChannels_Handler()), + // --- Registration V2: 6 согласованных публичных операций --- + Map.entry("GetNamespaces", new Net_Registration_Handler("GetNamespaces")), + Map.entry("CheckRegistrationLogin", new Net_Registration_Handler("CheckRegistrationLogin")), + Map.entry("CheckRegistrationEmail", new Net_Registration_Handler("CheckRegistrationEmail")), + Map.entry("StartFreeRegistration", new Net_Registration_Handler("StartFreeRegistration")), + Map.entry("ConfirmFreeRegistration", new Net_Registration_Handler("ConfirmFreeRegistration")), + Map.entry("GetRegistrationStatus", new Net_Registration_Handler("GetRegistrationStatus")), + // --- auth --- Map.entry("ResolveLoginForAuth", new Net_ResolveLoginForAuth_Handler()), Map.entry("AuthChallenge", new Net_AuthChallenge_Handler()), @@ -291,6 +301,14 @@ public final class JsonHandlerRegistry { Map.entry("SearchUsers", Net_SearchUsers_Request.class), Map.entry("SearchChannels", Net_SearchChannels_Request.class), + // --- Registration V2 --- + Map.entry("GetNamespaces", Net_Registration_Request.class), + Map.entry("CheckRegistrationLogin", Net_Registration_Request.class), + Map.entry("CheckRegistrationEmail", Net_Registration_Request.class), + Map.entry("StartFreeRegistration", Net_Registration_Request.class), + Map.entry("ConfirmFreeRegistration", Net_Registration_Request.class), + Map.entry("GetRegistrationStatus", Net_Registration_Request.class), + // --- auth --- Map.entry("ResolveLoginForAuth", Net_ResolveLoginForAuth_Request.class), Map.entry("AuthChallenge", Net_AuthChallenge_Request.class), diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonInboundProcessor.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonInboundProcessor.java index 3d8133e5..749535b2 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonInboundProcessor.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonInboundProcessor.java @@ -76,9 +76,12 @@ public final class JsonInboundProcessor { return out; } - // DEBUG: сырой вход (обрезаем, чтобы не убить лог) + // Не писать email, challenge и ключи в лог даже на DEBUG. if (log.isDebugEnabled()) { - log.debug("JSON IN (login={}, sessionId={}): {}", ctxLogin, ctxSessionId, shorten(json, 1200)); + log.debug("JSON IN (login={}, sessionId={}): {}", ctxLogin, ctxSessionId, + json.contains("FreeRegistration") || json.contains("RegistrationEmail") + || json.contains("RegistrationLogin") || json.contains("GetNamespaces") + || json.contains("GetRegistrationStatus") ? "" : shorten(json, 1200)); } // 1) Парсим общий пакет @@ -178,7 +181,7 @@ public final class JsonInboundProcessor { } catch (Exception mapErr) { // Важно: вот это часто “теряется”, если не логировать отдельно log.error("❌ JSON map error (op={}, requestId={}, login={}, sessionId={}): merged={}", - op, safe(requestId), ctxLogin, ctxSessionId, shorten(merged.toString(), 1200), mapErr); + op, safe(requestId), ctxLogin, ctxSessionId, "", mapErr); Net_Exception_Response err = NetExceptionResponseFactory.error( op, @@ -202,7 +205,7 @@ public final class JsonInboundProcessor { // DEBUG: нормализованный запрос (уже распарсен) if (log.isDebugEnabled()) { log.debug("REQ OBJ (login={}, sessionId={}, op={}, requestId={}): {}", - ctxLogin, ctxSessionId, safe(op), safe(requestId), shorten(safeToString(request), 1200)); + ctxLogin, ctxSessionId, safe(op), safe(requestId), isRegistrationOperation(op) ? "" : shorten(safeToString(request), 1200)); } // REMOTE-пользователь успешно авторизован, но этот сервер не является @@ -372,6 +375,11 @@ public final class JsonInboundProcessor { } } + private static boolean isRegistrationOperation(String op) { + return op != null && (op.endsWith("Registration") || op.startsWith("CheckRegistration") + || op.equals("GetNamespaces") || op.equals("GetRegistrationStatus")); + } + private static String safe(String s) { return s != null ? s : ""; } diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/SolanaUserPdaImportService.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/SolanaUserPdaImportService.java index b4b46158..843b6136 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/SolanaUserPdaImportService.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/SolanaUserPdaImportService.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.databind.ObjectMapper; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import utils.config.SolanaProgramsConfig; +import shine.db.dao.RegistrationIdentityDAO; import java.net.URI; import java.net.http.HttpClient; @@ -34,6 +35,10 @@ public final class SolanaUserPdaImportService { public static SessionTypeCheckResult checkSessionTypeAgainstPda(String loginRaw, String sessionKeyApi, int requestedSessionType) throws Exception { String login = normalizeLogin(loginRaw); if (login == null) return SessionTypeCheckResult.noRecord(); + // У FREE_CERT нет Solana PDA. Это НЕ означает отсутствие идентичности: + // AuthChallenge и подпись clientKey уже проверяются через общий индекс. + RegistrationIdentityDAO.ResolvedIdentity identity = RegistrationIdentityDAO.getInstance().get(login); + if (identity != null && identity.isFree()) return SessionTypeCheckResult.noRecord(); ParsedSolanaUser parsed = fetchFromSolana(login); if (parsed == null) return SessionTypeCheckResult.noRecord(); diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/KeyRotationApiSupport.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/KeyRotationApiSupport.java index d68af9a2..f6ae544c 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/KeyRotationApiSupport.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/KeyRotationApiSupport.java @@ -11,6 +11,23 @@ import java.util.Base64; final class KeyRotationApiSupport { private KeyRotationApiSupport() {} + /** Free identity не имеет Solana PDA и не вправе менять ключи/форки. */ + static server.logic.ws_protocol.JSON.entyties.Net_Response denyFreeRotation( + server.logic.ws_protocol.JSON.entyties.Net_Request req, String login) { + try { + var identity = shine.db.dao.RegistrationIdentityDAO.getInstance().get(login); + if (identity == null) return server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory.error( + req, 404, "KEY_ROTATION_USER_NOT_FOUND", "Пользователь не найден"); + if (identity.isFree()) return server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory.error( + req, 403, "KEY_ROTATION_PAID_ONLY", "Для смены ключей необходима регистрация в Solana"); + return null; + } catch (java.sql.SQLException e) { + // fail closed при неготовой миграции / ошибке БД + return server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory.error( + req, 503, "KEY_ROTATION_IDENTITY_UNAVAILABLE", "Невозможно проверить полномочия пользователя"); + } + } + static String normalizePublicKey32(String raw) { String normalized = KeyEncodingUtil.normalizeKeyToBase64_32(raw); if (normalized == null || normalized.isBlank()) { diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationAbort_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationAbort_Handler.java index 4e6c9036..4302ae73 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationAbort_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationAbort_Handler.java @@ -20,6 +20,8 @@ public final class Net_KeyRotationAbort_Handler implements JsonMessageHandler { if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) { return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия"); } + var freeCheck = KeyRotationApiSupport.denyFreeRotation(req, ctx.getLogin()); + if (freeCheck != null) return freeCheck; try { KeyRotationSessionEntry current = rotations.getActiveByLogin(ctx.getLogin().trim()); if (current == null) return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), null); diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationAddBlock_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationAddBlock_Handler.java index c6cac594..b5679182 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationAddBlock_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationAddBlock_Handler.java @@ -44,6 +44,8 @@ public final class Net_KeyRotationAddBlock_Handler implements JsonMessageHandler if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) { return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия"); } + var freeCheck = KeyRotationApiSupport.denyFreeRotation(req, ctx.getLogin()); + if (freeCheck != null) return freeCheck; if (req.getBlockNumber() < 0 || req.getBlockBytesB64() == null || req.getBlockBytesB64().isBlank()) { return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BAD_BLOCK", "blockNumber и blockBytesB64 обязательны"); } diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationContinue_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationContinue_Handler.java index 028e8a8c..faac51ec 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationContinue_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationContinue_Handler.java @@ -22,6 +22,8 @@ public final class Net_KeyRotationContinue_Handler implements JsonMessageHandler if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) { return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия"); } + var freeCheck = KeyRotationApiSupport.denyFreeRotation(req, ctx.getLogin()); + if (freeCheck != null) return freeCheck; try { String login = ctx.getLogin().trim(); KeyRotationSessionEntry current = rotations.getActiveByLogin(login); diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationFinishChain_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationFinishChain_Handler.java index 56def79e..64c08c1d 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationFinishChain_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationFinishChain_Handler.java @@ -47,6 +47,8 @@ public final class Net_KeyRotationFinishChain_Handler implements JsonMessageHand if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) { return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия"); } + var freeCheck = KeyRotationApiSupport.denyFreeRotation(req, ctx.getLogin()); + if (freeCheck != null) return freeCheck; String login = ctx.getLogin().trim(); KeyRotationSessionEntry initial; diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationRotatePda_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationRotatePda_Handler.java index 631d362f..8ba85c3d 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationRotatePda_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationRotatePda_Handler.java @@ -24,6 +24,8 @@ public final class Net_KeyRotationRotatePda_Handler implements JsonMessageHandle if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) { return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия"); } + var freeCheck = KeyRotationApiSupport.denyFreeRotation(req, ctx.getLogin()); + if (freeCheck != null) return freeCheck; String login = ctx.getLogin().trim(); final String signature; diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationStart_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationStart_Handler.java index 5b840bf7..278cb9cb 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationStart_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationStart_Handler.java @@ -39,6 +39,8 @@ public final class Net_KeyRotationStart_Handler implements JsonMessageHandler { if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) { return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия"); } + var freeCheck = KeyRotationApiSupport.denyFreeRotation(req, ctx.getLogin()); + if (freeCheck != null) return freeCheck; String login = ctx.getLogin().trim(); String currentSessionId = ctx.getSessionId() == null ? "" : ctx.getSessionId().trim(); if (currentSessionId.isEmpty()) { diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationStatus_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationStatus_Handler.java index 901249ea..a33c1fc1 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationStatus_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationStatus_Handler.java @@ -20,6 +20,8 @@ public final class Net_KeyRotationStatus_Handler implements JsonMessageHandler { if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) { return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия"); } + var freeCheck = KeyRotationApiSupport.denyFreeRotation(req, ctx.getLogin()); + if (freeCheck != null) return freeCheck; try { String login = ctx.getLogin().trim(); KeyRotationSessionEntry current = rotations.getActiveByLogin(login); diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/registration/Net_Registration_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/registration/Net_Registration_Handler.java new file mode 100644 index 00000000..a34f621c --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/registration/Net_Registration_Handler.java @@ -0,0 +1,47 @@ +package server.logic.ws_protocol.JSON.handlers.registration; + +import server.logic.ws_protocol.JSON.ConnectionContext; +import server.logic.ws_protocol.JSON.entyties.Net_Request; +import server.logic.ws_protocol.JSON.entyties.Net_Response; +import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler; +import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory; +import server.logic.ws_protocol.WireCodes; + +/** API доступно анонимному клиенту, но без разрешения приватных операций. */ +public final class Net_Registration_Handler implements JsonMessageHandler { + private final String operation; + private static final java.util.Map LIMITS = + java.util.Collections.synchronizedMap(new java.util.WeakHashMap<>()); + private static long globalMinute=-1; + private static int globalHits=0; + private static boolean throttled(ConnectionContext ctx) { + long minute=System.currentTimeMillis()/60000L; + synchronized (LIMITS) { + if(globalMinute!=minute){globalMinute=minute;globalHits=0;} + if(++globalHits>1200) return true; + if(ctx==null) return false; + long[] bucket=LIMITS.computeIfAbsent(ctx, c->new long[]{minute,0}); + if(bucket[0]!=minute){bucket[0]=minute;bucket[1]=0;} + return ++bucket[1]>30; + } + } + public Net_Registration_Handler(String operation) { this.operation=operation; } + @Override public Net_Response handle(Net_Request base, ConnectionContext ctx) throws Exception { + Net_Registration_Request request=(Net_Registration_Request)base; + if (throttled(ctx)) return NetExceptionResponseFactory.error(request,429,"RATE_LIMITED","Слишком много запросов регистрации"); + RegistrationApiBridge.Service service=RegistrationApiBridge.get(); + if (service==null) return NetExceptionResponseFactory.error(request,503,"REGISTRATION_UNAVAILABLE","Регистрация на сервере пока не настроена"); + try { + java.util.Map values=service.execute(operation,request); + Net_Registration_Response out=new Net_Registration_Response(); + out.setOp(request.getOp()); out.setRequestId(request.getRequestId()); + out.setStatus(WireCodes.Status.OK); out.setValues(values); + return out; + } catch (IllegalArgumentException e) { + // Без echo исходного email, чтобы не публиковать PII в ответе/логе. + return NetExceptionResponseFactory.error(request,400,"INVALID_REGISTRATION_INPUT","Данные регистрации не прошли проверку"); + } catch (IllegalStateException e) { + return NetExceptionResponseFactory.error(request,409,"REGISTRATION_CONFLICT","Регистрация недоступна или данные уже заняты"); + } + } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/registration/Net_Registration_Request.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/registration/Net_Registration_Request.java new file mode 100644 index 00000000..13ca5c93 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/registration/Net_Registration_Request.java @@ -0,0 +1,28 @@ +package server.logic.ws_protocol.JSON.handlers.registration; + +import server.logic.ws_protocol.JSON.entyties.Net_Request; + +/** JSON payload; публичные данные пользователя, пароли/приватные ключи не принимаются. */ +public final class Net_Registration_Request extends Net_Request { + private String fullLogin; + private String email; + private String rootPublicKeyB64; + private String blockchainPublicKeyB64; + private String clientPublicKeyB64; + private String challengeId; + private String code; + public String getFullLogin() { return fullLogin; } + public void setFullLogin(String v) { fullLogin = v; } + public String getEmail() { return email; } + public void setEmail(String v) { email = v; } + public String getRootPublicKeyB64() { return rootPublicKeyB64; } + public void setRootPublicKeyB64(String v) { rootPublicKeyB64 = v; } + public String getBlockchainPublicKeyB64() { return blockchainPublicKeyB64; } + public void setBlockchainPublicKeyB64(String v) { blockchainPublicKeyB64 = v; } + public String getClientPublicKeyB64() { return clientPublicKeyB64; } + public void setClientPublicKeyB64(String v) { clientPublicKeyB64 = v; } + public String getChallengeId() { return challengeId; } + public void setChallengeId(String v) { challengeId = v; } + public String getCode() { return code; } + public void setCode(String v) { code = v; } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/registration/Net_Registration_Response.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/registration/Net_Registration_Response.java new file mode 100644 index 00000000..3412054a --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/registration/Net_Registration_Response.java @@ -0,0 +1,12 @@ +package server.logic.ws_protocol.JSON.handlers.registration; + +import server.logic.ws_protocol.JSON.entyties.Net_Response; +import java.util.Map; +import com.fasterxml.jackson.annotation.JsonAnyGetter; + +/** Значения результата помещаются на верхний уровень объекта перед стандартной WS-обёрткой. */ +public final class Net_Registration_Response extends Net_Response { + private Map values = Map.of(); + public void setValues(Map values) { this.values = Map.copyOf(values); } + @JsonAnyGetter public Map getValues() { return values; } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/registration/RegistrationApiBridge.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/registration/RegistrationApiBridge.java new file mode 100644 index 00000000..0bece8c7 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/registration/RegistrationApiBridge.java @@ -0,0 +1,15 @@ +package server.logic.ws_protocol.JSON.handlers.registration; + +import java.util.Map; + +/** SPI: HTTP/WS модуль не зависит от archive-модуля, устраняя циклический Gradle dependency. */ +public final class RegistrationApiBridge { + @FunctionalInterface public interface Service { + Map execute(String operation, Net_Registration_Request request) throws Exception; + } + private static volatile Service service; + private RegistrationApiBridge() {} + public static void install(Service implementation) { service = java.util.Objects.requireNonNull(implementation); } + public static void uninstall() { service = null; } + public static Service get() { return service; } +} diff --git a/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/codec/ShineUsersCodec.java b/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/codec/ShineUsersCodec.java index 3f2e0e63..7b803adb 100644 --- a/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/codec/ShineUsersCodec.java +++ b/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/codec/ShineUsersCodec.java @@ -2,6 +2,7 @@ package sync.codec; import com.fasterxml.jackson.databind.JsonNode; import sync.util.Base58Util; +import sync.util.SolanaPdaUtil; import java.nio.charset.StandardCharsets; import java.util.ArrayList; @@ -29,6 +30,8 @@ public final class ShineUsersCodec { public static final int IX_CLOSE_LEGACY_USER_PDA = 6; + public static final int IX_CREATE_NAMESPACE = 7; + public static final long START_REGISTRATION_FEE_LAMPORTS = 10_000_000L; @@ -151,6 +154,16 @@ public final class ShineUsersCodec { null ); + case IX_CREATE_NAMESPACE -> + new ParsedInstruction( + TxKind.CREATE_NAMESPACE, + true, + accountAt(accounts, 1), + null, + null, + null + ); + case IX_CREATE_USER_PDA -> parseV12PdaMutationInstruction( TxKind.CREATE_USER_PDA, reader, accounts @@ -731,10 +744,55 @@ public final class ShineUsersCodec { } } + /** Строгий декодер бинарного namespace 1.0 с on-chain PDA address check. */ + public static NamespaceSnapshot parseNamespaceAccount( + String pdaAddress, long slot, String rawDataBase64, + String lastTxSignature, String programId + ) { + byte[] bytes = Base64.getDecoder().decode(rawDataBase64); + if (bytes.length < 13 || bytes[0] != 1 || bytes[1] != 0) { + throw new IllegalArgumentException("Not a namespace PDA 1.0"); + } + Reader r = new Reader(bytes); + r.readU8(); r.readU8(); + int type = r.readU8(); + if (type != 1 && type != 2) throw new IllegalArgumentException("Invalid namespace type"); + int minLen = r.readU8(); + String namespace = r.readStringU8(); + if (!namespace.matches("[a-z0-9_]+") || minLen < 1 || namespace.length() + minLen + 1 > 30) { + throw new IllegalArgumentException("Invalid namespace"); + } + byte[] feeLittleEndian = r.readFixed(8); + byte[] feeBigEndian = new byte[9]; + for (int n = 0; n < 8; n++) feeBigEndian[8 - n] = feeLittleEndian[n]; + java.math.BigInteger fee = new java.math.BigInteger(feeBigEndian); + String registrarKey = null, serverLogin = null; + if (type == 2) { + registrarKey = Base58Util.encode(r.readFixed(32)); + serverLogin = r.readStringU8(); + if (!serverLogin.matches("[a-z0-9_]+@[a-z0-9_]+") || serverLogin.length() > 30) { + throw new IllegalArgumentException("Invalid access server login"); + } + } + if (r.remaining() != 0 || !pdaAddress.equals(SolanaPdaUtil.findNamespacePda(namespace, programId))) { + throw new IllegalArgumentException("Invalid namespace bytes or PDA address"); + } + return new NamespaceSnapshot(namespace, pdaAddress, type, minLen, + fee, registrarKey, serverLogin, slot, lastTxSignature, rawDataBase64); + } + + public record NamespaceSnapshot( + String namespace, String pdaAddress, int type, int minLocalpartLength, + java.math.BigInteger registrationFeeLamports, String registrarPublicKey, + String defaultServerLogin, long slot, String lastTxSignature, + String rawDataBase64 + ) {} + public enum TxKind { INIT_USERS_ECONOMY_CONFIG, UPDATE_USERS_ECONOMY_CONFIG, CREATE_USER_PDA, + CREATE_NAMESPACE, UPDATE_USER_PDA, CLOSE_LEGACY_USER_PDA, OTHER diff --git a/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/service/SolanaUsersSyncService.java b/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/service/SolanaUsersSyncService.java index c1c745da..633959e8 100644 --- a/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/service/SolanaUsersSyncService.java +++ b/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/service/SolanaUsersSyncService.java @@ -386,6 +386,7 @@ public final class SolanaUsersSyncService ); storage.applyHistoryBatch( + List.of(), List.of(), List.of(), newState @@ -452,6 +453,7 @@ public final class SolanaUsersSyncService List snapshotsToPersist = new ArrayList<>(); + List namespacesToPersist = new ArrayList<>(); ShineUsersCodec.EconomyConfigState economyState = state.economyConfigState(); @@ -528,15 +530,19 @@ public final class SolanaUsersSyncService SolanaRpcClient.AccountBatchResult exactAccounts = rpcClient.getCurrentAccounts(exactFetchPdaAddresses, newestSeen.slot()); for (ProgramAccountUpdate account : exactAccounts.updates()) { - ShineUsersCodec.UserPdaSnapshot snapshot = - ShineUsersCodec.parseUserPdaAccount( - account.address(), - account.slot(), - account.dataBase64(), - latestRelevantSignatureByPda.getOrDefault(account.address(), "") - ); - snapshotsToPersist.removeIf(existing -> existing.pdaAddress().equals(snapshot.pdaAddress())); - snapshotsToPersist.add(snapshot); + String lastSignature = latestRelevantSignatureByPda.getOrDefault(account.address(), ""); + byte[] firstBytes = Base64.getDecoder().decode(account.dataBase64()); + if (firstBytes.length > 2 && firstBytes[0] == 1 && firstBytes[1] == 0) { + var ns = ShineUsersCodec.parseNamespaceAccount(account.address(), + account.slot(), account.dataBase64(), lastSignature, config.programId()); + namespacesToPersist.removeIf(existing -> existing.pdaAddress().equals(ns.pdaAddress())); + namespacesToPersist.add(ns); + } else { + var snapshot = ShineUsersCodec.parseUserPdaAccount(account.address(), + account.slot(), account.dataBase64(), lastSignature); + snapshotsToPersist.removeIf(existing -> existing.pdaAddress().equals(snapshot.pdaAddress())); + snapshotsToPersist.add(snapshot); + } } } @@ -558,6 +564,7 @@ public final class SolanaUsersSyncService storage.applyHistoryBatch( txEntries, snapshotsToPersist, + namespacesToPersist, newState ); @@ -595,6 +602,7 @@ public final class SolanaUsersSyncService List currentSnapshots = new ArrayList<>(); + List currentNamespaces = new ArrayList<>(); int processedAccounts = 0; @@ -604,14 +612,14 @@ public final class SolanaUsersSyncService processedAccounts++; try { - currentSnapshots.add( - ShineUsersCodec.parseUserPdaAccount( - account.address(), - account.slot(), - account.dataBase64(), - "" - ) - ); + byte[] firstBytes = Base64.getDecoder().decode(account.dataBase64()); + if (firstBytes.length > 2 && firstBytes[0] == 1 && firstBytes[1] == 0) { + currentNamespaces.add(ShineUsersCodec.parseNamespaceAccount( + account.address(), account.slot(), account.dataBase64(), "", config.programId())); + } else { + currentSnapshots.add(ShineUsersCodec.parseUserPdaAccount( + account.address(), account.slot(), account.dataBase64(), "")); + } } catch (Exception ignored) { } @@ -654,6 +662,7 @@ public final class SolanaUsersSyncService storage.replaceCurrentFromFullSnapshot( currentSnapshots, + currentNamespaces, newState ); diff --git a/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/storage/postgres/PostgresStorageRepository.java b/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/storage/postgres/PostgresStorageRepository.java index 9fe3aa7f..120a80b1 100644 --- a/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/storage/postgres/PostgresStorageRepository.java +++ b/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/storage/postgres/PostgresStorageRepository.java @@ -248,6 +248,7 @@ public final class PostgresStorageRepository public synchronized void applyHistoryBatch( List txEntries, List snapshots, + List namespaces, SyncStateSnapshot newState ) throws Exception { @@ -268,6 +269,7 @@ public final class PostgresStorageRepository snapshots ); + upsertNamespaceSnapshots(connection, namespaces); upsertCurrentSnapshots( connection, snapshots @@ -297,6 +299,7 @@ public final class PostgresStorageRepository public synchronized void replaceCurrentFromFullSnapshot( List snapshots, + List namespaces, SyncStateSnapshot newState ) throws Exception { @@ -306,6 +309,7 @@ public final class PostgresStorageRepository connection.setAutoCommit(false); try { + upsertNamespaceSnapshots(connection, namespaces); upsertCurrentSnapshots( connection, snapshots @@ -459,6 +463,39 @@ public final class PostgresStorageRepository } } + private void upsertNamespaceSnapshots(Connection connection, + List namespaces) throws Exception { + if (namespaces == null || namespaces.isEmpty()) return; + String sql = """ + INSERT INTO shine_namespace_current ( + namespace, pda_address, namespace_type, min_localpart_len, + registration_fee_lamports, registrar_pubkey, default_server_login, + slot, last_tx_signature, raw_data_base64 + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + ON CONFLICT (namespace) DO UPDATE SET + slot=EXCLUDED.slot, last_tx_signature=EXCLUDED.last_tx_signature, + raw_data_base64=EXCLUDED.raw_data_base64 + WHERE shine_namespace_current.pda_address=EXCLUDED.pda_address + AND shine_namespace_current.raw_data_base64=EXCLUDED.raw_data_base64 + """; + try (PreparedStatement ps = connection.prepareStatement(sql)) { + for (ShineUsersCodec.NamespaceSnapshot ns : namespaces) { + ps.setString(1, ns.namespace()); ps.setString(2, ns.pdaAddress()); + ps.setInt(3, ns.type()); ps.setInt(4, ns.minLocalpartLength()); + ps.setBigDecimal(5, new java.math.BigDecimal(ns.registrationFeeLamports())); + ps.setString(6, ns.registrarPublicKey()); + ps.setString(7, ns.defaultServerLogin()); ps.setLong(8, ns.slot()); + ps.setString(9, ns.lastTxSignature()); ps.setString(10, ns.rawDataBase64()); + ps.addBatch(); + } + ps.executeBatch(); + } + // Namespace появляется после сервера, пересчитываем маршруты free пользователей. + try (Statement st = connection.createStatement()) { + st.execute("SELECT shine_refresh_user_access_servers_all()"); + } + } + private void upsertCurrentSnapshots( Connection connection, List snapshots @@ -1076,6 +1113,16 @@ public final class PostgresStorageRepository "ON user_access_servers_current(server_login)" ); + // После PostgreSQL migration_v33 функции маршрутизации принадлежат + // общему реестру логических identity, их нельзя перезаписывать + // legacy Solana-only вариантом при старте sync. + boolean hasIdentityTable; + try (ResultSet check = statement.executeQuery( + "SELECT to_regclass('user_identity_current') IS NOT NULL")) { + check.next(); + hasIdentityTable = check.getBoolean(1); + } + if (!hasIdentityTable) { statement.execute( """ CREATE OR REPLACE FUNCTION shine_refresh_user_access_servers_for_user(p_user_login TEXT) @@ -1260,6 +1307,8 @@ public final class PostgresStorageRepository "EXECUTE FUNCTION trg_refresh_user_access_servers_from_user_pda_truncate()" ); + } + statement.execute("SELECT shine_refresh_user_access_servers_all()"); } } diff --git a/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/util/SolanaPdaUtil.java b/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/util/SolanaPdaUtil.java index 5e5fd518..77f0ece4 100644 --- a/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/util/SolanaPdaUtil.java +++ b/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/util/SolanaPdaUtil.java @@ -61,6 +61,27 @@ public final class SolanaPdaUtil { ); } + /** Новый v2 PDA. Старый двух-seed вариант оставлен только для legacy accounts. */ + public static String findUserPdaV2(String fullLogin, String programId) { + if (fullLogin == null || !fullLogin.matches("[a-z0-9_]+@[a-z0-9_]+") || fullLogin.length() > 30) { + throw new IllegalArgumentException("Invalid full login"); + } + return findHashedPda("user_login=" + fullLogin, programId); + } + + public static String findNamespacePda(String namespace, String programId) { + if (namespace == null || !namespace.matches("[a-z0-9_]+")) { + throw new IllegalArgumentException("Invalid namespace"); + } + return findHashedPda("namespace=" + namespace, programId); + } + + private static String findHashedPda(String preimage, String programId) { + SHA256.Digest digest = new SHA256.Digest(); + byte[] seed = digest.digest(preimage.getBytes(StandardCharsets.UTF_8)); + return findProgramAddress(List.of(seed), programId); + } + private static byte[] createProgramAddress( List seeds, byte[] programId diff --git a/SHiNE-server/shine-server-solana-users-sync/src/test/java/sync/codec/NamespaceV2VectorCheck.java b/SHiNE-server/shine-server-solana-users-sync/src/test/java/sync/codec/NamespaceV2VectorCheck.java new file mode 100644 index 00000000..a10a9f44 --- /dev/null +++ b/SHiNE-server/shine-server-solana-users-sync/src/test/java/sync/codec/NamespaceV2VectorCheck.java @@ -0,0 +1,35 @@ +package sync.codec; + +import sync.util.SolanaPdaUtil; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Base64; +import java.util.HexFormat; +import java.util.Properties; + +/** Отдельная offline-проверка, без RPC/DB; запуск через main(). */ +public final class NamespaceV2VectorCheck { + public static void main(String[] args) throws Exception { + Properties p = new Properties(); + try (var stream = Files.newInputStream(Path.of(args[0]))) { p.load(stream); } + String program = p.getProperty("program_id"); + if (!p.getProperty("namespace_free_pda").equals(SolanaPdaUtil.findNamespacePda("free", program))) + throw new AssertionError("Namespace seed/PDA mismatch"); + if (!p.getProperty("user_bob_free_pda").equals(SolanaPdaUtil.findUserPdaV2("bob@free", program))) + throw new AssertionError("User v2 seed/PDA mismatch"); + byte[] raw = HexFormat.of().parseHex(p.getProperty("namespace_free_bytes_hex")); + var ns = ShineUsersCodec.parseNamespaceAccount(p.getProperty("namespace_free_pda"), + 42, Base64.getEncoder().encodeToString(raw), "test-signature", program); + if (!"free".equals(ns.namespace()) || ns.type() != 2 || + ns.registrationFeeLamports().longValueExact() != 5_000_000L || + !"registrar@shine".equals(ns.defaultServerLogin())) + throw new AssertionError("Namespace value mismatch"); + byte[] corrupt = raw.clone(); corrupt[6] ^= 1; + try { + ShineUsersCodec.parseNamespaceAccount(p.getProperty("namespace_free_pda"), + 42, Base64.getEncoder().encodeToString(corrupt), "test-signature", program); + throw new AssertionError("Wrong PDA accepted"); + } catch (IllegalArgumentException expected) { } + System.out.println("PASS: Java namespace decoder & SHA256 PDA test vectors"); + } +} diff --git a/SHiNE-server/src/main/java/server/ws/WsServer.java b/SHiNE-server/src/main/java/server/ws/WsServer.java index ecd881f6..1c7abac7 100644 --- a/SHiNE-server/src/main/java/server/ws/WsServer.java +++ b/SHiNE-server/src/main/java/server/ws/WsServer.java @@ -9,6 +9,7 @@ import org.eclipse.jetty.websocket.server.config.JettyWebSocketServletContainerI import org.slf4j.Logger; import org.slf4j.LoggerFactory; import server.archive.ArweaveBlockPublisherScheduler; +import server.archive.registration.FreeRegistrationApiBootstrap; import server.archive.ArweaveBlockSyncScheduler; import server.debug.DebugApiConfigurator; import server.files.DmFileApiConfigurator; @@ -65,6 +66,7 @@ public final class WsServer { // PeriodicBlockchainSyncService is retained only as deprecated historical code. // ANS-104: publish locally-created signed user blocks and discover blocks published by other servers. + FreeRegistrationApiBootstrap.startOrThrow(); ArweaveBlockPublisherScheduler.startOrLog(); ArweaveBlockSyncScheduler.startOrLog(); KeyRotationRebuildScheduler.startOrLog(); @@ -104,7 +106,7 @@ public final class WsServer { log.info("✅ WS сервер запущен на ws://localhost:{}/ws", port); ServerConnectionPool.getInstance().startOrLog(); Runtime.getRuntime().addShutdownHook(new Thread( - () -> { ServerConnectionPool.getInstance().close(); ArweaveBlockPublisherScheduler.close(); ArweaveBlockSyncScheduler.close(); }, + () -> { ServerConnectionPool.getInstance().close(); ArweaveBlockPublisherScheduler.close(); ArweaveBlockSyncScheduler.close(); FreeRegistrationApiBootstrap.close(); }, "server-connection-pool-shutdown")); PeriodicDmDeliveryService.startOrLog(); server.join(); diff --git a/VERSION.properties b/VERSION.properties index 90187fe1..735d1823 100644 --- a/VERSION.properties +++ b/VERSION.properties @@ -1,2 +1,2 @@ -client.version=1.20.1 -server.version=1.16.0 +client.version=1.20.2 +server.version=1.16.1 diff --git a/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md b/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md index 05701538..489f068e 100644 --- a/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md +++ b/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md @@ -125,3 +125,8 @@ Migration v26 добавляет server-local поля `rotation_status` / `rota ## Миграции key rotation При обновлении сервера DatabaseInitializer последовательно применяет migration v26 (state machine смены ключей) и v27 (отдельные candidate-блоки будущего fork). Ручного создания таблиц не требуется. Candidate-блоки не входят в текущую таблицу `blocks` до финального переключения fork. + + +## Этапы регистрации V2 4–7: подготовка тестового окружения (23.10.2026) + +Перед запуском новой синхронизации нужен тестовый `shine_users` (opcode 7, namespace accounts), применённая PostgreSQL v33, бэкап и отдельная БД. Только после этого разрешён импорт namespace в отдельный регистр `shine_namespace_current`. Не совмещать с существующим UI/production. `freeRegistration.enabled` по умолчанию false; `freeRegistration.registrarSeedFile` — локальный secret path (Base64 seed32) вне Git. При несоответствии регистратора публичному ключу on-chain namespace выдача сертификата прекращается. Нет Arweave importer до этапа 8, API/UI до этапов 9–10. Сначала прогоните чистый snapshot, историю, restart/replay, FK и ключевую ротацию на тестовом контуре. diff --git a/docs/API/01_User_Registration_API.md b/docs/API/01_User_Registration_API.md index c582a5f5..100c727f 100644 --- a/docs/API/01_User_Registration_API.md +++ b/docs/API/01_User_Registration_API.md @@ -171,3 +171,11 @@ - `GetUser` — проверка существования пользователя на сервере. - `SearchUsers` — временный поиск пользователей по префиксу. - Регистрация выполняется только через Solana. + + +## Регистрация V2: полные логины и независимые проверки + +Публичные WS-операции нового протокола перечислены в `docs/registration-v2/WS_REGISTRATION_V2_PROPOSED_NOT_ENABLED.md`. +Сначала `GetNamespaces` → `CheckRegistrationLogin` с полным `login@namespace`; затем **только для бесплатной регистрации** отдельное `CheckRegistrationEmail`. После проверки запускается `StartFreeRegistration`, затем `ConfirmFreeRegistration` с тестовым кодом `1111`. Состояние читается через `GetRegistrationStatus`. + +Все бесплатные сертификаты подписаны ANS-104 и внутренней подписью Ed25519; успешный Turbo ACK не означает подтверждённую высоту Arweave. Клиент никогда не отправляет пароль или приватные ключи на сервер. diff --git a/docs/API/09_Operations_Index.md b/docs/API/09_Operations_Index.md index 7ab51448..abbff6b9 100644 --- a/docs/API/09_Operations_Index.md +++ b/docs/API/09_Operations_Index.md @@ -95,3 +95,15 @@ - HTTP endpoints публичных content-addressed файлов (`PUT/GET/HEAD/OPTIONS /files/{sha256}`) также не являются WebSocket `op` и описаны отдельно в `21_Public_File_Storage_API.md`. - Классы `Net_MarkChannelMessagesSeen_*` существуют в коде, но операция `MarkChannelMessagesSeen` не зарегистрирована в `JsonHandlerRegistry`, поэтому в публичный список API не входит. - HTTP debug endpoints из `src/main/java/server/debug/` не входят в этот индекс WebSocket `op`; они описаны отдельно в `13_HTTP_Debug_API.md`. + + +## Registration V2 (добавлено 23.10.2026, test/dev only) + +- `GetNamespaces` — список зарегистрированных namespace из Solana-синхронизации; +- `CheckRegistrationLogin` — отдельная проверка `login@namespace`; +- `CheckRegistrationEmail` — отдельная проверка email; +- `StartFreeRegistration` — запрос сертификата по трём публичным ключам; +- `ConfirmFreeRegistration` — подтверждение тестовым кодом и Turbo ACK; +- `GetRegistrationStatus` — статус и публичные поля сертификата для upgrade. + +Точный JSON и ограничения: `docs/registration-v2/WS_REGISTRATION_V2_PROPOSED_NOT_ENABLED.md` (имя сохранено для обратных ссылок; внутри утверждённая версия). diff --git a/docs/Blockchain/CHANGELOG.md b/docs/Blockchain/CHANGELOG.md index 990c166f..e916b0ff 100644 --- a/docs/Blockchain/CHANGELOG.md +++ b/docs/Blockchain/CHANGELOG.md @@ -318,3 +318,9 @@ - Экран «Мой блокчейн» теперь запрашивает уже существующее поле `blockBytesB64` и разбирает полный ANS-104 DataItem / SHiNE Frame v1 непосредственно в браузере. - Для текущих TECH/TEXT/REACTION/CONNECTION/USER_PROFILE/STATUS_ACTION событий добавлены человекочитаемые подписи, компактный preview и раскрываемые детали. - Arweave DataItem ID вычисляется локально как `SHA-256(signature64)` и используется для ссылки `https://arweave.net/`. + +- 2026-10-23 (без commit hash, ZIP patch): подготовлен код выдачи независимого `t=reg` ANS-104 DataItem (stage 7); существующий формат пользовательского блокчейна не изменён, деплой/Arweave публикация не выполнены. + +- 2026-10-23 — архив регистрирует отдельные `t=reg` DataItem (формат существующих BchBlock без изменений); исправление/дополнение в некоммитированном архивном патче 0–10, commit hash отсутствует; после коммита добавить hash. + +- 2026-10-23 — регистрационные WS операции и UI для отдельного `t=reg` ANS-104 DataItem, пользовательский Frame V1/AddBlock формат не менялся. Commit hash отсутствует (не коммитировалось), перед merge заменить на реальный hash. diff --git a/docs/Blockchain/README.md b/docs/Blockchain/README.md index e26ce663..8402b687 100644 --- a/docs/Blockchain/README.md +++ b/docs/Blockchain/README.md @@ -40,3 +40,10 @@ Other servers - `data_item_id` нужен для Arweave, поиска и дедупликации. - PostgreSQL — единственное локальное хранилище пользовательских блоков. - Тестовый namespace `App=test5591` специально отделён от будущего production namespace. + + +## Отдельные регистрационные DataItem V1 (test only; импорт реализован в коде, E2E не пройден) + +Новая платформа регистрации `t=reg` использует ANS-104 Ed25519 и независимый payload, **не являющийся пользовательским AddBlock**. Формат определён в [регистрационном протоколе](../Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md). Обычный формат пользовательских блоков не меняется. Новая регистрация отправляет `t=reg` через Turbo и отдельный импортёр, код включён только в тестовом патче; фактический Turbo/GraphQL E2E ещё не пройден. + +- Регистрационные Arweave ANS-104 DataItem `t=reg` (вне пользовательских блокчейнов): `../Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md`, `../registration-v2/PATCH_STAGES_8_9_10.md`. diff --git a/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md b/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md index 6b635ee5..d63ef825 100644 --- a/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md +++ b/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md @@ -609,3 +609,10 @@ Create/update транзакции больше не реконструирую Для каждого candidate DataItem сохраняются rotation session, login, candidate blockchain name, block number/hash, полный ANS-104 DataItem, DataItem id и статус публикации. Уникальность `(rotation_session_id, block_number)` запрещает две разные версии одного candidate-блока. Arweave/Turbo publisher обрабатывает candidate-блоки приоритетно. `key_rotation_sessions.progress_current` отражает число DataItem, уже реально опубликованных publisher-ом, а не число принятых API-сервером. + + +## V2 регистрация — разработка (2026-10-23, этап 6, без развёртывания) + +Для новых `login@namespace` используется `SHA256(UTF8("user_login=" + fullLogin))` как один 32-byte PDA seed; для namespace — `SHA256(UTF8("namespace=" + namespace))`. `IX_CREATE_NAMESPACE=7` читается как отдельное событие. `SolanaUsersSyncService` декодирует namespace независимо от user-PDA и сохраняет снапшоты namespaces в `shine_namespace_current`; paid user-PDA параллельно синхронизируются как прежде. При upsert Solana запись переносит логического пользователя `FREE_CERT → PAID_UPGRADED` без изменения логина и исходной даты в user_identity_current; free-сертификат не превращается в фальшивый Solana PDA. Общий индекс только в миграции DB v33. При запуске standalone sync сначала выполнить v33 migration через Java-сервер. + +**ВНИМАНИЕ:** проверить на настоящем PostgreSQL + RPC replay до включения. Read-only economy-PDA остаётся индексом истории через `getSignaturesForAddress`, не гарантирует websocket account notification. diff --git a/docs/registration-v2/IMPLEMENTATION_STATUS.md b/docs/registration-v2/IMPLEMENTATION_STATUS.md new file mode 100644 index 00000000..7c757d9b --- /dev/null +++ b/docs/registration-v2/IMPLEMENTATION_STATUS.md @@ -0,0 +1,85 @@ +# SHiNE Registration V2 — журнал выполнения + +**Дата:** 23.10.2026 +**Базовая версия:** `SHiNE-bundle-2026.10.23-12.36.02.zip` (SHA-256 `e2871bb11610437c354507dc9a723d64f14b0be4161af5f82d19f1466af648a6`) +**Исходная ветка/коммит:** не определены, потому что загруженный архив не содержит `.git`. + +## Прогресс всех этапов (мастер-план V2, всего 14: 0–13) + +| Этап | Название | Статус | +|---:|---|---| +| 0 | Исходный аудит, зависимости и baseline | **PARTIAL** — аудит и UI smoke выполнены, Rust/Gradle/DB baseline недоступны | +| 1 | Протоколы и межъязыковые тест-векторы | **PARTIAL** — V1 формат/векторы готов, Rust-тесты не запущены | +| 2 | Solana namespace PDA + upgrade authority | **PARTIAL** — Rust-код написан, сборка/localnet недоступны | +| 3 | Solana paid / certificate upgrade | **PARTIAL** — Rust-код написан, BPF/транзакции не тестировались | +| 4 | JS codecs + Solana client | **PARTIAL** — код нового контракта и unit-тесты есть, RPC/devnet не запускались | +| 5 | Unified PostgreSQL identity | **PARTIAL** — migration v33 написана, реального PostgreSQL integration нет | +| 6 | Java Solana sync | **PARTIAL** — namespace history/snapshot код, Java vector тест, нет Gradle/RPC/DB E2E | +| 7 | Сервер-регистратор и ключ подписи | **PARTIAL** — Java signer/certificate проходит offline; нет интеграции в lifecycle/Turbo | +| 8 | Arweave импорт + Turbo ACK | **PARTIAL** — importer / publisher / discovery; нет GraphQL/Turbo/DB E2E | +| 9 | WS/API free registration | **BLOCKED/PARTIAL** — internal workflow, публичный op требует отдельного утверждения | +| 10 | Auth и запреты FREE_CERT | **PARTIAL** — identity DAO / Solana lookup / guards, нет E2E | +| 11 | UI бесплатной и платной регистрации | NOT STARTED | +| 12 | UI free → paid upgrade | NOT STARTED | +| 13 | E2E/devnet и выпускная проверка | NOT STARTED | + +## Этап №0 — 23.10.2026 + +1. **Поручено:** распаковать архив, изучить AGENTS.md, зафиксировать реальное состояние и baseline, найти идентификационные зависимости и SQL FK, завести журнал. +2. **Реально изменено:** только новые файлы `docs/registration-v2/IMPLEMENTATION_STATUS.md`, `docs/registration-v2/SOURCE_BASELINE.md`, `docs/registration-v2/SQL_DEPENDENCIES.md`. Не изменены Rust, Java, JS, SQL, тесты существующего проекта, `VERSION.properties`. +3. **Новые форматы / opcodes / миграции / конфиги:** нет. Разработка протокола v1 — задача этапа 1. +4. **Тесты:** `node --test shine-UI/tests/*.test.*` → **18 passed, 0 failed**; `node --check` трёх ключевых JS-файлов → **3 passed**; `javac --release 17` изолированного `CurrentUsersSql.java` → **успешно**; `./gradlew --version` → **BLOCKED** (нет доступа к `services.gradle.org` для Gradle 8.14); Rust/Cargo/Anchor/Solana CLI и PostgreSQL → **NOT RUN** (toolchain отсутствует). +5. **Ручная проверка:** исходники, `settings.rs`, UI guard, SQL FK, Java-current user facade, Solana sync/authorize пути и доступные тесты просмотрены. Архив распакован; система end-to-end не запускалась. +6. **Не сделано:** рабочая git-ветка/commit (нет `.git`); server/Solana/SQL baseline compile/integration; реальная сверка `pg_catalog` тестовой БД. +7. **Совместимость:** существующий пользовательский блокчейн, PDA, API, данные и файлы программы не изменены. +8. **Документация:** `SOURCE_BASELINE.md`, `SQL_DEPENDENCIES.md`, этот журнал. +9. **Коммиты/патч:** git commit не создавался, только экспортируемый patch архива этапа 0; не объявлять за выполненный production deployment. +10. **Риски:** 16 FK/15 таблиц к Solana current, SQL триггеры/функции маршрутов, real PDA-сессионные проверки, старый seed/normalization, нет полного toolchain; актуальный архив новее мастер-плана. +11. **Следующий этап:** завершить отсутствующие baseline тесты этапа 0 в подготовленной среде, затем №1 (байтовые протоколы namespace и сертификата с фиксированными тест-векторами). +12. **С чего читать:** `SOURCE_BASELINE.md` → `SQL_DEPENDENCIES.md` → мастер-план V2 (А, В, этапы 1–3) → `shine-solana/shine/AGENTS.md` → `shine_users/src/lib.rs`/`settings.rs` и документы форматов. +13. **Разрешения:** этап 0 не требует изменения публичного WS API или текущего формата blockchain. Перед фактическим изменением публичного API (этап 9) и текущего формата существующего blockchain (если станет необходимым) запросить предусмотренное `AGENTS.md` подтверждение. Production deploy не санкционирован. + +**Правило статусов:** `PARTIAL` — не трактовать как `COMPLETED` и не считать, что проект уже поддерживает новую регистрацию. Для следующего сеанса сохранить эти три документа и исходный мастер-план V2 вместе с актуальным кодом. + +## Объединённый патч этапов №1–3 — 23.10.2026 + +**Выполнение по запросу владельца проекта:** три последовательных этапа объединены **в один архив/патч**, хотя первоначальный план предлагал один этап на патч. Это не считается эксплуатационной готовностью. + +1. **Исходный код:** `shine-solana/shine/programs/shine_users/src/lib.rs`, `settings.rs`: новый namespace PDA 1.0, `IX_CREATE_NAMESPACE=7`, ProgramData authority для namespace и economy update, новый SHA-256 user PDA для полного имени, Solana регистрация `PAID_DIRECT` и предъявление inner certificate для `PAID_UPGRADED`. Старый opcode 5 promo seller выключен; guard и promo из нового create удалены. Старые user PDA без namespace допускают прежний update и legacy close. Формат данных user PDA 1.2 не изменялся. +2. **Протоколы:** `shine-solana/shine/doc/formats/shine-namespace-pda-format-v1.md`; `docs/Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md`; документы программы и пользовательского PDA синхронизированы с переписанной реализацией. +3. **Фикстуры:** `tests/fixtures/registration-v2.json`, `.properties` с воспроизводимыми сырыми SHA-256, PDA+bump, Ed25519 inner message/signature, подписанным ANS-104 и двумя namespace binary; приватные пользовательские или серверные реальные ключи не включены. +4. **Тесты, РЕАЛЬНО выполнены:** `node --test shine-UI/tests/*.test.*` → **18/18**; `node --test shine-solana/shine/tests/registration-v2-*.test.mjs` → **9/9**; `javac --release 17` + автономная Java сверка PDA/SHA-256/Ed25519 → **OK**; `node --check` обеих scripts → **OK**; независимый decode бинарного namespace → **OK**. +5. **Не выполнены:** `cargo build`, `cargo test --test registration_v2_vectors`, `anchor build`, BPF, localnet/devnet smoke, negative cases authority mismatch, Solana transaction pay/create/update/upgrade. В окружении нет `cargo`/Rust toolchain и поднятой localnet. Статусы 2 и 3 **PARTIAL**, не COMPLETE. +6. **Не готовы и НЕ совместимы:** старый JS клиент, серверный Solana sync, PostgreSQL, WS API, UI регистрации — см. этапы 4–13; новая Solana программа **нельзя развёртывать с ними**. Требуются проверка ограничений на Solana compute/binary, связки treasury, регистрация сервера в paid namespace до namespace type2, тест восстановления и отсутствие начисления второго free-бонуса на upgrade. +7. **Влияние на production:** **НИКАКОГО**; запрос на deploy не поступал и не выполнялся. Git commit/push не выполнялись (.git в ZIP нет), VERSION.properties не изменялся — версия меняется по правилам перед отдельным commit. +8. **Следующая работа:** на полноценном Rust/Solana toolchain выполнить компиляцию, и негативные BPF/localnet тесты **до этапа 4**. Затем сделать этап 4: клиентский JS codec/account metas, с test fixtures; этапы 5–6: БД/синхронизация. После этих шагов можно начинать сервер-регистратор/WS/UI. +9. **Документ передачи:** этот журнал + `PATCH_STAGES_1_2_3.md` + вложенные копии мастер-плана/roadmap. Прежде чем принимать любое Solana изменение как завершённое, необходимо проверить его реальную работу и совместимость в testnet. + + +## 23 октября 2026: накопительный код этапов 4–7 + +- Поверх этапов 0–3 добавлены JS namespace client, DB миграция v33, Java Sync namespace codec, Java signer/certificate. +- Проверено локально: 23/23 UI Node; 6/6 Solana vectors Node; Java namespace и сертификат по независимым фикстурам. +- Блокеры: Rust toolchain/localnet, настоящий PostgreSQL, полная Gradle сборка/RPC replay. Архитектурный код **не равен готовности к развёртыванию**. +- Новая публичная WS операция отсутствует (отдельное согласование на этапе 9). +- Arweave/Turbo importer — этап 8; пока не реализован. +- Дальше: изолированная БД + localnet проверки, затем этап 8, далее API/UI. +- Документ: `PATCH_STAGES_4_5_6_7.md`. + + +## 23 октября 2026: накопительный код этапов 8–10 + +- Этап 8: новый `VerifiedFreeRegistrationImporter`, `FreeRegistrationPublisher`, GraphQL discovery отдельного `t=reg` и PostgreSQL миграция v34 для checkpoint; ACK Turbo и независимое Arweave подтверждение — разные события. +- Этап 9: Java `FreeRegistrationWorkflow` есть, но **новые публичные WS `op` не регистрировались** до отдельного согласования по `AGENTS.md`. Проект договора — `WS_REGISTRATION_V2_PROPOSED_NOT_ENABLED.md`. +- Этап 10: `RegistrationIdentityDAO` и проверка отсутствия PDA у бесплатного пользователя; семь серверных обработчиков KeyRotation проверяют статус. Платные могут исполнять старый процесс. +- Реальные тесты сквозного сервера/DB/сети по-прежнему не проведены. Патч только для test/dev review; **НЕ деплоить на production**. +- Отчёт: `PATCH_STAGES_8_9_10.md`. + + +## 23 октября 2026: накопительный патч с этапами 9 и 11–13 + +- **9:** шесть WS API с независимыми проверками имени и email. Утверждение владельца получено. JSON DTO, Registry и SPI в net-protocol, сервис в archive, startup в WsServer; ограничитель запросов по WebSocket и глобальный счётчик. Не проверено реальной Java Gradle-сборкой. +- **11:** переписана UI-регистрация под выбор paid/free namespace, Argon2id от полного логина, отдельный email, тест `1111`, Turbo ACK и текущую сессию. Существующая оплата Solana сохранена. Node-тесты проверяют кодеки/контракт, но не браузерное прохождение сценария. +- **12:** добавлен экран upgrade по неизменным ключам и внутренней подписи сертификата; status из сервера, fee из namespace-PDA. Не проверена отправка реальной транзакции localnet/devnet. +- **13:** добавлены контрактные тесты и smoke-runbook; полноценный E2E отложен до доступных Rust/Gradle/PostgreSQL/Turbo сетей. +- **Не готово:** `cargo`, full Gradle, PostgreSQL migration v33/v34, реальные WS, Turbo ACK, Solana localnet, браузер и межсерверный импорт. Все этапы **PARTIAL**, никакого production. diff --git a/docs/registration-v2/MASTER_PLAN_V2_2026-10-23.md b/docs/registration-v2/MASTER_PLAN_V2_2026-10-23.md new file mode 100644 index 00000000..b697bf67 --- /dev/null +++ b/docs/registration-v2/MASTER_PLAN_V2_2026-10-23.md @@ -0,0 +1,720 @@ +# SHiNE — МАСТЕР-ПЛАН РЕАЛИЗАЦИИ РЕГИСТРАЦИИ V2 + +**Дата:** 23 октября 2026 года +**Тип:** автономное техническое задание и инструкция для нового чата / Codex +**Базовый архив:** `SHiNE-bundle-2026.10.22-12.53.20(1).zip` +**Связанный предыдущий план:** `SHiNE_registration_roadmap_2026-10-23.md` +**Статус:** проектирование; изменения в исходный код этим документом НЕ внесены. +**Принцип:** один этап = один контролируемый патч. Не реализовывать весь документ за одну генерацию. + +> **ВАЖНО ДЛЯ СЛЕДУЮЩЕГО ИСПОЛНИТЕЛЯ.** Не воспринимай этот документ как свидетельство, что код уже изменён. Сперва открой архив / рабочий репозиторий, прочитай локальные AGENTS.md, проверь текущую ветку и выполни только тот этап, который явно поручен. Все пути ниже сверены с архивом от 22.10.2026; в другой версии они могут отличаться. Если обнаружишь техническую неточность плана, исправь её обоснованно, сохранив согласованные продуктовые правила. Не менять API и формат существующего пользовательского блокчейна без предусмотренного проектом согласования. + +--- + +## КАК ПЕРЕДАТЬ В НОВЫЙ ЧАТ (важнее всего) + +Передать **оба вложения**: +1. Полный исходный архив проекта `SHiNE-bundle-2026.10.22-12.53.20(1).zip` либо актуальную версию репозитория. +2. **Этот файл мастер-плана V2**, а также последний журнал завершённых этапов, если работа уже начата. + +В новом чате дать инструкцию: + +> «Это проект SHiNE. Прочитай `SHiNE_registration_implementation_masterplan_v2_2026-10-23.md`, затем AGENTS.md в корне и в изменяемых модулях. Сначала сверь план с реальным исходным кодом. Выполни **только этап № N**, включая тесты, актуализацию обязательной документации и отчёт по шаблону из конца плана. Не придумывай другую схему регистрации. Не трогай production, не меняй публичный API/формат старого блокчейна без отдельного разрешения. После выполнения остановись». + +Если кодовая база изменилась после архива, **источником истины для расположения кода является актуальный репозиторий**, а этот документ — источник согласованных требований и порядка действий. + +--- + +# А. ПРОДУКТОВОЕ ТЗ: ЧТО ДОЛЖНО ПОЛУЧИТЬСЯ + +## А1. Три допустимых состояния одного аккаунта + +| Состояние | Кто удостоверяет имя | Пользовательский PDA Solana | Сервер доступа | Смена ключей | +|---|---|---|---|---| +| `PAID_DIRECT` | `shine_users` | есть | определяется своим PDA | разрешена по правилам PDA | +| `FREE_CERT` | сертификат регистратора в Arweave | нет | общий сервер из namespace-PDA | запрещена | +| `PAID_UPGRADED` | `shine_users` + ранее выданный сертификат | есть | определяется своим PDA | разрешена по правилам PDA | + +`FREE_CERT → PAID_UPGRADED` **не создаёт нового пользователя**: полное имя `login@namespace`, root/client/blockchain публичные и приватные ключи, старые публикации, каналы и история блокчейна остаются прежними. Приватные ключи доступны только пользователю и не попадают на сервер. + +**Уточнение по времени:** дата создания Solana PDA при upgrade может быть новой датой on-chain регистрации; дата первоначальной бесплатной регистрации и история Arweave остаются отдельно. Нельзя выдавать новую on-chain дату за дату создания исходного аккаунта или обнулять историю/расход лимитов. + +## А2. Полные логины и пространства имён + +- Каждый пользователь имеет имя `login@namespace` (пример: `alice@shine`, `bob@free`). +- Namespace — реально существующий аккаунт PDA программы `shine_users`, а не hardcoded список в UI. +- Тип `1`: прямая платная регистрация в Solana. +- Тип `2`: первоначальная бесплатная регистрация с сертификатом регистратора; позднее возможна платная регистрация PDA. +- Оба namespace имеют стоимость создания пользовательского PDA. Цена в типе `2` списывается **в момент перехода на Solana**. +- У каждого namespace есть нижняя граница длины части `login`; общая максимальная длина `login@namespace` на этом этапе — 30 байт при ASCII-алфавите. +- Не продавать отдельные короткие логины, не вводить premium-классы. +- Пространства создаются действующей **upgrade authority Solana-программы `shine_users`**, а не отдельной константой DAO. В будущем upgrade authority сможет принадлежать DAO. +- Пока разрешено **создавать**, но не редактировать или удалять namespace. + +## А3. Ключи и пароль + +- Клиент получает root key, blockchain key, client key из своего существующего механизма восстановления по **полному нормализованному логину и паролю**; не придумывать новый KDF. +- При регистрации бесплатного пользователя сервер видит **только три публичных ключа**. +- Приватный ключ **регистратора** — совершенно другой ключ. Пока находится в защищённой конфигурации сервера (вне Git); в будущем замещается аппаратным регистратором. +- Публичный ключ регистратора записывается в PDA бесплатного namespace. +- Нельзя связывать бесплатную регистрацию с хранением пароля или приватных ключей пользователя на сервере. + +## А4. Сертификат и две подписи + +Последовательность данных внутри подписанного ANS-104 DataItem: + +1. Версия сертификата. +2. Полный `login@namespace`. +3. Три публичных ключа (порядок однозначно зафиксировать в протоколе; предлагается `root`, `blockchain`, `client`). +4. **Внутренняя Ed25519-подпись регистратора** только от полей идентичности — версии, полного имени и трёх публичных ключей (плюс протокольный domain separator). +5. SHA-256 от нормализованного email — **после внутренней подписи**, не входит в её сообщение. +6. Весь ANS-104 DataItem, включая поле хеша email и теги, подписывается **внешней подписью ANS-104 тем же ключом регистратора**. + +Внутренняя подпись нужна для последующей проверки в Solana, внешняя — для удостоверения полного DataItem при его импорте. Это **две разные подписи от разных последовательностей байтов**. + +Теги DataItem следует отделять от обычных пользовательских блоков, например существующим `App=test5591` плюс отдельный тег типа `t=reg`; точный набор тегов утвердить в документе протокола, не смешивать с `t=prof|conn|tech`. + +## А5. Email + +- При free-регистрации пользователь вводит email. +- Пока **проверка учебная**, реальная почта не отправляется; правильный код `1111` и это явно сказано в UI. +- В Arweave публикуется **только `SHA256(normalized_email)`**; исходный email не публикуется и не передаётся в Solana. +- Один нормализованный email-хеш должен соответствовать максимум одной бесплатной регистрации в известном реестре SHiNE. +- Пользователь понимает принятое ограничение: простой SHA-256 допускает проверку догадок об email; это не обещание полной анонимности. +- Пока единственный доверенный регистратор; не реализовывать сложную распределённую выдачу/резервирование и защиту от кражи ключа. +- Важная честная оговорка: `1111` доказывает только ввод фиксированного кода, **не подтверждает владение email**. Глобальная уникальность зависит от полноты синхронизации и единственного регистратора; не объявлять это криптографически абсолютной гарантией. + +## А6. Источники идентичности и приоритет + +- Для платных пользователей источником полномочий служит настоящий Solana PDA. +- Для бесплатных — проверенный сертификат Arweave, связанный с PDA бесплатного namespace. +- После upgrade статус меняется **у существующей логической личности**; Arweave-сертификат сохраняется как историческое основание исходной выдачи имени. +- При импорте сертификата всегда проверяется полномочие подписавшего ключа; сам факт хранения в Arweave не делает запись доверенной. +- Если запись уже принята, произвольная другая запись того же логина **не должна её заменять**. Дополнительную модель кражи ключа пока не строить. + +## А7. Сервер доступа и ограничения free + +- До Solana upgrade сервер доступа всех аккаунтов бесплатного namespace задаёт его namespace-PDA. +- Для платного пользователя сервер доступа берётся из собственного PDA v1.2. +- `FREE_CERT` не может менять root, blockchain и client keys; не может менять сервер доступа; не может запускать fork/key rotation, если это меняет ключи. +- Ограничение действует не только в UI, но и в серверных проверках; обязательно найти альтернативные пути соответствующих операций. +- Публикации, каналы, связи, личные сообщения и чтение истории должны работать обычным образом. +- После upgrade смена ключей/сервера работает по существующим правилам Solana. + +## А8. Экономика и управление + +- `init_users_economy_config` остаётся доступной любому подписанту; она инициализирует детерминированные исходные параметры только один раз. +- `update_users_economy_config` вместо постоянной `DAO_AUTHORITY` проверяет **действующую upgrade authority через ProgramData**. +- Стоимость **регистрации** — из соответствующего namespace-PDA; стоимость покупки дополнительных лимитов и иные параметры остаются в economy-PDA. +- При `create_namespace` и каждой новой регистрации economy-PDA присутствует в account metas как read-only для текущего механизма history/poll синхронизации. +- Чтение economy-PDA не обязано генерировать WebSocket account-change notification; для истории продолжает работать `getSignaturesForAddress`/периодический poll. +- Удалить использование promo_seller и shine_login_guard из **новой пользовательской регистрации**, связанные инструкционные ветки `shine_users`, клиентские поля промокодов и premium-проверки. Отдельные legacy-программы без необходимости не удалять. + +## А9. Мгновенный вход после Turbo + +`код 1111 → выпуск подписанного DataItem → успешный ACK Turbo → импорт тех же raw signed bytes локально → пользователь получает доступ`. + +- **Не ждать** высоты блока Arweave для первого входа. +- Другие серверы обнаружат запись позже через Arweave, и это нормально. +- Локально различать `TURBO_ACCEPTED` и `ARWEAVE_CONFIRMED`; не путать приём Turbo с окончательным подтверждением сети. +- При сетевой ошибке или неизвестном результате публикации не терять пользовательские ключи, не создавать бессмысленно новый сертификат и новый DataItem при каждом повторе. + +## А10. Не входит в этот релиз + +Нет реального SMTP, восстановления ключей через email, изменения/удаления namespace, аппаратного регистратора, мультиподписей регистраторов, обработки компрометации его ключа, управления DAO, продажи премиальных имён, автоматической миграции старых Solana PDA/логинов, масштабного редизайна остальных экранов. + +--- + +# Б. КАРТА РЕАЛЬНОГО ИСХОДНОГО КОДА (архив 22.10.2026) + +Эти файлы **существуют** в проверенном архиве. Для новых классов ниже будет явно сказано «создать». + +| Компонент | Существующие точки входа | Что там сейчас / зачем менять | +|---|---|---| +| Solana | `shine-solana/shine/programs/shine_users/src/lib.rs` | instruction dispatcher, `create_user_pda`, `update_user_pda`, Ed25519 precompile, экономика, promo и guard | +| Настройки Solana | `shine-solana/shine/programs/shine_users/src/settings.rs` | `USER_PDA_SEED_PREFIX="user_login="`, старые константы `DAO_AUTHORITY`, guard, promo | +| Документ Solana | `shine-solana/shine/doc/programs/shine_users.md` | контракт, аккаунты, инструкции | +| Документ PDA v1.2 | `shine-solana/shine/doc/formats/shine-user-pda-format-v.1.2.md` | существующий формат полноценного PDA; сохранять | +| Solana UI codec | `shine-UI/js/services/shine-user-pda-service.js` | seed, сериализация, транзакции регистрации, promo | +| Solana UI facade | `shine-UI/js/services/solana-register-service.js` | guard/premium precheck, доступность имени, вызов общего сервиса | +| Адреса программ | `shine-UI/js/solana-programs.js` | реальные program id считывать из актуального окружения | +| Получение ключей | `shine-UI/js/services/auth-service.js` | `derivePasswordKeyBundle(login,password)`; полный login входит в Argon2id/KDF | +| Регистрация UI | `shine-UI/js/pages/register-view.js`, `registration-payment-view.js`, `registration-draft-keys-view.js` | старая платная форма, лимиты длины и promo UI | +| Логин / настройки | `shine-UI/js/pages/login-view.js`, `login-password-view.js`, `settings-view.js`, `key-rotation-view.js` | вход и функции ключей | +| UI router/state | `shine-UI/js/router.js`, `shine-UI/js/state.js` | новые страницы и черновики регистрации | +| Solana sync | `SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/service/SolanaUsersSyncService.java` | историю отслеживает по economy-PDA; snapshot и checkpoint | +| Solana parser | `.../sync/codec/ShineUsersCodec.java` | декодирование инструкций и записей | +| Solana PDA utility | `.../sync/util/SolanaPdaUtil.java` | вычисляет findProgramAddress на Java | +| Solana sync DB | `.../sync/storage/postgres/PostgresStorageRepository.java` | upsert/account snapshot; нужны namespaces и новые статусы | +| База | `SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql` и `migration_v31.sql`, `migration_v32.sql` | baseline и текущие миграции; следующая — новая по порядку, НЕ переписывать прошлые | +| DB login facade | `SHiNE-server/shine-server-db/src/main/java/shine/db/sql/CurrentUsersSql.java` | сейчас возвращает пользователей только из `solana_user_pda_current` | +| DB DAO | `.../shine/db/dao/CurrentUsersDAO.java`, `SolanaUserPdaCurrentDAO.java`, `UserAccessServersCurrentDAO.java` | проверки пользователей, ключей, сервера | +| Авторизация | `SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/` | `SolanaUserPdaImportService`, `Net_ResolveLoginForAuth_Handler`, `Net_CreateAuthSession__Handler` и связанные классы | +| Ротация | `.../handlers/keyRotation/`, `KeyRotationSessionsDAO.java` | запреты для `FREE_CERT` | +| Config | `SHiNE-server/shine-server-config/src/main/java/utils/config/AppConfig.java` | встраивание параметров регистратора без Git-секрета | +| ANS-104 | `SHiNE-server/shine-server-blockchain/src/main/java/blockchain/Ans104DataItem.java` | сериализация, deep-hash, Ed25519 signature verify | +| Turbo | `SHiNE-server/shine-server-archive/src/main/java/server/archive/TurboDataItemUploader.java` | принимает **уже подписанный** DataItem, проверяет и отправляет | +| Arweave import | `SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java` | GraphQL discovery, блоки, фильтр `block.height`; нужен отдельный путь регистрации | +| API dispatch | `SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonHandlerRegistry.java` | подключение новых WS операций | +| Документация API | `docs/API/01_User_Registration_API.md`, `docs/API/09_Operations_Index.md` | новые операции и ошибки: согласовать изменения | +| Документация sync | `docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md`, `deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md` | алгоритм и эксплуатация sync | +| Деплой | `deploy/AGENTS.md`, `deploy/TEST_SERVERS.md`, `docs/Инициализация_Solana_регистрации/README.md` | тестовый контур и порядок инициализации | + +**Подтверждённые особенности кода:** +- В `shine_users` opcode 1 = init economy, 2 = update economy, 3 = create user, 4 = update user, 5 = upsert promo seller, 6 = close legacy. Новым инструкциям назначать непересекающиеся id, зафиксировать их в документации. +- Текущее `create_user_pda` подтверждает root и blockchain через Ed25519 instructions sysvar (разбор относительно текущей инструкции). Дополнительная подпись регистратора потребует тщательно задать расположение этих инструкций. +- Пользовательский PDA v1.2 содержит root, client, forks blockchain key, access servers, а не простую запись «три ключа + имя». +- `solana_user_pda_current` сейчас является центральной таблицей и целью внешних ключей; **нельзя** подделывать наличие on-chain PDA для free. +- В `CurrentUsersSql.usersSubquery` список сейчас берётся только из `solana_user_pda_current`. +- `TurboDataItemUploader.upload` не подписывает DataItem за клиента: raw signed DataItem нужно сформировать до вызова. +- В `ArweaveBlockSyncService` текущая основная выборка пропускает GraphQL-записи без `block.height`; free-registration требует отдельной ветки и немедленного локального пути. +- В `register-view.js` есть временная логика нормализации `<=20` и пропуск `_` для guard. Для новой системы `_` не удалять из идентичности: `a_b` и `ab` не должны внезапно стать одним именем. + +**Читать перед началом:** корневой `AGENTS.md`, `COMMIT_AND_VERSION_RULES.md` и локальные `shine-solana/shine/AGENTS.md`, `SHiNE-server/AGENTS.md`, `shine-UI/AGENTS.md` при работе с соответствующими модулями. Особенно: проект требует отдельного согласования перед **изменением публичного WebSocket API** или **формата существующего блокчейна**. Утверждённая архитектура не отменяет эти рабочие правила. + +--- + +# В. ПРОТОКОЛ V1: ПРЕДЛАГАЕМАЯ ТОЧНАЯ КОНКРЕТИЗАЦИЯ + +**Статус подраздела В:** проект формата для принятия на этапе 1. Дальше его нельзя «чуть изменить в одном месте»; изменение только одновременно в Rust, JS, Java, документах, фикстурах. Здесь изложены технические детали уже согласованного поведения, не новые продуктовые возможности. + +## В1. Канонический login + +- `localPart` и `namespace` — ASCII lowercase, разрешённые символы утвердить по совместимости с кодом; практичный набор: `[a-z0-9_]`, без пробелов, без второго `@`. +- Полное имя: `${localPart}@${namespace}`. +- `normalizedFullLogin` — байты UTF-8 ровно этой lowercase-строки, без пробелов по краям. Для проверки нового аккаунта отклонять неоднозначные формы, не преобразовывать «почти такие же» имена молча. +- Общее ограничение полного имени: 30 **UTF-8 байт** на этой версии; минимальная длина localPart — из namespace PDA, считать байты (ASCII = символы). +- Никогда не отбрасывать `_`, не обрезать строку, не менять namespace после создания. + +## В2. Seed пользовательского PDA + +```text +preimage = UTF8("user_login=" + normalizedFullLogin) +seed32 = SHA256(preimage) // именно 32 СЫРЫХ БАЙТА +userPda = findProgramAddress([seed32], shineUsersProgramId) +``` + +**Не** base58-строку хеша, не hex-строку, не два старых seed. На адрес дополнительно влияет programId и bump стандартного findProgramAddress. Для подписания `create_program_address` программа использует `[seed32, bump]`. + +## В3. Seed namespace PDA + +```text +preimage = UTF8("namespace=" + normalizedNamespace) +seed32 = SHA256(preimage) +namespacePda = findProgramAddress([seed32], shineUsersProgramId) +``` + +Префикс `namespace=` здесь предложен как **окончательная константа v1 после утверждения на этапе 1**; его нельзя менять после первых созданных PDA. + +## В4. Бинарный namespace-PDA + +```text +major u8 // 1 +minor u8 // 0 +namespace_type u8 // 1 paid-direct / 2 free-cert +min_localpart_len u8 +namespace_len u8 // N +namespace u8[N] // lowercase ASCII +registration_fee u64 LE // lamports; и для будущего upgrade free +if namespace_type == 2: + registrar_pubkey u8[32] // Ed25519 + server_login_len u8 // M + server_login u8[M] // полный login@namespace зарегистрированного сервера +``` + +Сериализатор и парсер должны отвергать неизвестные версии/типы, неправильную длину данных, некорректный namespace и подставленный PDA. Если Solana-аккаунт создаётся с дополнительной областью из-за выравнивания/rent, определить однозначную политику padding и её проверку. Для type 1 поля регистратора/сервера отсутствуют, а не заполнены «нулевой фикцией». + +## В5. Внутренняя подпись бесплатного сертификата + +Пример детерминированного массива байтов (предлагается как v1): + +```text +identity_fields = + major:u8 (=1) || minor:u8 (=0) || + full_login_len:u8 || full_login_utf8 || + root_pubkey:32 || blockchain_pubkey:32 || client_pubkey:32 + +inner_message = UTF8("SHiNE_FREE_REG_V1\u0000") || identity_fields +inner_signature64 = Ed25519.sign(registrar_private_key, inner_message) +``` + +- Domain separator убирает риск приравнивания подписи к подписи чужого протокола. +- Контракт должен проверить **байты** `inner_message`, а не локальный JSON/строковую интерпретацию. +- Внешняя ANS-104 подпись использует стандартный `deepHash(...)` и **не заменяет** внутреннюю подпись. +- Тот же публичный ключ регистратора должен быть в namespace PDA и в owner внешнего DataItem. + +## В6. Payload DataItem + +```text +payload = identity_fields || inner_signature64:64 || normalized_email_sha256:32 +``` + +Плюс теги, отделяющие регистрационный DataItem от пользовательского блока. Email внутри `inner_message` отсутствует **осознанно**, по решению владельца проекта. + +**Не включать:** пароль, masterSecret, root/blockchain/client private keys, приватный ключ регистратора, исходный email. + +## В7. Нормализация email + +- `trim` пробелы с краёв. +- Unicode NFC, lowercase без зависимости от локали. +- Не удалять `+tag` и точки: разные почтовые сервисы трактуют их неодинаково. +- `email_hash = SHA256(UTF8(normalizedEmail))`. +- Хеш проверяется по индексу, а не принимается на веру со слов клиента: пока сервер получает email по защищённому каналу, нормализует сам. + +## В8. On-chain Ed25519-инструкции и экономическая транзакция + +Упорядочить инструкции в Solana-транзакции так, чтобы контракт надёжно проверял (а) подпись root над хешем записи пользователя, (б) подпись blockchain над тем же хешем и (в) для type 2 подпись регистратора над `inner_message`. Количество/индексы Ed25519 IX и номера инструкций должны быть зафиксированы в документах **и тестах на отрицательные случаи**. Не делать проверку «подпись где-то есть в транзакции» без проверки конкретного сообщения, ключа и содержания. + +Регистрационную комиссию переводить в существующий `shine_payments` inflow-vault с сохранением текущего расчёта дополнительного лимита. Считывать цену регистрации из namespace, не из economy. Economy PDA участвует read-only и используется для параметров лимитов и истории транзакций. + +--- + +# Г. ВЫПОЛНЕНИЕ: 14 ПОСЛЕДОВАТЕЛЬНЫХ ЭТАПОВ + +Каждый этап начинается с аудита указанных файлов, завершается **сборкой, целевыми тестами, документацией и отчётом**. Завершение одного этапа не равно завершению всего проекта. + +## ЭТАП 0. Подготовить ветку, матрицу зависимостей и базовый тестовый стенд + +**Зачем:** зафиксировать исходное состояние и не выполнять изменения вслепую. + +**Файлы/места:** корень, все `AGENTS.md`, `COMMIT_AND_VERSION_RULES.md`, `deploy/TEST_SERVERS.md`, `shine-solana/shine/`, `SHiNE-server/`, `shine-UI/`. + +**Действия:** +1. Распаковать/клонировать исходник. Зафиксировать commit/архив, рабочую ветку, версии tools, Rust/Anchor/Solana, Java/Gradle, Node, PostgreSQL. +2. Прочитать инструкции по модулям. Разрешения на production **не подразумеваются**. +3. Установить базовые команды сборки/тестов по реальным файлам проекта; выполнить smoke baseline и записать результаты (включая уже существующие ошибки). +4. Найти все вызовы `find_user_pda`, `user_login=`, `getProgramAccounts`, константы 20/8, `shine_login_guard`, `promo_seller`, `registration_fee_lamports`, `solana_user_pda_current`, `resolveLogin`. +5. Выписать все SQL FK на `solana_user_pda_current`, PostgreSQL triggers/views и клиентов `CurrentUsersSql`; отдельным списком — операции, зависящие от real Solana PDA. +6. Создать в ветке `docs/registration-v2/IMPLEMENTATION_STATUS.md` (или отдельный рабочий журнал), заполнять после каждого этапа. + +**Готово, когда:** известны реальные точки редактирования, baseline сборки и правила релиза; основной код пока неизменён. + +## ЭТАП 1. Зафиксировать протоколы и тест-векторы Rust/Java/JS + +**Зависимость:** этап 0. + +**Создать/изменить:** +- `shine-solana/shine/doc/formats/shine-namespace-pda-format-v1.md` (новый). +- `docs/Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md` (новый). +- `shine-solana/shine/doc/programs/shine_users.md` (разделы новых IX и seed). +- Общие тестовые фикстуры по одному логину/ключам/email; место выбрать так, чтобы тесты трёх языков могли читать их. + +**Задачи:** +1. Застолбить все поля форматов, версии, число байт, encoding `u64 LE`, `full login`, запрет неоднозначных имён. +2. Застолбить доменные префиксы seed и внутренней подписи. +3. Зафиксировать структуру подписанного `inner_message` и `ANS-104 payload`, уникальные теги для регистраций. +4. Фиксировать максимумы, ошибка/результат на некорректном типе, парсинге, padding, цене, серверном логине. +5. Подготовить тест-векторы: `alice@shine`, `bob@free`, `_` в имени, минимальная длина, 30-й байт, 31-й байт; один детерминированный email. +6. Записать ожидаемые хеши и PDA **для конкретного program ID теста**. Проверка в Rust/Java/JS обязана давать побайтово одинаковые значения. +7. Зафиксировать как обрабатывается созданная ранее история free пользователя: ключи/блоки неизменны; создание Solana PDA может иметь новую timestamp без сброса логической регистрации. + +**Тесты:** round-trip кодирования; одинаковые хеши; подмена одного ключа ломает внутреннюю подпись; подмена email ломает внешнюю ANS-104 подпись. + +**Готово, когда:** ни исполнитель Solana, ни исполнитель UI не должен выбирать форматы заново. + +## ЭТАП 2. Solana: Namespace PDA и полномочия upgrade authority + +**Зависимость:** этап 1. + +**Изменить:** +- `shine-solana/shine/programs/shine_users/src/lib.rs`; +- `.../settings.rs`; +- `shine-solana/shine/tests/shine.ts` и документацию программы. + +**Задачи:** +1. Добавить типы `NamespaceState`/`CreateNamespaceArgs`, строгий parser/serializer. +2. Добавить **новый opcode** `IX_CREATE_NAMESPACE` без конфликта с текущими 1–6. +3. Проверять правильный PDA из SHA-256 seed `namespace=...`, owner, rent, размер, неповторяемость имени. +4. Проверять владельца `ProgramData`: это ProgramData **конкретной** программы, принадлежащий BPF upgradeable loader, с текущей `upgrade_authority_address`; signer должен совпадать. Если программа immutable — отказ. +5. В `update_users_economy_config` применить ту же проверку ProgramData. Инициализацию economy не менять. +6. В `create_namespace` принять economy-PDA как read-only account meta; проверить его ожидаемый адрес. Цена хранится в namespace. +7. Сделать CLI/скрипт подготовки создания двух test namespaces и независимый декодер. + +**Тесты:** админ создаёт; посторонний не создаёт; чужой/поддельный ProgramData не помогает; тот же namespace повторно отвергается; неверный type/version/данные отвергаются; economy init всё ещё открыт, economy update закрыт. + +**Готово, когда:** два test namespace создаются и читаются в localnet/devnet; **пока не изменять production**. + +## ЭТАП 3. Solana: создание PDA пользователем напрямую и по сертификату + +**Зависимость:** этап 2. + +**Изменить:** `shine_users/src/lib.rs`, `settings.rs`, `shine/tests/shine.ts`, документы формата PDA v1.2 и программы. + +**Задачи:** +1. Во всех местах create/update/close (где нужно) заменить вычисление пользовательского PDA на SHA-256 от **полного** имени, включая `@namespace`. +2. Проверять `(localPart, namespace)`, тип, min local length, max full length 30 байт, правильный namespace-PDA. +3. Оставить бинарный payload существующего PDA пользователя **версии 1.2**, если нет объективной необходимости его менять. +4. Для type 1: проверка доступности имени, root/blockchain подтверждение, создание PDA, комиссия по namespace + лимит из economy. +5. Для type 2: дополнительно требовать внутреннюю подпись регистрирующего ключа над тем же полным именем и **теми же** root/blockchain/client public keys. Ключ проверки брать из on-chain namespace. +6. Передать economy-PDA в account list read-only при любой регистрации; сохранить `shine_payments` inflow-vault. +7. Обновить Ed25519 instruction index: корректно отличать root, blockchain, registrar; отрицательные тесты на путаницу индексов. +8. Удалить из новой регистрации guard CPI, premium-classification, promo seller args/promo IX и связанные комиссии. Старые отдельные Solana-программы не трогать без причины. +9. Для upgrade не допускать повторного Solana PDA, не требовать создания заново пользовательского Arweave блокчейна. +10. Продумать состояние лимитов: бесплатный пользователь мог уже писать и тратить стартовый ресурс — не объявлять оплаченный лимит или баланс «с нуля» без согласования с реальным текущим учётом блоков. Не давать дополнительных стартовых бонусов за сам факт upgrade без явного правила. + +**Тесты:** прямой paid create; free→paid create; цена для разных namespaces; заблокирован type2 без сертификата; неверный регистратор; изменённый client/root/blockchain; чужой namespace; 30 vs 31 байт; повторное создание; корректность PDA; существующий paid update без регрессии. + +**Готово, когда:** новая Solana-программа умеет создавать обе категории PDA и корректно обновлять существующую v1.2 запись. UI можно внедрять позже. + +## ЭТАП 4. Клиентский Solana codec, поиск PDA и bootstrap namespace + +**Зависимость:** этап 3. + +**Изменить:** +- `shine-UI/js/services/shine-user-pda-service.js`; +- `shine-UI/js/services/solana-register-service.js`; +- `shine-UI/js/solana-programs.js` при необходимости; +- `shine-UI/server-ui/` (если инструменты управления серверным аккаунтом используют прежний seed). + +**Задачи:** +1. Добавить JS encode/decode NamespaceState, `deriveNamespacePda()` и `deriveUserPda(fullLogin)`. +2. Удалить `getProgramAccounts`/поиск по старой строке-логину или адаптировать под хеш seed и новый формат. Не предполагать, что seed можно восстановить из PDA без данных. +3. Переделать сериализацию `create_user_pda`, account metas (namespace, economy), fee display, IX order. +4. Для type2 сформировать и подключить Ed25519 ix с **готовой** внутренней подписью сертификата; приватный ключ регистратора в браузер не попадает. +5. Убрать UI service API `promoCode` и premium guard precheck там, где они обслуживают регистрацию. +6. Обновить код **создания серверного аккаунта**, который тоже является user PDA и тоже требует полный `login@namespace`. +7. Создать независимые JS unit tests на PDA, namespace decode, transaction serialization, equality signature message. + +**Готово, когда:** тестовый JS может создать correct paid/free Solana transaction по контракту без рабочего пользовательского экрана. + +## ЭТАП 5. PostgreSQL: единый логический пользователь вместо фиктивного free PDA + +**Зависимость:** этап 1; желательно готов этап 3 для схемы Solana полей. + +**Изменить:** schema/migrations `SHiNE-server/shine-server-db/src/main/resources/postgres/`; `CurrentUsersSql`, `CurrentUsersDAO`, `SolanaUserPdaCurrentDAO`, `UserAccessServersCurrentDAO`, зависимые views/triggers/DAO, отдельные entities. + +**Главный риск:** **текущие FK, stats и queries считают `solana_user_pda_current` полным списком пользователей.** Нельзя просто положить сертификаты в новую таблицу и надеяться, что всё заработает. + +**Предпочтительное решение:** создать каноническую таблицу **логических пользователей**, например `user_identity_current` (название финализировать по реальному SQL), с уникальным `normalized_login` и ключами; оставить `solana_user_pda_current` таблицей **только настоящих** PDA, связанной с логической личностью. Хранить `namespace`, `registration_source`, `registration_status`, `registered_at_ms`, `free_data_item_id`, `solana_pda_address (nullable)` и текущие ключи. В свободном состоянии `solana_pda_address = NULL`, не выдумывать адрес «как будто on-chain аккаунт есть». + +**Задачи:** +1. На основе полного поиска SQL составить список всех FK/views/triggers/запросов и миграционный граф. +2. Создать новую **следующую** миграцию после существующей v32 (номер брать из актуального исходника, если новее). Не переписывать исторические миграции. +3. Добавить таблицу синхронизированных namespaces, таблицу сертификатов (полный signed payload/ID/hash email/внутренняя подпись/публикационный статус) и индексы уникальности. +4. Сформировать общий индекс `user_identity_current`, связать paid/free; изменить зависимости SQL на него там, где нужна любая идентичность, а не именно реальный PDA. +5. Обновить `CurrentUsersSql.usersSubquery()` и соответствующие DAO на общее представление пользователя. В частях, где необходим фактический PDA (rotation, Solana-specific reads), делать явную проверку `has_solana_pda`. +6. Учитывать сервер доступа: `FREE_CERT` → namespace.defaultServerLogin; `PAID_DIRECT`/`PAID_UPGRADED` → account access servers из PDA. +7. Добавить атомарную операцию **upgrade существующего логического аккаунта** без дублирования `login`, ссылок, каналов и связей. +8. Для уже существующих реальных PDA подготовить idempotent backfill в канонический индекс; старая база не должна разрушаться. +9. Добавить интеграционные тесты на restart/re-run migration; FK, статистику, связи, access routing, уникальность. + +**Готово, когда:** тот же логин может существовать как `FREE_CERT` без PDA и затем приобрести настоящий PDA без новой строки логического пользователя. На чистой и обновляемой тестовой базе старые DAO продолжают работать. + +## ЭТАП 6. Java синхронизация Solana: namespaces + новые PDA + события + +**Зависимость:** этапы 3 и 5. + +**Изменить:** +- `SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/service/SolanaUsersSyncService.java`; +- `.../sync/codec/ShineUsersCodec.java`; +- `.../sync/storage/postgres/PostgresStorageRepository.java`; +- `.../sync/util/SolanaPdaUtil.java`; +- `docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md`; +- `deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md`. + +**Задачи:** +1. Кодеки namespace PDA, новой инструкции и нового расчёта seed. +2. History parse: `IX_CREATE_NAMESPACE`, новый `IX_CREATE_USER_PDA` и существующие update. Сохранять `economy PDA` как индекс RPC истории. +3. Snapshot bootstrap должен находить **все актуальные namespace** и **все реальные пользовательские PDA**, а не зависеть только от уже обработанных событий. +4. На каждое подтверждённое создание/обновление делать идемпотентный upsert в реестр, не изменять кэш бесплатного сертификата без проверок. +5. Если пришёл paid upgrade для существующего free логина — обновить ту же логическую личность, а не удалить/recreate. +6. Реализовать корректный checkpoint/retry при RPC timeout, ошибках декодера, дубликатах signature, задержках сети. +7. Сохранять доступ к деталям economy после init/update для прежней модели лимитов. +8. Проверить, что сервер умеет различать `free cert есть`, `Solana PDA ещё нет` и `Solana PDA уже появился`. + +**Готово, когда:** из clean snapshot и из history replay получается одна и та же PostgreSQL-сущность для пользователей и namespaces; upgrade не плодит дубли. + +## ЭТАП 7. Сервер: доверенный регистратор (временная программная заглушка) + +**Зависимость:** этапы 1, 5 и импорт namespace из 6. + +**Изменить/создать:** `SHiNE-server/shine-server-config/src/main/java/utils/config/AppConfig.java`; новый сервис/интерфейс registrar в подходящем Java модуле; unit tests; новый конфигурационный README. + +**Задачи:** +1. Настройки: включено ли бесплатное регистрирование, какие namespace обслуживает сервер, публичный ключ и **путь/secret reference** к приватному ключу регистратора; не хранить ключ в Git или логе. +2. При старте сверять локальный public key с public key **соответствующего** on-chain namespace; при несоответствии блокировать новые выдачи, не ломая работу старых пользователей. +3. Выделить интерфейс `RegistrarSigner.sign(byte[])` и software-реализацию. В будущем можно заменить на hardware signer. +4. Подготовить детерминированный `identity_fields` и `inner_message`; получить внутреннюю Ed25519-подпись. +5. Собрать `payload` и внешнюю ANS-104 подпись тем же keypair; задать отличающиеся от user block теги. +6. Проверять формат имени, min/max длины, неповторяемость известных login/email, тестовый код `1111` и соответствие namespace type2. +7. Не принимать приватные ключи пользователя даже «временно», не хранить пароли. +8. Не вводить сейчас аппаратное устройство и сложный распределённый mutex/компрометацию ключа; достаточно корректного последовательного выполнения обычной выдачи на одном регистраторе. + +**Тесты:** повторяемые фикстуры; правильная внутренняя + внешняя подпись; неверный namespace; отсутствие ключа; несоответствие pubkey; неправильный email code; секреты не появляются в диагностике. + +**Готово, когда:** Java локально выдаёт raw signed ANS-104 bytes с обеими проверяемыми подписями без Turbo и UI. + +## ЭТАП 8. Arweave: отдельный импорт сертификатов и немедленное принятие после Turbo + +**Зависимость:** этапы 5, 6 и 7. + +**Изменить:** `SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java`, `TurboDataItemUploader.java` **переиспользовать**, `Ans104DataItem.java` **переиспользовать**; новая ветка/сервис регистрации и DAO. Не менять формат существующих обычных блоков. + +**Задачи:** +1. Создать **отдельный importer** для `t=reg` DataItem, а не подделывать пользовательский блок. +2. Парсер payload; проверка внешней ANS104 подписи, owner = on-chain registrar pubkey, внутренней Ed25519 подписи, имени, namespace, структурных границ. +3. Проверить уникальность ID DataItem; не дать повторному discovery создать двойника или переписать существующий login. +4. После успешного Turbo upload сразу прогонять **точно те же raw signed bytes** через этот importer в локальную БД. +5. Обновить GraphQL discovery / типовые фильтры, чтобы независимый сервер мог получить `t=reg` и восстановить сертификаты позже. Не ограничиваться существующим фильтром только блоков/высот без учёта регистраций. +6. Хранить `TURBO_ACCEPTED`, последующее подтверждение Arweave, отметки retries, ID и ошибку при необходимости. +7. Idempotent import: immediate → GraphQL повторный импорт должен дать «уже учтено» и сохранить те же ключи/identity. +8. При Turbo timeout/неопределённости не выдавать ложный окончательный успех; предусмотреть проверку известного DataItem ID и повторную отправку идентичных байтов. +9. Сервер B импортирует записи, созданные сервером A, при достижении Arweave и наличии namespace registry. + +**Готово, когда:** подтверждение Turbo даёт первый вход на принимающем сервере без ожидания GraphQL; второй сервер узнаёт пользователя после sync; дубли harmless. + +## ЭТАП 9. Сервер: WS/API операции бесплатной регистрации + +**Зависимость:** этапы 7 и 8. + +**До изменения API:** прочитать `AGENTS.md`, `docs/API/*` и **получить отдельное согласование пользователя на конкретные новые операции/поля** — это правило репозитория, даже когда общая функциональность одобрена. + +**Изменить:** `JsonHandlerRegistry.java`, новые handler/DTO классы в `shine-server-net-protocol`, `docs/API/01_User_Registration_API.md`, `docs/API/09_Operations_Index.md`. + +**Предложение минимального протокола (ИМЕНА ОПЕРАЦИЙ — ПРОЕКТ, не существующий код):** + +| Операция | Ввод | Результат | +|---|---|---| +| `GetNamespaces` | — | список существующих namespace + type/fee/min/server | +| `CheckRegistrationAvailability` | fullLogin, email (для free) | доступен ли login/email; не считать результат резервированием | +| `StartFreeRegistration` | fullLogin, 3 public keys, email | продолжение проверки кода, id временного процесса при необходимости | +| `ConfirmFreeRegistration` | id/данные процесса, code=`1111` | Turbo dataItemId, статус, подтверждённый fullLogin | +| `GetRegistrationStatus` | login или ID операции | `FREE_CERT`, `PAID_DIRECT`, `PAID_UPGRADED`, `PENDING`, ошибка | + +**Задачи:** +1. Выбрать окончательные `op` имена по текущему стилю API, чтобы не ломать существующий клиент. +2. Согласовать поля/ответы/ошибки, зафиксировать в `docs/API/` **до редактирования реализации**. +3. Интегрировать `RegistrarSigner`, Turbo uploader, импортёр и logical identity DAO. +4. Не помещать приватные пользовательские ключи в requests/responses. Не отдавать приватный registrar key. +5. Любую выдачу завершать только после валидного signed DataItem и успешного локального импорта. +6. Возвращать явный статус `Turbo accepted, chain confirmation pending` без обещания финального подтверждения. +7. Сделать обработку ошибочного/отменённого запроса, потерянного ответа и retry. +8. Добавить unit/integration tests handler и документированные errors. + +**Готово, когда:** WS-клиент может пройти free-регистрацию и получить подтверждённую локальную идентичность без UI. + +## ЭТАП 10. Сервер: единая авторизация и реальные ограничения `FREE_CERT` + +**Зависимость:** этапы 5, 8, 9. + +**Изменить:** `.../handlers/auth/{SolanaUserPdaImportService,Net_ResolveLoginForAuth_Handler,Net_CreateAuthSession__Handler}` и соседние обработчики, `CurrentUsersDAO`, `UserAccessServersCurrentDAO`, `.../handlers/keyRotation/`, соответствующие docs/API. + +**Задачи:** +1. Определить единый объект `ResolvedIdentity`: fullLogin, root/client/blockchain public keys, source, status, namespace, accessServer, hasSolanaPda. +2. Разрешить login как через PDA, так и через сертификат; обе ветки выдают общую структуру авторизации, но не одинаковые права. +3. Проверять пароль локально через получение ключей, а серверу предоставлять существующие криптографические proofs; сервер не получает пароль или приватные ключи. +4. До upgrade routing `FREE_CERT` берёт сервер из namespace. После upgrade — из пользовательского PDA. +5. Закрыть все варианты server-side смены ключей, access server и fork rotation для free (искать как прямые обработчики, так и фоновые сервисы/обходные API). +6. Убедиться, что бесплатные могут создавать подписанные блоки, читать/писать в каналах и работать с direct messages как обычные пользователи. +7. Не использовать «наличие строки в solana_user_pda_current» как единственный признак существования человека в общих обработчиках. +8. При upgrade переключать источник полномочий без потери session, graph, messages, user profile, saved files. + +**Готово, когда:** free/paid login и работа с контентом функционируют; попытки обойти ограничения free отвергаются именно сервером. + +## ЭТАП 11. UI: выбор типа регистрации, формы и мгновенный вход + +**Зависимость:** этапы 4, 9 и 10. + +**Изменить:** `shine-UI/js/pages/{register-view,registration-payment-view,registration-draft-keys-view,login-view,settings-view,key-rotation-view}.js`, `js/state.js`, `js/router.js`, `js/services/solana-register-service.js`. При необходимости создать `registration-method-view.js`, `registration-email-view.js` и собственный контролируемый onboarding step. + +**Задачи:** +1. Первый экран: «Через Solana» или «Бесплатно»; UI не диктует namespace из захардкоженных названий. +2. Drop-down подгружает on-chain namespace list, показывает fee/min/type и разрешает выбирать соответствующие способу регистрации. +3. Пользователь вводит localPart и видит `localPart@namespace`; длина проверяется включая суффикс. Старые 20/8 и premium/promo form logic отключить в новой ветке. +4. Локальная генерация keyBundle из **полного имени и пароля**, одинаковая для free/direct paid/последующего входа. +5. Бесплатный flow: public keys + email → экран с текстом «Тест: код 1111; письмо не отправляется» → server-confirm → Turbo ACK → локальный sign-in. +6. Любая ошибка Turbo/сети **не должна заставлять генерировать новые ключи** или терять корректно введённый логин/пароль до понятного завершения процесса; обеспечить осознанную очистку чувствительного UI state. +7. Платный flow использует новую транзакцию, цену namespace и текущую существующую оплату. +8. У free отображается статус, фиксированный access server, ограничения ключей и будущая кнопка перехода в Solana. +9. Сохранить текущую архитектуру UI из `shine-UI/AGENTS.md`: App/Router единственный mount owner, shared components, никакого нового UI-framework. +10. Обновить FAQ, подсказки и ошибки; не обещать, что Arweave окончательно подтвердил запись при одном Turbo ACK. + +**Готово, когда:** новый человек может пройти paid или free регистрацию и войти с обычного экрана без ручных CLI/WS команд. + +## ЭТАП 12. Upgrade UI и end-to-end free → Solana без смены личности + +**Зависимость:** этапы 3, 4, 6, 10, 11. + +**Изменить:** `shine-UI/js/services/shine-user-pda-service.js`, `shine-UI/js/pages/settings-view.js` (или отдельная `registration-upgrade-view.js`), серверный статус identity при Solana sync. + +**Задачи:** +1. Кнопка «Зарегистрировать аккаунт в Solana» видна только `FREE_CERT`. +2. Показать **сумму из namespace type2**, получаемую из Solana, а не старую цену economy. +3. Прочитать сохранённый подписанный сертификат; предъявить **внутреннюю** подпись и идентификационные поля. +4. Использовать существующие три ключа пользователя. Root + blockchain подписывают актуальную запись PDA по правилам Solana; registrar private key не участвует в upgrade. +5. Сформировать новую Solana транзакцию; оплатить PDA и комиссию; дождаться корректного on-chain результата. +6. Синхронизация связывает PDA с **тем же normalized full login**; меняет регистрацию на `PAID_UPGRADED` без новой logical-user строки. +7. Не сбрасывать старые Arweave блоки, used bytes, channel ownership, connections, profile, DM адресацию, session state. +8. В интерфейсе после синхронизации показывать «Зарегистрирован в Solana», разрешать обычную key rotation/access-server operations. +9. Если Solana транзакция упала или UI перезагрузился — пользователь остаётся бесплатным, сертификат и история сохранены, повторная попытка безопасна. + +**Готово, когда:** пользователь Bob создал публикации/канал будучи free, оплатил Solana и затем видит все старые данные теми же ключами и именем. + +## ЭТАП 13. Сквозные тесты, тестовый релиз и выпускная проверка + +**Зависимость:** этапы 0–12. + +**Стенд:** localnet/devnet Solana; отдельная тестовая PostgreSQL; тестовый сервер SHiNE; Turbo (помнить, что публикация может быть реальной и долговечной); второй независимый тестовый сервер. + +**Сценарии приёмки:** +1. `create_namespace(@shine, type1)` и `create_namespace(@free, type2)` выполняет upgrade authority; посторонний отклонён. +2. Economy init разрешён любому, update только upgrade authority. +3. Серверный аккаунт регистрируется полноценным full login и имеет доступный server profile; free namespace ссылается на реально разрешаемый сервер. +4. `alice@shine` direct paid: PDA создан, сумма правильная, вход/профиль/публикации работают. +5. `bob@free`: три пары ключей генерируются локально, код 1111 принят, внутри и снаружи подпись правильная, email hash опубликован без email. +6. Turbo ACK → быстрый локальный импорт → вход Bob **без ожидания Arweave height**. +7. Независимый сервер импортирует Bob через Arweave и распознаёт тот же namespace/identity. +8. Повторный login/email отклоняется, повторный импорт того же DataItem идемпотентен. +9. Подменённый inner signature/root/client/blockchain/namespace/owner не проходит. +10. Bob не может менять ключи/access server до оплаты, включая прямой серверный вызов. +11. Bob создаёт профиль, публикацию, канал, связь и сообщение до Solana PDA. +12. Bob делает платный upgrade с сертификатом. Проверяются адрес PDA, fee, неизменность имени/3 ключей/блоков и отсутствие дублирующего пользователя. +13. После upgrade доступны штатные операции PDA/update/key rotation/access-server (по существующим ограничениям). +14. Перезапуск каждого сервера, новая БД + snapshot, обработка GraphQL повторно, задержка Turbo и Solana RPC не портят данные. +15. Две цены namespace ведут к двум разным корректным платежам. +16. Старые экраны, каналы, ссылки, DM, websocket auth, поиск, статистика и публикации не деградируют. +17. Проверить все места `getProgramAccounts`/PDA derivation; old seed не используется для **новых** регистраций. +18. Фактические сборки и тесты Rust/JS/Java, списки skip/fail, ручной smoke browser. +19. Обновлены документы Solana, DB, sync, API и runbooks. Разрешения на изменение API/формата соблюдены. +20. Все runtime secrets вне Git/logs/browser и test fixtures. Секрет регистратора не возвращается ни одним API. + +**Только после этого:** отдельная подготовка к production, backup и план переключения. Сам факт прохождения devnet **не является разрешением** деплоя на боевой контур. + +--- + +# Д. ОСОБЫЕ ЗАВИСИМОСТИ И СЛОЖНЫЕ УЧАСТКИ + +## Д1. Первоначальное развёртывание — устраняем «курица или яйцо» + +Один бесплатный namespace содержит **полный login сервера доступа**, а сервер сам является user PDA. Поэтому при развёртывании чистого проекта придерживаться порядка: + +1. Deploy тестовой `shine_users`, затем economy init. +2. Upgrade authority создаёт платный namespace, например `@shine`. +3. Создать **платный серверный аккаунт** с полным именем вроде `server@shine`, оформить ServerProfileBlock и адрес сервера. +4. Настроить в тестовом сервере публичный/временный приватный registrar key. +5. Upgrade authority создаёт `@free` type2, указывая public registrar key и **уже зарегистрированный** `server@shine`. +6. Синхронизировать namespaces/server account во всех тестовых серверах; только после этого открывать бесплатную регистрацию. + +Иначе free-пользователи получат несуществующий access-server login и не смогут подключаться. + +## Д2. Данные после перехода free → paid + +Создание Solana PDA — это **изменение статуса идентичности**, не новое начало пользовательского блокчейна. В E2E сравнивать до/после как минимум: fullLogin, 3 ключа, hash последнего блока, количество/ID публикаций, каналов, связей, значение used bytes, доступность DM. Не менять `blockchain_name` произвольно. + +## Д3. Консистентность подписей + +`inner signature` подтверждает только идентичность (имя + 3 публичных ключа), а **не email**. Solana проверяет `inner_message`, а не внешний DataItem и не email hash. Сервер, импортирующий Arweave, проверяет **обе** подписи и наличие email hash. Изменение email hash без нового ANS-104 DataItem изменит внешнюю подпись/ID, но не внутреннюю; это ожидаемое разделение функций. + +## Д4. Синхронизация Solana против Arweave + +Источник on-chain регистрации — Solana PDA. Источник бесплатной регистрации — подписанный Arweave DataItem. Локальная PostgreSQL — **индекс и рабочая проекция**, не третий независимый источник правды. При рестарте восстанавливать один и тот же логический набор. До Arweave confirmation локальная видимость законна после Turbo ACK, но межсерверная не обязана быть мгновенной. + +## Д5. Нельзя оставлять обход для free-ограничений + +Не ограничиваться disabled-кнопками. Free identity должна быть read-only по части **ротируемых прав** во всех server-side обработчиках. Для платного пользователя управление изменениями выполняется через существующий Solana PDA; нужно проверять, что после upgrade не осталось fallback на старый free certificate как источник прав смены ключей. + +## Д6. Legacy программы и история + +В этой версии нет миграции старых коротких Solana логинов. Не удалять старые PDA «для чистоты», не пересоздавать production. Удаление `promo_seller` из новой логики не означает обязательного удаления существующих PDA в блокчейне или программы `shine_login_guard`; это отдельное решение. + +## Д7. Правила, которые не стоит молча менять + +- Цена едина для всех имён одного namespace, нет premium tiers. +- Подпись регистратора не включает email. +- Один физический источник подписи пока программный. +- Код подтверждения строго `1111` и явно маркирован тестовым. +- Namespace creation через upgrade authority, economy-init остаётся открытым. +- Нет исправления угрозы украденного registrar key. +- Не меняются три ключа, логин, пользовательская цепочка при upgrade. +- До upgrade сервер доступа определяется только namespace. + +Если рабочий код требует продукта, меняющего эти правила, **остановиться только по конкретному архитектурному противоречию**, не изобретать новый продукт. Мелкие инженерные вопросы решать в соответствии с протоколом и фиксировать в документации. + +--- + +# Е. ПОШАГОВАЯ МАТРИЦА РЕЗУЛЬТАТОВ + +| № | Выходной артефакт | Не начинать без | Минимальный тест готовности | +|---:|---|---|---| +| 0 | Исходный аудит и status file | Архив/репо | baseline и карта SQL зависимостей | +| 1 | Протокол + fixtures | 0 | одинаковые байты Rust/Java/JS | +| 2 | create namespace + authority | 1 | 2 namespace, чужой signer отклонён | +| 3 | Solana register 2 types | 2 | on-chain create paid/free-upgrade | +| 4 | JS codecs, tx builder | 3 | сериализация, реальные Solana tests | +| 5 | Unified PostgreSQL identity | 1, 3 | free identity без fake PDA | +| 6 | Sync Solana | 3, 5 | snapshot/history = одинаковая БД | +| 7 | Registrar signer stub | 1, 5, 6 | 2 подписи валидны | +| 8 | Arweave registration importer | 5–7 | локально сразу, второй сервер потом | +| 9 | WS free registration API | 7–8 + API approval | успешный WS flow | +| 10 | Auth/free permissions | 5, 8, 9 | login works, rotation blocked | +| 11 | UI registration | 4, 9, 10 | free и paid через браузер | +| 12 | UI upgrade | 3, 4, 6, 10, 11 | free→paid без новых данных | +| 13 | E2E / devnet / release checks | 0–12 | full regression suite | + +**Условие завершения:** одно слово «готово» ничего не означает без доказанных тестов и списка изменённых файлов. + +--- + +# Ж. СТАНДАРТНЫЙ ОТЧЁТ ПОСЛЕ КАЖДОГО ЭТАПА + +В конце каждого этапа исполнитель обязан заполнить текст ниже и сохранить в `docs/registration-v2/IMPLEMENTATION_STATUS.md` (или приложить файл, если исходный репозиторий на этом этапе недоступен): + +```text +SHiNE Registration V2 — журнал выполнения +Дата и время: +Базовая ветка / коммит / архив: +Этап №: +Статус: COMPLETED / PARTIAL / BLOCKED / NOT STARTED + +1. Что было поручено: +2. Что реально изменено (полный список файлов): +3. Новые форматы / op codes / DB migrations / конфиги: +4. Команды сборки и тестов + результаты: +5. Ручная проверка и её фактический результат: +6. Что НЕ сделано или не проверено: +7. Совместимость с уже завершёнными этапами: +8. Обновлённые документы: +9. Коммит(ы) / diff / ссылка на патч: +10. Риски / открытые технические проблемы: +11. Следующий конкретный этап №: +12. Где следующий исполнитель должен начать чтение: +13. Нужны ли дополнительные разрешения по AGENTS.md: + +Запрещено: +- считать partial этап завершённым; +- утверждать, что тесты прошли, если они не запускались; +- раскрывать секреты и реальные приватные ключи; +- деплоить production без согласования; +- менять формат пользовательских блоков незаметно; +- брать новую архитектуру «из головы» вместо этого документа. +``` + +**Контроль перед началом новой сессии:** открыть этот журнал, прочитать решения из раздела А, проверить статус этапов, продолжать с первого незавершённого этапа. Если исходник изменился, сначала обновить карту файлов и тестовые ожидания. + +--- + +# З. КОНЕЧНАЯ ПРИЁМКА ПРОЕКТА + +Работа завершена только если одновременно верно следующее: + +- `[ ]` У каждого аккаунта формат полного логина `login@namespace`. +- `[ ]` Namespace-PDA обоих типов читаются любым сервером/клиентом. +- `[ ]` Namespace создаёт только действующая upgrade authority. +- `[ ]` Update economy контролируется upgrade authority; init economy остался публичным. +- `[ ]` PDA seed использует SHA-256, 32 сырых байта и полное имя. +- `[ ]` У paid direct есть полноценный PDA; цена берётся из namespace. +- `[ ]` Бесплатный DataItem содержит публичные ключи, две подписи и хеш email, но не секреты. +- `[ ]` Сертификат проходит внутреннюю Solana проверку и внешнюю ANS-104 проверку. +- `[ ]` Free user появляется локально после Turbo ACK без ожидания Arweave height. +- `[ ]` Другие серверы догоняют через Arweave sync, не создавая дублей. +- `[ ]` Free user реально входит и пользуется каналами/публикациями/связями/сообщениями. +- `[ ]` У free нельзя сменить ключи или access server через UI и через сервер. +- `[ ]` Free user платит за создание PDA, предъявляет сертификат и получает status paid. +- `[ ]` После upgrade сохраняются логин, три ключа, блокчейн, история, каналы, связи. +- `[ ]` Нет `shine_login_guard`/`promo_seller` в новом registration flow. +- `[ ]` Тестовые ошибочные подписи, суммы, seed, дубли и retry обрабатываются корректно. +- `[ ]` PostgreSQL migration/restart и Solana snapshot/history восстанавливают одинаковую картину. +- `[ ]` Документация соответствует Rust/Java/JS и текущему коду API. +- `[ ]` Тестовый стенд пройден; production не тронут без отдельного разрешения. + +**Финальное правило:** если новая регистрация работает, но пользователь теряет прежние данные при upgrade, **патч не готов**. Сохранение единой личности — центральное требование всей работы. diff --git a/docs/registration-v2/PATCH_STAGES_11_12_13.md b/docs/registration-v2/PATCH_STAGES_11_12_13.md new file mode 100644 index 00000000..40a63949 --- /dev/null +++ b/docs/registration-v2/PATCH_STAGES_11_12_13.md @@ -0,0 +1,42 @@ +# SHiNE — накопительный патч 0–13: дополнения 9, 11–13 + +**База:** `SHiNE-bundle-2026.10.23-12.36.02.zip`; патч включает все изменения 0–10 и последние дополнения. **Дата:** 2026-10-23. **Статус:** тестовый кандидат, NOT PRODUCTION READY. + +## Этап 9 (завершение подключения API — PARTIAL) + +Владелец согласовал шесть новых WS `op`: `GetNamespaces`, `CheckRegistrationLogin`, `CheckRegistrationEmail`, `StartFreeRegistration`, `ConfirmFreeRegistration`, `GetRegistrationStatus`. Проверка имени и email — две независимые операции и два экрана UI. Код интегрирован через Bridge SPI (`shine-server-net-protocol` ↔ `shine-server-archive`), поднимается в `WsServer` без циклической зависимости Gradle. Реестр API и docs/API обновлены. + +- Внутренняя Java-машина заявок сохраняет один подписанный ANS-104 DataItem на challenge, повторное подтверждение до TTL использует те же байты. +- Почтовый код `1111` учебный, факт владения email НЕ подтверждает. +- Код ответа `TURBO_ACCEPTED` отличается от `ARWEAVE_CONFIRMED`. +- Введены базовые ограничения частоты запросов (30 на соединение и 1200 глобально за минуту); не заменяют IP/rate limiting на reverse proxy. +- Debug-логи регистрации редактированы, чтобы не записывать email/публичные ключи и содержимое challenge. +- Если регистратор отключён в конфиге, список namespaces и проверки доступны, выдача сертификатов не работает. + +## Этап 11 — регистрационные экраны (PARTIAL) + +`register-view`: переключатель «Solana / бесплатно», on-chain список namespace через сервер, `login@namespace`, пароль, отдельный запрос доступности имени, исходный KDF Argon2id на полном имени и пароле, сохранение черновика в рамках текущего сеанса. Для платного переход в старую (адаптированную) страницу оплаты. Для бесплатного новая `registration-email-view`: запрос доступности email → временная заявка → код `1111` → Turbo → попытка штатного авто-входа. Ключи генерируются только локально; API передаёт только три публичных ключа в Base64. + +Требуется реальный браузерный E2E: итоговый экран входа и маршрутизация бесплатного пользователя не проверены. + +## Этап 12 — upgrade бесплатного аккаунта в Solana (PARTIAL) + +В настройках у `FREE_CERT` появляется кнопка «Зарегистрировать аккаунт в Solana». Экран запрашивает статус и внутреннюю подпись регистратора, получает цену из реального namespace-PDA Solana, повторно выводит прежние 3 ключа **из того же полного имени и исходного пароля**, проверяет совпадение трёх публичных ключей с сертификатом и использует существующий транзакционный конструктор `upgradeFreeUserOnSolana`. Не создаёт новый логин/ключи/историю; не объявляет upgrade успешным до подтверждения синхронизации PDA. + +Отдельно потребуется тестировать экономику, rent, реальный Solana RPC, состояние пользователя в БД и неизменность контента. + +## Этап 13 — подготовка E2E (PARTIAL) + +`VALIDATION_STAGE_13.md` содержит 20 контрольных требований и порядок стендовой проверки. Добавлены статические контрактные JS тесты. Проведено: + +- `node --test tests/*.test.mjs tests/*.test.cjs` → **28/28 OK** на JS-коде текущего патча. +- `node --check` новых/изменённых JS файлов → OK. +- Изолированный `javac --release 17` для новых API/Java workflow классов со заглушками отсутствующих модулей → OK; это НЕ реальная серверная сборка. +- Полная Gradle-сборка из корня не выполнена: wrapper требует скачать Gradle 8.14, DNS недоступен. +- Rust Solana (cargo/anchor) и PostgreSQL E2E в этом окружении отсутствуют. + +**Критическое исправление:** из трёх существовавших экранов test-topup убран публично встроенный приватный ключ отправителя и автораздача из браузера. Доступно только ручное пополнение из внешнего devnet faucet. Ранее опубликованный тестовый ключ следует считать скомпрометированным. + +## Фактически не проверено / не завершено + +Solana localnet/devnet; миграции PostgreSQL v33/v34 на пустой и существующей базе; реальные Rust/Gradle сборки; двойная подпись + настоящая Turbo публикация, GraphQL discovery на другом сервере, login/profile/channel/DM на FREE_CERT, запись/смена ключей только после upgrade, безопасность и отказоустойчивость перезапуска. До выполнения этих проверок **нельзя использовать патч на production**. diff --git a/docs/registration-v2/PATCH_STAGES_1_2_3.md b/docs/registration-v2/PATCH_STAGES_1_2_3.md new file mode 100644 index 00000000..93caba53 --- /dev/null +++ b/docs/registration-v2/PATCH_STAGES_1_2_3.md @@ -0,0 +1,31 @@ +# Объединённый патч SHiNE — этапы 1, 2 и 3 + +**Исходная база:** этап 0, архив от 23 октября 2026 г. **Ветка отсутствует** (в ZIP нет .git). + +## Содержимое + +- Этап 1: бинарные протоколы namespace/certificate, Rust/Java/JS детерминированные векторы и реальный подписанный тестовый DataItem ANS-104. +- Этап 2: `IX_CREATE_NAMESPACE=7`, сериализация/парсинг namespace 1.0, SHA-256 namespace PDA, authorization через ProgramData, `IX_UPDATE_USERS_ECONOMY_CONFIG` с новой authority, economy read-only. +- Этап 3: новые SHA-256 user PDA для полного `login@namespace`, цена из namespace, проверка `Ed25519` inner certificate для типа 2, прямое платное создание типа 1, обновление v1.2, legacy-update fallback, исключение guard/promo из новой регистрации. + +## Что ещё НЕ доказано и НЕ готово + +- Нет Rust/Solana toolchain в доступном окружении — **Rust программа не собрана и не проверена localnet/devnet**. Изменения в Rust требуют дополнительной компиляции и интеграционных тестов до merge/деплоя. +- В старом браузерном UI, Java Sync и серверной API нет нового формата аргументов и namespace; **платная регистрация с прежним UI станет несовместимой после преждевременного deploy**. Поэтому деплой категорически исключён. +- Нет Solana BPF integration tests транзакций `create_namespace`, `create_user` и upgrade; добавлены код и векторы Rust/JS/Java, но полноценную готовность этапов 2–3 **не утверждаем**. +- Сервер-регистратор, база, email, Turbo, локальный импорт, сохранение уже потраченного лимита и E2E — следующие этапы, не этот патч. +- Формат on-chain `created_at_ms` новой PDA оставлен текущим Solana временем. Реальную первую дату и уже использованный бесплатный бонус нужно сохранить в общем индексе идентичности этапов 5–6; on-chain выдача дополнительного стартового бонуса может потребовать изменения механизма лимитов на следующих этапах до эксплуатации. +- Перед production требуется отдельное согласование релиза и проверка существующего UI/сервера с новой программой. + +## Проверки + +```bash +cd shine-solana/shine +node --test tests/registration-v2-vectors.test.mjs +javac --release 17 -d /tmp/shine-reg-v2 tests/java/RegistrationV2VectorsCheck.java +java -cp /tmp/shine-reg-v2 RegistrationV2VectorsCheck tests/fixtures/registration-v2.properties +cargo test --test registration_v2_vectors # нужен Rust toolchain +cargo build --manifest-path programs/shine_users/Cargo.toml # нужен Rust toolchain +``` + +Дополнительно UI baseline: `node --test shine-UI/tests/*.test.*` из корня. diff --git a/docs/registration-v2/PATCH_STAGES_4_5_6_7.md b/docs/registration-v2/PATCH_STAGES_4_5_6_7.md new file mode 100644 index 00000000..b18016cc --- /dev/null +++ b/docs/registration-v2/PATCH_STAGES_4_5_6_7.md @@ -0,0 +1,40 @@ +# SHiNE — накопительный патч этапов 0–7 (новые изменения 4–7) + +**Основа:** в точности каталог исходников ZIP `SHiNE-registration-stages0-3-combined-2026.10.23.zip`. Без Git/commit, никаких deploy/запросов к production не производилось. Нумерация — 14 этапов из `MASTER_PLAN_V2_2026-10-23.md`. + +## Внесённые изменения + +**Этап 4 / UI Solana codec (код):** `shine-namespace-service.js` с нормализацией, deriveUserPda/deriveNamespacePda, read/list/decode/encode namespace; переписан create-user ix под `[payer,userPda,system,inflow,instructions,economy,namespace]`, с регистраторским `Ed25519 IX`, `root IX`, `blockchain IX`, `create IX` в этом порядке, новый байтовый суффикс option `registrarSignature64`, цены из namespace; `upgradeFreeUserOnSolana` использует уже существующие ключи и исходную подпись. Обновлены PDA reads/updates, сохранены legacy PDA seed для имён без `@`. Старый `precheckLoginClassOnSolana` заблокирован явной ошибкой (не возвращает фальшивый legacy результат), UI-экраны будут переделаны на этапе 10. Создание server-PDA использует тот же общий сервис и теперь тоже требует `login@namespace`. + +**Этап 5 / PostgreSQL (миграция, не применена):** `migration_v33.sql`, таблица `user_identity_current` (с настоящим `solana_pda_address = NULL` у FREE_CERT), `shine_namespace_current`, `free_registration_certificate`, backfill старых PDA, перелинковка FK, триггер `Solana→user identity`, запрет замены трёх ключей при upgrade, обновлённый local-routing по `namespace.default_server_login`, `CurrentUsersSql`, `CurrentUsersDAO.searchDirectory` и `UserAccessServersCurrentDAO`. Новая схема применяется `DatabaseInitializer` после v32; исторические миграции не переписывались. **Требуется PostgreSQL integration test и аудит всех business-DAO перед деплоем.** + +**Этап 6 / Solana Users Sync (код):** `IX_CREATE_NAMESPACE=7` распознаётся в history, бинарный namespace декодируется отдельно, адрес проверяется через `SHA256(namespace=...)`, `SHA256(user_login=...)` для новых пользователей; snapshot и history умеют получать namespace + user, атомарно upsert в PostgreSQL вместе с checkpoint, повторный on-chain snapshot не удаляет free-пользователей; `PostgresStorageRepository.migrate()` больше не перезаписывает функции v33 устаревшими Solana-only. Кодек и PDA проверены на известном векторе Java. Полный RPC/DB history replay **не выполнялся**. + +**Этап 7 / Java registrar (код):** интерфейс `RegistrarSigner`, локальный seed signer с конфигурацией вне Git, бинарный codec, формирование внутреннего Ed25519+внешнего ANS-104 с точными тегами и верификацией, `FreeRegistrationIssuer` проверяет доверенное namespace-PDA из синхронизированного реестра, занятость login/email и тестовый код `1111`. **Пока только выпускает raw signed bytes, не передаёт Turbo и не активирует пользователя** — это этап 8. Отдельный тест `FreeRegistrationCertificateV1Check` сверяет существующий JSON-фиксированный DataItem и отбрасывает искажения. + +## Обязательные проверки, которые реально прошли + +```text +node --test shine-UI/tests/*.test.* 23/23 passed +node --test shine-solana/shine/tests/registration-v2-vectors.test.mjs 6/6 passed +javac + java server.archive.FreeRegistrationCertificateV1Check ... PASS +javac + java sync.codec.NamespaceV2VectorCheck ... PASS +javac (partial) Java codec/repository с offline заглушками зависимостей PASS +node --check JS изменённых модулей PASS +``` + +Заглушки только в `/mnt/data/shine_java_stubs` (не входят в артефакт) для компиляции без Jackson/SLF4J. Это **не заменяет** полноценную сборку Gradle. + +## Что не проверено, почему нельзя включать новую регистрацию в production + +1. `cargo test`, `anchor build`, Solana localnet/devnet, транзакции регистрации и реальный devnet upgrade не запускались; Rust, как в предыдущем патче, пока не прошёл on-chain проверку. +2. PostgreSQL миграция v33 **не исполнялась на настоящем PostgreSQL**; динамическая перелинковка FK и триггеры требуют временной БД и резервной копии. Запускать только в изолированном контуре после одобрения. +3. Java Sync не проходил полноценный Gradle build/RPC/history replay/PostgreSQL integration; компилировались только отдельные части. +4. Java issuer не подключён к жизненному циклу сервера и WS API: без явного согласования проекта новые public operations добавлять нельзя. +5. Free-пользователь пока не активируется после Turbo: нет этапа 8 (импорт), этапа 9 (WS API), этапа 10 (полного UI), этапов 11–13 (E2E/релиз согласно мастер-плану). +6. Начальный бесплатный лимит при upgrade не должен начисляться дважды: Rust-контракт требует дополнительного on-chain решения/теста до включения оплаты. Штатные приватные ключи никогда не должны покидать браузер. +7. Не тестировались PostgreSQL миграционные объекты при одновременной синхронизации и update key rotation. Не включать флаги на действующем сервере. + +## Рекомендованный следующий блок + +Строго этап 8: raw signed DataItem → Turbo upload → **те же bytes** в idempotent локальный verified importer → последующий независимый Arweave discovery. Не менять public WS API до отдельного согласования операции/полей. Затем этап 9 для WS и этап 10 для пользовательских форм. diff --git a/docs/registration-v2/PATCH_STAGES_8_9_10.md b/docs/registration-v2/PATCH_STAGES_8_9_10.md new file mode 100644 index 00000000..8985f0ba --- /dev/null +++ b/docs/registration-v2/PATCH_STAGES_8_9_10.md @@ -0,0 +1,28 @@ +> **Исторический отчёт:** раздел «9 — WS API не включено» относился к состоянию патча 0–10. В накопительном патче 0–13 API включены; см. `PATCH_STAGES_11_12_13.md`. + +# SHiNE — накопительный патч 0–10: изменения 8–10 + +**База:** точный каталог из `SHiNE-registration-stages0-7-CUMULATIVE-2026-10-23.zip`. Архив 0–10 строится поверх него. Не production-ready; он только исходники и документация. Разработчикам по-прежнему нужны localnet Solana, тестовая PostgreSQL и Gradle сборка. + +## 8 — Arweave и Turbo (реализовано частично) +- `VerifiedFreeRegistrationImporter` — новый отдельный путь `t=reg`, отказывается принимать пользовательский BchBlock как сертификат. Проверяет структурный АНS-104, внешнюю Ed25519 и внутреннюю подпись, подписанта из namespace-PDA через реестр, полное имя и минимальную длину, транзакционную уникальность login/email; различает `TURBO_ACCEPTED` и `ARWEAVE_CONFIRMED`; повтор того же сырого DataItem не дублирует личность. +- `FreeRegistrationPublisher` предварительно проверяет сертификат и занятость имени/email до HTTP, затем отправляет уже подписанный DataItem через существующий `TurboDataItemUploader`; только после его успешного ACK вызывает тот же локальный importer. При unknown Turbo outcome не заявляет успех. +- `ArweaveBlockSyncService` распознаёт `t=reg` до обычной block queue, отдельно вычитывает GraphQL `App=test5591 AND t=reg` и хранит собственный checkpoint (`migration_v34.sql`). После появления height независимые серверы импортируют сертификат, повторное обнаружение подтверждает `ARWEAVE_CONFIRMED`. +- **Проверить в реальной сети:** Arweave gateway / GraphQL фильтрация / root-range доступность и работу с несколькими серверами. Нет фактического Turbo upload и PostgreSQL integration; нельзя считать этап завершённым. + +## 9 — WS API (подготовка, публичное API не изменено) +- Внутренний `FreeRegistrationWorkflow`: реестр namespace, precheck, 15-минутный временный challenge, `1111`, однократно сформированные raw bytes, тот же DataItem при повторе, status lookup. +- См. `WS_REGISTRATION_V2_PROPOSED_NOT_ENABLED.md`. По правилу `AGENTS.md` точные имена/поля/ErrorCodes требуют отдельного подтверждения. `JsonHandlerRegistry`, сериализация новых публичных запросов и действующая документация `docs/API/` **не изменены**; обычным WS-клиентом пройти free регистрацию пока нельзя. + +## 10 — единая авторизация и запреты free (частично) +- `RegistrationIdentityDAO.ResolvedIdentity` хранит источник, статус, namespace, root/blockchain/client keys, сервер доступа, `hasSolanaPda` (для FREE_CERT он false). +- `SolanaUserPdaImportService.checkSessionTypeAgainstPda` не пытается получить несуществующий Solana PDA бесплатного пользователя; существующая подпись по clientKey и nonce остаётся обязательной. +- Семь обработчиков процедуры KeyRotation вызывают серверную проверку прав: `FREE_CERT` запрещён вне зависимости от состояния UI. При ошибке БД guard fail-closed. Для upgrade source становится Solana, key rotation продолжает соблюдать прежний Solana порядок. +- Новые ошибки существующих KeyRotation handlers (`KEY_ROTATION_PAID_ONLY=403`, `KEY_ROTATION_IDENTITY_UNAVAILABLE=503`) **нужно согласовать** до вывода этого кода на публичный сервер, согласно правилам API. +- **Не подтверждено:** сквозной login, поток полной истории и DM для free, смена ключей после upgrade, полная проверка альтернативных путей доступа и реальная работа на PostgreSQL. + +## Итоги/ограничения +- Существующие форматы пользовательских блоков не изменены, namespace/certificate — отдельный формат `t=reg`. +- Не записано никаких данных в Solana/Arweave, не сделан deploy или git commit. +- Новый Java код компилируется частично через тестовые локальные заглушки зависимостей; это **не** полная Gradle сборка. +- До production обязательно: Rust+Anchor localnet, Gradle, PostgreSQL v33/v34 миграция и тест отката, GraphQL/Turbo, проверка API, E2E двух серверов и права бесплатного пользователя. diff --git a/docs/registration-v2/REGISTRAR_CONFIGURATION.md b/docs/registration-v2/REGISTRAR_CONFIGURATION.md new file mode 100644 index 00000000..6fd6a1c9 --- /dev/null +++ b/docs/registration-v2/REGISTRAR_CONFIGURATION.md @@ -0,0 +1,15 @@ +# Локальный регистратор SHiNE, этап 7 + +Модуль `shine-server-archive/server.archive.registration` выдаёт **сырой signed ANS-104 DataItem**, но **не публикует** его и **не создаёт пользователя** (это этап 8). В этот патч публичный WS/API не добавлялся. + +## Конфигурация + +- `freeRegistration.enabled=false` по умолчанию. Включается только на тестовом сервере после проверки соответствия namespace. +- `freeRegistration.registrarSeedFile` — абсолютный путь к файлу вне Git, внутри одна Base64-строка **32-byte Ed25519 seed**. Пример имени `/var/lib/shine/secrets/registrar-seed.b64`; не создавать файл с тестовым ключом внутри репозитория. +- `LocalRegistrarSigner.fromConfig(AppConfig)` проверяет enabled и наличие пути, не печатает секрет или bytes в лог. +- Публичный ключ signer должен совпадать с `shine_namespace_current.registrar_pubkey` (из on-chain namespace), иначе `FreeRegistrationIssuer.issue` отказывает. +- В режиме демонстрации код — `1111`. Владение почтой не подтверждается. Регистрация окончательно не активируется до Turbo ACK и проверенного импорта на этапе 8. + +**Безопасность:** на реальном сервере ограничить права файла регистратором/пользователем Java-процесса (0600), не сохранять секрет в stdout, crash reports, Git, backup без шифрования. В будущем заменить реализацию `RegistrarSigner` на аппаратный модуль. + +В `issue()` проверяются текущие известные login/email и namespace; эта проверка сама по себе не резервирует имя. Этап 8 обязан транзакционно повторить проверки и гарантировать уникальность с `UNIQUE` индексами БД. diff --git a/docs/registration-v2/ROADMAP_ORIGINAL_2026-10-23.md b/docs/registration-v2/ROADMAP_ORIGINAL_2026-10-23.md new file mode 100644 index 00000000..ac5248ab --- /dev/null +++ b/docs/registration-v2/ROADMAP_ORIGINAL_2026-10-23.md @@ -0,0 +1,251 @@ +# SHiNE — план поэтапной реализации новой регистрации + +**Версия плана:** 1.0, 23 октября 2026 года +**Исходный код:** `SHiNE-bundle-2026.10.22-12.53.20(1).zip` +**Статус:** планирование; код проекта этим документом НЕ изменён. + +## 0. Конечная цель и неизменяемые договорённости + +Один пользователь имеет глобальную идентичность `login@namespace`. Возможны три жизненных состояния: (а) сразу платно зарегистрирован в Solana; (б) бесплатно зарегистрирован сертификатом в Arweave без пользовательского Solana PDA; (в) тот же бесплатный пользователь, позднее оплативший Solana PDA. При (б) → (в) сохраняются полное имя, три публичных/приватных ключа пользователя (приватные всегда у пользователя), логика доступа и существующая история блокчейна. + +- В Solana создаются PDA двух видов namespace: тип 1 — прямая платная регистрация; тип 2 — сертификат регистратора + последующая платная регистрация. +- В namespace записаны версия (два байта), тип, минимальная длина **части `login`**, название, цена регистрации `u64` lamports; для типа 2 — публичный ключ регистратора и полный логин сервера доступа. +- Общий максимум полного имени `login@namespace` — **30 UTF-8 байт**, пока допускаются ASCII `a-z0-9_` и ровно один символ `@`; это ограничение формата, не семантики PDA seed. Нормализация — единая: ASCII lower-case, без неоднозначного преобразования/усечения. Если требуется иное правило знаков, менять его только одновременно везде. +- PDA пользователя получают seed `SHA256(UTF8("user_login=" + normalized_full_login))` длиной 32 сырых байта. Namespace PDA получает отдельный доменно-разделённый SHA-256 seed; точное значение префикса зафиксировать до создания PDA и больше не менять. +- Создание namespace и изменение `users economy config` может авторизовать **действующая upgrade authority** программы через аккаунт ProgramData; инициализацию economy-PDA по-прежнему разрешено вызывать любому. +- Обновлять или удалять namespace пока нельзя. Старую классификацию `shine_login_guard` и `promo_seller` исключаем из **новой** регистрации. Автоматическая миграция legacy пользователей не требуется; в других программах удалять лишнее без необходимости не нужно. +- Economy-PDA остаётся аккаунтом только для чтения во всех новых Solana-транзакциях регистрации и создания namespace, поскольку его история используется как источник транзакций для синхронизации. Цена регистрации берётся из namespace, а параметры лимитов — из economy. +- Бесплатный сертификат: бинарные версия, полный логин, root/client/blockchain **публичные** ключи, внутренняя Ed25519-подпись регистратора от этих полей, затем SHA-256 нормализованного email. Внешняя подпись ANS-104 DataItem — тем же ключом, но **это другая подпись от другого сообщения**. Email не включён во внутреннюю подпись. Приватные ключи пользователя нигде не публикуются и серверу не передаются. +- Пока email-подтверждение демонстрационное, фиксированный код `1111`; в интерфейсе явно указать «тестовый код, реального подтверждения владения почтой нет». Хеш email в Arweave публичен и может подбираться: это принятое ограничение тестовой схемы. +- Временный ключ регистратора (секрет) читается из конфигурации сервера/переменных окружения вне git. Не писать секрет в репозиторий, открытые настройки UI, журнал или лог. В перспективе интерфейс подписания отделяется на аппаратный регистратор. +- Система не реализует в этом патче защиту от компрометации ключа регистратора и отдельный аппаратный журнал. Однако обязательны проверки обычных подписей/полномочий и запрет перезаписи уже зарегистрированного логина. +- Бесплатным пользователям запрещены смена root/client/blockchain ключей, смена access-server и форки, меняющие ключи. Обычные операции публикации и работы с контентом остаются. +- После Turbo-ответа об успешном приёме сразу запускается **тот же доверенный импорт подписанного DataItem локально**, без ожидания Arweave GraphQL/высоты блока. Принятие Turbo — не тождественно окончательному включению в блокчейн; хранить статус публикации отдельно. + +## 1. Принципы исполнения — для всех этапов + +1. Выполнять **по одному этапу за отдельный патч/сеанс**. Если этап большой, делить на два коммита, не совмещать с соседними этапами. +2. Перед работой сверить рабочую ветку с указанным исходным архивом; если код изменился, провести локальную переоценку затронутых файлов. +3. Никогда не смешивать deploy Solana с деплоем Java/UI. Не трогать production и реальные пользовательские данные без отдельного разрешения. +4. Обновлять документацию вместе с кодом по требованиям `AGENTS.md`, `shine-solana/shine/AGENTS.md`, `SHiNE-server/AGENTS.md`, `shine-UI/AGENTS.md`; правила коммитов — `COMMIT_AND_VERSION_RULES.md`. +5. Там, где меняется публичный серверный WebSocket/API-контракт или формат существующего блокчейна, отдельно перечислить изменения и получить предусмотренное репозиторием подтверждение **перед непосредственной модификацией**. Новый регистрационный DataItem не следует незаметно маскировать под обычный блок. +6. В конце этапа: результаты сборок/тестов, список изменённых файлов, что проверено реально, что ещё не работает, текущий статус следующего этапа. +7. Использовать тестовую сеть Solana и отдельную тестовую PostgreSQL/Arweave-конфигурацию. Настоящие ключи и почту не включать в тестовые фикстуры. + +--- + +## Этап 1. Зафиксировать протоколы и сквозные тест-векторы + +**Задача:** до написания смарт-контракта определить неизменяемый бинарный «контракт» между Rust, JS и Java. + +**Где:** новый документ `shine-solana/shine/doc/formats/shine-namespace-pda-format-v1.md`; документ сертификата `docs/Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md` (или близкое место в существующей структуре); обновить `shine-solana/shine/doc/programs/shine_users.md`, `docs/Solana_Architecture/README.md`, `docs/Инициализация_Solana_регистрации/README.md`. + +**Действия:** +- Точно зафиксировать байтовую раскладку namespace: `[major:u8][minor:u8][type:u8][min_login_len:u8][namespace_len:u8][namespace:utf8][fee:u64 LE][type-2: registrar_pubkey(32), server_login_len:u8, server_login:utf8]` с явными правилами окончания, padding, размером аккаунта, owner и проверкой PDA. При желании разместить `magic` как дополнительное поле, **но сначала выбрать один окончательный формат**. +- Утвердить неизменные доменные префиксы для SHA-256 seed пользователя/namespace и подписи сертификата. Для сертификата использовать бинарное сообщение с версией, длиной логина и тремя `bytes32`, исключающее неоднозначную конкатенацию. Пример префикса: `SHiNE_FREE_REG_V1\0`; реальный префикс и порядок ключей определить только один раз. +- Зафиксировать, что бесплатный `login@free` сохраняет то же имя после Solana-оплаты; тип namespace не изменяется. +- Зафиксировать формат email-нормализации: trim, Unicode NFC, lower-case независимым от локали; **не** удалять точки и `+suffix`, потому что это зависит от провайдера. На всех серверах одна схема. +- Создать общие фикстуры с известными логинами, сырыми seed/hash, правильным и неправильным namespace, правильным/неправильным Ed25519 сертификатом и структурой DataItem. +- Зафиксировать политику начальных лимитов бесплатного пользователя: стартовый бонус из economy-PDA (без платежа), без покупки лимитов до on-chain регистрации либо с уже существующими допустимыми механизмами — не добавлять несанкционированные платежи. + +**Готовность:** один и тот же набор байтов даёт одни и те же SHA-256, PDA, разбирается в Rust/JS/Java по тест-векторам. Документация определяет всё без догадок. + +## Этап 2. Solana: пространства имён и полномочия + +**Где:** `shine-solana/shine/programs/shine_users/src/lib.rs`, `.../src/settings.rs`; тесты в `shine-solana/shine/tests/`; обновить `doc/programs/shine_users.md` и новый документ формата. + +**Действия:** +- Добавить `create_namespace` (новый ID инструкции), код сериализации/десериализации namespace, проверки имени, типа, длины, цены и публичного ключа регистратора. +- Создавать PDA только с рассчитанным адресом, не допускать дублирования; сверять owner программы и SystemProgram, выделять rent-exempt space. +- Реализовать проверку ProgramData/upgrade authority: аккаунт ProgramData обязан соответствовать **именно данной** upgradeable программе; signer обязан совпадать с её текущей upgrade authority. Отказывать, если программа immutable или передан поддельный аккаунт. Никаких «постоянных DAO ключей» в константах. +- Перевести `update_users_economy_config` с `DAO_AUTHORITY` на ту же проверку, не меняя разрешение `init_users_economy_config`. +- Передавать economy-PDA в `create_namespace` (read-only); проверять его корректный адрес. +- Подготовить локальный CLI/скрипт администратора для создания двух тестовых namespace с произвольной ценой и минимальной длиной. + +**Тесты:** владелец создаёт, не-владелец не создаёт, чужой ProgramData не работает, одинаковый namespace второй раз создать невозможно, неправильные бинарные размеры не принимаются, economy-init доступен всем, economy-update — только upgrade authority. + +**Готовность:** в localnet/devnet создаются и читаются два namespace; обычная регистрация пока может оставаться неработающей в промежуточной ветке. + +## Этап 3. Solana: новая платная регистрация и upgrade из бесплатной + +**Где:** `shine-solana/shine/programs/shine_users/src/lib.rs`, `settings.rs`, `shine-solana/shine/tests/shine.ts`; обновить формат PDA 1.2 и программу в `doc/`. + +**Действия:** +- Перевести `find_user_pda` и `create_pda_account` на единственный 32-байтовый хеш seed, полное нормализованное имя, проверки 30 байт и минимальной длины части `login`. +- Обновить `create_user_pda`: передача namespace-PDA, чтение namespace-PDA и economy-PDA, установка комиссии `namespace.fee + цена дополнительных лимитов из economy`. Оставить текущие проверки подписи root и blockchain ключей, строгие записи пользователя v1.2 и оплату в существующий inflow-vault. +- Для namespace типа 1 разрешить прямую регистрацию без сертификата; для типа 2 требовать корректную внутреннюю Ed25519-подпись регистратора на полном имени и трёх **тех же** ключах; ключ регистратора брать **только** из namespace-PDA. Подписи проверять через Instructions Sysvar. +- Не разрешать создание PDA на чужое имя с другими ключами или неподписанным сертификатом. +- Удалить из новой инструкции обращения к `shine_login_guard`, promo seller PDA, промоподписи и код продавцов. Удалить `upsert_promo_seller` и относящуюся к нему новую логику. +- Обновить `update_user_pda` и другие действующие инструкции, вычисляющие адрес по имени; при этом формат пользовательского PDA v1.2 по возможности не менять, меняются условия create и способ адресации. +- **Особо:** существующая Solana-create проверяет `created_at_ms` относительно текущего времени. При upgrade бесплатный блокчейн мог существовать месяцами. Разделить «время создания Solana PDA» и «первое время существующего блокчейна» так, чтобы не обнулять историю и не отклонять старую регистрацию. Не разрешать произвольную фальсификацию исторических данных. + +**Тесты:** namespace1 / namespace2, корректные/искажённые подписи, root/client/blockchain mismatch, точная сумма платежа, 30 байт, неверный namespace, чужой PDA, повторная оплата/создание, существующие update/fork правила, сохранение идентичности после upgrade. + +**Готовность:** оба сценария Solana-перехода проходят в тестовой сети при прямом вызове инструкций (даже если UI/сервер ещё не готовы). + +## Этап 4. JS: общие кодеки и Solana-клиент без UI + +**Где:** `shine-UI/js/services/shine-user-pda-service.js`, `shine-UI/js/services/solana-register-service.js`, `shine-UI/js/solana-programs.js`; возможно новые модули `shine-UI/js/services/shine-namespace-service.js`, `shine-UI/js/services/free-registration-certificate.js`; тесты `shine-UI/tests/`. + +**Действия:** +- Вынести вычисление полного нормализованного имени, seed SHA-256 и PDA в однозначные функции. +- Реализовать декодер namespace, список namespace из RPC (использовать RPC gateway существующего проекта), локальную проверку формы, цены, минимальной длины и типа. +- Переписать платную Solana-транзакцию под новые списки аккаунтов и инструкции; убрать `precheckLoginClassOnSolana`, обращения к `SHINE_LOGIN_GUARD_PROGRAM_ID`, promo параметры. +- Реализовать клиентский конструктор upgrade-транзакции из сертификата с Ed25519 verify instruction и подписями root/blockchain текущего пользователя. +- На клиенте **не генерировать новые пары ключей** при upgrade; использовать существующие ключи и прежний master-secret от **полного** `login@namespace`. +- Сравнивать адрес/стоимость, выведенные локально, с прочитанным namespace-PDA; ошибка чтения — не разрешать платёж вслепую. + +**Тесты:** JS ↔ Rust test vectors, платная транзакция работает с тестовыми программами, отсутствуют вызовы login guard/promo. + +**Готовность:** функции чтения, создания и upgrade доступны UI, но пока могут вызываться тестовыми скриптами. + +## Этап 5. PostgreSQL: единая идентичность и синхронизация Solana + +**Где:** новые миграции в `SHiNE-server/shine-server-db/src/main/resources/postgres/` (текущие миграции до `migration_v32.sql`); `SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/{codec/ShineUsersCodec.java,util/SolanaPdaUtil.java,service/SolanaUsersSyncService.java,storage/postgres/PostgresStorageRepository.java,source/rpc/SolanaRpcClient.java}`; `SHiNE-server/src/main/java/server/sync/SolanaUsersSyncStartupService.java`; документы `docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md`, `deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md`. + +**Действия:** +- **Сначала аудит всех FK/триггеров** к `solana_user_pda_current`: много таблиц, включая связи, пользователей, сообщения и блокчейны, зависят от неё. Нельзя просто добавить отдельную таблицу free-user и ожидать, что приложение их увидит. +- Выбрать и реализовать совместимый **единый индекс идентичностей**. Практичный путь: расширить существующую модель текущих пользователей признаками `registration_source=solana|arweave`, `has_onchain_pda`, идентификатором DataItem и сертификатом; адрес будущего PDA можно вычислить заранее, **но явно отмечать, что аккаунта on-chain ещё нет**, не подделывать слот/подпись транзакции. При необходимости вынести происхождение в отдельную связанную таблицу, чтобы не сломать старые ограничения. +- Создать таблицу namespace (PDA, тип, цена, ключ, server-login, slot/tx), таблицу Arweave сертификатов + hash-email и индексы уникальности; создать соответствующие DAO. +- Дополнить `ShineUsersCodec` инструкциями создания namespace/upgrade и новыми PDA seed; обновить program-account snapshot так, чтобы namespace не распознавался как пользователь. +- Сохранить поиск транзакций по economy-PDA (read-only account в инструкциях). В историю добавить распознавание создания namespace. При полном RPC snapshot восстанавливать и namespace, и on-chain пользователей. +- Не допускать, чтобы **полный Solana snapshot затёр/«понизил»** бесплатные Arweave-аккаунты, и чтобы повторный импорт платной регистрации создал второго пользователя. Переход `arweave → solana` обновляет ту же сущность в одной транзакции БД. +- Обеспечить воспроизводимость: переиндексация Solana + повторный Arweave импорт должны приводить к одному итоговому состоянию. + +**Тесты:** чистая/обновляемая БД, повторный snapshot, повторный сертификат, два пользователя разных namespace, FK на профиль/контент/маршруты, upgrade без смены строки логина, восстановление checkpoint после рестарта. + +**Готовность:** новая PostgreSQL-схема корректно хранит оба источника и namespace; периодическая Solana-синхронизация продолжает работать. + +## Этап 6. Сервер-регистратор и DataItem + +**Где:** `SHiNE-server/shine-server-config/src/main/java/utils/config/AppConfig.java` (чтение параметров); `SHiNE-server/shine-server-blockchain/src/main/java/blockchain/Ans104DataItem.java` (использовать готовый формат); `SHiNE-server/shine-server-archive/src/main/java/server/archive/TurboDataItemUploader.java`; новый отдельный Java-модуль/пакет `server.registration` или `server/archive/registration`; тесты `SHiNE-server/.../src/test/`. + +**Действия:** +- Добавить настройки `freeRegistration.enabled`, `namespace`, публичный ключ регистратора, путь к приватному ключу/защищённый override, опционально тестовый email-код; валидировать, что публичный ключ совпадает с namespace-PDA. +- Сделать интерфейс `FreeRegistrationSigner` с методом подписать регистрационные поля и подписать ANS-104 payload; реализация `LocalKeySigner`, которую позже заменит signer на отдельном устройстве. +- Реализовать бинарный codec сертификата, строгий парсер, проверку ключа, двух подписей и namespace; внутренний Ed25519 подписывает только версию, полное имя и три публичных ключа. Внешняя ANS-104 подпись — весь DataItem с hash-email. +- Кодирующий модуль должен выдавать **точные сырые байты ANS-104 DataItem** плюс ID (а не просто JSON с полями). Публиковать через текущий Turbo uploader с отдельным тегом типа `free_registration`, не маскируя запись под обычный блок. +- Регистратор проверяет перед подписанием текущие локально синхронизированные логины, хеш email, поддерживаемый namespace и подходящий ключ; повторная выдача для уже зарегистрированного имени отклоняется. Это обычная корректность регистрации, а не разработка новой защиты от кражи ключа. +- Код `1111` — только временный сценарий тестирования; UI должен прямо сообщать, что письмо не отправляется. + +**Тесты:** корректный DataItem проходит внешний/внутренний verify, изменение даже одного бита отбрасывается, секрет не попадает в логи/JSON, email не входит во внутреннюю подпись, отсутствие сертификата не заменяется «доверяем JSON». + +**Готовность:** сервер способен подписать и загрузить без UI тестовую бесплатную регистрацию; Turbo возвращает DataItem ID. + +## Этап 7. Arweave discovery, мгновенный импорт и восстановление + +**Где:** `SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java`, очередь/DAO архива в `SHiNE-server/shine-server-db/`, новый импортёр сертификатов, docs Arweave/Blockchain по правилам репозитория. + +**Действия:** +- В существующем `ArweaveBlockSyncService` обычные блоки проходят импорт отдельно: **новые сертификаты — отдельная ветка обработки**, не передавать их в `BchBlockEntry`. +- Реализовать единый `importVerifiedFreeRegistration(rawDataItem, provenance)` для обоих маршрутов: (1) мгновенно после успешного Turbo ответа (2) позже по Arweave discovery/повторному скачиванию. +- Сразу после Turbo ACK импортировать локально **тот же подписанный DataItem** через общий importer; запись в БД — следствие импорта, а не отдельный путь регистрации, создающий пользователя без артефакта Arweave. +- Добавить состояние загрузки `turbo_accepted / arweave_seen / confirmed / failed` (точные значения выбрать в реализации), обеспечив идемпотентность по DataItem ID и нормализованному логину. +- Учесть, что текущий `ArweaveBlockSyncService` пропускает GraphQL узлы без `block.height`: локальная активация не должна зависеть от этого фильтра. На других серверах регистрация видна по мере синхронизации. +- При конкурирующих сертификатах не считать порядок прихода на разные серверы глобальным порядком Arweave. До окончательного подтверждения хранить источник/статус, а при конфликтах использовать единое правило упорядочения подтверждённых записей; при штатной работе без конфликтов это незаметно пользователю. +- После перезапуска сервера очередь должна довосстанавливать сведения, а повторное скачивание не должно порождать дубликаты. + +**Тесты:** instant login до высоты блока, повторный импорт не создаёт копий, GraphQL позже подтверждает, «не блок» не попадает в BchBlock импорт, рестарт, повреждённый DataItem игнорируется. + +**Готовность:** бесплатная регистрация появляется локально почти сразу после принятия Turbo, а на других серверах после discovery. + +## Этап 8. Единая серверная авторизация, маршрутизация и ограничения free-пользователя + +**Где:** `SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/{SolanaUserPdaImportService.java,Net_ResolveLoginForAuth_Handler.java,Net_SessionLogin_Handler.java,Net_CreateAuthSession__Handler.java}`; хендлеры смены ключей в `.../handlers/keyRotation/`; `SHiNE-server/shine-server-db/src/main/java/shine/db/dao/CurrentUsersDAO.java`, `SolanaUserPdaCurrentDAO.java`; маршрутизация `UserAccessServersCurrentDAO`; исходный `docs/API/`. + +**Действия:** +- Сделать общий `ResolvedIdentity`/эквивалент: полное имя, root/client/blockchain ключи, `source`, наличие реального on-chain PDA, namespace и разрешённый сервер доступа. Платные читаются из Solana-синхронизации, бесплатные — из подтверждённого подписанного Arweave сертификата. +- На аутентификации free-user проверять пользователя и текущие ключи через единый индекс; не требовать существования Solana PDA для free. +- Для free получать сервер доступа **из namespace-PDA** (один общий сервер), а не из произвольных настроек клиента. После upgrade — из собственного пользовательского PDA. +- Ограничить серверные операции обновления root/client/blockchain ключей, access-server, форков с ключевой ротацией и связанные обходные пути; UI-блокировки — только дополнение. +- Сохранить публикацию обычных Arweave блоков, создание канала, связи, сообщения и текущую семантику session/login. +- Подготовить новые операции/ответы API: список namespace, проверка имени, старт free-registration, подтверждение кода/публикация, статус операции, статус регистрации пользователя; названия/структуры согласовать перед изменением публичного API согласно `AGENTS.md`. + +**Тесты:** авторизация free/paid, wrong key, восстановление с password→keys, маршрутизация на namespace server, запрещённые key-rotation и access-server для free, действующие операции для paid без регрессии. + +**Готовность:** после публикации free DataItem пользователь действительно входит, читает и публикует; доступ к смене ключей закрыт на сервере. + +## Этап 9. UI: оба вида регистрации и переход free → Solana + +**Где:** `shine-UI/js/pages/{register-view.js,registration-draft-keys-view.js,registration-payment-view.js,login-view.js,settings-view.js,access-keys-view.js,key-rotation-view.js}`; `shine-UI/js/state.js`, `js/router.js`, `js/services/solana-register-service.js`, `js/services/shine-user-pda-service.js`; при необходимости новые страницы `registration-method-view.js`, `registration-email-view.js`, `registration-upgrade-view.js`; стили в `shine-UI/styles/`; docs/API и регистрации. + +**Действия:** +- На первом шаге предложить «Регистрация через Solana» и «Бесплатная регистрация»; показывать только namespace соответствующего типа, загруженные из синхронизированного on-chain реестра. +- Поля логин (часть до `@`), namespace (dropdown), итоговое полное имя, цена в SOL, минимальная/максимальная длина, занятость; убрать premium/promo UI. +- Платный сценарий: генерация ключей от **полного логина**, существующая страница оплаты, новая Solana-транзакция, сохранение ключей и авторизация. +- Бесплатный: локальная генерация тех же трёх ключей → email → тестовый код `1111` → запрос серверу на сертификат+Turbo → локальное принятие → автоматический вход; при сетевой ошибке не перегенерировать ключи и не терять черновик. +- В аккаунте free отображать статус, отсутствие Solana PDA, закреплённый сервер, блокировку ключей и CTA «Зарегистрировать в Solana». Показать реальные lamports/SOL из namespace. +- Upgrade использует существующие локальные приватные ключи; отправляет сертификат (внутреннюю подпись) и оплачивает тот же логин. После подтверждения меняет только статус и разрешения, не создаёт новые ключи и новый блокчейн. +- Удалить все остатки promo code UI, старой проверки premium и guard; обновить FAQ, ошибки, экран входа по полному имени. + +**Тесты:** UI navigation, ввод регистрационных данных, корректное повторное открытие после ошибки, приватные ключи не отправляются на сервер, бесплатный вход почти сразу после Turbo, платный вход после Solana, upgrade без logout/раздвоения личности. + +**Готовность:** все три пользовательских сценария доступны обычному человеку без ручных RPC/CLI вызовов. + +## Этап 10. Сквозное тестирование, релиз на devnet и обратимость + +**Где:** `shine-solana/shine/tests/`, `shine-UI/tests/`, Java unit/integration tests всех модулей, `scripts/devnet/`, `deploy/TEST_SERVERS.md`, `deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md`, документация для операторов. + +**План E2E:** +1. Поднять изолированную PostgreSQL с миграциями и новым синхронизатором; проверить чистый старт и повторный старт. +2. Deploy тестового `shine_users`, инициализация economy от любого подписанта, обновление economy от upgrade authority. +3. Создать платный и бесплатный namespace, проверить чтение из UI и через сервер. +4. Зарегистрировать `alice@shine` напрямую в Solana, проверить PDA v1.2, сумму оплаты, login/session, AddBlock, каналы и сообщения. +5. Зарегистрировать `bob@free` через тестовый код; Turbo ACK → мгновенный локальный вход → Arweave discovery → импорт на другой сервер. +6. Проверить занятость имени/hash-email, неверные подписи, попытки регистрации с другими ключами, попытки сменить ключи и access-server на free. +7. Создать Bob публикацию и канал **до** оплаты; зарегистрировать Bob в Solana с исходными ключами; убедиться, что Arweave история, доступ и идентичность остались прежними. +8. Проверить обновление/форки/смену сервера уже после оплаты, повторный on-chain create запрещён. +9. Проверить восстановление после падения Turbo/Arweave/RPC, возвращение отложенных данных, replay и full snapshot без потери бесплатных пользователей. +10. Протестировать с двумя dev-серверами, учесть отставание peer по Arweave, проверить, что не обещается мгновенная глобальная видимость. +11. Прогнать сборки `cargo test`/Solana-specific tests, Java Gradle modules, Node UI tests, ручной browser smoke-test. +12. Подготовить manifest и инструкции для clean devnet, в том числе program ID, upgrade authority, начальные namespace, соответствие серверного ключа и namespace. + +**Откат:** отдельно для Solana (новые инструкции и PDA необратимы после записи в цепь), для DB (backup + миграционный откат только до появления новых данных), для server/UI (раздельное включение/отключение новой регистрации через feature flag). Отключение выдачи сертификатов не должно блокировать чтение уже созданных бесплатных аккаунтов. Production не обновлять без явного подтверждения. + +**Готовность всего проекта:** все сценарии из пунктов 1–12 прошли в test/devnet, данные не пропадают, двойников нет, старые функции не деградировали, документация и версии совпадают с кодом. + +--- + +## Карта зависимостей + +`1 протоколы → 2 namespace в Solana → 3 платная регистрация в Solana → 4 JS Solana-кодеки` +`1 протоколы → 5 БД и синхронизация → 6 сервер-регистратор → 7 импорт Arweave → 8 единая авторизация` +`4 + 8 → 9 UI → 10 E2E/devnet`. + +Параллельно допустимы только независимые тесты/документы. **Не начинать Этап 9 до рабочего серверного Этапа 8**; не деплоить новый контракт вместе со старым UI/синхронизацией на production. + +## Открытые технические особенности (не требующие новых продуктовых решений) + +- Сейчас `solana_user_pda_current` — корневая таблица многих FK; преобразование модели пользователей — самый рискованный серверный участок. Прежде чем писать миграцию, перечислить все зависимости и тестировать без разрушения старых данных. +- `ArweaveBlockSyncService` сейчас фильтрует записи по `block.height` и импортирует обычные блоки; сертификаты идут другой веткой и локальной немедленной обработкой. +- Текущая Solana-логика create привязывает `created_at_ms` к текущему времени; это обязательно учесть для старых бесплатных блокчейнов на этапе upgrade. +- На разных серверах нельзя считать «в какой последовательности я скачал DataItem» окончательным глобальным порядком. Даже если коллизии выдачи исключены организационно, безопасный импорт обязан проверять подписанта, и не должен заменять уже установленную идентичность произвольной повторной записью. +- Заявление «один email на всю SHiNE» при фиксированном коде `1111` означает уникальность **указанной строки email**, но не подтверждает владение почтовым ящиком. При задержке межсерверной синхронизации невозможно гарантировать идеальную моментальную глобальную блокировку без общего авторитетного регистратора; нынешняя схема предусматривает один регистратор. +- Экономический PDA в read-only accounts сохраняет **поиск через history/signatures**. Одно лишь чтение не обязано порождать account-change notification; периодический poll/snapshot уже существует, и остаётся. +- Проверка upgrade authority требует корректной работы с account `ProgramData`, а не сравнения с исполняемым Program ID и не обычного owner поля PDA. + +## Что сознательно НЕ делаем + +- `update_namespace`, `delete_namespace` и премиальные короткие имена. +- Реальный SMTP/email и восстановление доступа через почту. +- Подключение отдельного аппаратного регистратора; противодействие краже его ключа, выпуск сертификатов несколькими независимыми регистраторами. +- Миграцию старых Solana PDA и старого формата логинов в полном объёме; решается отдельным релизом. +- DAO governance-инструменты и редизайн прочих экранов. + +## Чеклист передачи работы следующему сеансу (обновлять после каждого этапа) + +```text +Текущий этап: ____ / 10 +Текущая ветка/коммит: _________________________ +Что уже сделано: ______________________________ +Файлы изменены: ______________________________ +Обновлённая документация: ____________________ +Тесты (команда → результат): __________________ +Что не готово/не проверено: ____________________ +Нужен ли API/blockchain format approval: ______ +Следующая конкретная задача: __________________ +Что НЕ трогать: реальные ключи, prod без разрешения, + существующие Arweave блоки и чужие сценарии UI. +``` + +**Правило перехода:** следующий этап начинается только после отчёта о предыдущем и зелёных обязательных тестов. Не объявлять весь проект законченным по результату одного этапа. diff --git a/docs/registration-v2/SERVER_PDA_V2_SETUP.md b/docs/registration-v2/SERVER_PDA_V2_SETUP.md new file mode 100644 index 00000000..e83dbc3d --- /dev/null +++ b/docs/registration-v2/SERVER_PDA_V2_SETUP.md @@ -0,0 +1,12 @@ +# Регистрация server@shine — дополнение к патчу 0–13 + +1. Проверьте, что новая `shine_users` развёрнута в **devnet/localnet** и её Program ID согласован с UI и скриптами. Нельзя использовать старую Solana-программу с новым интерфейсом. +2. Проверьте, что `users_economy_config` PDA существует. Повторно инициализировать существующую economy-PDA нельзя. +3. От имени действующей upgrade authority создайте namespace `shine` типа 1. Можно использовать `shine-solana/shine/scripts/registration-v2/create-namespace.mjs` в devnet/localnet после проверки actual Program ID и флагов. Укажите `--namespace shine --type 1 --min-length ... --fee-lamports ... --rpc ... --keypair ... --send`. +4. Откройте `shine-UI/server-ui/create-server-pda.html` из опубликованной тестовой сборки SHiNE (не через `file://`). Укажите тот же Solana RPC, полный логин `server@shine`, серверный адрес (например, `shineup.me`) и пароль либо исходные ключи. Для нового серверного аккаунта `accessServers` можно оставить пустым, если политика проекта позволяет. +5. При генерации ключей используется **полный логин** `server@shine`: смена логина меняет результат KDF. Сохраните master secret/ключи безопасно; не отправляйте их на сервер или в чат. +6. Пополните показанный client/device-адрес для оплаты **rent + регистрационная комиссия из namespace + network fee**; проверка namespace выполняется перед отправкой. Для devnet используйте faucet. Не подставляйте mainnet-ключи в тестовые формы. +7. Зарегистрируйте сервер и проверьте транзакцию, PDA 1.2 с непустым `server_addresses` и запись о сервере в локальной Solana-синхронизации. +8. После этого создайте `free` namespace типа 2, указав полное имя `server@shine` и публичный ключ регистратора; скрипт проверит наличие PDA сервера. Настройте регистратор и серверную БД. + +Ограничения: полная Rust/Java/PostgreSQL/Turbo E2E проверка проекта 0–13 не проведена. Не запускать на production. Админка читает price из namespace, но окончательную сумму rent определяет Solana-транзакция. diff --git a/docs/registration-v2/SOURCE_BASELINE.md b/docs/registration-v2/SOURCE_BASELINE.md new file mode 100644 index 00000000..a1257859 --- /dev/null +++ b/docs/registration-v2/SOURCE_BASELINE.md @@ -0,0 +1,81 @@ +# SHiNE Registration V2 — аудит исходников, этап 0 + +**Дата аудита:** 2026-10-23. **Статус:** инвентаризация выполнена; интеграционные сборки Rust/Gradle/PostgreSQL не подтверждены (ограничения окружения). + +## Исходник и правила + +- Фактический исходник: `SHiNE-bundle-2026.10.23-12.36.02.zip`, SHA-256: `e2871bb11610437c354507dc9a723d64f14b0be4161af5f82d19f1466af648a6`. +- Мастер-план V2 от 23.10.2026 ссылается на архив от **22.10.2026**. Здесь взята более свежая **прикреплённая версия 23.10.2026**. Все ссылки на файлы проверены относительно этого архива; при переходе к другому commit провести повторный diff/аудит. +- Архив **не содержит `.git/`**: исходная ветка, коммит и чистота git-дерева неизвестны. В данном пакете не создан git-коммит, не выполнен push, не объявлена связь с remote-веткой. Для работы в настоящем репозитории нужна отдельная ветка, например `feature/registration-v2`, от **реального** текущего commit. +- Прочитаны обязательные правила: корневой `AGENTS.md`, `COMMIT_AND_VERSION_RULES.md`, `deploy/AGENTS.md`, `deploy/TEST_SERVERS.md`, `shine-solana/shine/AGENTS.md`, `SHiNE-server/AGENTS.md`, `shine-UI/AGENTS.md`. Дополнительные `AGENTS.md` в unrelated ESP32/DM/test-publisher/backup не относятся к редактируемым в этапе 0 областям. +- Код регистрации и действующий API/форматы/миграции **не изменены**. Production, testnet, секреты и реальные базы **не тронуты**. `VERSION.properties` не изменялся, поскольку не было изменений клиентского/серверного кода или git-коммита. + +## Локальные инструменты и честный baseline + +| Компонент | Фактически обнаружено | Результат | +|---|---|---| +| ОС/runtime | Linux, Java 21.0.12.1 | Java runtime есть; Gradle `java.toolchain` просит Java 17 | +| Node.js | v22.16.0, npm 10.9.2 | `node --test shine-UI/tests/*.test.*` — **18 passed / 0 failed** | +| UI parse check | `node --check` на `register-view.js`, `solana-register-service.js`, `shine-user-pda-service.js` | **3/3 успешны** | +| Java isolated | `javac --release 17 -d /tmp/shine_stage0_javac SHiNE-server/shine-server-db/src/main/java/shine/db/sql/CurrentUsersSql.java` | **успешно**, лишь изолированный Java-файл, НЕ сборка сервера | +| Gradle wrapper | `./gradlew --version` | **BLOCKED**: попытка загрузить Gradle 8.14 с `services.gradle.org`, `UnknownHostException`; Gradle не собран | +| Solana/Rust | `rustc`, `cargo`, `anchor`, `solana` отсутствуют | **NOT RUN**: Solana build/test невозможен в данном окружении | +| PostgreSQL | `psql`/Docker не обнаружены | **NOT RUN**: SQL migration/integration тесты не выполнены | +| Git | `/usr/bin/git` имеется, внутри архива нет `.git` | реальные branch/commit неизвестны | + +**Команды для полноценной перепроверки в подготовленной среде:** + +```bash +# Из корня отдельной рабочей ветки репозитория +./gradlew assemble +# Обратите внимание: в корневом build.gradle задача test отключена: +# tasks.named('test') { enabled = false } +# Поэтому ./gradlew test сам по себе не доказывает прохождение тестов сервера. +node --test shine-UI/tests/*.test.* +node --check shine-UI/js/pages/register-view.js +node --check shine-UI/js/services/solana-register-service.js +node --check shine-UI/js/services/shine-user-pda-service.js +cd shine-solana/shine +cargo test -p shine_users +# Специальные Anchor/local validator тесты — по AGENTS.md и тестовым конфигурациям; +# перед запуском убедиться, что тесты не используют реальные кошельки/production. +``` + +Для Java/SQL настоящих интеграционных тестов нужен безопасный локальный или выделенный **тестовый** PostgreSQL и подготовленная JDK17/Gradle инфраструктура. Не запускать деплой в production автоматически. + +## Прямые точки изменений + +| Подсистема | Файлы / исходное состояние | Этапы | +|---|---|---| +| Solana PDA | `shine-solana/shine/programs/shine_users/src/lib.rs`, `settings.rs`: `find_user_pda` строит 2 отдельных seed (`user_login=` и `login`), не SHA256 всей строки; program IX 1–6 | 1–3 | +| Экономика/guard | В `shine_users` есть `DAO_AUTHORITY`, `registration_fee_lamports`, `promo_seller` и CPI к `shine_login_guard`; сменить только новый registration flow согласно плану | 2–3 | +| Пользовательская запись | `shine-solana/shine/doc/formats/shine-user-pda-format-v.1.2.md` — не изменять формат существующей PDA без необходимости | 1–3 | +| UI PDA/transaction | `shine-UI/js/services/shine-user-pda-service.js`, `solana-register-service.js`, `solana-programs.js` — старые seed, promo и guard | 4, 11–12 | +| UI форма | `shine-UI/js/pages/register-view.js`: временная нормализация удаляет `_`, отсекает >20 символов, `MIN_REGISTRATION_LOGIN_LENGTH=8`; менять **одновременно с** полным логином и namespace | 11 | +| UI KDF | `shine-UI/js/services/auth-service.js`: `derivePasswordKeyBundle(login,password)`; после новой регистрации ключи выводить из полного `login@namespace` без изменения KDF | 4, 11–12 | +| Solana sync | `SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/service/SolanaUsersSyncService.java`, `sync/codec/ShineUsersCodec.java`, `sync/util/SolanaPdaUtil.java`, `sync/source/rpc/SolanaRpcClient.java`, `sync/storage/postgres/PostgresStorageRepository.java` | 6 | +| База | `SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql`; миграции через `migration_v32.sql`; `SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java` разрешает текущую версию 32 | 5–6 | +| SQL единый пользователь | `SHiNE-server/shine-server-db/src/main/java/shine/db/sql/CurrentUsersSql.java`: `usersSubquery` строит список **только** из `solana_user_pda_current` | 5, 10 | +| Server auth | `.../handlers/auth/Net_ResolveLoginForAuth_Handler.java`, `Net_CreateAuthSession__Handler.java`, `Net_SessionLogin_Handler.java`, `SolanaUserPdaImportService.java` (проверка сессий ходит в real Solana PDA) | 10 | +| Сервер доступа | `CurrentUsersDAO.java`, `SolanaUserPdaCurrentDAO.java`, `UserAccessServersCurrentDAO.java`, `AuthAccessScopeSupport.java` и SQL-функции refresh | 5, 10 | +| Key rotation | `.../handlers/keyRotation/Net_KeyRotationStart_Handler.java`, `KeyRotationSessionsDAO.java`, операции обновления PDA | 10 | +| Сертификат | `SHiNE-server/shine-server-blockchain/src/main/java/blockchain/Ans104DataItem.java`; `SHiNE-server/shine-server-archive/src/main/java/server/archive/TurboDataItemUploader.java` принимает подписанный DataItem, сам не подписывает | 7 | +| Arweave | `.../server/archive/ArweaveBlockSyncService.java`: обычный импорт зависит от `block.height`; требуется отдельный тип сертификата + локальный импорт по Turbo ACK | 8 | +| WS | `.../JSON/JsonHandlerRegistry.java`, `docs/API/01_User_Registration_API.md`, `docs/API/09_Operations_Index.md` | 9 | + +## Ключевые найденные несовместимости с будущим V2 + +1. **Старый пользовательский PDA seed:** `lib.rs` использует `[b'user_login=', login.as_bytes()]`; новый план использует **один** сырой 32-байтовый SHA256 seed полного логина. Существующие legacy PDA автоматически не мигрируют. +2. **Старый UI:** `register-view.js` удаляет `_`, хотя `a_b` и `ab` должны быть разными пользователями. В Solana нормализация тоже ограничивает длину 20 (`lib.rs`); нельзя менять лишь одну сторону. +3. **Точка поиска Solana PDA в авторизации:** `SolanaUserPdaImportService.fetchRawUserPda` через `getProgramAccounts`/memcmp по offsets 61 и 62. Для нового типа аккаунтов потребуется корректное различение namespace и user PDA и прямые PDA-адреса, а для `FREE_CERT` — отдельный проверенный путь. +4. **Системная SQL-зависимость:** реестр логинов, связи, блоки, статистика, сессии, маршруты и уведомления имеют FK к `solana_user_pda_current`. Простая таблица «free_users» без переноса зависимостей неработоспособна: подробнее в `SQL_DEPENDENCIES.md`. +5. **Маршрутизация:** `shine_refresh_user_access_servers_for_user` (`migration_v16.sql`) читает `solana_user_pda_current` и его `access_servers_json` и ищет сервер только среди on-chain пользователей; для free должен быть server из namespace-PDA без фальшивого on-chain user PDA. +6. **DB миграции:** `DatabaseInitializer` обработал переходы 30→31→32 и требует итоговую 32. Для v33 нужно и отдельную миграцию, и обновление инициализатора, и сценарий как для чистой БД, так и для 32→33. Старые миграции не переписывать. +7. **Лимиты и история:** у бесплатного аккаунта до upgrade мог существовать контент и расход лимитов. Не сбрасывать при создании on-chain PDA; отдельно тестировать старую дату создания blockchain и новую дату Solana PDA. +8. **Необходимы согласования:** изменение публичных WS операций и формата **существующего** пользовательского блокчейна подпадает под `AGENTS.md`. Этап 0 не меняет ни того ни другого. Протокол нового отдельного сертификата разрабатывается на этапе 1 без маскировки под обычный блок. + +## Очерёдность (основной мастер-план V2) + +`0 аудит → 1 протоколы → 2 namespace Solana → 3 create/upgrade Solana → 4 JS-кодеки → 5 identity DB → 6 Solana sync → 7 signer → 8 Arweave importer → 9 WS API → 10 auth → 11 UI registration → 12 UI upgrade → 13 E2E / тестовый релиз`. + +**Состояние на конец этапа 0:** точные файлы и SQL-зависимости найдены, UI smoke прошёл, Java isolate compile прошёл; полный baseline Java/SQL/Solana заблокирован отсутствием дистрибутивов/toolchain и БД. Следующий исполнитель должен повторить заблокированные проверки в dev-среде, прежде чем маркировать этап 0 полностью завершённым. diff --git a/docs/registration-v2/SQL_DEPENDENCIES.md b/docs/registration-v2/SQL_DEPENDENCIES.md new file mode 100644 index 00000000..85bbac66 --- /dev/null +++ b/docs/registration-v2/SQL_DEPENDENCIES.md @@ -0,0 +1,76 @@ +# SHiNE Registration V2 — связи с `solana_user_pda_current` (этап 0) + +**Источник:** `SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql`, текущие SQL-миграции до `migration_v32.sql`; Java исходники архива 23.10.2026. Это **статический** аудит исходников, а не `pg_catalog` реальной БД. Перед этапом 5 обязательно проверить живую тестовую БД через `pg_constraint`/`pg_trigger`/`pg_views`, поскольку baseline + миграции содержат переопределения. + +## Foreign keys, объявленные в текущем `schema_v1.sql` + +| Таблица-зависимость | Ключ таблицы пользователя | Исходная строка `schema_v1.sql` | +|---|---|---:| +| `user_access_servers_current` (два FK: пользователь и сервер) | `login` | 150–151 | +| `active_sessions` | `login` | 369 | +| `esp_pairing_settings` | `login` | 389 | +| `esp_pairing_requests` | `login` | 401 | +| `users_params` | `login` | 422 | +| `user_settings` | `login` | 435 | +| `channel_read_state` | `login` | 453 | +| `test_free_avatar_uploads` | `login` | 482 | +| `blockchain_state` | `login` | 502 | +| `blocks` | `normalized_login` | 518 | +| `connections_state` | `normalized_login` | 590 | +| `user_stats_state` | `login` | 684 | +| `user_push_tokens` | `login` | 745 | +| `user_notifications_state` | `normalized_login` | 856 | +| `key_rotation_sessions` | `login` | 2158 | + +В текущем `schema_v1.sql` явно перечислено **16 FK** в **15 таблицах** на `solana_user_pda_current` (из них один двойной для `user_access_servers_current`). Проверить финальное состояние ограничений в PostgreSQL: в некоторых старых миграциях (`migration_v7`, `migration_v8`) FK накладывались через `ALTER TABLE`, а в `schema_v1.sql` уже представлены встроенными. Не применять миграции вслепую поверх готового baseline. + +Дополнительные места объявления/изменения FK в `migration_v2`, `v7`, `v8`, `v9`, `v10`, `v14`, `v21`, `v26`: оригиналы нужны для трассировки истории схемы и корректной миграции существующих БД; не считать эти объявления отдельными дополнительными активными FK без `pg_catalog`. + +## Функции и триггеры с зависимостью от таблицы + +- `shine_refresh_user_access_servers_for_user`: финальная версия в `migration_v16.sql` (строка 4). Удаляет маршруты и пересчитывает их через `solana_user_pda_current u`, `access_servers_json` и lookup server `s` из той же таблицы. +- `shine_refresh_user_access_servers_for_server`: версия `migration_v16.sql` (строка 64); перечисляет затронутых пользователей в таблице Solana. +- `shine_refresh_user_access_servers_all`: исходная функция `schema_v1.sql` (строка 262) / `migration_v2.sql` (строка 116): массовое обновление маршрутов на основании Solana списка. +- `trg_refresh_user_access_servers_row` и `trg_refresh_user_access_servers_truncate`: подключены к `solana_user_pda_current` в `schema_v1.sql` (строки 313, 319) и `migration_v2.sql` (строки 167, 173), в частности реагируют на обновление/очистку on-chain snapshot. +- `shine_resolve_login`: `schema_v1.sql`, строка 965, выполняет lookup в `solana_user_pda_current` (строка 979). +- `shine_refresh_user_stats`: оригинал `schema_v1.sql`, а переопределение в `migration_v19.sql` (строка 6) проверяет наличие логина в `solana_user_pda_current` (строка 16). Функция повторно менялась в `migration_v31.sql`; перед этапом 5 получить конечное определение из реально инициализированной БД. +- `shine_channel_names_state_stats_ai`: определение `migration_v15.sql` (строка 3) читает `solana_user_pda_current` для логики канала; оценить влияние на free. +- `migration_v5.sql` содержит JOIN на `solana_user_pda_current` для connections. Проверить актуальность этого legacy-прохода на текущем schema baseline. +- `schema_v1.sql` объявляет `CREATE VIEW blockchain_state` и `CREATE VIEW blocks` около строк 2277–2279. Это **исторические/переопределяемые объявления**, не доказательство текущих зависимостей view от Solana. Проверить финальный `pg_views`/`pg_rewrite` до миграции. + +## Вызовы из Java — единая идентичность / Solana-only допущения + +- `shine-server-db/src/main/java/shine/db/sql/CurrentUsersSql.java::usersSubquery()` — источник логинов **только** `solana_user_pda_current`. +- Его потребители: `CurrentUsersDAO`, `ConnectionsStateDAO`, `Net_AddCloseFriend_Handler`, `Net_GetUserConnectionsGraph_Handler`, `Net_GetFriendsLists_Handler`, `ChannelsReadSupport`. +- Прямая зависимость от `SolanaUserPdaCurrentDAO`: `Net_GetMyBlockchain_Handler`, обработчики сессий и ротации через `SolanaUserPdaImportService`, `KeyRotationSessionsDAO`. +- `SolanaUserPdaImportService.fetchRawUserPda` делает `getProgramAccounts`/memcmp и предполагает user PDA; это **не** способ признавать free identity. +- `AuthAccessScopeSupport` опирается на `UserAccessServersCurrentDAO` и на маршруты, созданные из Solana PDA. +- `SolanaUsersSyncService` + `PostgresStorageRepository` создают/перезаписывают snapshots; не допустить, чтобы sync очищал доверенные free-сертификаты или создавал дубль при Solana upgrade. +- `ArweaveBlockSyncService` читает `solana_user_pda_current` и blockchain-данные: восстановление free должно оставаться независимым от факта существования реального Solana PDA. + +## Решение для этапа 5 — пока НЕ принято + +Требование мастер-плана: одна логическая личность для `FREE_CERT` и `PAID_UPGRADED`; при free **нет on-chain PDA**, но сохраняются FK/индексы/функциональность сообщений, каналов, связей и сессий. Не вставлять фиктивный Solana snapshot со slot/signature только ради удовлетворения FK. Выбрать единый identity-index после проверки реальной схемы и протестировать: + +1. создание free до появления в Solana, работа всех 15 зависимых таблиц; +2. транзакционный upgrade без перегенерации root/blockchain/client и без переименования логина; +3. re-sync snapshot Solana и повторный импорт сертификата, отсутствие потерянных FK/двойников; +4. безошибочный sync/route, если namespace server зарегистрирован в Solana, а сам free-user — нет; +5. rollback сценарий **только** для изолированной тестовой БД до появления новых данных. + +Проверки каталога PostgreSQL на этапе 5 (проверить в тестовой копии, не в production): + +```sql +SELECT conrelid::regclass AS dependent_table, + conname, confrelid::regclass AS referenced_table, + pg_get_constraintdef(oid) AS definition +FROM pg_constraint +WHERE contype='f' AND confrelid='solana_user_pda_current'::regclass +ORDER BY 1,2; + +SELECT tgrelid::regclass AS table_name, tgname, + pg_get_triggerdef(oid) AS definition +FROM pg_trigger +WHERE NOT tgisinternal AND tgrelid='solana_user_pda_current'::regclass +ORDER BY 1,2; +``` diff --git a/docs/registration-v2/VALIDATION_STAGE_13.md b/docs/registration-v2/VALIDATION_STAGE_13.md new file mode 100644 index 00000000..aa35c4c4 --- /dev/null +++ b/docs/registration-v2/VALIDATION_STAGE_13.md @@ -0,0 +1,22 @@ +# SHiNE Registration V2 — приёмка на devnet/localnet (этап 13) + +## Проверено локально в этом патче + +- `node --test shine-UI/tests/*.test.mjs` — контракт JS/namespace (результаты записывать по фактическому запуску). +- Проверка синтаксиса новых JS страниц и API — `node --check file.js`. +- ZIP `testzip` и patch application vs исходный архив. + +## Обязательно выполнить на стенде (ещё не выполнено) + +1. `./gradlew :shine-server-net-protocol:compileJava :shine-server-archive:test :shine-server-solana-users-sync:test` с работающим интернетом/cache Gradle. +2. Solana `cargo test`, `anchor test`, local validator: IX7 type1/type2, чужая ProgramData/authority, 32B PDA seed, Ed25519 root/blockchain/registrar и точные суммы. +3. PostgreSQL: чистая БД с v33/v34 и обновление existing до v34; проверить FK, snapshot и сохраняемые связи/каналы. +4. Настроить вне Git registrar 32B seed, Turbo credits, отдельный test namespace type2; API на dev WS. +5. В браузере: `alice@shine` paid → профиль, блоки, каналы; `bob@free` → логин → email → `1111` → Turbo → мгновенная сессия. +6. Два сервера: второй находит ту же запись из Arweave, правильный owner, inner signature, отсутствие дубликатов. +7. У Bob создать сообщения и канал, затем Solana upgrade; сравнить login, три ключа, хеш цепи, число блоков, каналы, used bytes, DM, доступ до/после. Если хоть один отличается — release blocked. +8. Отрицательные тесты: неверные подписи, повтор email/login, потеря WS ответа, Turbo timeout и restart, попытки free key rotation/access-server. +9. `GetRegistrationStatus` не должен возвращать секреты/сырой email; `CheckRegistrationEmail` ограничить на reverse proxy/IP при публичном развертывании. +10. После полного E2E сформировать отчёт с commit/версиями, backup, отдельный Solana deploy и rollout server/UI. Production НЕ менять без разрешения. + +**Release status: NOT READY.** Код — тестовый кандидат, отсутствие ошибок при `node --test` не подтверждает работоспособность всей сети. diff --git a/docs/registration-v2/WS_REGISTRATION_V2_PROPOSED_NOT_ENABLED.md b/docs/registration-v2/WS_REGISTRATION_V2_PROPOSED_NOT_ENABLED.md new file mode 100644 index 00000000..98ba8825 --- /dev/null +++ b/docs/registration-v2/WS_REGISTRATION_V2_PROPOSED_NOT_ENABLED.md @@ -0,0 +1,22 @@ +# Регистрация V2: утверждённый API (23.10.2026) + +**Статус:** код шести новых операций зарегистрирован в `JsonHandlerRegistry` по явному согласованию владельца. Не означает успешную проверку devnet или разрешение на production. + +Общий транспорт: `{"op":"...","requestId":"...","payload":{...}}` и `{"op":"...","requestId":"...","status":200,"ok":true,"payload":{...}}`. + +| op | Поля payload запроса | Поля результата (payload) | Когда нужен | +|---|---|---|---| +| `GetNamespaces` | `{}` | `namespaces:[{name,type,minLocalLength,registrationFeeLamports,defaultServerLogin}]` | первый экран | +| `CheckRegistrationLogin` | `fullLogin` | `loginAvailable,namespaceType,minLocalLength,registrationFeeLamports` | после логина/пароля, до генерации ключей | +| `CheckRegistrationEmail` | `email` | `emailAvailable` | отдельный экран email | +| `StartFreeRegistration` | `fullLogin,rootPublicKeyB64,blockchainPublicKeyB64,clientPublicKeyB64,email` | `challengeId,expiresAtMs` | создание временной заявки | +| `ConfirmFreeRegistration` | `challengeId,code` (учебное `1111`) | `fullLogin,dataItemId,publicationStatus,chainConfirmed:false` | выпуск+Turbo ACK+локальный импорт | +| `GetRegistrationStatus` | `fullLogin` | `registrationStatus,dataItemId,publicationStatus`; для FREE_CERT дополнительно `innerSignature64B64,rootPublicKey,blockchainPublicKey,clientPublicKey,defaultServerLogin` | retry/upgrade | + +`registrationFeeLamports` — строка десятичного целого u64. Публичные ключи запроса — Base64 от ровно 32 байт (не PKCS#8). `innerSignature64B64` — Base64 внутренней подписи Ed25519, публичная информация сертификата; PRIVATE-ключ регистратора никогда не отдаётся. + +**Ошибки:** `REGISTRATION_UNAVAILABLE` 503, `INVALID_REGISTRATION_INPUT` 400, `REGISTRATION_CONFLICT` 409, `RATE_LIMITED` 429, прочие 500 требуют анализа логов без раскрытия секретов. Проверка логина и email *не резервирует* их; перед подписью и перед импортом делается повторная проверка. + +**Ограничения приватности:** публичный boolean `emailAvailable` допускает подбор адресов. Действует глобальный/per-WebSocket счётчик запросов; пересоздание WebSocket может обходить персональную квоту, перед production нужен rate limit на edge по IP/ASN и CAPTCHA, плюс переход с тестового кода на реальное подтверждение email. Учебный код `1111` не означает подтверждения владения адресом. + +**Ограничения надёжности:** challenge и единожды подписанные bytes пока живут в памяти сервера не более 15 минут. Если сервер перезапущен после Turbo ACK, пользователь проверяет `GetRegistrationStatus`, но повтор той же challenge невозможен. Для production нужна долговечная очередь заявок/подписанных артефактов с защитой от повторного выпуска. diff --git a/docs/Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md b/docs/Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md new file mode 100644 index 00000000..d2c90b03 --- /dev/null +++ b/docs/Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md @@ -0,0 +1,35 @@ +# SHiNE — сертификат бесплатной регистрации V1 + +Статус: бинарный протокол для отдельного ANS-104 DataItem `t=reg`; регистрация и импорт Java появятся в последующих этапах. В текущем патче готова Solana-проверка **внутренней** подписи при upgrade, а не выпуск сертификатов сервером. + +## Байты и нормализация + +`full_login` = `localpart@namespace` — **строго ASCII lowercase**, максимум 30 байт, regex `[a-z0-9_]+@[a-z0-9_]+`. Бинарная идентичность: + +```text +identity_fields = major:u8(1) || minor:u8(0) || full_login_len:u8 || full_login:utf8 + || root_pubkey:32 || blockchain_pubkey:32 || client_pubkey:32 +inner_message = UTF8("SHiNE_FREE_REG_V1\0") || identity_fields +inner_signature64 = Ed25519.sign(registrar_private_key, inner_message) +payload = identity_fields || inner_signature64 || email_sha256:32 +``` + +Порядок ключей фиксирован: **root → blockchain → client**. Регистратор не имеет доступа к приватным ключам пользователя. Адрес public key регистратора хранится в namespace-PDA типа 2. Подделка любого байта identity приводит к отказу. + +Нормализация email: удалить пробелы только по краям (`trim`), Unicode NFC, lowercase независимо от locale; **не** удалять `+tag` и точки. `email_sha256=SHA256(UTF8(normalized_email))` публикуется после внутренней подписи, **не входит в `inner_message`**. Это обычный SHA-256, допускающий словарный подбор email; не обеспечивает полной анонимности. В тестовом UI код `1111` и явно сказано, что письма нет и владение email не подтверждается. + +## ANS-104 внешний контейнер + +Подписанный бинарный DataItem типа Ed25519 (`signature_type=2`, `owner=registrar_pubkey`) создаётся **тем же** приватным ключом регистратора через стандартный `deepHash` ANS-104 от всех полей и всего payload. Теги в точном порядке: + +1. `App=test5591` +2. `t=reg` +3. `Protocol=SHiNE-Free-Registration-V1` + +Без target/anchor в V1. Внешняя подпись удостоверяет email hash и теги; ID DataItem = `SHA256(outer_signature64)`. Она НЕ равна внутренней, поскольку подписаны разные сообщения. Проверка внешней подписи обязательна при импорте (включая Turbo ACK), хотя Solana при upgrade проверяет только inner signature по публичному ключу из namespace-PDA. Сервер должен отвергать конфликт имени/hash-email и не заменять принятую идентичность иной записью. + +`FREE_CERT → PAID_UPGRADED`: при Solana-create повторно предъявляется **та же внутренняя подпись**, созданная для тех же `login`, root, blockchain, client. Клиент не должен генерировать новые ключи. `created_at_ms` новой PDA — время регистрации в Solana, первоначальная дата, история и потраченные лимиты остаются в Arweave/БД; нельзя начислить дважды бесплатный бонус. Solana программа не проверяет наличие публикации ANS-104; её проверяет доверенный сервер. Детали защиты от смены ключа регистратора в этой версии не реализуются. + +## Тестирование + +Детерминированные фикстуры: `shine-solana/shine/tests/fixtures/registration-v2.json` (в том числе полноценный signed ANS-104 DataItem, его ID, hex подписи, отрицательные тесты изменения email и тегов). Векторные ключи предназначены только для тестов. Java-подписание и проверка сертификата присутствуют в этапе 7; загрузка через Turbo и доверенный импорт — этап 8. diff --git a/shine-UI/js/app.js b/shine-UI/js/app.js index 84b0e1c1..d07c47ad 100644 --- a/shine-UI/js/app.js +++ b/shine-UI/js/app.js @@ -63,7 +63,9 @@ import { setSolanaCluster } from './services/solana-rpc-gateway.js'; import * as startView from './pages/start-view.js?v=202610072303'; import * as entrySettingsView from './pages/entry-settings-view.js?v=202609260900'; -import * as registerView from './pages/register-view.js?v=202609260900'; +import * as registerView from './pages/register-view.js?v=202610231'; +import * as registrationEmailView from './pages/registration-email-view.js'; +import * as registrationUpgradeView from './pages/registration-upgrade-view.js'; import * as registrationFaqView from './pages/registration-faq-view.js?v=202610072303'; import * as registrationPaymentView from './pages/registration-payment-view.js?v=202606180940'; import * as registrationDraftKeysView from './pages/registration-draft-keys-view.js'; @@ -145,6 +147,8 @@ const routes = { 'start-view': startView, 'entry-settings-view': entrySettingsView, 'register-view': registerView, + 'registration-email-view': registrationEmailView, + 'registration-upgrade-view': registrationUpgradeView, 'registration-faq-view': registrationFaqView, 'registration-payment-view': registrationPaymentView, 'registration-draft-keys-view': registrationDraftKeysView, diff --git a/shine-UI/js/pages/devnet-topup-view.js b/shine-UI/js/pages/devnet-topup-view.js index 88e905a9..c1e5993e 100644 --- a/shine-UI/js/pages/devnet-topup-view.js +++ b/shine-UI/js/pages/devnet-topup-view.js @@ -1,197 +1,28 @@ import { createTopBar } from '../components/topbar.js'; -import { formatSol, getBalanceSol, transferSol, createSolanaWalletFromPrivateBase58 } from '../services/solana-wallet-service.js'; - -export const pageMeta = { id: 'devnet-topup-view', title: 'Пополнение DEVNET', showAppChrome: false }; - -const DEVNET_ENDPOINT = 'https://api.devnet.solana.com'; -const SENDER_PRIVATE_32_BASE58 = '6xqAuKYvA8qrCdAkcw7Y8aMgvBnYk8JLxWLma5BzbAvu'; -const TRANSFER_AMOUNT_SOL = 0.02; +import { formatSol, getBalanceSol } from '../services/solana-wallet-service.js'; +export const pageMeta = {id:'devnet-topup-view', title:'Пополнение DEVNET', showAppChrome:false}; +const DEVNET_ENDPOINT='https://api.devnet.solana.com'; function readWalletFromUrl() { - try { - const url = new URL(window.location.href); - return String(url.searchParams.get('wallet') || '').trim(); - } catch { - return ''; - } + try { return new URL(window.location.href).searchParams.get('wallet')?.trim() || ''; } + catch { return ''; } } - export function render() { - const screen = document.createElement('section'); - screen.className = 'stack'; - screen.style.width = '100%'; - screen.style.justifyItems = 'center'; - - const targetWallet = readWalletFromUrl(); - - const senderBox = document.createElement('div'); - senderBox.className = 'card stack'; - senderBox.style.width = 'min(100%, 320px)'; - senderBox.innerHTML = ` - Тестовый DEVNET-кошелёк -

Адрес: ...

-

Баланс: ...

- `; - - const targetBox = document.createElement('div'); - targetBox.className = 'card stack'; - targetBox.style.width = 'min(100%, 320px)'; - targetBox.innerHTML = ` - Кошелёк получателя -

${targetWallet || 'Не передан параметр wallet'}

-

Сумма перевода: ${TRANSFER_AMOUNT_SOL} SOL

-

Баланс: ...

- `; - - const status = document.createElement('p'); - status.className = 'meta-muted'; - status.style.width = 'min(100%, 320px)'; - status.style.overflowWrap = 'anywhere'; - status.style.wordBreak = 'break-word'; - status.style.whiteSpace = 'pre-wrap'; - status.textContent = `Готово к пополнению.\nСеть: DEVNET (${DEVNET_ENDPOINT})`; - - const amountHint = document.createElement('p'); - amountHint.style.width = 'min(100%, 320px)'; - amountHint.style.display = 'none'; - amountHint.style.margin = '0'; - amountHint.style.fontSize = '22px'; - amountHint.style.fontWeight = '800'; - amountHint.style.lineHeight = '1.25'; - amountHint.style.color = 'var(--success)'; - amountHint.style.textAlign = 'center'; - amountHint.textContent = ''; - - const balanceHint = document.createElement('p'); - balanceHint.className = 'meta-muted'; - balanceHint.style.width = 'min(100%, 320px)'; - balanceHint.style.display = 'none'; - balanceHint.style.margin = '0'; - balanceHint.style.textAlign = 'center'; - balanceHint.style.fontSize = '14px'; - balanceHint.style.color = 'var(--text-primary)'; - balanceHint.textContent = ''; - - const closeHint = document.createElement('p'); - closeHint.style.width = 'min(100%, 320px)'; - closeHint.style.display = 'none'; - closeHint.style.margin = '0'; - closeHint.style.fontSize = '26px'; - closeHint.style.fontWeight = '800'; - closeHint.style.lineHeight = '1.25'; - closeHint.style.color = 'var(--success)'; - closeHint.style.textAlign = 'center'; - closeHint.textContent = 'Можете закрыть эту страницу и продолжить регистрацию.'; - - const fillBtn = document.createElement('button'); - fillBtn.className = 'primary-btn'; - fillBtn.type = 'button'; - fillBtn.textContent = `Пополнить на ${TRANSFER_AMOUNT_SOL} SOL`; - - const actions = document.createElement('div'); - actions.className = 'auth-footer-actions'; - actions.style.width = 'min(100%, 320px)'; - actions.style.justifySelf = 'center'; - actions.append(fillBtn); - - let senderAddress = ''; - let senderKeypair = null; - - const updateSenderBalance = async () => { - if (!senderAddress) return; - const balance = await getBalanceSol({ endpoint: DEVNET_ENDPOINT, address: senderAddress }); - const senderBalanceEl = senderBox.querySelector('#devnet-topup-sender-balance'); - if (senderBalanceEl) senderBalanceEl.textContent = `Баланс: ${formatSol(balance.sol, 6)} SOL`; - }; - - const updateTargetBalance = async () => { - if (!targetWallet) return null; - const balance = await getBalanceSol({ endpoint: DEVNET_ENDPOINT, address: targetWallet }); - const targetBalanceEl = targetBox.querySelector('#devnet-topup-target-balance'); - if (targetBalanceEl) targetBalanceEl.textContent = `Баланс: ${formatSol(balance.sol, 6)} SOL`; - return balance.sol; - }; - - fillBtn.addEventListener('click', async () => { - if (!targetWallet) { - status.textContent = 'Ошибка: в URL не передан параметр wallet.'; - return; - } - if (!senderKeypair) { - status.textContent = 'Ошибка: кошелёк отправителя не инициализирован.'; - return; - } - - fillBtn.disabled = true; - status.textContent = 'Отправляем перевод...'; - amountHint.style.display = 'none'; - balanceHint.style.display = 'none'; - closeHint.style.display = 'none'; - - try { - const tx = await transferSol({ - endpoint: DEVNET_ENDPOINT, - fromKeypair: senderKeypair, - toAddress: targetWallet, - amountSol: TRANSFER_AMOUNT_SOL, - }); - await updateSenderBalance(); - const targetBalanceSol = await updateTargetBalance(); - status.textContent = `Транзакция прошла.\nSignature: ${tx.signature}`; - status.style.fontSize = '13px'; - status.style.fontWeight = '500'; - status.style.color = 'var(--text-secondary)'; - fillBtn.style.display = 'none'; - actions.style.display = 'none'; - amountHint.style.display = ''; - amountHint.textContent = `Кошелёк пополнен на ${TRANSFER_AMOUNT_SOL} SOL`; - balanceHint.style.display = ''; - balanceHint.textContent = `Новый баланс: ${formatSol(targetBalanceSol || 0, 6)} SOL`; - closeHint.style.display = ''; - } catch (error) { - status.textContent = `Ошибка перевода: ${error?.message || 'unknown'}`; - status.style.fontSize = ''; - status.style.fontWeight = ''; - status.style.color = ''; - amountHint.style.display = 'none'; - balanceHint.style.display = 'none'; - closeHint.style.display = 'none'; - } finally { - fillBtn.disabled = false; - } - }); - - (async () => { - try { - const sender = await createSolanaWalletFromPrivateBase58(SENDER_PRIVATE_32_BASE58); - senderAddress = sender.address; - senderKeypair = sender.keypair; - const senderAddressEl = senderBox.querySelector('#devnet-topup-sender-address'); - if (senderAddressEl) senderAddressEl.textContent = `Адрес: ${senderAddress}`; - await updateSenderBalance(); - await updateTargetBalance(); - if (!targetWallet) { - fillBtn.disabled = true; - status.textContent = 'Передайте адрес получателя в параметре wallet.'; - } - } catch (error) { - fillBtn.disabled = true; - status.textContent = `Ошибка инициализации отправителя: ${error?.message || 'unknown'}`; - } - })(); - - screen.append( - createTopBar({ - title: 'DEVNET пополнение', - }), - senderBox, - targetBox, - status, - amountHint, - balanceHint, - closeHint, - actions, - ); - + const screen=document.createElement('section');screen.className='stack registration-screen'; + const card=document.createElement('div');card.className='card stack'; + const title=document.createElement('h3');title.textContent='Пополнение DEVNET'; + const note=document.createElement('p');note.className='meta-muted'; + note.textContent='Автоматическое пополнение из браузера отключено: приватный ключ отправителя нельзя публиковать в приложении. Используйте внешний доверенный Solana devnet faucet.'; + const wallet=readWalletFromUrl(); + const input=document.createElement('input');input.className='input';input.readOnly=true;input.value=wallet; + const copy=document.createElement('button');copy.className='secondary-btn';copy.textContent='Скопировать адрес'; + copy.addEventListener('click',()=>navigator.clipboard.writeText(input.value).catch(()=>{})); + const balance=document.createElement('p');balance.className='meta-muted'; + balance.textContent=wallet?'Проверяем баланс…':'Не передан параметр wallet'; + if(wallet)void getBalanceSol({endpoint:DEVNET_ENDPOINT,address:wallet}) + .then(value=>balance.textContent=`Баланс: ${formatSol(value.sol,6)} SOL`) + .catch(()=>balance.textContent='Баланс недоступен; проверьте адрес и сеть'); + card.append(title,note,input,copy,balance); + screen.append(createTopBar({title:'Пополнение DEVNET'}),card); return screen; } diff --git a/shine-UI/js/pages/register-view.js b/shine-UI/js/pages/register-view.js index 47acd135..81071645 100644 --- a/shine-UI/js/pages/register-view.js +++ b/shine-UI/js/pages/register-view.js @@ -1,427 +1,86 @@ import { createTopBar } from '../components/topbar.js'; -import { iconHtml } from '../components/ui-icon.js'; import { authService, clearAuthMessages, resetRegistrationFlow, state } from '../state.js'; -import { toUserMessage } from '../services/ui-error-texts.js'; -import { - checkLoginExistsOnSolana, - formatSolanaErrorDetails, - isSolanaRpcUnavailableError, - precheckLoginClassOnSolana, -} from '../services/solana-register-service.js'; -import { - emptyPasswordWords, - PASSWORD_MAX_LENGTH, -} from '../services/password-words.js'; -import { openRegistrationFaq } from './registration-faq-view.js'; +import { PASSWORD_MAX_LENGTH } from '../services/password-words.js'; +import { getRegistrationNamespaces, checkRegistrationLogin } from '../services/registration-v2-api.js'; +import { normalizeFullLogin } from '../services/shine-namespace-service.js'; export const pageMeta = { id: 'register-view', title: 'Регистрация', showAppChrome: false }; -const MIN_REGISTRATION_LOGIN_LENGTH = 8; - -function normalizeLoginForTemporaryUiGuard(login) { - const source = String(login || '').trim(); - if (!source || source.length > 20) return null; - let normalized = ''; - for (const ch of source) { - if (ch === '_') continue; - if (!/[0-9A-Za-z]/.test(ch)) return null; - normalized += ch.toLowerCase(); - } - if (!normalized || normalized.length > 20) return null; - return normalized; -} - -function makePasswordToggleIcons() { - return { - eye: iconHtml('eye', false, 'key-toggle-icon'), - eyeOff: iconHtml('eyeOff', false, 'key-toggle-icon'), - }; -} - -export function render({ navigate }) { - const screen = document.createElement('section'); - screen.className = 'stack registration-screen'; +export function render({navigate}) { clearAuthMessages(); - - const form = document.createElement('div'); - form.className = 'card stack registration-form'; - - state.registrationDraft.passwordMode = 'single'; - state.registrationDraft.passwordWords = emptyPasswordWords(); - state.registrationDraft.passwordWordsLinked = false; - state.registrationDraft.usePromoCode = false; - state.registrationDraft.promoCode = ''; - let loginCheckTimer = 0; - let loginCheckRunId = 0; - - const loginInput = document.createElement('input'); - loginInput.className = 'input'; - loginInput.type = 'text'; - loginInput.autocomplete = 'off'; - loginInput.autocapitalize = 'off'; - loginInput.spellcheck = false; - loginInput.value = state.registrationDraft.login; - loginInput.placeholder = 'Введите логин'; - - const passwordInput = document.createElement('input'); - passwordInput.className = 'input'; - passwordInput.type = 'password'; - passwordInput.name = 'shine-register-password'; - passwordInput.autocomplete = 'new-password'; - passwordInput.autocapitalize = 'off'; - passwordInput.spellcheck = false; - passwordInput.maxLength = PASSWORD_MAX_LENGTH; - passwordInput.value = String(state.registrationDraft.password || ''); - passwordInput.placeholder = 'Введите пароль'; - - const passwordIcons = makePasswordToggleIcons(); - - const passwordToggleButton = document.createElement('button'); - passwordToggleButton.className = 'icon-btn key-toggle-btn registration-password-toggle'; - passwordToggleButton.type = 'button'; - passwordToggleButton.setAttribute('aria-label', 'Показать пароль'); - passwordToggleButton.setAttribute('title', 'Показать пароль'); - passwordToggleButton.innerHTML = passwordIcons.eyeOff; - - const passwordInputRow = document.createElement('div'); - passwordInputRow.className = 'inline-input-row'; - passwordInputRow.append(passwordInput, passwordToggleButton); - - // Строка под логином всегда занимает место — сообщения не сдвигают форму. - const statusText = document.createElement('span'); - statusText.className = 'status-line registration-login-status'; - statusText.setAttribute('aria-live', 'polite'); - - const formError = document.createElement('p'); - formError.className = 'status-line is-unavailable'; - formError.style.display = 'none'; - - // Компактная ссылка на экран «Вопросы о регистрации» (registration-faq-view). - const faqButton = document.createElement('button'); - faqButton.className = 'registration-faq-link'; - faqButton.type = 'button'; - faqButton.textContent = 'Вопросы о регистрации'; - faqButton.addEventListener('click', () => openRegistrationFaq(navigate, 'key-derivation')); - - const actions = document.createElement('div'); - actions.className = 'auth-footer-actions'; - - const nextButton = document.createElement('button'); - nextButton.className = 'primary-btn'; - nextButton.type = 'button'; - nextButton.textContent = 'Далее'; - - const passwordLengthText = document.createElement('p'); - passwordLengthText.className = 'password-length-hint'; - let lastCheckedLogin = ''; - let lastCheckedFree = false; - let lastCheckedClassName = ''; - let generationRunId = 0; - - function getCurrentPassword() { - return String(passwordInput.value || ''); - } - - function updatePasswordLength() { - passwordLengthText.textContent = `Символов в пароле: ${getCurrentPassword().length}`; - } - - function setStatusMessage(message, kind = '', details = '') { - statusText.textContent = message; - statusText.title = details || message; - statusText.className = kind ? `status-line registration-login-status ${kind}` : 'status-line registration-login-status'; - } - - function showCheckedLoginStatus(isFree, className) { - if (!isFree) { - setStatusMessage('Логин уже занят', 'is-unavailable'); - } else if (className === 'free') { - setStatusMessage('Логин свободен', 'is-available'); - } else if (className === 'premium') { - setStatusMessage('Премиум-логин – покупка через DAO', 'is-unavailable'); - } else if (className === 'company') { - setStatusMessage('Логин бренда – нужно согласование', 'is-unavailable'); - } else { - setStatusMessage('Не подходит для обычной регистрации', 'is-unavailable'); + const screen=document.createElement('section'); screen.className='stack registration-screen'; + const form=document.createElement('div'); form.className='card stack registration-form'; + const method=document.createElement('select'); method.className='input'; + method.innerHTML=''; + method.value=state.registrationDraft.flowType==='free'?'2':'1'; + const namespace=document.createElement('select'); namespace.className='input'; + const local=document.createElement('input'); local.className='input'; local.placeholder='Логин (без @)'; + local.autocomplete='off';local.spellcheck=false;local.autocapitalize='off'; + local.value=String(state.registrationDraft.login || '').split('@')[0]; + const full=document.createElement('p'); full.className='meta-muted'; + const password=document.createElement('input'); password.className='input';password.type='password'; + password.autocomplete='new-password';password.maxLength=PASSWORD_MAX_LENGTH; + password.placeholder='Пароль';password.value=state.registrationDraft.password || ''; + const status=document.createElement('p'); status.className='status-line';status.setAttribute('aria-live','polite'); + const action=document.createElement('button');action.className='primary-btn';action.textContent='Проверить логин и продолжить'; + const nsLabel=document.createElement('label');nsLabel.className='stack';nsLabel.textContent='Пространство имён'; nsLabel.append(namespace); + const methodLabel=document.createElement('label');methodLabel.className='stack'; methodLabel.textContent='Способ регистрации';methodLabel.append(method); + const pwLabel=document.createElement('label');pwLabel.className='stack';pwLabel.textContent='Пароль (ключи остаются только у вас)';pwLabel.append(password); + form.append(methodLabel,nsLabel,local,full,pwLabel,status,action); + let namespaces=[]; let disposed=false; let request=0; + const feeToSol = fee => (Number(fee || '0')/1e9).toFixed(6); + function selected() { return namespaces.find(n=>n.name===namespace.value); } + function display() { + namespace.replaceChildren(); + for (const ns of namespaces.filter(n=>Number(n.type)===Number(method.value))) { + const opt=document.createElement('option');opt.value=ns.name; + opt.textContent=`@${ns.name} · от ${ns.minLocalLength} симв. · ${feeToSol(ns.registrationFeeLamports)} SOL`; + namespace.append(opt); } - } - - function resetLoginCheckState() { - lastCheckedLogin = ''; - lastCheckedFree = false; - lastCheckedClassName = ''; - loginCheckRunId += 1; - if (loginCheckTimer) { - window.clearTimeout(loginCheckTimer); - loginCheckTimer = 0; + if (state.registrationDraft.login.includes('@')) { + const wanted=state.registrationDraft.login.split('@')[1]; + if([...namespace.options].some(x=>x.value===wanted))namespace.value=wanted; } + showFull(); } - - function scheduleAvailabilityCheck() { - resetLoginCheckState(); - setStatusMessage(''); - if (!loginInput.value.trim()) return; - loginCheckTimer = window.setTimeout(() => { - loginCheckTimer = 0; - runAvailabilityCheck({ automatic: true }).catch(() => {}); - }, 1500); + function showFull() { + full.textContent=namespace.value?`Полное имя: ${local.value.trim()}@${namespace.value}`:'Нет доступных namespace этого типа'; + status.textContent='';request++; } - - function togglePasswordVisibility() { - const reveal = passwordInput.type === 'password'; - passwordInput.type = reveal ? 'text' : 'password'; - passwordToggleButton.innerHTML = reveal ? passwordIcons.eye : passwordIcons.eyeOff; - passwordToggleButton.setAttribute('aria-label', reveal ? 'Скрыть пароль' : 'Показать пароль'); - passwordToggleButton.setAttribute('title', reveal ? 'Скрыть пароль' : 'Показать пароль'); - } - - function syncDraftState() { - state.registrationDraft.login = String(loginInput.value.trim()); - state.registrationDraft.password = getCurrentPassword(); - } - - async function runAvailabilityCheck({ automatic = false } = {}) { - const runId = ++loginCheckRunId; - const login = loginInput.value.trim(); - if (!login) { - setStatusMessage(automatic ? '' : 'Введите логин'); - formError.style.display = 'none'; - return false; - } - - const normalizedLogin = normalizeLoginForTemporaryUiGuard(login); - if (!normalizedLogin) { - setStatusMessage('Только латиница, цифры и _, до 20 символов', 'is-unavailable'); - formError.style.display = 'none'; - return false; - } - - if (normalizedLogin.length < MIN_REGISTRATION_LOGIN_LENGTH) { - setStatusMessage(`Не короче ${MIN_REGISTRATION_LOGIN_LENGTH} символов`, 'is-unavailable'); - formError.style.display = 'none'; - return false; - } - - if (login === lastCheckedLogin) { - showCheckedLoginStatus(lastCheckedFree, lastCheckedClassName); - formError.style.display = 'none'; - return lastCheckedFree && lastCheckedClassName === 'free'; - } - - setStatusMessage('Проверяем логин…', 'is-checking'); + method.addEventListener('change',display);namespace.addEventListener('change',showFull);local.addEventListener('input',showFull); + void getRegistrationNamespaces().then(data=>{ + if(disposed)return;namespaces=Array.isArray(data.namespaces)?data.namespaces:[];display(); + if(!namespaces.length)status.textContent='Solana namespace ещё не синхронизированы с сервером'; + }).catch(error=>{if(!disposed)status.textContent=`Не удалось получить namespace: ${error.message}`;}); + action.addEventListener('click',async()=>{ + const ns=selected();if(!ns){status.textContent='Выберите доступный namespace';return;} + let login; try { - const check = await checkLoginExistsOnSolana({ - login, - solanaEndpoint: state.entrySettings.solanaServer, - }); - if (runId !== loginCheckRunId) return false; - const isFree = !check.exists; - let className = ''; - if (isFree) { - try { - const precheck = await precheckLoginClassOnSolana({ - login, - solanaEndpoint: state.entrySettings.solanaServer, - }); - className = precheck.className; - } catch (precheckError) { - className = 'free'; - console.warn('Solana login precheck fallback to free', formatSolanaErrorDetails(precheckError)); - } - } - lastCheckedLogin = login; - lastCheckedFree = isFree; - lastCheckedClassName = className; - showCheckedLoginStatus(isFree, className); - formError.style.display = 'none'; - return isFree && className === 'free'; - } catch (error) { - if (runId !== loginCheckRunId) return false; - if (isSolanaRpcUnavailableError(error)) { - setStatusMessage('Нет связи с Solana – попробуйте позже', 'is-unavailable'); - return false; - } - const base = toUserMessage(error, 'Не удалось проверить логин'); - const details = formatSolanaErrorDetails(error); - setStatusMessage(base, 'is-unavailable', `${base}. Детали: ${details}`); - return false; - } - } - - passwordToggleButton.addEventListener('click', togglePasswordVisibility); - - loginInput.addEventListener('input', () => { - syncDraftState(); - scheduleAvailabilityCheck(); - }); - - passwordInput.addEventListener('input', () => { - syncDraftState(); - updatePasswordLength(); - }); - - nextButton.addEventListener('click', async () => { - formError.style.display = 'none'; - const isFree = await runAvailabilityCheck(); - if (!isFree) return; - - const prevLogin = String(state.registrationDraft.login || ''); - const prevPassword = String(state.registrationDraft.password || ''); - const nextLogin = String(loginInput.value.trim()); - const nextPassword = getCurrentPassword(); - if (nextPassword.length === 0) { - formError.textContent = 'Пустой пароль запрещён. Введите непустой пароль для регистрации.'; - formError.style.display = ''; - return; - } - if (nextPassword.length > PASSWORD_MAX_LENGTH) { - formError.textContent = `Пароль получился слишком длинным. Максимальная длина: ${PASSWORD_MAX_LENGTH} символов.`; - formError.style.display = ''; - return; - } - const credsChanged = prevLogin !== nextLogin || prevPassword !== nextPassword; - - state.registrationDraft.login = nextLogin; - state.registrationDraft.password = nextPassword; - if (credsChanged) { - state.registrationDraft.preGeneratedKeyBundle = null; - } - - startGenerationStage(); - }); - - function renderInputStage() { - form.innerHTML = ''; - const loginField = document.createElement('label'); - loginField.className = 'stack'; - loginField.innerHTML = 'Логин'; - const passwordLabel = document.createElement('label'); - passwordLabel.className = 'stack registration-password-single'; - passwordLabel.innerHTML = 'Пароль'; - form.append(loginField, passwordLabel); - loginField.append(loginInput, statusText); - passwordLabel.append(passwordInputRow); - form.append(passwordLengthText, formError, faqButton); - actions.innerHTML = ''; - actions.append(nextButton); - updatePasswordLength(); - syncDraftState(); - } - - async function startGenerationStage() { - const runId = ++generationRunId; - form.innerHTML = ''; - - const title = document.createElement('p'); - title.className = 'auth-copy'; - title.textContent = 'Для повышения безопасности мы генерируем секрет из вашего логина и пароля с помощью Argon2id.'; - - const subtitle = document.createElement('p'); - subtitle.className = 'meta-muted'; - subtitle.textContent = 'Процесс запускается сразу: из этого секрета будут вычислены ключ восстановления, ключ блокчейна и ключ доступа.'; - - const details = document.createElement('p'); - details.className = 'meta-muted'; - details.textContent = 'Параметры: t=2, m=65536 KiB (64 MB), p=1, dkLen=32.'; - - const details2 = document.createElement('p'); - details2.className = 'meta-muted'; - details2.textContent = 'Замедление нужно специально: оно усложняет подбор пароля и повышает цену атак на видеокартах и GPU.'; - - const details3 = document.createElement('p'); - details3.className = 'meta-muted'; - details3.textContent = `Длина вашего текущего пароля: ${getCurrentPassword().length} символов.`; - - const progressWrap = document.createElement('div'); - progressWrap.className = 'registration-progress'; - - const progressBar = document.createElement('div'); - progressBar.className = 'registration-progress-bar'; - progressWrap.append(progressBar); - - const progressText = document.createElement('p'); - progressText.className = 'meta-muted'; - progressText.textContent = 'Подготовка...'; - - const genError = document.createElement('p'); - genError.className = 'status-line is-unavailable'; - genError.style.display = 'none'; - - form.append(title, subtitle, details, details2, details3, progressWrap, progressText, genError); - - const cancelBtn = document.createElement('button'); - cancelBtn.className = 'ghost-btn'; - cancelBtn.type = 'button'; - cancelBtn.textContent = 'Отмена'; - cancelBtn.addEventListener('click', () => { - generationRunId += 1; - renderInputStage(); - }); - actions.innerHTML = ''; - actions.append(cancelBtn); - + login=normalizeFullLogin(`${local.value.trim()}@${ns.name}`); + if(local.value.trim().length < Number(ns.minLocalLength))throw new Error(`Логин не короче ${ns.minLocalLength} символов`); + if(!password.value || password.value.length>PASSWORD_MAX_LENGTH)throw new Error('Введите непустой пароль допустимой длины'); + }catch(error){status.textContent=error.message;return;} + const thisRun=++request; + action.disabled=true;status.textContent='Проверяем выбранный логин…'; try { - if (!state.registrationDraft.preGeneratedKeyBundle) { - const keyBundle = await authService.derivePasswordKeyBundle( - state.registrationDraft.login, - state.registrationDraft.password, - { - onProgress: ({ percent, message }) => { - if (runId !== generationRunId) return; - const safePercent = Math.max(0, Math.min(100, Number(percent) || 0)); - progressBar.style.width = `${safePercent}%`; - progressText.textContent = `${safePercent}% · ${String(message || '').trim()}`; - }, - isCancelled: () => runId !== generationRunId, - }, - ); - if (runId !== generationRunId) return; - state.registrationDraft.preGeneratedKeyBundle = keyBundle; - } - if (runId !== generationRunId) return; - progressBar.style.width = '100%'; - progressText.textContent = '100%'; - title.textContent = 'Ключи сгенерированы'; - window.setTimeout(() => navigate('registration-payment-view'), 350); - } catch (error) { - if (runId !== generationRunId) return; - if (String(error?.message || '') === 'DERIVE_CANCELLED') { - renderInputStage(); - return; - } - genError.textContent = `Ошибка генерации ключей: ${error?.message || 'неизвестная ошибка'}`; - genError.style.display = ''; - const retry = document.createElement('button'); - retry.className = 'primary-btn'; - retry.type = 'button'; - retry.textContent = 'Повторить'; - retry.addEventListener('click', startGenerationStage); - const goBack = document.createElement('button'); - goBack.className = 'ghost-btn'; - goBack.type = 'button'; - goBack.textContent = 'Назад'; - goBack.addEventListener('click', renderInputStage); - actions.innerHTML = ''; - actions.append(goBack, retry); - } - } - - renderInputStage(); - - screen.append( - createTopBar({ - title: 'Регистрация', - back: { - label: '←', - onClick: () => { - resetRegistrationFlow(); - navigate('start-view'); - }, - }, - }), - form, - actions, - ); - + const check=await checkRegistrationLogin(login); + if(disposed || thisRun!==request)return; + if(!check.loginAvailable)throw new Error('Этот логин уже занят'); + if(Number(check.namespaceType)!==Number(method.value))throw new Error('Тип namespace изменился. Обновите список.'); + const draft=state.registrationDraft; + const changed=draft.login!==login || draft.password!==password.value; + draft.login=login;draft.password=password.value;draft.flowType=method.value==='2'?'free':'paid'; + draft.namespaceFeeLamports=String(check.registrationFeeLamports||ns.registrationFeeLamports); + draft.namespaceServerLogin=ns.defaultServerLogin||''; + if(changed)draft.preGeneratedKeyBundle=null; + status.textContent='Создаём ключи локально (Argon2id)…'; + const bundle=draft.preGeneratedKeyBundle || await authService.derivePasswordKeyBundle(login,password.value); + if(disposed || thisRun!==request)return; + draft.preGeneratedKeyBundle=bundle; + navigate(draft.flowType==='free'?'registration-email-view':'registration-payment-view'); + }catch(error){if(!disposed && thisRun===request)status.textContent=error.message;} + finally {action.disabled=false;} + }); + screen.append(createTopBar({title:'Регистрация',back:{label:'←',onClick:()=>{resetRegistrationFlow();navigate('start-view');}}}),form); return screen; } diff --git a/shine-UI/js/pages/registration-email-view.js b/shine-UI/js/pages/registration-email-view.js new file mode 100644 index 00000000..83e9ea80 --- /dev/null +++ b/shine-UI/js/pages/registration-email-view.js @@ -0,0 +1,60 @@ +import { createTopBar } from '../components/topbar.js'; +import { state } from '../state.js'; +import { checkRegistrationEmail, startFreeRegistration, confirmFreeRegistration } from '../services/registration-v2-api.js'; +import { completeRegistrationLogin } from './registration-payment-view.js'; + +export const pageMeta={ id:'registration-email-view', title:'Проверка email', showAppChrome:false }; +export function render({navigate}) { + const screen=document.createElement('section'); screen.className='stack registration-screen'; + const form=document.createElement('div');form.className='card stack registration-form'; + const draft=state.registrationDraft; + const input=document.createElement('input');input.className='input';input.type='email';input.autocomplete='email'; + input.placeholder='Email';input.value=draft.email || ''; + const info=document.createElement('p');info.className='meta-muted'; + info.textContent='Email используется только для регистрации. В Arweave публикуется SHA-256 от email; его можно подобрать перебором.'; + const status=document.createElement('p');status.className='status-line';status.setAttribute('aria-live','polite'); + const next=document.createElement('button');next.className='primary-btn';next.textContent='Проверить email'; + const code=document.createElement('input');code.className='input';code.inputMode='numeric';code.placeholder='Код 1111'; + const codeLabel=document.createElement('p');codeLabel.className='meta-muted'; + codeLabel.textContent='Тест: код 1111. Письмо не отправляется, владение email не подтверждается.'; + const confirm=document.createElement('button');confirm.className='primary-btn';confirm.textContent='Подтвердить и зарегистрироваться'; + const retry=document.createElement('button');retry.className='secondary-btn';retry.textContent='Проверить статус и повторить'; + code.hidden=true;codeLabel.hidden=true;confirm.hidden=true;retry.hidden=true; + form.append(info,input,status,next,codeLabel,code,confirm,retry); + let disposed=false; + function showConfirm(){ input.disabled=true;next.hidden=true;code.hidden=false;codeLabel.hidden=false;confirm.hidden=false;retry.hidden=false; } + next.addEventListener('click',async()=>{ + if(!draft.preGeneratedKeyBundle || draft.flowType!=='free'){status.textContent='Сначала подготовьте ключи на предыдущем экране';return;} + next.disabled=true;status.textContent='Проверяем email…'; + try { + const address=input.value.trim(); + const available=await checkRegistrationEmail(address); + if(!available.emailAvailable) throw new Error('Этот email уже использован для бесплатной регистрации'); + draft.email=address; + status.textContent='Создаём временную заявку…'; + const started=await startFreeRegistration({fullLogin:draft.login,keyBundle:draft.preGeneratedKeyBundle,email:address}); + if(disposed)return; + draft.challengeId=started.challengeId;draft.challengeExpiresAtMs=started.expiresAtMs; + status.textContent='Заявка создана. Введите тестовый код 1111.';showConfirm(); + }catch(error){if(!disposed)status.textContent=error.message;next.disabled=false;} + }); + async function submit(){ + if(!draft.challengeId){status.textContent='Нет активной заявки';return;} + confirm.disabled=true;retry.disabled=true; + status.textContent='Подписываем сертификат и отправляем его через Turbo…'; + try{ + const res=await confirmFreeRegistration(draft.challengeId,code.value.trim()); + if(disposed)return; + draft.dataItemId=res.dataItemId; + status.textContent='Turbo принял сертификат. Входим без ожидания блока Arweave…'; + await completeRegistrationLogin({navigate,keyBundle:draft.preGeneratedKeyBundle}); + }catch(error){if(!disposed){status.textContent=`${error.message}. При сетевой ошибке повторите ту же заявку, ключи не меняются.`;}} + finally{confirm.disabled=false;retry.disabled=false;} + } + confirm.addEventListener('click',submit);retry.addEventListener('click',submit); + if(draft.challengeId && draft.challengeExpiresAtMs>Date.now()){ + status.textContent='Есть незавершённая заявка. Можно повторить подтверждение без новых ключей.';showConfirm(); + } + screen.append(createTopBar({title:'Подтверждение email',back:{label:'←',onClick:()=>navigate('register-view')}}),form); + return screen; +} diff --git a/shine-UI/js/pages/registration-payment-view.js b/shine-UI/js/pages/registration-payment-view.js index a6b5277e..5f405201 100644 --- a/shine-UI/js/pages/registration-payment-view.js +++ b/shine-UI/js/pages/registration-payment-view.js @@ -13,10 +13,8 @@ import { import { clearStoredMessages } from '../services/message-store.js'; import { toUserMessage } from '../services/ui-error-texts.js'; import { - createSolanaWalletFromPrivateBase58, formatSol, getBalanceSol, - transferSol, } from '../services/solana-wallet-service.js'; import { loadSolanaWeb3 } from '../vendor/solana-web3-loader.js'; import { @@ -33,7 +31,6 @@ const MIN_REQUIRED_SOL = 0.01; const RECOMMENDED_TOPUP_SOL = 0.02; const TEST_TOPUP_AMOUNT_SOL = 0.02; const DEVNET_ENDPOINT = 'https://api.devnet.solana.com'; -const TEST_TOPUP_SENDER_PRIVATE_32_BASE58 = '6xqAuKYvA8qrCdAkcw7Y8aMgvBnYk8JLxWLma5BzbAvu'; const AUTO_LOGIN_INITIAL_DELAY_MS = 1000; const AUTO_LOGIN_RETRY_MS = 2000; const REGISTRATION_PROGRESS_DURATION_MS = 12000; @@ -83,7 +80,7 @@ function clamp(value, min, max) { return Math.max(min, Math.min(max, value)); } -async function completeRegistrationLogin({ navigate, keyBundle }) { +export async function completeRegistrationLogin({ navigate, keyBundle }) { await authService.reconnect(state.entrySettings.shineServer); const result = await authService.createSessionForExistingUser( state.registrationDraft.login, @@ -252,35 +249,13 @@ export function render({ navigate }) { topupButton.className = 'ghost-btn'; topupButton.type = 'button'; topupButton.textContent = 'Тестовое пополнение (пока доступно в тестовом режиме)'; - topupButton.addEventListener('click', async () => { - status.style.display = 'none'; - topupButton.disabled = true; - const defaultText = 'Тестовое пополнение (пока доступно в тестовом режиме)'; - topupButton.textContent = 'Пополняем...'; - try { - const address = await deriveUserWalletAddress(); - const sender = await createSolanaWalletFromPrivateBase58(TEST_TOPUP_SENDER_PRIVATE_32_BASE58); - await transferSol({ - endpoint: DEVNET_ENDPOINT, - fromKeypair: sender.keypair, - toAddress: address, - amountSol: TEST_TOPUP_AMOUNT_SOL, - }); - const balance = await getBalanceSol({ - endpoint: DEVNET_ENDPOINT, - address, - }); - state.registrationPayment.balanceSOL = String(balance.sol); - balanceValue.textContent = `${formatSol(balance.sol, 6)} SOL`; - status.className = 'status-line is-available'; - status.textContent = `Тестовое пополнение выполнено: +${TEST_TOPUP_AMOUNT_SOL} SOL. Баланс: ${formatSol(balance.sol, 6)} SOL.`; - status.style.display = ''; - } catch (error) { - showWalletError(error, 'Не удалось выполнить тестовое пополнение. Попробуйте ещё раз.'); - } finally { - topupButton.disabled = false; - topupButton.textContent = defaultText; - } + // Браузерная раздача devnet SOL с приватным ключом отправителя опасна. + // Ссылка на публичный faucet безопаснее, чем встраивать секрет в JS. + topupButton.textContent = 'Как пополнить через devnet faucet'; + topupButton.addEventListener('click', () => { + status.className = 'status-line is-unavailable'; + status.textContent = 'Скопируйте адрес кошелька выше и пополните его через доверенный Solana devnet faucet. Приватный ключ отправителя не должен находиться в приложении.'; + status.style.display = ''; }); const submitButton = document.createElement('button'); @@ -305,14 +280,16 @@ export function render({ navigate }) { const walletAddress = await deriveUserWalletAddress(); const currentBalance = await refreshBalance({ showError: true, addressOverride: walletAddress }); if (currentBalance == null) return; - if (currentBalance < MIN_REQUIRED_SOL) { + const namespaceFeeSol = Number(state.registrationDraft.namespaceFeeLamports || 0) / 1e9; + const requiredSol = Math.max(MIN_REQUIRED_SOL, namespaceFeeSol + 0.004); + if (currentBalance < requiredSol) { status.className = 'status-line is-unavailable'; status.textContent = isTestContour - ? `Для регистрации нужно минимум ${MIN_REQUIRED_SOL} SOL. Рекомендуем пополнить кошелёк примерно на ${RECOMMENDED_TOPUP_SOL} SOL. Сейчас на кошельке ${formatSol(currentBalance, 6)} SOL.` - : `Для регистрации пополните этот кошелёк соланами примерно на ${RECOMMENDED_TOPUP_SOL} SOL. Сейчас на кошельке ${formatSol(currentBalance, 6)} SOL. Минимум для продолжения: ${MIN_REQUIRED_SOL} SOL.`; + ? `Для регистрации нужно минимум ${requiredSol.toFixed(6)} SOL. Рекомендуем пополнить кошелёк примерно на ${RECOMMENDED_TOPUP_SOL} SOL. Сейчас на кошельке ${formatSol(currentBalance, 6)} SOL.` + : `Для регистрации пополните этот кошелёк соланами примерно на ${RECOMMENDED_TOPUP_SOL} SOL. Сейчас на кошельке ${formatSol(currentBalance, 6)} SOL. Минимум для продолжения: ${requiredSol.toFixed(6)} SOL.`; status.style.display = ''; if (isTestContour) { - status.textContent += ` Нажмите «Тестовое пополнение», чтобы сразу добавить ${TEST_TOPUP_AMOUNT_SOL} SOL без перехода на другой экран.`; + status.textContent += ' Для тестового пополнения используйте внешний devnet faucet.'; } return; } @@ -339,7 +316,6 @@ export function render({ navigate }) { keyBundle, solanaEndpoint: state.entrySettings.solanaServer, accessServers: [state.entrySettings.shineServerLogin || defaultServerLogin], - promoCode: '', }); registrationTxId = String(registrationResult?.signature || '').trim(); } catch (solanaError) { diff --git a/shine-UI/js/pages/registration-upgrade-view.js b/shine-UI/js/pages/registration-upgrade-view.js new file mode 100644 index 00000000..7a477535 --- /dev/null +++ b/shine-UI/js/pages/registration-upgrade-view.js @@ -0,0 +1,64 @@ +import { createTopBar } from '../components/topbar.js'; +import { authService, state } from '../state.js'; +import { getRegistrationStatus } from '../services/registration-v2-api.js'; +import { getNamespace } from '../services/shine-namespace-service.js'; +import { upgradeFreeUserOnSolana } from '../services/shine-user-pda-service.js'; +import { base64ToBytes, bytesToBase58 } from '../services/crypto-utils.js'; + +export const pageMeta={id:'registration-upgrade-view',title:'Регистрация в Solana'}; +export function render({navigate,chrome}) { + const screen=document.createElement('section');screen.className='stack'; + chrome?.setTopbar(createTopBar({title:'Регистрация в Solana',back:{label:'←',onClick:()=>navigate('settings-view')}})); + const card=document.createElement('div');card.className='card stack'; + const heading=document.createElement('h3');heading.textContent='Закрепить существующий аккаунт в Solana'; + const description=document.createElement('p');description.className='meta-muted'; + description.textContent='Имя, история Arweave, каналы и три публичных ключа не меняются. Создаётся только пользовательский PDA Solana.'; + const price=document.createElement('p');price.className='meta-muted';price.textContent='Читаем стоимость из Solana…'; + const password=document.createElement('input');password.className='input';password.type='password'; + password.autocomplete='current-password';password.placeholder='Пароль существующего аккаунта'; + const action=document.createElement('button');action.className='primary-btn';action.textContent='Зарегистрировать в Solana'; + const status=document.createElement('p');status.className='status-line';status.setAttribute('aria-live','polite'); + card.append(heading,description,price,password,action,status);screen.append(card); + const login=state.session?.login || ''; + let identity=null;let namespace=null;let disposed=false; + async function refresh(){ + if(!login.includes('@'))throw new Error('Нужен полный login@namespace'); + identity=await getRegistrationStatus(login); + if(identity.registrationStatus!=='FREE_CERT') throw new Error('Платная регистрация доступна только для бесплатного аккаунта'); + namespace=await getNamespace({namespace:login.split('@')[1],solanaEndpoint:state.entrySettings.solanaServer}); + if(namespace.type!==2)throw new Error('Сертификат не соответствует namespace'); + if(disposed)return; + price.textContent=`Комиссия namespace: ${(Number(namespace.registrationFeeLamports)/1e9).toFixed(6)} SOL + rent/сетевые комиссии`; + action.disabled=false; + } + action.disabled=true; + void refresh().catch(error=>{if(!disposed)status.textContent=error.message;}); + action.addEventListener('click',async()=>{ + action.disabled=true; + try{ + if(!identity || !namespace)throw new Error('Namespace/сертификат ещё не проверены'); + if(!password.value)throw new Error('Введите исходный пароль для восстановления тех же ключей'); + status.textContent='Восстанавливаем первоначальные ключи локально…'; + const keys=await authService.derivePasswordKeyBundle(login,password.value); + for(const [pair,expected] of [[keys.rootPair,identity.rootPublicKey], + [keys.blockchainPair,identity.blockchainPublicKey],[keys.clientPair,identity.clientPublicKey]]) { + if(bytesToBase58(base64ToBytes(pair.publicKeyB64))!==expected) + throw new Error('Пароль не соответствует исходным ключам этого сертификата'); + } + const signature=base64ToBytes(identity.innerSignature64B64); + if(signature.length!==64)throw new Error('Не получена проверяемая подпись регистратора'); + status.textContent='Подписываем новую запись PDA существующими ключами…'; + const tx=await upgradeFreeUserOnSolana({ + login,keyBundle:keys,solanaEndpoint:state.entrySettings.solanaServer, + innerSignature64:signature, + accessServers:identity.defaultServerLogin?[identity.defaultServerLogin]:[], + }); + if(disposed)return; + password.value=''; + status.textContent=`Транзакция отправлена (${tx.signature||'успешно'}). Ожидаем синхронизацию статуса Solana; история и ключи сохранены.`; + // UI не делает ложных выводов до фактической синхронизации PDA. + }catch(error){if(!disposed)status.textContent=error.message;} + finally {if(!disposed)action.disabled=false;} + }); + return screen; +} diff --git a/shine-UI/js/pages/settings-view.js b/shine-UI/js/pages/settings-view.js index d17daca5..6c95699b 100644 --- a/shine-UI/js/pages/settings-view.js +++ b/shine-UI/js/pages/settings-view.js @@ -1,4 +1,5 @@ import { confirmDialog } from '../components/confirm-dialog.js'; +import { getRegistrationStatus } from '../services/registration-v2-api.js'; import { createTopBar } from '../components/topbar.js'; import { addAppLogEntry, authService, closeSavedProfile, state } from '../state.js'; import { openSheet } from '../components/sheet.js'; @@ -143,6 +144,19 @@ export function render({navigate, chrome}) { `; + // Кнопка доступна только владельцу действительного бесплатного сертификата. + if (String(state.session?.login||'').includes('@')) { + void getRegistrationStatus(state.session.login).then(info=>{ + if (isDisposed || info.registrationStatus!=='FREE_CERT') return; + const list=card.querySelector('.nav-list'); + if(!list || card.querySelector('#settings-solana-upgrade')) return; + const button=document.createElement('button'); + button.id='settings-solana-upgrade'; button.className='nav-row'; + button.textContent='Зарегистрировать аккаунт в Solana'; + button.addEventListener('click',()=>navigate('registration-upgrade-view')); + list.append(button); + }).catch(()=>{}); + } card.querySelector('#settings-appearance').addEventListener('click', () => navigate('appearance-view')); card.querySelector('#settings-notifications').addEventListener('click', () => navigate('notification-settings-view')); card.querySelector('#settings-about').addEventListener('click', () => { diff --git a/shine-UI/js/pages/topup-view.js b/shine-UI/js/pages/topup-view.js index 0cd0ec6d..cc00137b 100644 --- a/shine-UI/js/pages/topup-view.js +++ b/shine-UI/js/pages/topup-view.js @@ -2,18 +2,15 @@ import { createTopBar } from '../components/topbar.js'; import { showToast } from '../services/channels-ux.js'; import { state } from '../state.js'; import { - createSolanaWalletFromPrivateBase58, formatSol, getBalanceSol, getTopupSiteUrl, - transferSol, } from '../services/solana-wallet-service.js'; import { loadSolanaWeb3 } from '../vendor/solana-web3-loader.js'; import { actionErrorText } from '../services/ui-error-texts.js'; export const pageMeta = { id: 'topup-view', title: 'Пополнение solana счета', showAppChrome: false }; const DEVNET_ENDPOINT = 'https://api.devnet.solana.com'; -const SENDER_PRIVATE_32_BASE58 = '6xqAuKYvA8qrCdAkcw7Y8aMgvBnYk8JLxWLma5BzbAvu'; const REGISTRATION_TOPUP_AMOUNT_SOL = 0.02; // Канонический Solana-кошелёк пользователя = текущий blockchain key. @@ -72,7 +69,7 @@ export function render({ navigate }) { const card = document.createElement('div'); card.className = 'card stack'; card.innerHTML = ` -

Можете или пополнить счёт тестовыми соланами и продолжить регистрацию.

+

Пополните счёт через доверенный devnet faucet и продолжите регистрацию.

Кошелёк для пополнения (blockchain key = Solana wallet)
@@ -87,43 +84,9 @@ export function render({ navigate }) { testButton.className = 'ghost-btn'; testButton.type = 'button'; testButton.textContent = 'Тестовое пополнение для регистрации'; - testButton.addEventListener('click', async () => { - const address = String(walletValue.value || '').trim(); - if (!address) { - showToast('Адрес кошелька не найден.', { kind: 'error' }); - return; - } - if (!senderKeypair) { - status.textContent = 'Ошибка: тестовый кошелёк отправителя ещё не инициализирован.'; - return; - } - testButton.disabled = true; - try { - status.textContent = 'Отправляем тестовое пополнение для регистрации...'; - const tx = await transferSol({ - endpoint: DEVNET_ENDPOINT, - fromKeypair: senderKeypair, - toAddress: address, - amountSol: REGISTRATION_TOPUP_AMOUNT_SOL, - }); - const bal = await getBalanceSol({ - endpoint: DEVNET_ENDPOINT, - address, - }); - state.registrationPayment.balanceSOL = String(bal.sol); - status.style.fontSize = '12px'; - status.textContent = [ - 'Тестовое пополнение для регистрации выполнено.', - `Кошелёк пополнен на ${REGISTRATION_TOPUP_AMOUNT_SOL} SOL.`, - `Новый баланс: ${formatSol(bal.sol, 6)} SOL.`, - `Signature: ${tx.signature}`, - ].join('\n'); - } catch (error) { - status.style.fontSize = '13px'; - status.textContent = actionErrorText('Ошибка тестового пополнения', error); - } finally { - testButton.disabled = false; - } + testButton.textContent = 'Как пополнить через devnet faucet'; + testButton.addEventListener('click', () => { + status.textContent = 'Для пополнения скопируйте адрес блокчейн-кошелька и используйте внешний доверенный Solana devnet faucet. Приватный ключ отправителя не должен находиться в публичном приложении.'; }); const backButton = document.createElement('button'); @@ -135,7 +98,6 @@ export function render({ navigate }) { const actions = document.createElement('div'); actions.className = 'auth-footer-actions'; actions.append(testButton, backButton); - let senderKeypair = null; (async () => { try { @@ -154,8 +116,6 @@ export function render({ navigate }) { }); state.registrationPayment.balanceSOL = String(balance.sol); status.textContent = `Текущий баланс: ${formatSol(balance.sol, 6)} SOL`; - const sender = await createSolanaWalletFromPrivateBase58(SENDER_PRIVATE_32_BASE58); - senderKeypair = sender.keypair; } catch (error) { status.textContent = actionErrorText('Не удалось получить баланс', error); } diff --git a/shine-UI/js/router.js b/shine-UI/js/router.js index ba45d078..f9217404 100644 --- a/shine-UI/js/router.js +++ b/shine-UI/js/router.js @@ -6,6 +6,8 @@ const PRETTY_PATHS = new Map([ ['start-view', 'start'], ['entry-settings-view', 'entry-settings'], ['register-view', 'register'], + ['registration-email-view', 'register/email'], + ['registration-upgrade-view', 'settings/solana-upgrade'], ['registration-faq-view', 'register/faq'], ['registration-payment-view', 'register/payment'], ['registration-draft-keys-view', 'register/draft-keys'], diff --git a/shine-UI/js/services/registration-v2-api.js b/shine-UI/js/services/registration-v2-api.js new file mode 100644 index 00000000..8e6f3316 --- /dev/null +++ b/shine-UI/js/services/registration-v2-api.js @@ -0,0 +1,24 @@ +/** Разделённые шаги V2: независимая проверка логина, затем email. */ +import { authService } from '../state.js'; +import { normalizeFullLogin } from './shine-namespace-service.js'; + +async function call(op, payload = {}) { + const response = await authService.ws.request(op, payload, op==='ConfirmFreeRegistration'?150000:18000); + if (response.status !== 200 || response.ok === false) { + const error=new Error(response.message || response.error || `${op}: ошибка сервера`); + error.code=response.error || 'REGISTRATION_REQUEST_FAILED'; + throw error; + } + return response.payload || {}; +} +export const getRegistrationNamespaces = () => call('GetNamespaces'); +export const checkRegistrationLogin = (fullLogin) => call('CheckRegistrationLogin', { fullLogin: normalizeFullLogin(fullLogin) }); +export const checkRegistrationEmail = (email) => call('CheckRegistrationEmail', { email }); +export const startFreeRegistration = ({ fullLogin, keyBundle, email }) => call('StartFreeRegistration', { + fullLogin: normalizeFullLogin(fullLogin), email, + rootPublicKeyB64: keyBundle.rootPair.publicKeyB64, + blockchainPublicKeyB64: keyBundle.blockchainPair.publicKeyB64, + clientPublicKeyB64: keyBundle.clientPair.publicKeyB64, +}); +export const confirmFreeRegistration = (challengeId, code) => call('ConfirmFreeRegistration',{challengeId,code}); +export const getRegistrationStatus = (fullLogin) => call('GetRegistrationStatus',{fullLogin: normalizeFullLogin(fullLogin)}); diff --git a/shine-UI/js/services/shine-namespace-service.js b/shine-UI/js/services/shine-namespace-service.js new file mode 100644 index 00000000..7fbcd2fe --- /dev/null +++ b/shine-UI/js/services/shine-namespace-service.js @@ -0,0 +1,112 @@ +// Общий бинарный протокол namespace PDA v1; используется платным create и upgrade. +import { sha256Bytes } from './crypto-utils.js'; +import { loadSolanaWeb3 } from '../vendor/solana-web3-loader.js'; +import { SHINE_USERS_PROGRAM_ID } from '../solana-programs.js'; +const enc = new TextEncoder(); +const dec = new TextDecoder('utf-8', { fatal: true }); +export function normalizeNamespace(value) { + const name = String(value ?? ''); + if (!/^[a-z0-9_]+$/.test(name)) throw new Error('Некорректный namespace: разрешены только ASCII lowercase a-z0-9_'); + return name; +} +export function normalizeFullLogin(value) { + const login = String(value ?? ''); + const parts = login.split('@'); + if (parts.length !== 2 || !/^[a-z0-9_]+$/.test(parts[0])) throw new Error('Требуется полный login@namespace без автоматического преобразования'); + normalizeNamespace(parts[1]); + if (enc.encode(login).length > 30) throw new Error('Полный логин превышает 30 байт'); + return login; +} +export async function userPdaSeed32(fullLogin) { + return sha256Bytes(enc.encode('user_login=' + normalizeFullLogin(fullLogin))); +} +export async function namespacePdaSeed32(namespace) { + return sha256Bytes(enc.encode('namespace=' + normalizeNamespace(namespace))); +} +export function buildFreeCertificateInnerMessage(fullLogin, root32, blockchain32, client32) { + const name = enc.encode(normalizeFullLogin(fullLogin)); + for (const key of [root32, blockchain32, client32]) { + if (!(key instanceof Uint8Array) || key.length !== 32) throw new Error('Ожидается 32-байтовый публичный ключ'); + } + return new Uint8Array([ + ...enc.encode('SHiNE_FREE_REG_V1\0'), 1, 0, name.length, ...name, + ...root32, ...blockchain32, ...client32, + ]); +} +export function decodeNamespacePda(data) { + const bytes = new Uint8Array(data); + if (bytes.length < 13 || bytes[0] !== 1 || bytes[1] !== 0 || (bytes[2] !== 1 && bytes[2] !== 2)) throw new Error('Неподдерживаемый namespace PDA'); + const type = bytes[2], minLocalpartLength = bytes[3], len = bytes[4]; + if (len === 0 || 5 + len + 8 > bytes.length) throw new Error('Обрезанный namespace PDA'); + const namespace = dec.decode(bytes.slice(5, 5 + len)); + normalizeNamespace(namespace); + if (minLocalpartLength < 1 || minLocalpartLength + len + 1 > 30) throw new Error('Недопустимая минимальная длина'); + const fee = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getBigUint64(5 + len, true); + let offset = 5 + len + 8, registrarPublicKey32 = null, serverLogin = null; + if (type === 2) { + if (bytes.length < offset + 33) throw new Error('В namespace типа 2 отсутствует ключ регистратора'); + registrarPublicKey32 = bytes.slice(offset, offset + 32); offset += 32; + const serverLen = bytes[offset++]; + if (serverLen < 1 || bytes.length !== offset + serverLen) throw new Error('Неверная длина серверного логина'); + serverLogin = normalizeFullLogin(dec.decode(bytes.slice(offset, offset + serverLen))); + offset += serverLen; + } + if (bytes.length !== offset) throw new Error('Лишние данные namespace PDA'); + return { namespace, type, minLocalpartLength, registrationFeeLamports: fee, registrarPublicKey32, serverLogin }; +} +export function encodeNamespacePda({ namespace, type, minLocalpartLength, registrationFeeLamports, registrarPublicKey32, serverLogin }) { + const name = enc.encode(normalizeNamespace(namespace)); + if (!Number.isInteger(minLocalpartLength) || minLocalpartLength < 1 || minLocalpartLength + name.length + 1 > 30) throw new Error('Недопустимая длина локального логина'); + if (type !== 1 && type !== 2) throw new Error('Недопустимый тип namespace'); + const fee = BigInt(registrationFeeLamports); + if (fee < 0n || fee > (2n ** 64n - 1n)) throw new Error('Неверная цена регистрации'); + const server = type === 2 ? enc.encode(normalizeFullLogin(serverLogin)) : new Uint8Array(); + const pub = type === 2 ? new Uint8Array(registrarPublicKey32) : new Uint8Array(); + if (type === 2 && pub.length !== 32) throw new Error('Ключ регистратора должен быть 32 байта'); + const out = new Uint8Array(5 + name.length + 8 + (type === 2 ? 32 + 1 + server.length : 0)); + out.set([1, 0, type, minLocalpartLength, name.length]); out.set(name, 5); + let offset = 5 + name.length; + new DataView(out.buffer).setBigUint64(offset, fee, true); offset += 8; + if (type === 2) { out.set(pub, offset); offset += 32; out[offset++] = server.length; out.set(server, offset); } + return out; +} +export function assertLoginInNamespace(fullLogin, ns) { + const login = normalizeFullLogin(fullLogin); + if (login.split('@')[1] !== ns.namespace || login.split('@')[0].length < ns.minLocalpartLength) throw new Error('Логин не соответствует namespace'); + return login; +} +export async function deriveUserPda(fullLogin) { + const solana = await loadSolanaWeb3(); + const program = new solana.PublicKey(SHINE_USERS_PROGRAM_ID); + return solana.PublicKey.findProgramAddressSync([await userPdaSeed32(fullLogin)], program)[0]; +} +export async function deriveNamespacePda(namespace) { + const solana = await loadSolanaWeb3(); + const program = new solana.PublicKey(SHINE_USERS_PROGRAM_ID); + return solana.PublicKey.findProgramAddressSync([await namespacePdaSeed32(namespace)], program)[0]; +} +export async function getNamespace({ namespace, solanaEndpoint }) { + const solana = await loadSolanaWeb3(); + const connection = new solana.Connection(String(solanaEndpoint || '').trim(), 'confirmed'); + const address = await deriveNamespacePda(namespace); + const info = await connection.getAccountInfo(address, 'confirmed'); + if (!info || !info.owner.equals(new solana.PublicKey(SHINE_USERS_PROGRAM_ID))) throw new Error('Namespace PDA не найдена в программе shine_users'); + const ns = decodeNamespacePda(info.data); + if (ns.namespace !== namespace) throw new Error('PDA namespace не совпадает с именем'); + return { ...ns, pdaAddress: address.toBase58(), address }; +} +export async function listNamespaces({ solanaEndpoint }) { + const solana = await loadSolanaWeb3(); + const conn = new solana.Connection(String(solanaEndpoint || '').trim(), 'confirmed'); + const accounts = await conn.getProgramAccounts(new solana.PublicKey(SHINE_USERS_PROGRAM_ID)); + const out = []; + for (const entry of accounts) { + try { + const ns = decodeNamespacePda(entry.account.data); + const expected = await deriveNamespacePda(ns.namespace); + if (!entry.pubkey.equals(expected)) continue; + out.push({ ...ns, pdaAddress: entry.pubkey.toBase58(), address: entry.pubkey }); + } catch { /* User PDA или неподдерживаемый формат */ } + } + return out.sort((a, b) => a.namespace.localeCompare(b.namespace)); +} diff --git a/shine-UI/js/services/shine-user-pda-service.js b/shine-UI/js/services/shine-user-pda-service.js index c61b9ef4..2f3e37e6 100644 --- a/shine-UI/js/services/shine-user-pda-service.js +++ b/shine-UI/js/services/shine-user-pda-service.js @@ -8,6 +8,7 @@ import { SHINE_USERS_PROGRAM_ID, } from '../solana-programs.js'; import { loadSolanaWeb3 } from '../vendor/solana-web3-loader.js'; +import { getNamespace, assertLoginInNamespace, normalizeFullLogin, userPdaSeed32, buildFreeCertificateInnerMessage } from './shine-namespace-service.js'; const MAGIC = 'SHiNE'; const FORMAT_MAJOR = 1; @@ -364,7 +365,7 @@ export function serializeUnsignedRecordFromState(stateLike) { return new Uint8Array(out); } -function serializeCreateUserPdaArgs(args) { +export function serializeCreateUserPdaArgs(args) { const out = [IX_CREATE_USER_PDA]; pushStrU8(out, args.login); pushBytes(out, toUint8Array(args.rootKey32, 32)); @@ -382,8 +383,9 @@ function serializeCreateUserPdaArgs(args) { out.push(access.length); for (const value of access) pushStrU8(out, value); pushBytes(out, toUint8Array(args.recordSignature64, 64)); - const promo = normalizeLogin(args.promoSellerLogin || ''); - if (promo) pushStrU8(out, promo); + const registrar = args.registrarSignature64 == null ? null : toUint8Array(args.registrarSignature64, 64); + out.push(registrar ? 1 : 0); + if (registrar) pushBytes(out, registrar); return new Uint8Array(out); } @@ -468,7 +470,8 @@ export async function readShineUserPda({ login, solanaEndpoint }) { const endpoint = String(solanaEndpoint || '').trim(); const connection = new solana.Connection(endpoint, 'confirmed'); const usersProgram = new solana.PublicKey(SHINE_USERS_PROGRAM_ID); - const [pda] = solana.PublicKey.findProgramAddressSync([new TextEncoder().encode(SHINE_USERS_USER_PDA_SEED_PREFIX), new TextEncoder().encode(cleanLogin)], usersProgram); + const [pda] = solana.PublicKey.findProgramAddressSync( + cleanLogin.includes('@') ? [await userPdaSeed32(cleanLogin)] : [new TextEncoder().encode(SHINE_USERS_USER_PDA_SEED_PREFIX), new TextEncoder().encode(cleanLogin)], usersProgram); const info = await connection.getAccountInfo(pda, 'confirmed'); if (!info?.data) throw new Error(`PDA пользователя @${cleanLogin} не найдена`); return { ...parseShineUserPda(new Uint8Array(info.data)), userPda: pda.toBase58(), pdaAddress: pda.toBase58(), endpoint }; @@ -523,11 +526,11 @@ async function buildCommonContext({ login, clientPrivatePkcs8B64, payerPrivatePk const connection = new solana.Connection(endpoint, 'confirmed'); const usersProgram = new solana.PublicKey(SHINE_USERS_PROGRAM_ID); const paymentsProgram = new solana.PublicKey(SHINE_PAYMENTS_PROGRAM_ID); - const loginGuardProgram = new solana.PublicKey(SHINE_LOGIN_GUARD_PROGRAM_ID); const ed25519Program = new solana.PublicKey(ED25519_PROGRAM_ID); const sysvarInstructions = new solana.PublicKey(SYSVAR_INSTRUCTIONS_ID); const enc = new TextEncoder(); - const [userPda] = solana.PublicKey.findProgramAddressSync([enc.encode(SHINE_USERS_USER_PDA_SEED_PREFIX), enc.encode(cleanLogin)], usersProgram); + const [userPda] = solana.PublicKey.findProgramAddressSync( + cleanLogin.includes('@') ? [await userPdaSeed32(cleanLogin)] : [enc.encode(SHINE_USERS_USER_PDA_SEED_PREFIX), enc.encode(cleanLogin)], usersProgram); const [economyConfigPda] = solana.PublicKey.findProgramAddressSync([enc.encode(SHINE_USERS_ECONOMY_CONFIG_SEED)], usersProgram); const [inflowVault] = solana.PublicKey.findProgramAddressSync([enc.encode(SHINE_PAYMENTS_INFLOW_VAULT_SEED)], paymentsProgram); const payerPkcs8 = String(payerPrivatePkcs8B64 || clientPrivatePkcs8B64 || ''); @@ -536,7 +539,7 @@ async function buildCommonContext({ login, clientPrivatePkcs8B64, payerPrivatePk const payerKeypair = solana.Keypair.fromSeed(payerSeed32); // Имя clientKeypair сохранено в возвращаемом объекте для совместимости текущих UI-callers; // фактически это произвольный fee payer и он не обязан совпадать с ClientKeyBlock. - return { cleanLogin, endpoint, solana, connection, usersProgram, paymentsProgram, loginGuardProgram, ed25519Program, sysvarInstructions, userPda, economyConfigPda, inflowVault, clientKeypair: payerKeypair, payerKeypair }; + return { cleanLogin, endpoint, solana, connection, usersProgram, paymentsProgram, ed25519Program, sysvarInstructions, userPda, economyConfigPda, inflowVault, clientKeypair: payerKeypair, payerKeypair }; } async function createShineUserPdaOnSolana({ @@ -549,10 +552,11 @@ async function createShineUserPdaOnSolana({ addressFormatVersion = 0, serverAddress = '', accessServers = [], - promoCode = '', + registrarSignature64 = null, + feePayerPrivatePkcs8B64 = '', }) { - const rawLogin = String(login || '').trim(); - const cleanLogin = normalizeLogin(rawLogin); + const rawLogin = normalizeFullLogin(login); + const cleanLogin = rawLogin; const rootKey32 = base64ToBytes(keyBundle.rootPair.publicKeyB64); const blockchainKey32 = base64ToBytes(keyBundle.blockchainPair.publicKeyB64); const clientKey32 = base64ToBytes(keyBundle.clientPair.publicKeyB64); @@ -561,9 +565,17 @@ async function createShineUserPdaOnSolana({ const ctx = await buildCommonContext({ login: cleanLogin, clientPrivatePkcs8B64: keyBundle.clientPair.privatePkcs8B64, - payerPrivatePkcs8B64: keyBundle.blockchainPair.privatePkcs8B64, + payerPrivatePkcs8B64: feePayerPrivatePkcs8B64 || keyBundle.blockchainPair.privatePkcs8B64, solanaEndpoint, }); + const namespaceName = cleanLogin.split('@')[1]; + const namespace = await getNamespace({ namespace: namespaceName, solanaEndpoint }); + assertLoginInNamespace(cleanLogin, namespace); + const registrar = registrarSignature64 == null ? null : toUint8Array(registrarSignature64, 64); + if ((namespace.type === 2) !== Boolean(registrar)) throw new Error('Тип 2 требует сертификат, тип 1 не принимает его'); + // При upgrade сохраняется исходный сервер доступа; после on-chain create его можно сменить. + const effectiveAccessServers = (namespace.type === 2 && accessServers.length === 0) + ? [namespace.serverLogin] : accessServers; const ecoInfo = await ctx.connection.getAccountInfo(ctx.economyConfigPda, 'confirmed'); if (!ecoInfo?.data) throw new Error('Economy config не инициализирован.'); const startBonusLimit = parseUsersEconomyConfig(new Uint8Array(ecoInfo.data)).startBonusLimit; @@ -580,30 +592,23 @@ async function createShineUserPdaOnSolana({ clientKey: clientKey32, forks: [{ blockchainKey: blockchainKey32, createdAtMs, paidLimitBytes: startBonusLimit }], serverAddresses: addresses, - accessServers, + accessServers: effectiveAccessServers, }; const unsigned = serializeUnsignedRecordFromState(initial); const hash = await sha256Bytes(unsigned); const rootSig = await signBytes(rootPriv, hash); const recordSig = await signBytes(bchPriv, hash); - let promoSellerPda = null; - let promoEdIx = null; - let promoSellerLogin = ''; - const cleanPromoCode = String(promoCode || '').trim(); - if (cleanPromoCode) { - const dash = cleanPromoCode.indexOf('-'); - if (!cleanPromoCode.startsWith('1') || dash <= 1 || dash === cleanPromoCode.length - 1) throw new Error('Некорректный формат промокода'); - promoSellerLogin = normalizeLogin(cleanPromoCode.slice(1, dash)); - const sig = base58ToBytes(cleanPromoCode.slice(dash + 1)); - const [sellerPda] = ctx.solana.PublicKey.findProgramAddressSync([new TextEncoder().encode(SHINE_USERS_PROMO_SELLER_PDA_SEED_PREFIX), new TextEncoder().encode(promoSellerLogin)], ctx.usersProgram); - promoSellerPda = sellerPda; - const sellerInfo = await ctx.connection.getAccountInfo(sellerPda, 'confirmed'); - if (!sellerInfo?.data || sellerInfo.data.length < 42) throw new Error('Promo seller PDA не найдена'); - promoEdIx = new ctx.solana.TransactionInstruction({ programId: ctx.ed25519Program, keys: [], data: buildEd25519IxData(sig, new Uint8Array(sellerInfo.data.slice(10, 42)), buildPromoMessageBytes(cleanLogin)) }); - } + // Namespace читается из цепи, комиссия никогда не берётся из старого economy.registrationFee. + const certMessage = registrar + ? buildFreeCertificateInnerMessage(cleanLogin, rootKey32, blockchainKey32, clientKey32) + : null; + const registrarIx = registrar ? new ctx.solana.TransactionInstruction({ + programId: ctx.ed25519Program, keys: [], + data: buildEd25519IxData(registrar, namespace.registrarPublicKey32, certMessage), + }) : null; - const ixData = serializeCreateUserPdaArgs({ login: rawLogin, rootKey32, createdAtMs, additionalLimitBytes: 0n, clientKey32, blockchainKey32, serverAddresses: addresses, accessServers, recordSignature64: recordSig, promoSellerLogin }); + const ixData = serializeCreateUserPdaArgs({ login: rawLogin, rootKey32, createdAtMs, additionalLimitBytes: 0n, clientKey32, blockchainKey32, serverAddresses: addresses, accessServers: effectiveAccessServers, recordSignature64: recordSig, registrarSignature64: registrar }); const rootIx = new ctx.solana.TransactionInstruction({ programId: ctx.ed25519Program, keys: [], data: buildEd25519IxData(rootSig, rootKey32, hash) }); const recordIx = new ctx.solana.TransactionInstruction({ programId: ctx.ed25519Program, keys: [], data: buildEd25519IxData(recordSig, blockchainKey32, hash) }); const createIx = new ctx.solana.TransactionInstruction({ @@ -615,26 +620,31 @@ async function createShineUserPdaOnSolana({ { pubkey: ctx.inflowVault, isSigner: false, isWritable: true }, { pubkey: ctx.sysvarInstructions, isSigner: false, isWritable: false }, { pubkey: ctx.economyConfigPda, isSigner: false, isWritable: false }, - { pubkey: ctx.loginGuardProgram, isSigner: false, isWritable: false }, - ...(promoSellerPda ? [{ pubkey: promoSellerPda, isSigner: false, isWritable: true }] : []), + { pubkey: namespace.address, isSigner: false, isWritable: false }, ], data: ixData, }); try { const tx = new ctx.solana.Transaction(); - if (promoEdIx) tx.add(promoEdIx); + if (registrarIx) tx.add(registrarIx); tx.add(rootIx, recordIx, createIx); const signature = await sendAndConfirmSolanaHttp(ctx.connection, tx, [ctx.payerKeypair]); - return { signature, userPda: ctx.userPda.toBase58(), pdaAddress: ctx.userPda.toBase58(), blockchainName: `${cleanLogin}-001` }; + return { signature, userPda: ctx.userPda.toBase58(), pdaAddress: ctx.userPda.toBase58(), blockchainName: `${cleanLogin}-001`, registrationFeeLamports: namespace.registrationFeeLamports }; } catch (error) { throw await attachSolanaLogs(error, ctx.connection); } } -export async function registerUserOnSolana({ login, keyBundle, solanaEndpoint, accessServers = [], promoCode = '' }) { - return createShineUserPdaOnSolana({ login, keyBundle, solanaEndpoint, accessServers, promoCode }); +export async function registerUserOnSolana({ login, keyBundle, solanaEndpoint, accessServers = [], registrarSignature64 = null }) { + return createShineUserPdaOnSolana({ login, keyBundle, solanaEndpoint, accessServers, registrarSignature64 }); +} + +export async function upgradeFreeUserOnSolana({ login, keyBundle, solanaEndpoint, innerSignature64, accessServers = [] }) { + if (!innerSignature64) throw new Error('Необходима внутренняя подпись исходного сертификата'); + return createShineUserPdaOnSolana({ login, keyBundle, solanaEndpoint, accessServers, registrarSignature64: innerSignature64 }); } export async function registerServerOnSolana({ login, keyBundle, serverAddress, serverAddresses = null, addressFormatType = 1, addressFormatVersion = 0, accessServers = [], solanaEndpoint }) { - return createShineUserPdaOnSolana({ login, keyBundle, solanaEndpoint, isServer: true, serverAddress, serverAddresses: serverAddresses || [], addressFormatType, addressFormatVersion, accessServers }); + // Серверная админка показывает баланс client/device-кошелька; именно он оплачивает создание PDA. + return createShineUserPdaOnSolana({ login, keyBundle, solanaEndpoint, isServer: true, serverAddress, serverAddresses: serverAddresses || [], addressFormatType, addressFormatVersion, accessServers, feePayerPrivatePkcs8B64: keyBundle.clientPair.privatePkcs8B64 }); } export async function closeLegacyShineUserPdaOnSolana({ login, solanaEndpoint, callerPrivatePkcs8B64 }) { diff --git a/shine-UI/js/services/solana-register-service.js b/shine-UI/js/services/solana-register-service.js index f19306e6..b493c01d 100644 --- a/shine-UI/js/services/solana-register-service.js +++ b/shine-UI/js/services/solana-register-service.js @@ -1,12 +1,6 @@ import { registerUserOnSolana as registerUserOnSolanaShared } from './shine-user-pda-service.js'; -import { - SHINE_USERS_PROGRAM_ID, - SHINE_LOGIN_GUARD_PROGRAM_ID, -} from '../solana-programs.js'; import { loadSolanaWeb3 } from '../vendor/solana-web3-loader.js'; - -const CLASSIFY_LOGIN_INSTRUCTION_TAG = 1; -const SHINE_USERS_USER_PDA_SEED_PREFIX = 'user_login='; +import { deriveUserPda, normalizeFullLogin } from './shine-namespace-service.js'; let solanaLibPromise = null; function loadSolanaLib() { @@ -14,37 +8,6 @@ function loadSolanaLib() { return solanaLibPromise; } -function pushU32LE(buf, v) { - const n = v >>> 0; - buf.push(n & 0xFF, (n >> 8) & 0xFF, (n >> 16) & 0xFF, (n >> 24) & 0xFF); -} - -class BorshBuf { - constructor() { this._b = []; } - u8(v) { this._b.push(v & 0xFF); } - u32(v) { pushU32LE(this._b, v); } - str(s) { - const enc = new TextEncoder().encode(s); - this.u32(enc.length); - for (const x of enc) this._b.push(x); - } - raw(bytes) { for (const x of bytes) this._b.push(x); } - result() { return new Uint8Array(this._b); } -} - -function serializeClassifyLoginArgs(login) { - const b = new BorshBuf(); - b.u8(CLASSIFY_LOGIN_INSTRUCTION_TAG); - b.str(String(login || '')); - return b.result(); -} - -function decodeU32FromB64(rawB64) { - const bytes = Uint8Array.from(atob(rawB64), (ch) => ch.charCodeAt(0)); - if (bytes.length < 4) throw new Error('LOGIN_GUARD_BAD_RETURN_DATA'); - return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(0, true); -} - function safeJson(value) { try { return JSON.stringify(value); @@ -94,64 +57,21 @@ export function isUserAlreadyExistsSolanaError(error) { || details.includes('Instruction 2: custom program error: 0x4'); } -export async function precheckLoginClassOnSolana({ login, solanaEndpoint }) { - const solana = await loadSolanaLib(); - const connection = new solana.Connection(String(solanaEndpoint || ''), 'confirmed'); - const loginGuardProgram = new solana.PublicKey(SHINE_LOGIN_GUARD_PROGRAM_ID); - const ix = new solana.TransactionInstruction({ - programId: loginGuardProgram, - keys: [], - data: serializeClassifyLoginArgs(String(login || '').toLowerCase()), - }); - const { blockhash } = await connection.getLatestBlockhash('confirmed'); - const v0Message = new solana.TransactionMessage({ - // Для simulateTransaction нужен существующий аккаунт payer. - // Используем сам program id, чтобы не зависеть от внешнего тестового адреса. - payerKey: loginGuardProgram, - recentBlockhash: blockhash, - instructions: [ix], - }).compileToV0Message(); - const tx = new solana.VersionedTransaction(v0Message); - - const sim = await connection.simulateTransaction(tx, { - commitment: 'confirmed', - sigVerify: false, - replaceRecentBlockhash: true, - }); - if (sim?.value?.err) { - const simErr = new Error(`LOGIN_GUARD_SIMULATION_FAILED: ${safeJson(sim.value.err)}`); - simErr.logs = sim?.value?.logs || []; - simErr.err = sim?.value?.err; - throw simErr; - } - const returnData = sim?.value?.returnData; - if (!returnData || returnData.programId !== SHINE_LOGIN_GUARD_PROGRAM_ID) { - throw new Error('LOGIN_GUARD_BAD_RETURN_DATA'); - } - const classValue = decodeU32FromB64(returnData.data?.[0] || ''); - if (classValue === 0) return { classCode: 0, className: 'free' }; - if (classValue === 1) return { classCode: 1, className: 'premium' }; - if (classValue === 2) return { classCode: 2, className: 'company' }; - return { classCode: classValue, className: 'unknown' }; +export async function precheckLoginClassOnSolana() { + throw new Error('CLASSIFY_LOGIN_DEPRECATED: новая регистрация использует namespace PDA; UI требуется обновить на этапе 10'); } export async function checkLoginExistsOnSolana({ login, solanaEndpoint }) { + const full = normalizeFullLogin(login); const solana = await loadSolanaLib(); const connection = new solana.Connection(String(solanaEndpoint || ''), 'confirmed'); - const usersProgram = new solana.PublicKey(SHINE_USERS_PROGRAM_ID); - const enc = new TextEncoder(); - const loginNorm = String(login || '').trim().toLowerCase(); - if (!loginNorm) { - throw new Error('EMPTY_LOGIN'); - } - const [userPda] = solana.PublicKey.findProgramAddressSync( - [enc.encode(SHINE_USERS_USER_PDA_SEED_PREFIX), enc.encode(loginNorm)], - usersProgram, - ); + const userPda = await deriveUserPda(full); const ai = await connection.getAccountInfo(userPda, 'confirmed'); - return { exists: !!ai, userPda: userPda.toBase58() }; + // Для type2 нужно также сверяться с отдельным серверным индексом free сертификатов; + // отсутствие PDA НЕ является доказательством свободы логина. + return { exists: Boolean(ai), userPda: userPda.toBase58(), solanaPdaExists: Boolean(ai) }; } -export async function registerUserOnSolana({ login, keyBundle, solanaEndpoint, accessServers, promoCode = '' }) { - return registerUserOnSolanaShared({ login, keyBundle, solanaEndpoint, accessServers, promoCode }); +export async function registerUserOnSolana({ login, keyBundle, solanaEndpoint, accessServers, registrarSignature64 = null }) { + return registerUserOnSolanaShared({ login, keyBundle, solanaEndpoint, accessServers, registrarSignature64 }); } diff --git a/shine-UI/js/state.js b/shine-UI/js/state.js index 9672ee44..cef41c5d 100644 --- a/shine-UI/js/state.js +++ b/shine-UI/js/state.js @@ -459,6 +459,12 @@ function createInitialState({ withStoredSession = true } = {}) { }, registrationDraft: { flowType: '', + namespaceFeeLamports: '', + namespaceServerLogin: '', + email: '', + challengeId: '', + challengeExpiresAtMs: 0, + dataItemId: '', login: '', password: '', passwordMode: 'single', diff --git a/shine-UI/server-ui/create-server-pda.html b/shine-UI/server-ui/create-server-pda.html index ac2560ff..af26bec9 100644 --- a/shine-UI/server-ui/create-server-pda.html +++ b/shine-UI/server-ui/create-server-pda.html @@ -42,7 +42,7 @@

Регистрация серверного аккаунта

-

Создаёт серверную user_pda в Solana (PDA 1.2)

+

Создаёт серверную user_pda в Solana (PDA 1.2) по полному логину server@shine

Параметры Solana

@@ -57,11 +57,12 @@

Данные сервера

- -
Только a-z, 0-9, _ · без точки · макс. 20 символов
+ +
Полный логин server@shine · только a-z, 0-9, _ и одна @ · максимум 30 байт. Namespace типа 1 должен уже существовать в Solana.
+
Сначала создайте @shine и настройте Solana endpoint. Проверка выполняется перед отправкой.
- +
@@ -111,7 +112,7 @@
Положите SOL на этот адрес перед регистрацией:
-
Это Solana-адрес device-ключа (public key в base58 = Solana-адрес). С него оплачиваются и создание, и обновление PDA.
+
Это Solana-адрес client/device-ключа (base58). В этой форме он оплачивает создание серверного PDA; для обновления PDA проверьте отдельный экран и его fee payer.
Баланс device ещё не запрашивался.
diff --git a/shine-UI/server-ui/js/create-server-pda-page.js b/shine-UI/server-ui/js/create-server-pda-page.js index 05acbf99..87139d0d 100644 --- a/shine-UI/server-ui/js/create-server-pda-page.js +++ b/shine-UI/server-ui/js/create-server-pda-page.js @@ -1,4 +1,5 @@ import { registerServerOnSolana } from '../../js/services/shine-user-pda-service.js'; +import { getNamespace, assertLoginInNamespace } from '../../js/services/shine-namespace-service.js'; import { $, buildKeyBundleFromForm, @@ -33,7 +34,7 @@ const fieldMap = { setupPasswordEye($('btnEye'), $('password')); wireDeviceAddressPreview(fieldMap); $('password').value = ''; -$('login').placeholder = defaultServerLogin; +$('login').placeholder = defaultServerLogin.includes('@') ? defaultServerLogin : `${defaultServerLogin}@shine`; $('serverAddress').placeholder = defaultServerAddress; $('endpoint').value = defaultSolanaEndpoint; @@ -91,8 +92,15 @@ $('btnCreate').addEventListener('click', async () => { $('btnCreate').disabled = true; try { const login = validateLoginOrThrow($('login').value); + if (!login.includes('@')) throw new Error('Новая серверная регистрация требует полный логин, например server@shine'); const endpoint = String($('endpoint').value || '').trim(); if (!endpoint) throw new Error('Укажите Solana endpoint'); + setStatus($('status'), 'Проверка namespace в Solana...', 'info'); + const namespace = await getNamespace({ namespace: login.split('@')[1], solanaEndpoint: endpoint }); + assertLoginInNamespace(login, namespace); + if (namespace.type !== 1) throw new Error('Сервер должен регистрироваться в платном namespace типа 1 (например @shine)'); + const namespaceFee = namespace.registrationFeeLamports.toString(); + $('namespaceInfo').textContent = `Namespace @${namespace.namespace} проверен · комиссия: ${namespaceFee} lamports. Дополнительно потребуется rent и комиссия транзакции.`; const serverAddress = String($('serverAddress').value || '').trim(); if (!serverAddress) throw new Error('Укажите адрес сервера'); diff --git a/shine-UI/server-ui/js/server-ui-shared.js b/shine-UI/server-ui/js/server-ui-shared.js index 0602ed09..2e5e73d7 100644 --- a/shine-UI/server-ui/js/server-ui-shared.js +++ b/shine-UI/server-ui/js/server-ui-shared.js @@ -9,7 +9,8 @@ import { } from '../../js/services/crypto-utils.js'; import { formatSol, getBalanceSol } from '../../js/services/solana-wallet-service.js'; -const LOGIN_RE = /^[a-z0-9_]{1,20}$/; +const LEGACY_LOGIN_RE = /^[a-z0-9_]{1,20}$/; +const FULL_LOGIN_RE = /^[a-z0-9_]+@[a-z0-9_]+$/; const ED25519_PKCS8_PREFIX = new Uint8Array([ 0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x04, 0x22, 0x04, 0x20, ]); @@ -24,8 +25,14 @@ export function normalizeLogin(login) { export function validateLoginOrThrow(login) { const clean = normalizeLogin(login); - if (!LOGIN_RE.test(clean)) { - throw new Error('Логин должен содержать только a-z, 0-9, _ и быть длиной 1..20 символов'); + if (clean.includes('@')) { + if (!FULL_LOGIN_RE.test(clean) || new TextEncoder().encode(clean).length > 30) { + throw new Error('Полный логин должен иметь вид server@shine, только a-z, 0-9, _, максимум 30 байт'); + } + return clean; + } + if (!LEGACY_LOGIN_RE.test(clean)) { + throw new Error('Старый логин должен содержать только a-z, 0-9, _ и быть длиной 1..20 символов'); } return clean; } diff --git a/shine-UI/server-ui/update-server-pda.html b/shine-UI/server-ui/update-server-pda.html index 82dff372..c3d741b5 100644 --- a/shine-UI/server-ui/update-server-pda.html +++ b/shine-UI/server-ui/update-server-pda.html @@ -64,7 +64,7 @@

Загрузить существующую PDA

- +
diff --git a/shine-UI/tests/registration-api-v2-contract.test.mjs b/shine-UI/tests/registration-api-v2-contract.test.mjs new file mode 100644 index 00000000..4fd02251 --- /dev/null +++ b/shine-UI/tests/registration-api-v2-contract.test.mjs @@ -0,0 +1,42 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import fs from 'node:fs'; +import path from 'node:path'; +import { fileURLToPath } from 'node:url'; +const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'../..'); +const read = path => fs.readFileSync(`${root}/${path}`,'utf8'); +const registry=read('SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonHandlerRegistry.java'); +const api=read('shine-UI/js/services/registration-v2-api.js'); +const ops=['GetNamespaces','CheckRegistrationLogin','CheckRegistrationEmail', + 'StartFreeRegistration','ConfirmFreeRegistration','GetRegistrationStatus']; +test('в серверном реестре ровно согласованные шесть операций, каждый op имеет request type',()=>{ + for(const op of ops) { + assert.ok(registry.includes(`Map.entry("${op}", new Net_Registration_Handler`)); + assert.ok(registry.includes(`Map.entry("${op}", Net_Registration_Request.class`)); + } + assert.doesNotMatch(registry,/Map\.entry\("CheckRegistrationAvailability"/); +}); +test('проверки login и email независимы и не отправляют лишних данных',()=>{ + assert.match(api,/checkRegistrationLogin = .*call\('CheckRegistrationLogin', \{ fullLogin:/); + assert.match(api,/checkRegistrationEmail = .*call\('CheckRegistrationEmail', \{ email \}/); +}); +test('free-регистрация передаёт ровно три публичных ключа, не пароли и не секреты',()=>{ + const request=api.match(/export const startFreeRegistration = \([\s\S]*?\n\}\);/); + assert.ok(request); + assert.match(request[0],/rootPublicKeyB64/); + assert.match(request[0],/blockchainPublicKeyB64/); + assert.match(request[0],/clientPublicKeyB64/); + assert.doesNotMatch(request[0],/password|masterSecret|privatePkcs8|seed32/); +}); +test('free экран показывает учебный код и ждёт Turbo, платный upgrade требует сравнить ключи',()=>{ + const email=read('shine-UI/js/pages/registration-email-view.js'); + assert.match(email,/код 1111/);assert.match(email,/confirmFreeRegistration/); + assert.match(email,/completeRegistrationLogin/); + const upgrade=read('shine-UI/js/pages/registration-upgrade-view.js'); + assert.match(upgrade,/keys\.rootPair/);assert.match(upgrade,/bytesToBase58/); + assert.match(upgrade,/upgradeFreeUserOnSolana/); +}); +test('никто не выкладывает регистрационный email в debug log',()=>{ + const processor=read('SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonInboundProcessor.java'); + assert.match(processor,/registration payload redacted/); +}); diff --git a/shine-UI/tests/registration-namespace-v2.test.mjs b/shine-UI/tests/registration-namespace-v2.test.mjs new file mode 100644 index 00000000..e2607adc --- /dev/null +++ b/shine-UI/tests/registration-namespace-v2.test.mjs @@ -0,0 +1,52 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import fs from 'node:fs'; +import { fileURLToPath } from 'node:url'; +import { resolve, dirname } from 'node:path'; +import { encodeNamespacePda, decodeNamespacePda, normalizeFullLogin, userPdaSeed32, + namespacePdaSeed32, buildFreeCertificateInnerMessage } from '../js/services/shine-namespace-service.js'; +import { serializeCreateUserPdaArgs } from '../js/services/shine-user-pda-service.js'; +const dirnameHere = dirname(fileURLToPath(import.meta.url)); +const props = Object.fromEntries(fs.readFileSync(resolve(dirnameHere, '../../shine-solana/shine/tests/fixtures/registration-v2.properties'), 'utf8') + .split(/\r?\n/).filter(x => x.includes('=')).map(line => [line.slice(0,line.indexOf('=')), line.slice(line.indexOf('=')+1)])); +const hex = x => Buffer.from(x).toString('hex'); +const bh = x => Uint8Array.from(Buffer.from(x, 'hex')); + +test('строгая нормализация полных логинов', () => { + assert.equal(normalizeFullLogin('alice@shine'), 'alice@shine'); + for (const bad of ['alice','ALICE@shine','alice@Shine',' alice@shine','alice@@shine','alice.s@shine','a'.repeat(30)+'@a']) + assert.throws(() => normalizeFullLogin(bad)); + assert.notEqual(normalizeFullLogin('a_b@shine'), normalizeFullLogin('ab@shine')); +}); +test('namespace v1 бинарно соответствует Rust/Java вектору', () => { + const raw = bh(props.namespace_free_bytes_hex); + const ns = decodeNamespacePda(raw); + assert.equal(ns.namespace, 'free'); assert.equal(ns.type, 2); + assert.equal(ns.serverLogin, 'registrar@shine'); + assert.deepEqual(encodeNamespacePda(ns), raw); + assert.throws(() => decodeNamespacePda(new Uint8Array([...raw, 0]))); + assert.throws(() => decodeNamespacePda(raw.slice(0,-1))); +}); +test('SHA256 PDA seeds stable and domain separated', async () => { + assert.equal(hex(await userPdaSeed32('bob@free')), props.user_bob_free_seed); + assert.equal(hex(await namespacePdaSeed32('free')), props.namespace_free_seed); + assert.notEqual(hex(await userPdaSeed32('bob@free')), hex(await namespacePdaSeed32('free'))); +}); +test('inner message is byte-for-byte fixture', () => { + const b = buildFreeCertificateInnerMessage('bob@free', + bh('03a107bff3ce10be1d70dd18e74bc09967e4d6309ba50d5f1ddc8664125531b8'), + bh('29acbae141bccaf0b22e1a94d34d0bc7361e526d0bfe12c89794bc9322966dd7'), + bh('2543b92ff1095511476adc8369db6ddc933665a11978dda1404ee1066ca9559d')); + assert.equal(hex(b), props.inner_message_hex); +}); +test('create instruction suffix encodes registrar signature, never promo', () => { + const common = {login:'bob@free', rootKey32: new Uint8Array(32), createdAtMs:1n, + clientKey32:new Uint8Array(32), blockchainKey32:new Uint8Array(32), + recordSignature64:new Uint8Array(64), accessServers:[], serverAddresses:[]}; + const paid = serializeCreateUserPdaArgs(common); + const free = serializeCreateUserPdaArgs({...common, registrarSignature64: new Uint8Array(64).fill(7)}); + assert.equal(paid[paid.length-1], 0); + assert.equal(free[paid.length-1], 1); + assert.deepEqual(free.slice(paid.length), new Uint8Array(64).fill(7)); + assert.equal(free[0],3); +}); diff --git a/shine-UI/tests/server-pda-v2-ui.test.mjs b/shine-UI/tests/server-pda-v2-ui.test.mjs new file mode 100644 index 00000000..89fc9b0f --- /dev/null +++ b/shine-UI/tests/server-pda-v2-ui.test.mjs @@ -0,0 +1,21 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { readFileSync } from 'node:fs'; +import { validateLoginOrThrow } from '../server-ui/js/server-ui-shared.js'; +const read = p => readFileSync(new URL(p, import.meta.url), 'utf8'); +test('server UI принимает полные логины и legacy при обновлении', () => { + assert.equal(validateLoginOrThrow('server@shine'), 'server@shine'); + assert.equal(validateLoginOrThrow('old_server'), 'old_server'); + assert.throws(() => validateLoginOrThrow('x'.repeat(26)+'@shine')); + assert.throws(() => validateLoginOrThrow('server@@shine')); + assert.throws(() => validateLoginOrThrow('server.name@shine')); +}); +test('форма создания требует namespace type1 и правильный fee payer', () => { + const page = read('../server-ui/js/create-server-pda-page.js'); + const service = read('../js/services/shine-user-pda-service.js'); + const html = read('../server-ui/create-server-pda.html'); + assert.match(page, /namespace\.type !== 1/); + assert.match(page, /getNamespace\(/); + assert.match(html, /maxlength="30"/); + assert.match(service, /feePayerPrivatePkcs8B64: keyBundle\.clientPair\.privatePkcs8B64/); +}); diff --git a/shine-solana/shine/doc/formats/shine-namespace-pda-format-v1.md b/shine-solana/shine/doc/formats/shine-namespace-pda-format-v1.md new file mode 100644 index 00000000..caf6d008 --- /dev/null +++ b/shine-solana/shine/doc/formats/shine-namespace-pda-format-v1.md @@ -0,0 +1,41 @@ +# SHiNE — Namespace PDA, бинарный формат 1.0 + +Статус: **черновая реализация в объединённом патче этапов 1–3**, не развёрнута; формат предложен как протокол V1. Перед деплоем обязательна компиляция Rust и тесты localnet/devnet. + +## Идентичность и адреса + +- `login@namespace`: строго ASCII lowercase, обе части `[a-z0-9_]+`, ровно один `@`. +- Полная длина имени — не более **30 байт**; `min_localpart_len` из namespace. Никаких обрезаний, удаления `_`, автоматических преобразований регистра; некорректный ввод отвергается. +- Пользовательский PDA: `seed=SHA256(UTF8("user_login=" + fullLogin))`, **один seed из 32 сырых байт**; `findProgramAddress([seed], shine_users_program_id)`. +- Namespace PDA: `seed=SHA256(UTF8("namespace=" + namespace))`, **один seed из 32 сырых байт**; `findProgramAddress([seed], shine_users_program_id)`. +- `program_id` из тестовых векторов: `SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6`. При другой программе адреса PDA изменятся. + +## NamespaceState 1.0, байтовая раскладка + +| Смещение | Значение | Байты | +|---|---|---:| +| 0 | major=1 | 1 | +| 1 | minor=0 | 1 | +| 2 | namespace_type: 1 платный; 2 бесплатный сертификат | 1 | +| 3 | min_localpart_len: u8, не менее 1, вместе с названием укладывается в 30 байт | 1 | +| 4 | namespace_len: u8 | 1 | +| 5 | namespace: lowercase ASCII | namespace_len | +| следующий | registration_fee: u64 little-endian (lamports) | 8 | +| только type=2 | registrar_pubkey: Ed25519 | 32 | +| только type=2 | server_login_len: u8; server_login в формате `login@namespace` | 1+N | + +**Размер аккаунта ровно соответствует сериализованному размеру. Padding в namespace-PDA отсутствует.** Десериализатор отвергает лишние/недостающие байты, неверные версии, неизвестные типы, пустые/невалидные имена, несоответствие PDA, owner, namespace. В type=1 НЕ существует дополнительных нулевых полей. В type=2 оба поля обязательны. Цена допускает `0` для тестового namespace; защищённый signer authority выбирает значение до создания аккаунта. Изменение или удаление namespace пока отсутствует. + +## Полномочия и создание + +Создавать namespaces может только **текущая upgrade authority именно этой программы**. Программа читает аккаунт самой программы (`UpgradeableLoaderState::Program`) и связанный с ним ProgramData, проверяет владельца upgradeable loader, совпадение programData address и `Some(upgrade_authority)` с фактическим подписантом. При immutable программе — отказ. Для type=2 обязательная дополнительная read-only мета с **настоящим PDA v1.2** указанного `server_login`, у записи должен быть ServerProfile адрес; сначала регистрируется сервер в платном namespace. Economy PDA должен существовать, передаётся read-only, чтобы транзакция находилась через его историю `getSignaturesForAddress`. Уведомление `accountSubscribe` только из-за read-only меты не гарантировано. + +## Векторы и воспроизводимость + +- `tests/fixtures/registration-v2.json` — полный вектор, включая реальные синтетические ANS-104 bytes. +- `tests/fixtures/registration-v2.properties` — общий простой формат для Rust/Java/JS. +- `node --test tests/registration-v2-vectors.test.mjs` — проверка в Node без npm. +- `javac --release 17 -d /tmp/shine-reg-v2 tests/java/RegistrationV2VectorsCheck.java && java -cp /tmp/shine-reg-v2 RegistrationV2VectorsCheck tests/fixtures/registration-v2.properties`. +- `cargo test --test registration_v2_vectors` — в Rust окружении с toolchain (здесь недоступно). + +Детерминированные приватные ключи, которыми построены фикстуры, **никогда не использовать** как настоящие ключи пользователей/регистратора. diff --git a/shine-solana/shine/doc/formats/shine-user-pda-format-v.1.2.md b/shine-solana/shine/doc/formats/shine-user-pda-format-v.1.2.md index af7018fe..0e6b773c 100644 --- a/shine-solana/shine/doc/formats/shine-user-pda-format-v.1.2.md +++ b/shine-solana/shine/doc/formats/shine-user-pda-format-v.1.2.md @@ -183,3 +183,10 @@ Root доказывает владение recovery-key отдельной Ed255 - переводит его lamports вызывающему signer. Legacy migration в 1.2 отсутствует. После удаления тестовых PDA временную close-инструкцию можно удалить из программы. + + +## Изменение адресации регистрации V2 (этапы 1–3, dev-only) + +Бинарный user-PDA 1.2 **не изменён**. Меняется seed новых PDA на `SHA256(UTF8("user_login="+normalizedFullLogin))` (32 сырых байта), а полная строка `login@namespace` входит в поле `login` и в существующую подпись. Ограничение полного имени — 30 байт. `created_at_ms` в новой PDA при free→paid соответствует дате on-chain создания и не является датой первого Arweave сертификата. Историческая идентичность и потраченные лимиты остаются за логическим пользователем, их сохраняет сервер/БД последующих этапов. + +Существующие PDA старых логинов без namespace продолжают принимать `update_user_pda` по старому seed `user_login=` + lowercase login; новых аккаунтов такого типа создать V2 больше нельзя. Новая регистрация **не будет совместима со старым клиентом** до обновления JS/сервера. diff --git a/shine-solana/shine/doc/programs/shine_users.md b/shine-solana/shine/doc/programs/shine_users.md index dbb5ebeb..483a0ec5 100644 --- a/shine-solana/shine/doc/programs/shine_users.md +++ b/shine-solana/shine/doc/programs/shine_users.md @@ -21,41 +21,55 @@ Legacy 1.0 считается тестовым и не мигрируется. Без изменений. ### `2 update_users_economy_config` -Без изменений. -### `3 create_user_pda` +Меняется **только** право доступа: текущая upgrade authority из ProgramData данного `shine_users`, а не статическая DAO-константа. Accounts: `signer writable?` (signer), `users_economy_config_pda writable`, `program read-only executable`, `programdata read-only`. `init` (opcode 1) остаётся доступным любому подписанту один раз. + + +### `3 create_user_pda` — новая V2-инструкция + +**Внимание:** wire и account metas здесь уже несовместимы со старым UI. До завершения клиентского этапа №4 **НЕ DEPLOY** программу. Клиентский JS ещё не переписан. ```text tag:u8 = 3 -login:string_u8 +login:string_u8 // полный lowercase login@namespace, <= 30 байт root_key:[32] -created_at_ms:u64 -additional_limit:u64 +created_at_ms:u64 LE // новая Solana дата в пределах +-5 мин +additional_limit:u64 LE // кратно LIMIT_STEP client_key:[32] blockchain_key:[32] address_count:u8 // 0 или 1 -[address] +[address] // type:u8, version:u8, address:string_u8 access_server_count:u8 // 0 или 1 -[access_server] -record_signature:[64] -[promo_seller_login:string_u8] +[access_server:string_u8] +record_signature:[64] // подпись текущего blockchain-key, сохраняется в PDA +registrar_signature_present:u8 // 0 для type 1, 1 для type 2 +[registrar_signature:[64]] // только type 2, внутренняя подпись сертификата ``` -Server address: +Accounts в неизменном порядке: -```text -address_format_type:u8 -address_format_version:u8 -address:string_u8 -``` +1. `payer` — signer, writable; +2. `user_pda` — writable (SHA-256 полного логина); +3. `system_program` — read-only; +4. `shine_payments` inflow vault — writable; +5. `sysvar::instructions` — read-only; +6. `users_economy_config_pda` — **read-only**; +7. `namespace_pda` — read-only, owner `shine_users`. -Fee payer — любой переданный signer; он не обязан совпадать с client key. -`created_at_ms` должен быть в пределах ±5 минут от Solana Clock. -Root даёт proof-of-possession, а initial blockchain key подписывает саму новую PDA. +Проверки: namespace реально существует в программе, `localPart >= min_localpart_len`, общая длина <= 30, обе части ASCII lowercase `[a-z0-9_]+`, PDA соответствует `SHA256("user_login="+fullLogin)`, схема v1.2, root и blockchain Ed25519 proof-of-possession. Цена = `namespace.registration_fee + additional_limit/LIMIT_STEP * economy.lamports_per_limit_step` в существующий `shine_payments` vault. На create сохраняется существующая схема starter quota из economy-PDA: при переходе free→paid внешняя БД обязана учесть уже использованный бонус и не выдать его снова. + +**Ed25519 инструкции перед opcode 3 (строго непосредственно):** + +- Тип 1: `[root_verify(unsigned_hash), blockchain_verify(unsigned_hash), create_user]`; смещения `-2`, `-1`. +- Тип 2: `[registrar_verify(inner_message), root_verify(unsigned_hash), blockchain_verify(unsigned_hash), create_user]`; смещения `-3`, `-2`, `-1`. + +Всем проверкам нужны именно требуемые `pubkey`, `message`, а blockchain также сопоставляется с `record_signature`. Проверка сертификата использует `registrar_pubkey` **из указанного namespace-PDA**, а не ключ клиента. Порядок байтов inner message см. `docs/Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md`. Solana подтверждает право создать PDA, но не утверждает успешную публикацию сертификата в Arweave. + +**Upgrade free→paid** — тот же opcode 3 на том же полном логине и публичных ключах. Старые приватные ключи клиента не раскрываются; сохранение исходных публикаций обеспечивают синхронизатор/сервер (не Solana). Дата создания on-chain PDA может быть новой. Повторное создание PDA отвергается. ### `4 update_user_pda` -Работает только с PDA 1.2. +Работает только с PDA 1.2. Для нового `login@namespace` ищет SHA-256 PDA; для существующего старого логина без `@` сохраняет прежнюю схему `[b"user_login=", lowercase_login]`, чтобы не блокировать прежние аккаунты. Оплата дополнительных лимитов и авторизация обновлений не меняются. ```text tag:u8 = 4 @@ -101,8 +115,9 @@ Root-mode: Обе Ed25519-подписи проверяются по одному и тому же hash нового unsigned PDA state, поэтому новые root/client/blockchain public keys входят в подписываемое состояние. -### `5 upsert_promo_seller` -Без изменений. +### `5` — зарезервированная старая promo instruction + +В V2 диспетчер не исполняет opcode 5. Новая регистрация не обращается в `shine_login_guard`, не использует promo seller и premium классы. Исторические standalone программы не удалялись. ### `6 close_legacy_pda` @@ -120,6 +135,21 @@ Accounts: Программа проверяет PDA seed/owner и `format=1.0`, переводит все lamports PDA вызывающему и обнуляет account data. PDA 1.2 этой инструкцией закрыть нельзя. +### `7 create_namespace` + +```text +tag:u8=7 +namespace_type:u8 // 1 paid-direct / 2 free-cert +min_localpart_len:u8 +namespace:string_u8 +registration_fee:u64 LE +[if type=2: registrar_pubkey:[32]; server_login:string_u8] +``` + +Accounts: `payer signer writable`, `namespace_pda writable`, `system_program read-only`, `economy_pda read-only`, `shine_users program executable read-only`, `shine_users ProgramData read-only`; **только type=2** — `registered_access_server_user_pda` (read-only) настоящего зарегистрированного сервера с ServerProfile. + +Проверки: точный PDA по 32-байтному SHA-256 seed `namespace=NAME`, owner, пустой system PDA, версия 1.0, длина имени, тип, поля регистратора; economy валиден и read-only; `ProgramData` строго относится к этому исполняемому program ID и `upgrade_authority=Some(signer)`. У immutable программы создание запрещено; изменить/удалить namespace нельзя. Отдельная документация: `doc/formats/shine-namespace-pda-format-v1.md`. + ## BlockchainRegistry 1.2 ```text diff --git a/shine-solana/shine/programs/shine_users/src/lib.rs b/shine-solana/shine/programs/shine_users/src/lib.rs index 99923f18..b2acadb0 100644 --- a/shine-solana/shine/programs/shine_users/src/lib.rs +++ b/shine-solana/shine/programs/shine_users/src/lib.rs @@ -3,9 +3,9 @@ use solana_program::{ clock::Clock, entrypoint, entrypoint::ProgramResult, - hash::hashv, - instruction::Instruction, - program::{get_return_data, invoke, invoke_signed}, + hash::{hash, hashv}, + bpf_loader_upgradeable, + program::{invoke, invoke_signed}, program_error::ProgramError, program_memory::sol_memcmp, pubkey::Pubkey, @@ -44,9 +44,9 @@ const IX_INIT_USERS_ECONOMY_CONFIG: u8 = 1; const IX_UPDATE_USERS_ECONOMY_CONFIG: u8 = 2; const IX_CREATE_USER_PDA: u8 = 3; const IX_UPDATE_USER_PDA: u8 = 4; -const IX_UPSERT_PROMO_SELLER: u8 = 5; const IX_CLOSE_LEGACY_USER_PDA: u8 = 6; -const LOGIN_GUARD_IX_CLASSIFY_LOGIN: u8 = 1; +const IX_CREATE_NAMESPACE: u8 = 7; +const CERTIFICATE_DOMAIN: &[u8] = b"SHiNE_FREE_REG_V1\0"; #[repr(u32)] #[derive(Clone, Copy, Debug)] @@ -91,6 +91,10 @@ enum ShineUsersError { RootChangeRequiresRoot = 38, AmbiguousAuthorityRotation = 39, RootModeRequiresFullRotation = 40, + InvalidNamespace = 41, + InvalidUpgradeAuthority = 42, + NamespaceAlreadyExists = 43, + CertificateRequired = 44, } impl From for ProgramError { @@ -161,7 +165,7 @@ pub struct CreateUserPdaArgs { pub server_addresses: Vec, pub access_servers: Vec, pub signature: [u8; 64], - pub promo_seller_login: Option, + pub registrar_signature: Option<[u8; 64]>, } #[derive(Clone, Debug)] @@ -198,20 +202,14 @@ pub struct UsersEconomyConfigState { pub start_bonus_limit: u64, } -#[derive(Clone, Debug)] -pub struct UpsertPromoSellerArgs { - pub seller_login: String, - pub remaining_sales: u64, - pub min_login_length: u8, - pub signer_pubkey: Pubkey, -} - -#[derive(Clone, Debug)] -pub struct PromoSellerState { - pub version: u8, - pub remaining_sales: u64, - pub min_login_length: u8, - pub signer_pubkey: Pubkey, +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct NamespaceState { + pub namespace_type: u8, + pub min_localpart_len: u8, + pub namespace: String, + pub registration_fee: u64, + pub registrar_pubkey: Option, + pub server_login: Option, } struct Reader<'a> { @@ -294,7 +292,11 @@ fn process_instruction<'a>(program_id: &Pubkey, accounts: &'a [AccountInfo<'a>], } IX_CREATE_USER_PDA => dispatch_create_user_pda(program_id, accounts, r), IX_UPDATE_USER_PDA => dispatch_update_user_pda(program_id, accounts, r), - IX_UPSERT_PROMO_SELLER => dispatch_upsert_promo_seller(program_id, accounts, r), + IX_CREATE_NAMESPACE => { + let args = parse_namespace_args(&mut r)?; + r.finish()?; + process_create_namespace(program_id, accounts, args) + }, IX_CLOSE_LEGACY_USER_PDA => dispatch_close_legacy_user_pda(program_id, accounts, r), _ => Err(ProgramError::from(ShineUsersError::InvalidInstruction)), } @@ -312,15 +314,19 @@ fn dispatch_update_user_pda(program_id: &Pubkey, accounts: &[AccountInfo], mut r process_update_user_pda(program_id, accounts, args) } -fn dispatch_upsert_promo_seller(program_id: &Pubkey, accounts: &[AccountInfo], mut r: Reader<'_>) -> ProgramResult { - let args = UpsertPromoSellerArgs { - seller_login: r.read_string_u8()?, - remaining_sales: r.read_u64()?, - min_login_length: r.read_u8()?, - signer_pubkey: r.read_pubkey()?, +fn parse_namespace_args(r: &mut Reader<'_>) -> Result { + let namespace_type = r.read_u8()?; + let min_localpart_len = r.read_u8()?; + let namespace = r.read_string_u8()?; + let registration_fee = r.read_u64()?; + let (registrar_pubkey, server_login) = match namespace_type { + 1 => (None, None), + 2 => (Some(r.read_pubkey()?), Some(r.read_string_u8()?)), + _ => return Err(ShineUsersError::InvalidNamespace.into()), }; - r.finish()?; - process_upsert_promo_seller(program_id, accounts, args) + let state = NamespaceState { namespace_type, min_localpart_len, namespace, registration_fee, registrar_pubkey, server_login }; + validate_namespace_state(&state)?; + Ok(state) } fn parse_server_addresses(r: &mut Reader<'_>) -> Result, ProgramError> { @@ -356,7 +362,11 @@ fn parse_create_args(r: &mut Reader<'_>) -> Result 0 { Some(r.read_string_u8()?) } else { None }, + registrar_signature: match r.read_u8()? { + 0 => None, + 1 => Some(r.read_fixed_64()?), + _ => return Err(ShineUsersError::InvalidInstruction.into()), + }, }) } @@ -433,11 +443,11 @@ fn process_update_users_economy_config(program_id: &Pubkey, accounts: &[AccountI let mut it = accounts.iter(); let signer = next_account_info(&mut it)?; let users_economy_config_pda = next_account_info(&mut it)?; + let program_ai = next_account_info(&mut it)?; + let programdata_ai = next_account_info(&mut it)?; require!(it.next().is_none(), ShineUsersError::InvalidInstruction); - require!(signer.is_signer, ShineUsersError::InvalidSigner); - let dao_authority = Pubkey::from_str(settings::DAO_AUTHORITY).map_err(|_| ProgramError::from(ShineUsersError::InvalidSigner))?; - require_keys_eq!(dao_authority, *signer.key, ShineUsersError::InvalidSigner); + validate_upgrade_authority(program_id, signer, program_ai, programdata_ai)?; let (expected_pda, _) = find_users_economy_config_pda(program_id); require_keys_eq!(expected_pda, *users_economy_config_pda.key, ShineUsersError::InvalidPdaAddress); require!(users_economy_config_pda.owner == program_id, ShineUsersError::InvalidPdaAddress); @@ -451,46 +461,55 @@ fn process_update_users_economy_config(program_id: &Pubkey, accounts: &[AccountI Ok(()) } -fn process_upsert_promo_seller(program_id: &Pubkey, accounts: &[AccountInfo], args: UpsertPromoSellerArgs) -> ProgramResult { +fn process_create_namespace(program_id: &Pubkey, accounts: &[AccountInfo], state: NamespaceState) -> ProgramResult { let mut it = accounts.iter(); let signer = next_account_info(&mut it)?; - let promo_seller_pda = next_account_info(&mut it)?; + let namespace_pda = next_account_info(&mut it)?; let system_program_ai = next_account_info(&mut it)?; + let economy_pda = next_account_info(&mut it)?; + let program_ai = next_account_info(&mut it)?; + let programdata_ai = next_account_info(&mut it)?; + // Для free namespace сервер обязан иметь уже созданную настоящую PDA 1.2. + let registered_server = if state.namespace_type == 2 { Some(next_account_info(&mut it)?) } else { None }; require!(it.next().is_none(), ShineUsersError::InvalidInstruction); require!(signer.is_signer, ShineUsersError::InvalidSigner); require_keys_eq!(*system_program_ai.key, system_program::id(), ShineUsersError::InvalidSystemProgram); - validate_login(&args.seller_login)?; - require!((1..=20).contains(&args.min_login_length), ShineUsersError::InvalidPromoSellerState); - - let dao_authority = Pubkey::from_str(settings::DAO_AUTHORITY).map_err(|_| ProgramError::from(ShineUsersError::InvalidSigner))?; - require_keys_eq!(dao_authority, *signer.key, ShineUsersError::InvalidSigner); - - let seller_seed = login_seed_normalized(&args.seller_login); - let (expected_pda, bump) = find_promo_seller_pda(program_id, &seller_seed); - require_keys_eq!(expected_pda, *promo_seller_pda.key, ShineUsersError::InvalidPdaAddress); - - if promo_seller_pda.owner == &system_program::id() { - create_pda_account( - signer, - promo_seller_pda, - system_program_ai, - program_id, - &[settings::PROMO_SELLER_PDA_SEED_PREFIX.as_bytes(), seller_seed.as_bytes(), &[bump]], - settings::PROMO_SELLER_PDA_SPACE, - )?; - } else { - require!(promo_seller_pda.owner == program_id, ShineUsersError::InvalidPdaAddress); - ensure_pda_size_and_rent(promo_seller_pda, signer, system_program_ai, settings::PROMO_SELLER_PDA_SPACE)?; + validate_upgrade_authority(program_id, signer, program_ai, programdata_ai)?; + if let Some(server_ai) = registered_server { + let login = state.server_login.as_deref().ok_or(ShineUsersError::InvalidNamespace)?; + require_keys_eq!(*server_ai.key, find_user_pda(program_id, login).0, ShineUsersError::InvalidPdaAddress); + require!(server_ai.owner == program_id, ShineUsersError::InvalidAccountOwner); + let server_record = deserialize_record_v12_from_pda(&read_pda_all(server_ai)?)?; + require!(server_record.login == login && !server_record.server_addresses.is_empty(), ShineUsersError::InvalidNamespace); } + validate_users_economy_config_pda(program_id, economy_pda)?; + read_users_economy_config(economy_pda)?; + require!(!economy_pda.is_writable, ShineUsersError::InvalidAccountData); + validate_namespace_state(&state)?; + let (expected, bump) = find_namespace_pda(program_id, &state.namespace); + require_keys_eq!(*namespace_pda.key, expected, ShineUsersError::InvalidPdaAddress); + require!(namespace_pda.owner == &system_program::id() && namespace_pda.data_is_empty(), ShineUsersError::NamespaceAlreadyExists); + let data = serialize_namespace(&state); + let seed = hash(format!("{}{}", settings::NAMESPACE_PDA_SEED_PREFIX, state.namespace).as_bytes()).to_bytes(); + create_pda_account(signer, namespace_pda, system_program_ai, program_id, &[&seed, &[bump]], data.len())?; + write_pda_exact(namespace_pda, &data) +} - let state = PromoSellerState { - version: 1, - remaining_sales: args.remaining_sales, - min_login_length: args.min_login_length, - signer_pubkey: args.signer_pubkey, - }; - write_pda_exact(promo_seller_pda, &serialize_promo_seller_state(&state))?; +/// Проверяем не просто подписанта, а актуальную authority ProgramData ИМЕННО этой программы. +/// Bincode layout UpgradeableLoaderState: Program = [2:u32LE, programdata:32], +/// ProgramData = [3:u32LE, slot:u64LE, Option:1+32]. +fn validate_upgrade_authority(program_id: &Pubkey, signer: &AccountInfo, program_ai: &AccountInfo, programdata_ai: &AccountInfo) -> ProgramResult { + require!(signer.is_signer, ShineUsersError::InvalidSigner); + require_keys_eq!(*program_ai.key, *program_id, ShineUsersError::InvalidUpgradeAuthority); + require!(program_ai.executable && *program_ai.owner == bpf_loader_upgradeable::id(), ShineUsersError::InvalidUpgradeAuthority); + let program_data = program_ai.try_borrow_data()?; + require!(program_data.len() >= 36 && program_data[0..4] == 2u32.to_le_bytes(), ShineUsersError::InvalidUpgradeAuthority); + require!(program_data[4..36] == programdata_ai.key.to_bytes(), ShineUsersError::InvalidUpgradeAuthority); + require!(*programdata_ai.owner == bpf_loader_upgradeable::id(), ShineUsersError::InvalidUpgradeAuthority); + let pd = programdata_ai.try_borrow_data()?; + require!(pd.len() >= 45 && pd[0..4] == 3u32.to_le_bytes(), ShineUsersError::InvalidUpgradeAuthority); + require!(pd[12] == 1 && pd[13..45] == signer.key.to_bytes(), ShineUsersError::InvalidUpgradeAuthority); Ok(()) } @@ -502,38 +521,38 @@ fn process_create_user_pda<'a>(program_id: &Pubkey, accounts: &'a [AccountInfo<' let inflow_vault = next_account_info(&mut it)?; let instructions_sysvar = next_account_info(&mut it)?; let users_economy_config_pda = next_account_info(&mut it)?; - let login_guard_program = next_account_info(&mut it)?; - let promo_seller_pda = it.next(); + let namespace_pda = next_account_info(&mut it)?; require!(it.next().is_none(), ShineUsersError::InvalidInstruction); require!(signer.is_signer, ShineUsersError::InvalidSigner); require_keys_eq!(*system_program_ai.key, system_program::id(), ShineUsersError::InvalidSystemProgram); - - validate_login(&args.login)?; + let namespace_name = validate_full_login(&args.login)?; + require!(!namespace_pda.is_writable, ShineUsersError::InvalidAccountData); + let namespace = read_namespace(program_id, namespace_pda, namespace_name)?; + let local_len = args.login.split('@').next().unwrap().len(); + require!(local_len >= namespace.min_localpart_len as usize, ShineUsersError::InvalidLogin); validate_server_addresses(&args.server_addresses)?; validate_access_servers(&args.access_servers)?; + for server in &args.access_servers { validate_full_login(server)?; } validate_inflow_vault(inflow_vault)?; require!(args.additional_limit % settings::LIMIT_STEP == 0, ShineUsersError::InvalidLimitIncrement); - require_keys_eq!(*login_guard_program.key, Pubkey::from_str(settings::SHINE_LOGIN_GUARD_PROGRAM_ID).map_err(|_| ProgramError::from(ShineUsersError::InvalidLoginGuardResponse))?, ShineUsersError::InvalidLoginGuardResponse); validate_users_economy_config_pda(program_id, users_economy_config_pda)?; - - let promo_context = if let Some(seller_login) = args.promo_seller_login.as_deref().filter(|value| !value.trim().is_empty()) { - let seller_pda = promo_seller_pda.ok_or(ProgramError::from(ShineUsersError::InvalidInstruction))?; - Some(verify_promo_registration(program_id, instructions_sysvar, seller_pda, &args.login, seller_login)?) - } else { - require!(promo_seller_pda.is_none(), ShineUsersError::InvalidInstruction); - None - }; - if promo_context.is_none() { - classify_login_or_fail(login_guard_program, &args.login)?; - } - + require!(!users_economy_config_pda.is_writable, ShineUsersError::InvalidAccountData); let economy = read_users_economy_config(users_economy_config_pda)?; - let login_seed = login_seed_normalized(&args.login); - let (expected_pda, bump) = find_user_pda(program_id, &login_seed); + let (expected_pda, bump) = find_user_pda(program_id, &args.login); require_keys_eq!(expected_pda, *user_pda.key, ShineUsersError::InvalidPdaAddress); require!(user_pda.owner == &system_program::id(), ShineUsersError::UserAlreadyExists); require!(user_pda.data_is_empty(), ShineUsersError::UserAlreadyExists); + match namespace.namespace_type { + 1 => require!(args.registrar_signature.is_none(), ShineUsersError::InvalidInstruction), + 2 => { + let signature = args.registrar_signature.as_ref().ok_or(ShineUsersError::CertificateRequired)?; + let registrar = namespace.registrar_pubkey.ok_or(ShineUsersError::InvalidNamespace)?; + let message = certificate_inner_message(&args.login, &args.root_key, &args.blockchain_key, &args.client_key)?; + verify_ed25519_signature_instruction(instructions_sysvar, -3, ®istrar, signature, &message)?; + }, + _ => return Err(ShineUsersError::InvalidNamespace.into()), + } let start_balance_u64 = economy.start_bonus_limit.checked_add(args.additional_limit).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?; let start_balance = u32::try_from(start_balance_u64).map_err(|_| ProgramError::from(ShineUsersError::PaidLimitTooLarge))?; @@ -572,16 +591,12 @@ fn process_create_user_pda<'a>(program_id: &Pubkey, accounts: &'a [AccountInfo<' user_pda, system_program_ai, program_id, - &[settings::USER_PDA_SEED_PREFIX.as_bytes(), login_seed.as_bytes(), &[bump]], + &[&user_pda_seed(&record.login), &[bump]], settings::USER_PDA_SPACE, )?; write_pda_exact(user_pda, &serialized)?; - if let Some(promo) = promo_context { - write_pda_exact(promo.promo_seller_pda, &serialize_promo_seller_state(&promo.updated_state))?; - } - - let total_fee = economy.registration_fee_lamports.checked_add(limit_fee_lamports(args.additional_limit, economy.lamports_per_limit_step)?).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?; + let total_fee = namespace.registration_fee.checked_add(limit_fee_lamports(args.additional_limit, economy.lamports_per_limit_step)?).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?; transfer_lamports(signer, inflow_vault, system_program_ai, total_fee)?; Ok(()) } @@ -598,7 +613,10 @@ fn process_update_user_pda(program_id: &Pubkey, accounts: &[AccountInfo], args: require!(signer.is_signer, ShineUsersError::InvalidSigner); require_keys_eq!(*system_program_ai.key, system_program::id(), ShineUsersError::InvalidSystemProgram); - validate_login(&args.login)?; + // Старые аккаунты без namespace сохраняют прежнюю возможность update. + // Новый create всегда требует полный login@namespace. + if args.login.contains('@') { validate_full_login(&args.login)?; } + else { validate_legacy_login(&args.login)?; } validate_server_addresses(&args.server_addresses)?; validate_access_servers(&args.access_servers)?; validate_inflow_vault(inflow_vault)?; @@ -606,8 +624,12 @@ fn process_update_user_pda(program_id: &Pubkey, accounts: &[AccountInfo], args: validate_users_economy_config_pda(program_id, users_economy_config_pda)?; let economy = read_users_economy_config(users_economy_config_pda)?; - let normalized_login = login_seed_normalized(&args.login); - require_keys_eq!(find_user_pda(program_id, &normalized_login).0, *user_pda.key, ShineUsersError::InvalidPdaAddress); + let expected_pda = if args.login.contains('@') { + find_user_pda(program_id, &args.login).0 + } else { + find_legacy_user_pda(program_id, &args.login.to_ascii_lowercase()).0 + }; + require_keys_eq!(expected_pda, *user_pda.key, ShineUsersError::InvalidPdaAddress); require!(user_pda.owner == program_id, ShineUsersError::InvalidPdaAddress); let raw = read_pda_all(user_pda)?; @@ -703,9 +725,8 @@ fn process_close_legacy_user_pda(program_id: &Pubkey, accounts: &[AccountInfo], require!(caller.is_writable, ShineUsersError::InvalidAccountData); require!(user_pda.is_writable, ShineUsersError::InvalidAccountData); - validate_login(&args.login)?; - let normalized_login = login_seed_normalized(&args.login); - require_keys_eq!(find_user_pda(program_id, &normalized_login).0, *user_pda.key, ShineUsersError::InvalidPdaAddress); + validate_legacy_login(&args.login)?; + require_keys_eq!(find_legacy_user_pda(program_id, &args.login.to_ascii_lowercase()).0, *user_pda.key, ShineUsersError::InvalidPdaAddress); require!(user_pda.owner == program_id, ShineUsersError::InvalidPdaAddress); let raw = read_pda_all(user_pda)?; @@ -724,66 +745,6 @@ fn process_close_legacy_user_pda(program_id: &Pubkey, accounts: &[AccountInfo], Ok(()) } -struct PromoRegistrationContext<'a> { - promo_seller_pda: &'a AccountInfo<'a>, - updated_state: PromoSellerState, -} - -fn verify_promo_registration<'a>( - program_id: &Pubkey, - instructions_sysvar: &AccountInfo<'a>, - promo_seller_pda: &'a AccountInfo<'a>, - target_login: &str, - seller_login: &str, -) -> Result, ProgramError> { - validate_login(seller_login)?; - let normalized_seller_login = login_seed_normalized(&seller_login); - let expected_pda = find_promo_seller_pda(program_id, &normalized_seller_login).0; - require_keys_eq!(expected_pda, *promo_seller_pda.key, ShineUsersError::InvalidPdaAddress); - require!(promo_seller_pda.owner == program_id, ShineUsersError::PromoSellerNotFound); - - let state = read_promo_seller_state(promo_seller_pda)?; - require!(state.remaining_sales > 0, ShineUsersError::PromoSalesExhausted); - require!(target_login.len() >= state.min_login_length as usize, ShineUsersError::PromoLoginTooShort); - - let message = build_promo_sign_message(target_login); - verify_ed25519_instruction_pubkey_message(instructions_sysvar, -3, &state.signer_pubkey, message.as_bytes()) - .map_err(|_| ProgramError::from(ShineUsersError::PromoSignatureMismatch))?; - - let updated_state = PromoSellerState { - version: state.version, - remaining_sales: state.remaining_sales.saturating_sub(1), - min_login_length: state.min_login_length, - signer_pubkey: state.signer_pubkey, - }; - Ok(PromoRegistrationContext { - promo_seller_pda, - updated_state, - }) -} - -fn classify_login_or_fail(login_guard_program: &AccountInfo, login: &str) -> ProgramResult { - let login_guard_program_id = Pubkey::from_str(settings::SHINE_LOGIN_GUARD_PROGRAM_ID) - .map_err(|_| ProgramError::from(ShineUsersError::InvalidLoginGuardResponse))?; - require_keys_eq!(*login_guard_program.key, login_guard_program_id, ShineUsersError::InvalidLoginGuardResponse); - let mut data = Vec::with_capacity(1 + 4 + login.len()); - data.push(LOGIN_GUARD_IX_CLASSIFY_LOGIN); - data.extend_from_slice(&(login.len() as u32).to_le_bytes()); - data.extend_from_slice(login.as_bytes()); - let ix = Instruction { program_id: login_guard_program_id, accounts: vec![], data }; - invoke(&ix, &[login_guard_program.clone()])?; - let (program_id, raw) = get_return_data().ok_or(ProgramError::from(ShineUsersError::InvalidLoginGuardResponse))?; - require_keys_eq!(program_id, login_guard_program_id, ShineUsersError::InvalidLoginGuardResponse); - require!(raw.len() == 4, ShineUsersError::InvalidLoginGuardResponse); - let class = u32::from_le_bytes([raw[0], raw[1], raw[2], raw[3]]); - match class { - 0 => Ok(()), - 1 => Err(ProgramError::from(ShineUsersError::PremiumLogin)), - 2 => Err(ProgramError::from(ShineUsersError::TrademarkLoginRequiresReview)), - _ => Err(ProgramError::from(ShineUsersError::InvalidLoginGuardResponse)), - } -} - fn serialize_users_economy_config(state: &UsersEconomyConfigState) -> Vec { let mut out = Vec::with_capacity(1 + 8 + 8 + 8); out.push(state.version); @@ -793,15 +754,6 @@ fn serialize_users_economy_config(state: &UsersEconomyConfigState) -> Vec { out } -fn serialize_promo_seller_state(state: &PromoSellerState) -> Vec { - let mut out = Vec::with_capacity(1 + 8 + 1 + 32); - out.push(state.version); - out.extend_from_slice(&state.remaining_sales.to_le_bytes()); - out.push(state.min_login_length); - out.extend_from_slice(state.signer_pubkey.as_ref()); - out -} - fn validate_users_economy_config_pda(program_id: &Pubkey, pda: &AccountInfo) -> ProgramResult { let (expected_pda, _) = find_users_economy_config_pda(program_id); require_keys_eq!(expected_pda, *pda.key, ShineUsersError::InvalidPdaAddress); @@ -812,7 +764,7 @@ fn validate_users_economy_config_pda(program_id: &Pubkey, pda: &AccountInfo) -> fn read_users_economy_config(pda: &AccountInfo) -> Result { let raw = read_pda_all(pda)?; require!(!raw.is_empty(), ShineUsersError::EmptyPdaData); - require!(raw.len() >= 25, ShineUsersError::InvalidAccountData); + require!(raw.len() >= 25 && raw[0] == 1, ShineUsersError::InvalidAccountData); Ok(UsersEconomyConfigState { version: raw[0], registration_fee_lamports: u64::from_le_bytes(raw[1..9].try_into().unwrap()), @@ -821,19 +773,6 @@ fn read_users_economy_config(pda: &AccountInfo) -> Result Result { - let raw = read_pda_all(pda)?; - require!(!raw.is_empty(), ShineUsersError::PromoSellerNotFound); - require!(raw.len() >= 42, ShineUsersError::InvalidPromoSellerState); - let signer_pubkey = Pubkey::new_from_array(raw[10..42].try_into().map_err(|_| ProgramError::from(ShineUsersError::InvalidPromoSellerState))?); - Ok(PromoSellerState { - version: raw[0], - remaining_sales: u64::from_le_bytes(raw[1..9].try_into().unwrap()), - min_login_length: raw[9], - signer_pubkey, - }) -} - fn record_format_minor(raw: &[u8]) -> Result { require!(raw.len() >= 9, ShineUsersError::InvalidRecordData); require!(sol_memcmp(&raw[0..5], MAGIC, 5) == 0, ShineUsersError::InvalidRecordMagic); @@ -1131,20 +1070,89 @@ fn le_u16(data: &[u8], offset: usize) -> Result { Ok(u16::from_le_bytes([s[0], s[1]])) } -fn build_promo_sign_message(login: &str) -> String { - let mut message = String::with_capacity(settings::PROMO_SIGN_PREFIX.len() + login.len()); - message.push_str(settings::PROMO_SIGN_PREFIX); - message.push_str(login); - message -} - -fn validate_login(login: &str) -> ProgramResult { - require!(!login.is_empty(), ShineUsersError::InvalidLogin); - require!(login.len() <= 20, ShineUsersError::InvalidLogin); - for ch in login.chars() { if !(ch.is_ascii_alphabetic() || ch.is_ascii_digit() || ch == '_') { return Err(ProgramError::from(ShineUsersError::InvalidLogin)); } } +fn validate_legacy_login(value: &str) -> ProgramResult { + require!(!value.is_empty() && value.len() <= 20 && value.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_'), ShineUsersError::InvalidLogin); Ok(()) } -fn login_seed_normalized(login: &str) -> String { login.to_ascii_lowercase() } + +fn validate_namespace_name(value: &str) -> ProgramResult { + require!(!value.is_empty() && value.len() <= 29, ShineUsersError::InvalidNamespace); + require!(value.bytes().all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'_'), ShineUsersError::InvalidNamespace); + Ok(()) +} + +fn validate_full_login(login: &str) -> Result<&str, ProgramError> { + require!(login.len() <= 30, ShineUsersError::InvalidLogin); + let (local, namespace) = login.split_once('@').ok_or(ShineUsersError::InvalidLogin)?; + validate_namespace_name(namespace)?; + require!(!local.is_empty(), ShineUsersError::InvalidLogin); + require!(local.bytes().all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'_'), ShineUsersError::InvalidLogin); + Ok(namespace) +} + +pub fn validate_namespace_state(state: &NamespaceState) -> ProgramResult { + validate_namespace_name(&state.namespace)?; + require!(state.namespace.len() + 1 + state.min_localpart_len as usize <= 30 && state.min_localpart_len > 0, ShineUsersError::InvalidNamespace); + match state.namespace_type { + 1 => require!(state.registrar_pubkey.is_none() && state.server_login.is_none(), ShineUsersError::InvalidNamespace), + 2 => { + require!(state.registrar_pubkey.is_some(), ShineUsersError::InvalidNamespace); + validate_full_login(state.server_login.as_deref().ok_or(ShineUsersError::InvalidNamespace)?)?; + }, + _ => return Err(ShineUsersError::InvalidNamespace.into()), + } + Ok(()) +} + +pub fn serialize_namespace(state: &NamespaceState) -> Vec { + let mut out = vec![1, 0, state.namespace_type, state.min_localpart_len, state.namespace.len() as u8]; + out.extend_from_slice(state.namespace.as_bytes()); + out.extend_from_slice(&state.registration_fee.to_le_bytes()); + if let (Some(registrar), Some(server)) = (state.registrar_pubkey, state.server_login.as_ref()) { + out.extend_from_slice(registrar.as_ref()); + out.push(server.len() as u8); + out.extend_from_slice(server.as_bytes()); + } + out +} + +fn read_namespace(program_id: &Pubkey, ai: &AccountInfo, name: &str) -> Result { + let expected = find_namespace_pda(program_id, name).0; + require_keys_eq!(expected, *ai.key, ShineUsersError::InvalidPdaAddress); + require!(ai.owner == program_id, ShineUsersError::InvalidAccountOwner); + let data = ai.try_borrow_data()?; + let mut r = Reader::new(&data); + require!(r.read_u8()? == 1 && r.read_u8()? == 0, ShineUsersError::InvalidNamespace); + let namespace_type = r.read_u8()?; + let min_localpart_len = r.read_u8()?; + let namespace = r.read_string_u8()?; + let registration_fee = r.read_u64()?; + let (registrar_pubkey, server_login) = match namespace_type { + 1 => (None, None), + 2 => (Some(r.read_pubkey()?), Some(r.read_string_u8()?)), + _ => return Err(ShineUsersError::InvalidNamespace.into()), + }; + r.finish()?; + let state = NamespaceState { namespace_type, min_localpart_len, namespace, registration_fee, registrar_pubkey, server_login }; + require!(state.namespace == name, ShineUsersError::InvalidNamespace); + validate_namespace_state(&state)?; + Ok(state) +} + +pub fn certificate_inner_message(login: &str, root: &Pubkey, blockchain: &Pubkey, client: &Pubkey) -> Result, ProgramError> { + validate_full_login(login)?; + let mut msg = CERTIFICATE_DOMAIN.to_vec(); + msg.extend_from_slice(&[1, 0, login.len() as u8]); + msg.extend_from_slice(login.as_bytes()); + msg.extend_from_slice(root.as_ref()); + msg.extend_from_slice(blockchain.as_ref()); + msg.extend_from_slice(client.as_ref()); + Ok(msg) +} + +pub fn user_pda_seed(login: &str) -> [u8; 32] { + hash(format!("{}{}", settings::USER_PDA_SEED_PREFIX, login).as_bytes()).to_bytes() +} fn validate_server_addresses(addresses: &[ServerAddressRecordV12]) -> ProgramResult { require!(addresses.len() <= 1, ShineUsersError::InvalidRecordData); @@ -1158,7 +1166,8 @@ fn validate_server_addresses(addresses: &[ServerAddressRecordV12]) -> ProgramRes fn validate_access_servers(servers: &[String]) -> ProgramResult { require!(servers.len() <= 1, ShineUsersError::InvalidRecordData); for login in servers { - validate_login(login)?; + if login.contains('@') { validate_full_login(login)?; } + else { validate_legacy_login(login)?; } } Ok(()) } @@ -1238,9 +1247,13 @@ fn ensure_pda_size_and_rent<'a>(pda: &AccountInfo<'a>, payer: &AccountInfo<'a>, pda.realloc(required_len, false) } -fn find_user_pda(program_id: &Pubkey, login: &str) -> (Pubkey, u8) { Pubkey::find_program_address(&[settings::USER_PDA_SEED_PREFIX.as_bytes(), login.as_bytes()], program_id) } +pub fn find_user_pda(program_id: &Pubkey, login: &str) -> (Pubkey, u8) { Pubkey::find_program_address(&[&user_pda_seed(login)], program_id) } +fn find_legacy_user_pda(program_id: &Pubkey, login: &str) -> (Pubkey, u8) { Pubkey::find_program_address(&[settings::USER_PDA_SEED_PREFIX.as_bytes(), login.as_bytes()], program_id) } +pub fn find_namespace_pda(program_id: &Pubkey, name: &str) -> (Pubkey, u8) { + let seed = hash(format!("{}{}", settings::NAMESPACE_PDA_SEED_PREFIX, name).as_bytes()).to_bytes(); + Pubkey::find_program_address(&[&seed], program_id) +} fn find_users_economy_config_pda(program_id: &Pubkey) -> (Pubkey, u8) { Pubkey::find_program_address(&[settings::USERS_ECONOMY_CONFIG_SEED], program_id) } -fn find_promo_seller_pda(program_id: &Pubkey, seller_login: &str) -> (Pubkey, u8) { Pubkey::find_program_address(&[settings::PROMO_SELLER_PDA_SEED_PREFIX.as_bytes(), seller_login.as_bytes()], program_id) } fn limit_fee_lamports(limit_delta: u64, lamports_per_limit_step: u64) -> Result { (limit_delta / settings::LIMIT_STEP).checked_mul(lamports_per_limit_step).ok_or(ProgramError::from(ShineUsersError::MathOverflow)) } fn pad_to_fixed_size(mut bytes: Vec, target_size: usize) -> Result, ProgramError> { require!(bytes.len() <= target_size, ShineUsersError::RecordTooLarge); bytes.resize(target_size, 0); Ok(bytes) } diff --git a/shine-solana/shine/programs/shine_users/src/settings.rs b/shine-solana/shine/programs/shine_users/src/settings.rs index df0f775e..5e7f34e8 100644 --- a/shine-solana/shine/programs/shine_users/src/settings.rs +++ b/shine-solana/shine/programs/shine_users/src/settings.rs @@ -2,27 +2,17 @@ pub const USER_PDA_SEED_PREFIX: &str = "user_login="; /// Seed PDA с экономическими параметрами программы `shine_users`. pub const USERS_ECONOMY_CONFIG_SEED: &[u8] = b"shine_users_economy_config"; -/// Префикс seed для PDA продавца promo-логинов. -pub const PROMO_SELLER_PDA_SEED_PREFIX: &str = "promo_seller="; +/// Префикс хешируемого namespace PDA seed. +pub const NAMESPACE_PDA_SEED_PREFIX: &str = "namespace="; /// Стартовый размер PDA пользователя, дальше запись может расширяться через realloc. pub const USER_PDA_SPACE: usize = 768; /// Размер PDA с экономическими параметрами `shine_users`. pub const USERS_ECONOMY_CONFIG_SPACE: usize = 32; -/// Размер PDA продавца promo-логинов. -pub const PROMO_SELLER_PDA_SPACE: usize = 64; - -/// Адрес DAO authority, который имеет право обновлять economy-конфиг. -pub const DAO_AUTHORITY: &str = "aiShm43fZjm3YkMs22sYL1bpXaL3bVxv7SSraPHzVgq"; /// Адрес программы `shine_payments`, от которой вычисляется PDA inflow-вольта. pub const SHINE_PAYMENTS_PROGRAM_ID: &str = "SHiPmXbM9Fs9khzRUW3TGKsS2W84aqaXTxs3ZkajW9v"; /// Seed inflow-вольта в программе `shine_payments`. pub const SHINE_PAYMENTS_INFLOW_VAULT_SEED: &[u8] = b"shine_payments_inflow_vault"; -/// Адрес отдельной программы проверки премиальности логина. -pub const SHINE_LOGIN_GUARD_PROGRAM_ID: &str = "SHiGxGsXGioQYCYhchQ5R7KWoxN5UjFAFsucPf6sfnh"; -/// Доменный префикс для подписи promo-кода. -pub const PROMO_SIGN_PREFIX: &str = "shine_promo_v1:"; - /// Стартовая комиссия регистрации (0.01 SOL) для initial economy-конфига. pub const START_REGISTRATION_FEE_LAMPORTS: u64 = 10_000_000; /// Шаг пополнения лимита. diff --git a/shine-solana/shine/scripts/registration-v2/create-namespace.mjs b/shine-solana/shine/scripts/registration-v2/create-namespace.mjs new file mode 100644 index 00000000..a0b759fc --- /dev/null +++ b/shine-solana/shine/scripts/registration-v2/create-namespace.mjs @@ -0,0 +1,82 @@ +#!/usr/bin/env node +// Сборщик транзакции администратора namespace. Никаких сетевых действий без --send. +// Требует npm install в shine-solana/shine; не запускайте с mainnet до проверки. +import { readFileSync } from 'node:fs'; +import { createHash } from 'node:crypto'; +import { createRequire } from 'node:module'; +import { decodeNamespace } from './decode-namespace.mjs'; +const require=createRequire(import.meta.url); +const {Connection,PublicKey,Keypair,Transaction,TransactionInstruction,SystemProgram,sendAndConfirmTransaction}=require('@solana/web3.js'); +const PROGRAM_ID=new PublicKey('SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6'); +const ECONOMY_SEED=Buffer.from('shine_users_economy_config'); +const options={}; +for(let i=2;i=process.argv.length)throw Error(`Отсутствует значение --${name}`); + options[name]=process.argv[++i]; +} +function str(s){if(!s || Buffer.byteLength(s)>255)throw Error('Пустая или слишком длинная строка');return Buffer.concat([Buffer.from([Buffer.byteLength(s)]),Buffer.from(s)]);} +function key(raw){const b=new PublicKey(raw);return b;} +function accountData(type,name,minLocalLen,fee,registrar,serverLogin){ + const n=Buffer.from(name); + const output=[Buffer.from([7,type,minLocalLen]),str(name),Buffer.alloc(8)]; + output[2].writeBigUInt64LE(fee); + if(type===2)output.push(key(registrar).toBuffer(),str(serverLogin)); + return Buffer.concat(output); +} +async function run(){ + const rpc=options.rpc,secret=options.keypair,namespace=options.namespace; + if(!rpc || !secret || !namespace)throw Error('Обязательные параметры: --rpc --keypair --namespace --type --min-length --fee-lamports'); + // Выбранный сценарий создаёт только localnet/devnet; никакого скрытого доступа к mainnet. + const endpoint=new URL(rpc); + if(!(['localhost','127.0.0.1'].includes(endpoint.hostname)||endpoint.hostname.endsWith('.devnet.solana.com'))) + throw Error('Разрешены только localhost/127.0.0.1 и *.devnet.solana.com; production запрещён'); + const type=Number(options.type),minimum=Number(options['min-length']); + const fee=BigInt(options['fee-lamports']); + if(![1,2].includes(type) || !Number.isInteger(minimum) || minimum<1 || minimum+1+namespace.length>30 || fee<0n || fee>0xffffffffffffffffn) + throw Error('Некорректные тип, длина или цена'); + if(!/^[a-z0-9_]+$/.test(namespace))throw Error('namespace может содержать только lowercase a-z0-9_'); + if(type===2 && (!options.registrar || !/^[a-z0-9_]+@[a-z0-9_]+$/.test(options.server)))throw Error('Для type=2 нужны --registrar и --server'); + if(type===1 && (options.registrar || options.server))throw Error('type=1 не поддерживает регистратор/сервер'); + const bytes=JSON.parse(readFileSync(secret,'utf8')); + const wallet=Keypair.fromSecretKey(Uint8Array.from(bytes)); + const seed=createHash('sha256').update('namespace='+namespace).digest(); + const [pda,bump]=PublicKey.findProgramAddressSync([seed],PROGRAM_ID); + const [economy]=PublicKey.findProgramAddressSync([ECONOMY_SEED],PROGRAM_ID); + const connection=new Connection(rpc,'confirmed'); + const executable=await connection.getAccountInfo(PROGRAM_ID,'confirmed'); + if(!executable || !executable.executable || !executable.owner.equals(new PublicKey('BPFLoaderUpgradeab1e11111111111111111111111'))) + throw Error('Программа не является upgradeable Program'); + const programdata=new PublicKey(executable.data.subarray(4,36)); + const pd=await connection.getAccountInfo(programdata,'confirmed'); + if(!pd || pd.data.length<45 || pd.data.readUInt32LE(0)!==3 || pd.data[12]!==1 || !new PublicKey(pd.data.subarray(13,45)).equals(wallet.publicKey)) + throw Error('Указанный signer не является текущей upgrade authority'); + const economyInfo=await connection.getAccountInfo(economy,'confirmed'); + if(!economyInfo || !economyInfo.owner.equals(PROGRAM_ID))throw Error('Сначала инициализируйте economy PDA'); + const payload=accountData(type,namespace,minimum,fee,options.registrar,options.server); + const serverPda=type===2?PublicKey.findProgramAddressSync([ + createHash('sha256').update('user_login='+options.server).digest()],PROGRAM_ID)[0]:null; + if(serverPda){ + const registered=await connection.getAccountInfo(serverPda,'confirmed'); + if(!registered || !registered.owner.equals(PROGRAM_ID))throw Error('У сервера доступа отсутствует реальный PDA 1.2'); + } + const instruction=new TransactionInstruction({programId:PROGRAM_ID,keys:[ + {pubkey:wallet.publicKey,isSigner:true,isWritable:true}, + {pubkey:pda,isSigner:false,isWritable:true}, + {pubkey:SystemProgram.programId,isSigner:false,isWritable:false}, + {pubkey:economy,isSigner:false,isWritable:false}, + {pubkey:PROGRAM_ID,isSigner:false,isWritable:false}, + {pubkey:programdata,isSigner:false,isWritable:false}, + ...(serverPda?[{pubkey:serverPda,isSigner:false,isWritable:false}]:[]), + ],data:payload}); + console.log(JSON.stringify({namespace,type,minimum,fee:fee.toString(),pda:pda.toBase58(),bump,economy:economy.toBase58(),programdata:programdata.toBase58(),mode:options.send?'SEND':'DRY-RUN'},null,2)); + if(!options.send)return; + const signature=await sendAndConfirmTransaction(connection,new Transaction().add(instruction),[wallet],{commitment:'confirmed'}); + console.log('Подтверждённая devnet/localnet транзакция:',signature); + const state=await connection.getAccountInfo(pda,'confirmed'); + if(!state)throw Error('После транзакции namespace отсутствует'); + console.log('Считанный PDA:',decodeNamespace(state.data)); +} +run().catch(err=>{console.error('Ошибка создания namespace:',err.message);process.exitCode=1;}); diff --git a/shine-solana/shine/scripts/registration-v2/decode-namespace.mjs b/shine-solana/shine/scripts/registration-v2/decode-namespace.mjs new file mode 100644 index 00000000..bc3b7519 --- /dev/null +++ b/shine-solana/shine/scripts/registration-v2/decode-namespace.mjs @@ -0,0 +1,36 @@ +#!/usr/bin/env node +import { readFileSync } from 'node:fs'; + +// Автономный декодер namespace 1.0 (без RPC и внешних пакетов). +export function decodeNamespace(data) { + const b=Buffer.from(data); + if(b.length<13) throw Error('namespace: payload слишком короткий'); + if(b[0]!==1 || b[1]!==0) throw Error('namespace: неизвестная версия'); + const type=b[2],minLocalLen=b[3],len=b[4]; + if(type!==1 && type!==2)throw Error('namespace: неверный тип'); + if(!len || !minLocalLen || len+1+minLocalLen>30) throw Error('namespace: некорректная длина'); + let p=5; + if(p+len+8>b.length)throw Error('namespace: обрезанные поля'); + const name=b.subarray(p,p+len).toString('utf8');p+=len; + if(!/^[a-z0-9_]+$/.test(name) || Buffer.byteLength(name)!==len) throw Error('namespace: некорректное название'); + const fee=b.readBigUInt64LE(p).toString();p+=8; + let registrar=null,serverLogin=null; + if(type===2){ + if(p+33>b.length)throw Error('namespace: отсутствуют ключ и логин сервера'); + registrar=b.subarray(p,p+32).toString('hex');p+=32; + const serverLen=b[p++]; + if(p+serverLen>b.length)throw Error('namespace: обрезан логин сервера'); + serverLogin=b.subarray(p,p+serverLen).toString('utf8');p+=serverLen; + if(!/^[a-z0-9_]+@[a-z0-9_]+$/.test(serverLogin) || Buffer.byteLength(serverLogin)>30)throw Error('namespace: неверный логин сервера'); + } + if(p!==b.length) throw Error('namespace: лишние байты запрещены'); + return {major:1,minor:0,type,minLocalLen,name,registrationFeeLamports:fee,registrarPubkeyHex:registrar,serverLogin}; +} +if(process.argv[1]?.endsWith('decode-namespace.mjs')){ + const data=process.argv[2]; + if(!data || !/^(?:[\da-fA-F]{2})+$/.test(data)){ + console.error('Использование: node decode-namespace.mjs ');process.exit(2); + } + try{console.log(JSON.stringify(decodeNamespace(Buffer.from(data,'hex')),null,2));} + catch(e){console.error(e.message);process.exit(1);} +} diff --git a/shine-solana/shine/tests/fixtures/registration-v2.json b/shine-solana/shine/tests/fixtures/registration-v2.json new file mode 100644 index 00000000..6067d200 --- /dev/null +++ b/shine-solana/shine/tests/fixtures/registration-v2.json @@ -0,0 +1,100 @@ +{ + "version": 1, + "program_id": "SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6", + "test_key_notice": "FIXTURES ONLY, never use these deterministic seeds for real accounts", + "email_input": " Alice.Example+Tag@Example.COM ", + "normalized_email": "alice.example+tag@example.com", + "email_sha256_hex": "cbc605c49fd774ff4d9ea789d8f6bffa719e9774cb86f62d11fd244121150956", + "public_keys_hex": { + "root": "03a107bff3ce10be1d70dd18e74bc09967e4d6309ba50d5f1ddc8664125531b8", + "blockchain": "29acbae141bccaf0b22e1a94d34d0bc7361e526d0bfe12c89794bc9322966dd7", + "client": "2543b92ff1095511476adc8369db6ddc933665a11978dda1404ee1066ca9559d", + "registrar": "174553b456dddfc6908ecab1c101fe6ab21e2baa0617795b7d43a63482993fd5" + }, + "users": [ + { + "login": "alice@shine", + "valid": true, + "user_seed_hex": "b82963883026329da3289e9f103a3c8883ed8ecfc4c31d9c3118a2650a00342a", + "user_pda": "Fj61xHrbqCeWq5LiX3PnUgyuwemVNx1ydo5c7oy99Tzo", + "bump": 255 + }, + { + "login": "bob@free", + "valid": true, + "user_seed_hex": "316a2f8889e56e583350d02227c14a7ce0d0e9475d05fd11918fb48fdcfa6c4b", + "user_pda": "CYQTXWaTiEjBvg9eMcRuJYoRSgEY6YupCKnmqdEAoepD", + "bump": 253 + }, + { + "login": "a_b@shine", + "valid": true, + "user_seed_hex": "7bb903c31cd612026cf8afde3b26f8124ddb08969349c1c6f8830bf33323b51e", + "user_pda": "AJBuEQNYLYJJYn1NLV9CDe1YNyvNrYoGjrr9zzwxFUDr", + "bump": 253 + }, + { + "login": "a@shine", + "valid": true, + "user_seed_hex": "8ee3fb297bc57ae5669f3b9c94a4d4cc3a97a1c334ecdadd94375dd1a6848190", + "user_pda": "Aez41BW2iKLo2DNYQdF4hcx22G2xhtdrU2HnH7Fg4mZx", + "bump": 255 + }, + { + "login": "aaaaaaaaaaaaaaaaaaaaaaaa@shine", + "valid": true, + "user_seed_hex": "ed5c0130230c3fa9c19bfe133b88ed767bfcbd60cf37461ecb3d65676af97c9f", + "user_pda": "HXtFs2maytc7s6w62y7gprGKJvMt3aR7ErWQUqYwzE3X", + "bump": 254 + }, + { + "login": "aaaaaaaaaaaaaaaaaaaaaaaaa@shine", + "valid": false, + "user_seed_hex": "a0d506d1619b55f61af17454adc138bd0f60d1f667181b456b38c2716b39dd07", + "user_pda": "EwMLHtuJJ9bzCFRtu6Y2iBQXPPiN3B8Tnewp1ktjcBS4", + "bump": 255 + } + ], + "namespace": [ + { + "name": "shine", + "type": 1, + "seed_hex": "bdb6dfbe3ba61f66e177ed92ddd85270cd653ba0b92f31d91bf94877ced616ea", + "pda": "G1QwyeTcyqBMitsTpGpbwwbCYMFqGkTiGw6trKr5baLa", + "bump": 254, + "bytes_hex": "01000103057368696e658096980000000000" + }, + { + "name": "free", + "type": 2, + "seed_hex": "ceb53ebd89ee0b2663831b8a458cc7ac53a507e0a5f7b7a5766311348d829dcb", + "pda": "C4W54n5sfJfCQLwQb8bDox6JAf98YA2MMFPU2mfhefJh", + "bump": 255, + "bytes_hex": "010002030466726565404b4c0000000000174553b456dddfc6908ecab1c101fe6ab21e2baa0617795b7d43a63482993fd50f726567697374726172407368696e65" + } + ], + "certificate": { + "login": "bob@free", + "inner_message_hex": "5348694e455f465245455f5245475f563100010008626f62406672656503a107bff3ce10be1d70dd18e74bc09967e4d6309ba50d5f1ddc8664125531b829acbae141bccaf0b22e1a94d34d0bc7361e526d0bfe12c89794bc9322966dd72543b92ff1095511476adc8369db6ddc933665a11978dda1404ee1066ca9559d", + "inner_signature_hex": "e2edfcd8b1b7a1823f56b827ddfa8a3682793e036141b526467ae346e220d08757d0a878a2f722562e6d3132ef9df04b1ab9e2f65d72bb0f48c17b7ada3e5a0a", + "payload_hex": "010008626f62406672656503a107bff3ce10be1d70dd18e74bc09967e4d6309ba50d5f1ddc8664125531b829acbae141bccaf0b22e1a94d34d0bc7361e526d0bfe12c89794bc9322966dd72543b92ff1095511476adc8369db6ddc933665a11978dda1404ee1066ca9559de2edfcd8b1b7a1823f56b827ddfa8a3682793e036141b526467ae346e220d08757d0a878a2f722562e6d3132ef9df04b1ab9e2f65d72bb0f48c17b7ada3e5a0acbc605c49fd774ff4d9ea789d8f6bffa719e9774cb86f62d11fd244121150956", + "identity_fields_hex": "010008626f62406672656503a107bff3ce10be1d70dd18e74bc09967e4d6309ba50d5f1ddc8664125531b829acbae141bccaf0b22e1a94d34d0bc7361e526d0bfe12c89794bc9322966dd72543b92ff1095511476adc8369db6ddc933665a11978dda1404ee1066ca9559d", + "dataitem_sha256_id_hex": "45ef42eda7c7e76d222ecce8a7678edb923ae63f8419ea0899701551c2466770", + "dataitem_hex": "0200a9de19b3551ace117973b80d632503bf2a55f0aa2490deb1474a280b675fa01bb2ccb5890faadcb213d3882fb21a7af13702526a569f7807b1c8b6963c0be402174553b456dddfc6908ecab1c101fe6ab21e2baa0617795b7d43a63482993fd500000300000000000000390000000000000006064170701074657374353539310274067265671050726f746f636f6c345348694e452d467265652d526567697374726174696f6e2d563100010008626f62406672656503a107bff3ce10be1d70dd18e74bc09967e4d6309ba50d5f1ddc8664125531b829acbae141bccaf0b22e1a94d34d0bc7361e526d0bfe12c89794bc9322966dd72543b92ff1095511476adc8369db6ddc933665a11978dda1404ee1066ca9559de2edfcd8b1b7a1823f56b827ddfa8a3682793e036141b526467ae346e220d08757d0a878a2f722562e6d3132ef9df04b1ab9e2f65d72bb0f48c17b7ada3e5a0acbc605c49fd774ff4d9ea789d8f6bffa719e9774cb86f62d11fd244121150956", + "dataitem_deep_hash_hex": "45d96dbd7e4e81420f06fb591be56c80f9b5da3df647c460d1ecea37b26e6c2b0fbaaf7531cb9ed5be10d8fe224091c6", + "tags": [ + [ + "App", + "test5591" + ], + [ + "t", + "reg" + ], + [ + "Protocol", + "SHiNE-Free-Registration-V1" + ] + ] + } +} diff --git a/shine-solana/shine/tests/fixtures/registration-v2.properties b/shine-solana/shine/tests/fixtures/registration-v2.properties new file mode 100644 index 00000000..e2a53838 --- /dev/null +++ b/shine-solana/shine/tests/fixtures/registration-v2.properties @@ -0,0 +1,32 @@ +program_id=SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6 +email_hash_hex=cbc605c49fd774ff4d9ea789d8f6bffa719e9774cb86f62d11fd244121150956 +inner_message_hex=5348694e455f465245455f5245475f563100010008626f62406672656503a107bff3ce10be1d70dd18e74bc09967e4d6309ba50d5f1ddc8664125531b829acbae141bccaf0b22e1a94d34d0bc7361e526d0bfe12c89794bc9322966dd72543b92ff1095511476adc8369db6ddc933665a11978dda1404ee1066ca9559d +inner_signature_hex=e2edfcd8b1b7a1823f56b827ddfa8a3682793e036141b526467ae346e220d08757d0a878a2f722562e6d3132ef9df04b1ab9e2f65d72bb0f48c17b7ada3e5a0a +registrar_pubkey_hex=174553b456dddfc6908ecab1c101fe6ab21e2baa0617795b7d43a63482993fd5 +ans104_id_hex=45ef42eda7c7e76d222ecce8a7678edb923ae63f8419ea0899701551c2466770 +user_alice_shine_seed=b82963883026329da3289e9f103a3c8883ed8ecfc4c31d9c3118a2650a00342a +user_alice_shine_pda=Fj61xHrbqCeWq5LiX3PnUgyuwemVNx1ydo5c7oy99Tzo +user_alice_shine_bump=255 +user_bob_free_seed=316a2f8889e56e583350d02227c14a7ce0d0e9475d05fd11918fb48fdcfa6c4b +user_bob_free_pda=CYQTXWaTiEjBvg9eMcRuJYoRSgEY6YupCKnmqdEAoepD +user_bob_free_bump=253 +user_a_underscore_b_shine_seed=7bb903c31cd612026cf8afde3b26f8124ddb08969349c1c6f8830bf33323b51e +user_a_underscore_b_shine_pda=AJBuEQNYLYJJYn1NLV9CDe1YNyvNrYoGjrr9zzwxFUDr +user_a_underscore_b_shine_bump=253 +user_a_shine_seed=8ee3fb297bc57ae5669f3b9c94a4d4cc3a97a1c334ecdadd94375dd1a6848190 +user_a_shine_pda=Aez41BW2iKLo2DNYQdF4hcx22G2xhtdrU2HnH7Fg4mZx +user_a_shine_bump=255 +user_aaaaaaaaaaaaaaaaaaaaaaaa_shine_seed=ed5c0130230c3fa9c19bfe133b88ed767bfcbd60cf37461ecb3d65676af97c9f +user_aaaaaaaaaaaaaaaaaaaaaaaa_shine_pda=HXtFs2maytc7s6w62y7gprGKJvMt3aR7ErWQUqYwzE3X +user_aaaaaaaaaaaaaaaaaaaaaaaa_shine_bump=254 +user_aaaaaaaaaaaaaaaaaaaaaaaaa_shine_seed=a0d506d1619b55f61af17454adc138bd0f60d1f667181b456b38c2716b39dd07 +user_aaaaaaaaaaaaaaaaaaaaaaaaa_shine_pda=EwMLHtuJJ9bzCFRtu6Y2iBQXPPiN3B8Tnewp1ktjcBS4 +user_aaaaaaaaaaaaaaaaaaaaaaaaa_shine_bump=255 +namespace_shine_seed=bdb6dfbe3ba61f66e177ed92ddd85270cd653ba0b92f31d91bf94877ced616ea +namespace_shine_pda=G1QwyeTcyqBMitsTpGpbwwbCYMFqGkTiGw6trKr5baLa +namespace_shine_bump=254 +namespace_shine_bytes_hex=01000103057368696e658096980000000000 +namespace_free_seed=ceb53ebd89ee0b2663831b8a458cc7ac53a507e0a5f7b7a5766311348d829dcb +namespace_free_pda=C4W54n5sfJfCQLwQb8bDox6JAf98YA2MMFPU2mfhefJh +namespace_free_bump=255 +namespace_free_bytes_hex=010002030466726565404b4c0000000000174553b456dddfc6908ecab1c101fe6ab21e2baa0617795b7d43a63482993fd50f726567697374726172407368696e65 diff --git a/shine-solana/shine/tests/java/RegistrationV2VectorsCheck.java b/shine-solana/shine/tests/java/RegistrationV2VectorsCheck.java new file mode 100644 index 00000000..f0681740 --- /dev/null +++ b/shine-solana/shine/tests/java/RegistrationV2VectorsCheck.java @@ -0,0 +1,75 @@ +import java.math.BigInteger; +import java.nio.charset.StandardCharsets; +import java.nio.file.*; +import java.security.*; +import java.security.spec.*; +import java.util.*; + +/** Автономная проверка Rust/Java/JS фикстур; не зависит от Solana SDK и сетевого RPC. */ +public final class RegistrationV2VectorsCheck { + private static final BigInteger P=BigInteger.ONE.shiftLeft(255).subtract(BigInteger.valueOf(19)); + private static final BigInteger D=BigInteger.valueOf(-121665).multiply(BigInteger.valueOf(121666).modInverse(P)).mod(P); + private static final String B58="123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; + private static byte[] utf8(String s){return s.getBytes(StandardCharsets.UTF_8);} + private static byte[] sha(byte[] b){try{return MessageDigest.getInstance("SHA-256").digest(b);}catch(Exception e){throw new IllegalStateException(e);}} + private static byte[] join(byte[]... array){int n=0;for(var a:array)n+=a.length;byte[] out=new byte[n];int i=0;for(var a:array){System.arraycopy(a,0,out,i,a.length);i+=a.length;}return out;} + private static String hex(byte[] b){return HexFormat.of().formatHex(b);} + private static byte[] fromHex(String s){return HexFormat.of().parseHex(s);} + private static byte[] base58decode(String text){ + BigInteger n=BigInteger.ZERO, b=BigInteger.valueOf(58); + for(char c:text.toCharArray()) {int digit=B58.indexOf(c);if(digit<0)throw new IllegalArgumentException();n=n.multiply(b).add(BigInteger.valueOf(digit));} + byte[] raw=n.equals(BigInteger.ZERO)?new byte[0]:n.toByteArray();if(raw.length>0 && raw[0]==0)raw=Arrays.copyOfRange(raw,1,raw.length); + int zero=0;while(zero0){BigInteger[] div=n.divideAndRemainder(b);result.append(B58.charAt(div[1].intValue()));n=div[0];} + int zero=0;while(zero>7;ybytes[31]&=127; + for(int i=0;i<16;i++){byte x=ybytes[i];ybytes[i]=ybytes[31-i];ybytes[31-i]=x;} + BigInteger y=new BigInteger(1,ybytes);if(y.compareTo(P)>=0)return false; + BigInteger yy=y.multiply(y).mod(P); + BigInteger xx=yy.subtract(BigInteger.ONE).multiply(D.multiply(yy).add(BigInteger.ONE).mod(P).modInverse(P)).mod(P); + if(xx.equals(BigInteger.ZERO))return sign==0; + return xx.modPow(P.subtract(BigInteger.ONE).shiftRight(1),P).equals(BigInteger.ONE); + } + private static String[] pda(byte[] seed,byte[] program){ + for(int bump=255;bump>=0;bump--){byte[] bytes=sha(join(seed,new byte[]{(byte)bump},program,utf8("ProgramDerivedAddress"))); + if(!onCurve(bytes))return new String[]{base58encode(bytes),Integer.toString(bump)};} + throw new IllegalStateException("PDA unavailable"); + } + private static void check(boolean condition,String text){if(!condition)throw new AssertionError(text);} + public static void main(String[] argv)throws Exception{ + Path path=argv.length>0?Path.of(argv[0]):Path.of("tests/fixtures/registration-v2.properties"); + Properties props=new Properties();try(var reader=Files.newBufferedReader(path)){props.load(reader);} + byte[] program=base58decode(props.getProperty("program_id"));check(program.length==32,"program id"); + for(String name:List.of("alice@shine","bob@free","a_b@shine","a@shine","aaaaaaaaaaaaaaaaaaaaaaaa@shine","aaaaaaaaaaaaaaaaaaaaaaaaa@shine")){ + String key=name.replace("a_b","a_underscore_b").replace('@','_'); + byte[] seed=sha(utf8("user_login="+name));check(hex(seed).equals(props.getProperty("user_"+key+"_seed")),"seed " + name); + String[] result=pda(seed,program); + check(result[0].equals(props.getProperty("user_"+key+"_pda")),"user pda " + name); + check(result[1].equals(props.getProperty("user_"+key+"_bump")),"user bump " + name); + } + for(String name:List.of("shine","free")){ + byte[] seed=sha(utf8("namespace="+name)); + check(hex(seed).equals(props.getProperty("namespace_"+name+"_seed")),"namespace seed"); + String[] result=pda(seed,program); + check(result[0].equals(props.getProperty("namespace_"+name+"_pda")),"namespace pda"); + check(result[1].equals(props.getProperty("namespace_"+name+"_bump")),"namespace bump"); + } + byte[] raw=fromHex(props.getProperty("registrar_pubkey_hex")); + byte[] der=join(fromHex("302a300506032b6570032100"),raw); + PublicKey signer=KeyFactory.getInstance("Ed25519").generatePublic(new X509EncodedKeySpec(der)); + byte[] msg=fromHex(props.getProperty("inner_message_hex")),signature=fromHex(props.getProperty("inner_signature_hex")); + Signature verifier=Signature.getInstance("Ed25519");verifier.initVerify(signer);verifier.update(msg); + check(verifier.verify(signature),"inner signature"); + byte[] bad=msg.clone();bad[bad.length-1]^=1; + verifier.initVerify(signer);verifier.update(bad);check(!verifier.verify(signature),"tamper should fail"); + check(hex(sha(utf8("alice.example+tag@example.com"))).equals(props.getProperty("email_hash_hex")),"email hash"); + System.out.println("OK: SHA-256 + user/namespace PDA + Ed25519 + email vector"); + } +} diff --git a/shine-solana/shine/tests/registration-v2-decoder.test.mjs b/shine-solana/shine/tests/registration-v2-decoder.test.mjs new file mode 100644 index 00000000..4c42335e --- /dev/null +++ b/shine-solana/shine/tests/registration-v2-decoder.test.mjs @@ -0,0 +1,32 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { readFileSync } from 'node:fs'; +import { decodeNamespace } from '../scripts/registration-v2/decode-namespace.mjs'; +const vec=JSON.parse(readFileSync(new URL('./fixtures/registration-v2.json',import.meta.url))); +function throws(data,msg){assert.throws(()=>decodeNamespace(data),msg);} +test('Декодирование paid/free namespaces',()=>{ + const shine=decodeNamespace(Buffer.from(vec.namespace[0].bytes_hex,'hex')); + const free=decodeNamespace(Buffer.from(vec.namespace[1].bytes_hex,'hex')); + assert.equal(shine.registrarPubkeyHex,null); + assert.equal(shine.serverLogin,null); + assert.equal(shine.registrationFeeLamports,'10000000'); + assert.equal(free.serverLogin,'registrar@shine'); + assert.equal(free.minLocalLen,3); +}); +test('Некорректный namespace не пройдет строгий декодер',()=>{ + const canonical=Buffer.from(vec.namespace[1].bytes_hex,'hex'); + for(const index of [0,1,2,3,4]){ + const bad=Buffer.from(canonical);bad[index]=index===1?1:0; + throws(bad); + } + throws(canonical.subarray(0,-1)); + throws(Buffer.concat([canonical,Buffer.from([0])])); + const bad=Buffer.from(canonical); + bad[5]='F'.charCodeAt(0); + throws(bad); +}); +test('Некорректный server login отвергается',()=>{ + const canonical=Buffer.from(vec.namespace[1].bytes_hex,'hex'); + const bad=Buffer.from(canonical);bad[bad.length-1]='@'.charCodeAt(0); + throws(bad); +}); diff --git a/shine-solana/shine/tests/registration-v2-vectors.test.mjs b/shine-solana/shine/tests/registration-v2-vectors.test.mjs new file mode 100644 index 00000000..034c5097 --- /dev/null +++ b/shine-solana/shine/tests/registration-v2-vectors.test.mjs @@ -0,0 +1,110 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { readFileSync } from 'node:fs'; +import { createHash, createPublicKey, verify } from 'node:crypto'; + +// Полностью автономные тесты: не требуют RPC, приватных ключей и npm install. +const vectors = JSON.parse(readFileSync(new URL('./fixtures/registration-v2.json', import.meta.url), 'utf8')); +const hash = data => createHash('sha256').update(data).digest(); +const hash384 = data => createHash('sha384').update(data).digest(); +const pubkeyFromRaw = hex => createPublicKey({key: Buffer.concat([Buffer.from('302a300506032b6570032100','hex'),Buffer.from(hex,'hex')]),format:'der',type:'spki'}); +const b58abc = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'; +function decode58(text) { + let v=0n; + for (const char of text) { const n=b58abc.indexOf(char);assert.ok(n>=0);v=v*58n+BigInt(n); } + let b=[]; + while(v>0n){b.unshift(Number(v%256n));v/=256n;} + return Buffer.concat([Buffer.alloc((text.match(/^1*/)?.[0]||'').length),Buffer.from(b)]); +} +function encode58(bytes) { + let value=BigInt('0x'+bytes.toString('hex'));let result=''; + while(value>0n){result=b58abc[Number(value%58n)]+result;value/=58n;} + return '1'.repeat(bytes.findIndex(byte=>byte!==0)<0?bytes.length:bytes.findIndex(byte=>byte!==0))+result; +} +const p=(1n<<255n)-19n; +function mod(a){return (a%p+p)%p;} +function pow(a,n){let result=1n;while(n>0n){if(n&1n)result=mod(result*a);a=mod(a*a);n>>=1n;}return result;} +const d=mod(-121665n*pow(121666n,p-2n)); +function onCurve(bytes) { + const copy=Buffer.from(bytes),sign=copy[31]>>7;copy[31]&=127; + let y=0n;for(let i=31;i>=0;i--)y=y*256n+BigInt(copy[i]); + if(y>=p)return false; + const yy=mod(y*y), xx=mod((yy-1n)*pow(d*yy+1n,p-2n)); + return xx===0n ? sign===0 : pow(xx,(p-1n)/2n)===1n; +} +function address(prefix, name) { + const seed=hash(Buffer.from(prefix+name)); + const program=decode58(vectors.program_id); + assert.equal(program.length,32); + for(let bump=255;bump>=0;bump--){ + const a=hash(Buffer.concat([seed,Buffer.from([bump]),program,Buffer.from('ProgramDerivedAddress')])); + if(!onCurve(a))return {seed:seed.toString('hex'),pda:encode58(a),bump}; + } + throw Error('PDA was not found'); +} +function deepHash(item){ + if(Buffer.isBuffer(item))return hash384(Buffer.concat([hash384(Buffer.from('blob'+item.length)),hash384(item)])); + let acc=hash384(Buffer.from('list'+item.length)); + for(const child of item)acc=hash384(Buffer.concat([acc,deepHash(child)])); + return acc; +} + +test('Одинаковые SHA-256 и PDA для всех пользователей',()=>{ + for(const u of vectors.users){ + const actual=address('user_login=',u.login); + assert.deepEqual(actual,{seed:u.user_seed_hex,pda:u.user_pda,bump:u.bump}); + assert.equal(u.valid,u.login.length<=30); + } +}); +test('Два PDA namespace отличаются от пользовательских',()=>{ + for(const ns of vectors.namespace){ + assert.deepEqual(address('namespace=',ns.name),{seed:ns.seed_hex,pda:ns.pda,bump:ns.bump}); + assert.notEqual(ns.pda,address('user_login=',ns.name).pda); + } +}); +test('namespace-PDA строгая раскладка и округления нет',()=>{ + for(const ns of vectors.namespace){ + const b=Buffer.from(ns.bytes_hex,'hex'),name=b.subarray(5,5+b[4]).toString(); + assert.equal(b[0],1);assert.equal(b[1],0);assert.equal(b[2],ns.type);assert.equal(name,ns.name); + const offset=5+b[4],fee=b.readBigUInt64LE(offset); + assert.equal(fee,BigInt(ns.type===1?10_000_000:5_000_000)); + if(ns.type===2){assert.equal(b.subarray(offset+8,offset+40).toString('hex'),vectors.public_keys_hex.registrar);} + assert.equal(b.length,ns.type===1?5+ns.name.length+8:5+ns.name.length+8+32+1+'registrar@shine'.length); + } +}); +test('Внутренняя подпись защищает имя и все три публичных ключа',()=>{ + const c=vectors.certificate,msg=Buffer.from(c.inner_message_hex,'hex'),sign=Buffer.from(c.inner_signature_hex,'hex'); + const key=pubkeyFromRaw(vectors.public_keys_hex.registrar); + assert.ok(verify(null,msg,key,sign)); + assert.equal(msg.subarray(0,18).toString('hex'),Buffer.from('SHiNE_FREE_REG_V1\0').toString('hex')); + for(const idx of [18,21,21+c.login.length,21+c.login.length+32,21+c.login.length+64]){ + const bad=Buffer.from(msg);bad[idx]^=1; + assert.equal(verify(null,bad,key,sign),false); + } +}); +test('Email-хеш стоит после внутренней подписи',()=>{ + const c=vectors.certificate,payload=Buffer.from(c.payload_hex,'hex'); + assert.equal(hash(Buffer.from(vectors.normalized_email)).toString('hex'),vectors.email_sha256_hex); + assert.equal(payload.subarray(-32).toString('hex'),vectors.email_sha256_hex); + assert.equal(payload.subarray(0,-96).toString('hex'),c.identity_fields_hex); + assert.equal(payload.subarray(-96,-32).toString('hex'),c.inner_signature_hex); +}); +test('ANS-104 подпись защищает email и теги, ID фиксирован',()=>{ + const item=Buffer.from(vectors.certificate.dataitem_hex,'hex'),key=pubkeyFromRaw(vectors.public_keys_hex.registrar); + assert.equal(item.readUInt16LE(0),2); + const sign=item.subarray(2,66),owner=item.subarray(66,98); + assert.equal(owner.toString('hex'),vectors.public_keys_hex.registrar); + assert.equal(item[98],0);assert.equal(item[99],0); + const count=Number(item.readBigUInt64LE(100)),size=Number(item.readBigUInt64LE(108)); + assert.equal(count,3); + const tags=item.subarray(116,116+size),data=item.subarray(116+size); + assert.equal(data.toString('hex'),vectors.certificate.payload_hex); + const msg=deepHash([Buffer.from('dataitem'),Buffer.from('1'),Buffer.from('2'),owner,Buffer.alloc(0),Buffer.alloc(0),tags,data]); + assert.equal(msg.toString('hex'),vectors.certificate.dataitem_deep_hash_hex); + assert.equal(hash(sign).toString('hex'),vectors.certificate.dataitem_sha256_id_hex); + assert.ok(verify(null,msg,key,sign)); + let changed=Buffer.from(data);changed[changed.length-1]^=1; + assert.equal(verify(null,deepHash([Buffer.from('dataitem'),Buffer.from('1'),Buffer.from('2'),owner,Buffer.alloc(0),Buffer.alloc(0),tags,changed]),key,sign),false); + changed=Buffer.from(tags);changed[0]^=1; + assert.equal(verify(null,deepHash([Buffer.from('dataitem'),Buffer.from('1'),Buffer.from('2'),owner,Buffer.alloc(0),Buffer.alloc(0),changed,data]),key,sign),false); +}); diff --git a/shine-solana/shine/tests/registration_v2_vectors.rs b/shine-solana/shine/tests/registration_v2_vectors.rs new file mode 100644 index 00000000..0d66d1c4 --- /dev/null +++ b/shine-solana/shine/tests/registration_v2_vectors.rs @@ -0,0 +1,59 @@ +//! Общие зафиксированные Rust/Java/JS фикстуры. Запуск: cargo test --test registration_v2_vectors. +use std::str::FromStr; +use solana_program::{hash::hash, pubkey::Pubkey}; +use shine_users::{certificate_inner_message, find_namespace_pda, find_user_pda, serialize_namespace, user_pda_seed, NamespaceState}; + +fn fixture(key: &str) -> String { + include_str!("fixtures/registration-v2.properties").lines() + .find_map(|line| line.split_once('=').filter(|(name,_)| *name==key).map(|(_,value)| value.to_string())) + .expect("ключ тест-вектора") +} +fn decode_hex(text: &str) -> Vec { + assert_eq!(text.len()%2,0); + (0..text.len()).step_by(2).map(|i| u8::from_str_radix(&text[i..i+2],16).unwrap()).collect() +} +fn encode_hex(bytes: &[u8]) -> String { + bytes.iter().map(|b| format!("{:02x}",b)).collect() +} +#[test] +fn user_pdas_match_portable_vectors() { + let program=Pubkey::from_str(&fixture("program_id")).unwrap(); + for (login,key) in [ + ("alice@shine","alice_shine"), ("bob@free","bob_free"), + ("a_b@shine","a_underscore_b_shine"), ("a@shine","a_shine"), + ("aaaaaaaaaaaaaaaaaaaaaaaa@shine","aaaaaaaaaaaaaaaaaaaaaaaa_shine"), + ("aaaaaaaaaaaaaaaaaaaaaaaaa@shine","aaaaaaaaaaaaaaaaaaaaaaaaa_shine") + ] { + assert_eq!(encode_hex(&user_pda_seed(login)),fixture(&format!("user_{key}_seed"))); + let (pda,bump)=find_user_pda(&program,login); + assert_eq!(pda.to_string(),fixture(&format!("user_{key}_pda"))); + assert_eq!(bump.to_string(),fixture(&format!("user_{key}_bump"))); + } +} +#[test] +fn namespace_pdas_and_binaries_match_vectors() { + let program=Pubkey::from_str(&fixture("program_id")).unwrap(); + for (name,typ,fee) in [("shine",1,10_000_000), ("free",2,5_000_000)] { + let (pda,bump)=find_namespace_pda(&program,name); + assert_eq!(pda.to_string(),fixture(&format!("namespace_{name}_pda"))); + assert_eq!(bump.to_string(),fixture(&format!("namespace_{name}_bump"))); + assert_eq!(encode_hex(hash(format!("namespace={name}").as_bytes()).as_ref()),fixture(&format!("namespace_{name}_seed"))); + let registrar=if typ==2 {Some(Pubkey::new_from_array(decode_hex(&fixture("registrar_pubkey_hex")).try_into().unwrap()))}else{None}; + let state=NamespaceState {namespace_type:typ,min_localpart_len:3,namespace:name.to_string(),registration_fee:fee,registrar_pubkey:registrar,server_login:if typ==2{Some("registrar@shine".to_string())}else{None}}; + assert_eq!(encode_hex(&serialize_namespace(&state)),fixture(&format!("namespace_{name}_bytes_hex"))); + } +} +#[test] +fn free_certificate_inner_message_matches_vector() { + let msg=decode_hex(&fixture("inner_message_hex")); + assert!(msg.starts_with(b"SHiNE_FREE_REG_V1\0")); + assert_eq!(msg[18],1); + assert_eq!(msg[19],0); + assert_eq!(msg[20],8); + assert_eq!(&msg[21..29],b"bob@free"); + let message=certificate_inner_message("bob@free", + &Pubkey::new_from_array(msg[29..61].try_into().unwrap()), + &Pubkey::new_from_array(msg[61..93].try_into().unwrap()), + &Pubkey::new_from_array(msg[93..125].try_into().unwrap())).unwrap(); + assert_eq!(message,msg); +} From a520c5c5e1fc602ad57275c2c59d0121768026085d880147441b3adb3f392871 Mon Sep 17 00:00:00 2001 From: AidarKC Date: Sat, 24 Oct 2026 16:17:34 +0300 Subject: [PATCH 03/82] =?UTF-8?q?=D0=A0=D0=B5=D0=B3=D0=B8=D1=81=D1=82?= =?UTF-8?q?=D1=80=D0=B0=D1=86=D0=B8=D1=8F:=20=D0=B1=D0=B5=D1=81=D0=BF?= =?UTF-8?q?=D0=BB=D0=B0=D1=82=D0=BD=D0=B0=D1=8F=20=D1=80=D0=B5=D0=B3=D0=B8?= =?UTF-8?q?=D1=81=D1=82=D1=80=D0=B0=D1=86=D0=B8=D1=8F=20=D1=80=D0=B0=D0=B1?= =?UTF-8?q?=D0=BE=D1=82=D0=B0=D0=B5=D1=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../main/java/blockchain/body/HeaderBody.java | 8 ++- .../blockchain/TargetLoginFormatTest.java | 17 +++++++ .../Net_GetMyBlockchain_Handler.java | 8 +-- VERSION.properties | 4 +- deploy/scripts/deploy_ui.sh | 3 +- deploy/scripts/test_t2_ui.sh | 2 +- docs/API/20_Get_My_Blockchain_API.md | 4 +- docs/Blockchain/10_TECH_Blocks.md | 2 + docs/Blockchain/CHANGELOG.md | 2 + shine-UI/js/app.js | 8 +-- shine-UI/js/pages/register-view.js | 26 ++++++---- shine-UI/js/pages/registration-email-view.js | 9 +++- .../js/pages/registration-payment-view.js | 50 +++++++++++++++---- shine-UI/js/router.js | 2 + 14 files changed, 111 insertions(+), 34 deletions(-) diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/HeaderBody.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/HeaderBody.java index bc0089ed..e1d279fa 100644 --- a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/HeaderBody.java +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/HeaderBody.java @@ -78,8 +78,14 @@ public final class HeaderBody implements BodyRecord { public HeaderBody check() { if ((subType & 0xFFFF) != 0) throw new IllegalArgumentException("HeaderBody subType must be 0"); if (login == null || login.isBlank()) throw new IllegalArgumentException("Login is blank"); - if (!login.matches("^[A-Za-z0-9_]+$")) throw new IllegalArgumentException("Login must match ^[A-Za-z0-9_]+$"); byte[] loginUtf8 = login.getBytes(StandardCharsets.UTF_8); + // Legacy login remains valid; new registration uses a canonical full login@namespace. + // This changes only validation, not the serialized HEADER body or signature format. + boolean legacyLogin = login.matches("^[A-Za-z0-9_]+$"); + boolean namespacedLogin = loginUtf8.length <= 30 && login.matches("^[a-z0-9_]+@[a-z0-9_]+$"); + if (!legacyLogin && !namespacedLogin) { + throw new IllegalArgumentException("Login must be legacy [A-Za-z0-9_]+ or canonical login@namespace (max 30 bytes)"); + } if (loginUtf8.length == 0 || loginUtf8.length > 255) throw new IllegalArgumentException("Login utf8 len must be 1..255"); requireNonZeroKey(initialBlockchainKey32); return this; diff --git a/SHiNE-server/shine-server-blockchain/src/test/java/blockchain/TargetLoginFormatTest.java b/SHiNE-server/shine-server-blockchain/src/test/java/blockchain/TargetLoginFormatTest.java index d5f89ff9..4bc9a192 100644 --- a/SHiNE-server/shine-server-blockchain/src/test/java/blockchain/TargetLoginFormatTest.java +++ b/SHiNE-server/shine-server-blockchain/src/test/java/blockchain/TargetLoginFormatTest.java @@ -98,6 +98,23 @@ final class TargetLoginFormatTest { assertArrayEquals(INITIAL_KEY, parsed.initialBlockchainKey32); } + @Test + void namespacedHeaderRoundTripAcceptsPaidAndFreeUsers() { + for (String login : new String[]{"alice@free", "alice@shine", "a_b@free", "abcdefghijklmnopqrstuvwxy@free"}) { + HeaderBody source = new HeaderBody(login, INITIAL_KEY); + HeaderBody parsed = new HeaderBody(HeaderBody.SUBTYPE_COMPAT, HeaderBody.VER, source.toBytes()).check(); + assertEquals(login, parsed.login); + assertArrayEquals(INITIAL_KEY, parsed.initialBlockchainKey32); + } + } + + @Test + void namespacedHeaderRejectsMalformedOrOversizedLogin() { + for (String login : new String[]{"alice@", "@shine", "alice@@free", "Alice@free", "alice@FREE", "alice.free@shine", "abcdefghijklmnopqrstuvwxyz@free"}) { + assertThrows(IllegalArgumentException.class, () -> new HeaderBody(login, INITIAL_KEY), login); + } + } + private static byte[] hash(int seed) { byte[] out = new byte[32]; Arrays.fill(out, (byte) seed); diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_GetMyBlockchain_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_GetMyBlockchain_Handler.java index 3e254ca0..0baafb14 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_GetMyBlockchain_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_GetMyBlockchain_Handler.java @@ -13,10 +13,10 @@ import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory; import server.logic.ws_protocol.WireCodes; import shine.db.dao.BlockchainStateDAO; import shine.db.dao.CanonicalChainResolver; -import shine.db.dao.SolanaUserPdaCurrentDAO; +import shine.db.dao.CurrentUsersDAO; import shine.db.entities.BlockEntry; import shine.db.entities.BlockchainStateEntry; -import shine.db.entities.SolanaUserPdaCurrentEntry; +import shine.db.entities.CurrentUserEntry; import java.util.ArrayList; import java.util.Collections; @@ -26,7 +26,7 @@ import java.util.List; public final class Net_GetMyBlockchain_Handler implements JsonMessageHandler { private final CanonicalChainResolver canonical = CanonicalChainResolver.getInstance(); private final BlockchainStateDAO states = BlockchainStateDAO.getInstance(); - private final SolanaUserPdaCurrentDAO users = SolanaUserPdaCurrentDAO.getInstance(); + private final CurrentUsersDAO users = CurrentUsersDAO.getInstance(); @Override public Net_Response handle(Net_Request baseReq, ConnectionContext ctx) { @@ -36,7 +36,7 @@ public final class Net_GetMyBlockchain_Handler implements JsonMessageHandler { } try { String login = ctx.getLogin().trim(); - SolanaUserPdaCurrentEntry user = users.getByLogin(login); + CurrentUserEntry user = users.getByLogin(login); if (user == null || user.getBlockchainName() == null || user.getBlockchainName().isBlank()) { return NetExceptionResponseFactory.error(req, 404, "BLOCKCHAIN_NOT_FOUND", "Текущий блокчейн пользователя не найден"); } diff --git a/VERSION.properties b/VERSION.properties index 735d1823..ee17eca9 100644 --- a/VERSION.properties +++ b/VERSION.properties @@ -1,2 +1,2 @@ -client.version=1.20.2 -server.version=1.16.1 +client.version=1.20.3 +server.version=1.16.2 diff --git a/deploy/scripts/deploy_ui.sh b/deploy/scripts/deploy_ui.sh index a9fa1238..d365db8e 100755 --- a/deploy/scripts/deploy_ui.sh +++ b/deploy/scripts/deploy_ui.sh @@ -65,7 +65,8 @@ rsync -a "$SRC_DIR"/ "$TMP_DIR"/ DEPLOY_CONFIG_FILE="$TMP_DIR/js/deploy-config.js" if [[ -f "$DEPLOY_CONFIG_FILE" ]]; then if [[ -n "$DEPLOY_SERVER_LOGIN" ]]; then - perl -0pi -e "s/export const defaultServerLogin = '.*?';/export const defaultServerLogin = '$DEPLOY_SERVER_LOGIN';/s" "$DEPLOY_CONFIG_FILE" + export DEPLOY_SERVER_LOGIN + perl -0pi -e 's/export const defaultServerLogin = '\''[^'\'']*'\'';/export const defaultServerLogin = '\''$ENV{DEPLOY_SERVER_LOGIN}'\'';/' "$DEPLOY_CONFIG_FILE" fi if [[ -n "$DEPLOY_SERVER_ADDRESS" ]]; then perl -0pi -e "s/export const defaultServerAddress = '.*?';/export const defaultServerAddress = '$DEPLOY_SERVER_ADDRESS';/s" "$DEPLOY_CONFIG_FILE" diff --git a/deploy/scripts/test_t2_ui.sh b/deploy/scripts/test_t2_ui.sh index 345ba0d2..f4619a95 100755 --- a/deploy/scripts/test_t2_ui.sh +++ b/deploy/scripts/test_t2_ui.sh @@ -5,7 +5,7 @@ REMOTE_HOST="player@t2.shineup.me" \ REMOTE_UI_DIR="/home/player/t2/UI" \ EXPECTED_CADDY_UI_ROOT="/home/player/t2/UI" \ EXPECTED_CADDY_SITE="t2.shineup.me" \ -DEPLOY_SERVER_LOGIN="server_t2" \ +DEPLOY_SERVER_LOGIN="server_t2@shine" \ DEPLOY_SERVER_ADDRESS="t2.shineup.me" \ DEPLOY_SOLANA_CLUSTER="devnet" \ DEPLOY_SOLANA_ENDPOINT="https://devnet.helius-rpc.com/?api-key=0614c894-52d8-4ddc-bbbc-0947ce5ec3a4" \ diff --git a/docs/API/20_Get_My_Blockchain_API.md b/docs/API/20_Get_My_Blockchain_API.md index 129e617e..edd60c85 100644 --- a/docs/API/20_Get_My_Blockchain_API.md +++ b/docs/API/20_Get_My_Blockchain_API.md @@ -2,7 +2,9 @@ `GetMyBlockchain` — авторизованное постраничное чтение **только текущей активной версии собственного блокчейна**. API используется постоянным экраном «Мой блокчейн» и мастером смены ключей для выбора последнего доверенного блока. -Login и активный `blockchainName` сервер определяет из авторизованной сессии/current PDA; клиент не может запросить этим методом чужую цепочку. +Login сервер берёт только из авторизованной пользовательской сессии. Активное `blockchainName` определяется через общий реестр `user_identity_current` (DAO `CurrentUsersDAO`): для `PAID_DIRECT`/`PAID_UPGRADED` он синхронизирован с Solana, для `FREE_CERT` — с проверенным сертификатом Arweave. Наличие пользовательского Solana PDA **не требуется** для чтения собственного блокчейна. Клиент не может запросить этим методом чужую цепочку. + +У только что зарегистрированного пользователя до первого `HEADER` может отсутствовать запись с блоками: тогда при существующей идентичности возвращается `status=200`, `tipBlockNumber=-1`, `blocks=[]`, а не `BLOCKCHAIN_NOT_FOUND`. Ошибка `BLOCKCHAIN_NOT_FOUND` относится к отсутствующему пользователю или отсутствующему в его записи имени блокчейна; отсутствие блоков само по себе не является ошибкой. Это изменение внутреннего источника поиска, **без изменения JSON-полей, op или кодировки блоков**. ## Request diff --git a/docs/Blockchain/10_TECH_Blocks.md b/docs/Blockchain/10_TECH_Blocks.md index ef7ba550..cfc5be2c 100644 --- a/docs/Blockchain/10_TECH_Blocks.md +++ b/docs/Blockchain/10_TECH_Blocks.md @@ -14,6 +14,8 @@ t=tech Стартовый блок цепочки (`block #0`). Payload содержит tag `SHiNE`, login владельца и `initialBlockchainKey32`. +Поле `login` хранит **полную строку идентичности**: legacy-логины из `[A-Za-z0-9_]+` сохраняют прежнюю поддержку; для новой регистрации допускается каноническое `login@namespace` из `[a-z0-9_]+@[a-z0-9_]+` длиной не более 30 байт. Запись `@` не меняет бинарную структуру HEADER: это те же `[loginLength:uint8][login UTF-8 bytes]`. + `initialBlockchainKey32` — public blockchain-signing key, которым был создан fork №1; это историческая точка происхождения. При последующих fork значение не меняется. HEADER сам не хранит line-prefix, но является root TECH-линии. diff --git a/docs/Blockchain/CHANGELOG.md b/docs/Blockchain/CHANGELOG.md index e916b0ff..a0ba47c7 100644 --- a/docs/Blockchain/CHANGELOG.md +++ b/docs/Blockchain/CHANGELOG.md @@ -324,3 +324,5 @@ - 2026-10-23 — архив регистрирует отдельные `t=reg` DataItem (формат существующих BchBlock без изменений); исправление/дополнение в некоммитированном архивном патче 0–10, commit hash отсутствует; после коммита добавить hash. - 2026-10-23 — регистрационные WS операции и UI для отдельного `t=reg` ANS-104 DataItem, пользовательский Frame V1/AddBlock формат не менялся. Commit hash отсутствует (не коммитировалось), перед merge заменить на реальный hash. + +- 2026-10-23 — исправлена валидация `HeaderBody`: кроме legacy-логинов разрешены `login@namespace` (до 30 ASCII-байт). Это устраняет `BAD_BLOCK_FORMAT` при первом AddBlock новых free/paid пользователей. Порядок байт HEADER, Frame v1, ANS-104 и API без изменений. Commit hash отсутствует (патч без git-коммита); после коммита добавить хэш. diff --git a/shine-UI/js/app.js b/shine-UI/js/app.js index d07c47ad..7c8a4842 100644 --- a/shine-UI/js/app.js +++ b/shine-UI/js/app.js @@ -4,7 +4,7 @@ import { PRE_AUTH_PAGES, syncTrackedRouteHistory, consumeHistoryLayerPop, -} from './router.js'; +} from './router.js?v=2026102311015'; import { renderToolbar } from './components/toolbar.js'; import { captureClientError, @@ -63,11 +63,11 @@ import { setSolanaCluster } from './services/solana-rpc-gateway.js'; import * as startView from './pages/start-view.js?v=202610072303'; import * as entrySettingsView from './pages/entry-settings-view.js?v=202609260900'; -import * as registerView from './pages/register-view.js?v=202610231'; -import * as registrationEmailView from './pages/registration-email-view.js'; +import * as registerView from './pages/register-view.js?v=2026102311015'; +import * as registrationEmailView from './pages/registration-email-view.js?v=202610231930'; import * as registrationUpgradeView from './pages/registration-upgrade-view.js'; import * as registrationFaqView from './pages/registration-faq-view.js?v=202610072303'; -import * as registrationPaymentView from './pages/registration-payment-view.js?v=202606180940'; +import * as registrationPaymentView from './pages/registration-payment-view.js?v=202610231945'; import * as registrationDraftKeysView from './pages/registration-draft-keys-view.js'; import * as topupView from './pages/topup-view.js'; import * as devnetTopupView from './pages/devnet-topup-view.js'; diff --git a/shine-UI/js/pages/register-view.js b/shine-UI/js/pages/register-view.js index 81071645..bd740d15 100644 --- a/shine-UI/js/pages/register-view.js +++ b/shine-UI/js/pages/register-view.js @@ -27,7 +27,7 @@ export function render({navigate}) { const methodLabel=document.createElement('label');methodLabel.className='stack'; methodLabel.textContent='Способ регистрации';methodLabel.append(method); const pwLabel=document.createElement('label');pwLabel.className='stack';pwLabel.textContent='Пароль (ключи остаются только у вас)';pwLabel.append(password); form.append(methodLabel,nsLabel,local,full,pwLabel,status,action); - let namespaces=[]; let disposed=false; let request=0; + let namespaces=[]; let disposed=false; let inputRevision=0; let submission=0; const feeToSol = fee => (Number(fee || '0')/1e9).toFixed(6); function selected() { return namespaces.find(n=>n.name===namespace.value); } function display() { @@ -45,9 +45,11 @@ export function render({navigate}) { } function showFull() { full.textContent=namespace.value?`Полное имя: ${local.value.trim()}@${namespace.value}`:'Нет доступных namespace этого типа'; - status.textContent='';request++; + status.textContent=''; } - method.addEventListener('change',display);namespace.addEventListener('change',showFull);local.addEventListener('input',showFull); + method.addEventListener('change',()=>{inputRevision++;display();}); + namespace.addEventListener('change',()=>{inputRevision++;showFull();}); + local.addEventListener('input',()=>{inputRevision++;showFull();}); void getRegistrationNamespaces().then(data=>{ if(disposed)return;namespaces=Array.isArray(data.namespaces)?data.namespaces:[];display(); if(!namespaces.length)status.textContent='Solana namespace ещё не синхронизированы с сервером'; @@ -60,11 +62,13 @@ export function render({navigate}) { if(local.value.trim().length < Number(ns.minLocalLength))throw new Error(`Логин не короче ${ns.minLocalLength} символов`); if(!password.value || password.value.length>PASSWORD_MAX_LENGTH)throw new Error('Введите непустой пароль допустимой длины'); }catch(error){status.textContent=error.message;return;} - const thisRun=++request; + const thisRun=++submission; + const thisInputRevision=inputRevision; action.disabled=true;status.textContent='Проверяем выбранный логин…'; try { const check=await checkRegistrationLogin(login); - if(disposed || thisRun!==request)return; + if(disposed || thisRun!==submission)return; + if(thisInputRevision!==inputRevision)throw new Error('Данные формы изменились. Проверьте их и повторите попытку.'); if(!check.loginAvailable)throw new Error('Этот логин уже занят'); if(Number(check.namespaceType)!==Number(method.value))throw new Error('Тип namespace изменился. Обновите список.'); const draft=state.registrationDraft; @@ -73,13 +77,17 @@ export function render({navigate}) { draft.namespaceFeeLamports=String(check.registrationFeeLamports||ns.registrationFeeLamports); draft.namespaceServerLogin=ns.defaultServerLogin||''; if(changed)draft.preGeneratedKeyBundle=null; + if(draft.flowType==='free') { + navigate('registration-email-view'); + return; + } status.textContent='Создаём ключи локально (Argon2id)…'; const bundle=draft.preGeneratedKeyBundle || await authService.derivePasswordKeyBundle(login,password.value); - if(disposed || thisRun!==request)return; + if(disposed || thisRun!==submission)return; draft.preGeneratedKeyBundle=bundle; - navigate(draft.flowType==='free'?'registration-email-view':'registration-payment-view'); - }catch(error){if(!disposed && thisRun===request)status.textContent=error.message;} - finally {action.disabled=false;} + navigate('registration-payment-view'); + }catch(error){if(!disposed && thisRun===submission)status.textContent=error.message || 'Не удалось продолжить регистрацию.';} + finally {if(thisRun===submission)action.disabled=false;} }); screen.append(createTopBar({title:'Регистрация',back:{label:'←',onClick:()=>{resetRegistrationFlow();navigate('start-view');}}}),form); return screen; diff --git a/shine-UI/js/pages/registration-email-view.js b/shine-UI/js/pages/registration-email-view.js index 83e9ea80..6391b518 100644 --- a/shine-UI/js/pages/registration-email-view.js +++ b/shine-UI/js/pages/registration-email-view.js @@ -1,5 +1,5 @@ import { createTopBar } from '../components/topbar.js'; -import { state } from '../state.js'; +import { authService, state } from '../state.js'; import { checkRegistrationEmail, startFreeRegistration, confirmFreeRegistration } from '../services/registration-v2-api.js'; import { completeRegistrationLogin } from './registration-payment-view.js'; @@ -24,13 +24,18 @@ export function render({navigate}) { let disposed=false; function showConfirm(){ input.disabled=true;next.hidden=true;code.hidden=false;codeLabel.hidden=false;confirm.hidden=false;retry.hidden=false; } next.addEventListener('click',async()=>{ - if(!draft.preGeneratedKeyBundle || draft.flowType!=='free'){status.textContent='Сначала подготовьте ключи на предыдущем экране';return;} + if(draft.flowType!=='free'){status.textContent='Выберите бесплатную регистрацию на предыдущем экране';return;} next.disabled=true;status.textContent='Проверяем email…'; try { const address=input.value.trim(); const available=await checkRegistrationEmail(address); if(!available.emailAvailable) throw new Error('Этот email уже использован для бесплатной регистрации'); draft.email=address; + if(!draft.preGeneratedKeyBundle){ + if(!draft.login || !draft.password) throw new Error('Логин или пароль не сохранены. Вернитесь на предыдущий экран.'); + status.textContent='Создаём ключи локально (Argon2id)…'; + draft.preGeneratedKeyBundle=await authService.derivePasswordKeyBundle(draft.login,draft.password); + } status.textContent='Создаём временную заявку…'; const started=await startFreeRegistration({fullLogin:draft.login,keyBundle:draft.preGeneratedKeyBundle,email:address}); if(disposed)return; diff --git a/shine-UI/js/pages/registration-payment-view.js b/shine-UI/js/pages/registration-payment-view.js index 5f405201..63f71999 100644 --- a/shine-UI/js/pages/registration-payment-view.js +++ b/shine-UI/js/pages/registration-payment-view.js @@ -13,8 +13,10 @@ import { import { clearStoredMessages } from '../services/message-store.js'; import { toUserMessage } from '../services/ui-error-texts.js'; import { + createSolanaWalletFromPrivateBase58, formatSol, getBalanceSol, + transferSol, } from '../services/solana-wallet-service.js'; import { loadSolanaWeb3 } from '../vendor/solana-web3-loader.js'; import { @@ -25,12 +27,14 @@ import { registerUserOnSolana, } from '../services/solana-register-service.js'; import { defaultServerLogin } from '../deploy-config.js'; +import { normalizeFullLogin } from '../services/shine-namespace-service.js'; export const pageMeta = { id: 'registration-payment-view', title: 'Оплата регистрации', showAppChrome: false }; const MIN_REQUIRED_SOL = 0.01; const RECOMMENDED_TOPUP_SOL = 0.02; const TEST_TOPUP_AMOUNT_SOL = 0.02; const DEVNET_ENDPOINT = 'https://api.devnet.solana.com'; +const TEST_TOPUP_SENDER_PRIVATE_32_BASE58 = '6xqAuKYvA8qrCdAkcw7Y8aMgvBnYk8JLxWLma5BzbAvu'; const AUTO_LOGIN_INITIAL_DELAY_MS = 1000; const AUTO_LOGIN_RETRY_MS = 2000; const REGISTRATION_PROGRESS_DURATION_MS = 12000; @@ -68,6 +72,12 @@ function parseBalanceSol(value) { return Number.isFinite(parsed) ? parsed : 0; } +function registrationAccessServerLogin() { + const configured = String(state.entrySettings.shineServerLogin || defaultServerLogin || '').trim().toLowerCase(); + if (!configured) return ''; + return normalizeFullLogin(configured.includes('@') ? configured : `${configured}@shine`); +} + function getCryptoRuntimeState() { const hasCrypto = Boolean(globalThis.crypto); const hasGetRandomValues = Boolean(globalThis.crypto && typeof globalThis.crypto.getRandomValues === 'function'); @@ -249,13 +259,35 @@ export function render({ navigate }) { topupButton.className = 'ghost-btn'; topupButton.type = 'button'; topupButton.textContent = 'Тестовое пополнение (пока доступно в тестовом режиме)'; - // Браузерная раздача devnet SOL с приватным ключом отправителя опасна. - // Ссылка на публичный faucet безопаснее, чем встраивать секрет в JS. - topupButton.textContent = 'Как пополнить через devnet faucet'; - topupButton.addEventListener('click', () => { - status.className = 'status-line is-unavailable'; - status.textContent = 'Скопируйте адрес кошелька выше и пополните его через доверенный Solana devnet faucet. Приватный ключ отправителя не должен находиться в приложении.'; - status.style.display = ''; + topupButton.addEventListener('click', async () => { + status.style.display = 'none'; + topupButton.disabled = true; + const defaultText = 'Тестовое пополнение (пока доступно в тестовом режиме)'; + topupButton.textContent = 'Пополняем...'; + try { + const address = await deriveUserWalletAddress(); + const sender = await createSolanaWalletFromPrivateBase58(TEST_TOPUP_SENDER_PRIVATE_32_BASE58); + await transferSol({ + endpoint: DEVNET_ENDPOINT, + fromKeypair: sender.keypair, + toAddress: address, + amountSol: TEST_TOPUP_AMOUNT_SOL, + }); + const balance = await getBalanceSol({ + endpoint: DEVNET_ENDPOINT, + address, + }); + state.registrationPayment.balanceSOL = String(balance.sol); + balanceValue.textContent = `${formatSol(balance.sol, 6)} SOL`; + status.className = 'status-line is-available'; + status.textContent = `Тестовое пополнение выполнено: +${TEST_TOPUP_AMOUNT_SOL} SOL. Баланс: ${formatSol(balance.sol, 6)} SOL.`; + status.style.display = ''; + } catch (error) { + showWalletError(error, 'Не удалось выполнить тестовое пополнение. Попробуйте ещё раз.'); + } finally { + topupButton.disabled = false; + topupButton.textContent = defaultText; + } }); const submitButton = document.createElement('button'); @@ -289,7 +321,7 @@ export function render({ navigate }) { : `Для регистрации пополните этот кошелёк соланами примерно на ${RECOMMENDED_TOPUP_SOL} SOL. Сейчас на кошельке ${formatSol(currentBalance, 6)} SOL. Минимум для продолжения: ${requiredSol.toFixed(6)} SOL.`; status.style.display = ''; if (isTestContour) { - status.textContent += ' Для тестового пополнения используйте внешний devnet faucet.'; + status.textContent += ` Нажмите «Тестовое пополнение», чтобы сразу добавить ${TEST_TOPUP_AMOUNT_SOL} SOL без перехода на другой экран.`; } return; } @@ -315,7 +347,7 @@ export function render({ navigate }) { login: state.registrationDraft.login, keyBundle, solanaEndpoint: state.entrySettings.solanaServer, - accessServers: [state.entrySettings.shineServerLogin || defaultServerLogin], + accessServers: [registrationAccessServerLogin()], }); registrationTxId = String(registrationResult?.signature || '').trim(); } catch (solanaError) { diff --git a/shine-UI/js/router.js b/shine-UI/js/router.js index f9217404..6730747c 100644 --- a/shine-UI/js/router.js +++ b/shine-UI/js/router.js @@ -72,6 +72,7 @@ export const PRE_AUTH_PAGES = [ 'start-view', 'entry-settings-view', 'register-view', + 'registration-email-view', 'registration-faq-view', 'registration-payment-view', 'registration-draft-keys-view', @@ -232,6 +233,7 @@ export function parseRouteFromPath(pathname = '') { if (pageId === 'register') { const sub = decodePart(segments[1] || '').toLowerCase(); + if (sub === 'email') return { pageId: 'registration-email-view', params: {} }; if (sub === 'faq') return { pageId: 'registration-faq-view', params: {} }; if (sub === 'payment') return { pageId: 'registration-payment-view', params: {} }; if (sub === 'draft-keys') return { pageId: 'registration-draft-keys-view', params: {} }; From a22f590395d01e6c453fea3200a29f89aad2851488317d551b5db3ed314a9706 Mon Sep 17 00:00:00 2001 From: AidarKC Date: Wed, 28 Oct 2026 11:27:42 +0300 Subject: [PATCH 04/82] =?UTF-8?q?=D0=B0=D0=BF=D0=B4=D0=B5=D0=B9=D1=82=20?= =?UTF-8?q?=D0=BF=D0=BE=20=D1=80=D0=B5=D0=B3=D0=B8=D1=81=D1=82=D1=80=D0=B0?= =?UTF-8?q?=D1=86=D0=B8=D0=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../js/pages/registration-payment-view.js | 18 + .../js/pages/registration-upgrade-view.js | 385 +++++++++++++++--- shine-UI/js/pages/settings-view.js | 33 +- shine-UI/js/router.js | 2 + .../services/registration-upgrade-helpers.js | 23 ++ .../tests/registration-upgrade-flow.test.mjs | 43 ++ 6 files changed, 439 insertions(+), 65 deletions(-) create mode 100644 shine-UI/js/services/registration-upgrade-helpers.js create mode 100644 shine-UI/tests/registration-upgrade-flow.test.mjs diff --git a/shine-UI/js/pages/registration-payment-view.js b/shine-UI/js/pages/registration-payment-view.js index 63f71999..2228d117 100644 --- a/shine-UI/js/pages/registration-payment-view.js +++ b/shine-UI/js/pages/registration-payment-view.js @@ -693,3 +693,21 @@ function renderSolanaDoneStage({ navigate, status, keyBundle, registrationTxId = }, AUTO_LOGIN_RETRY_MS); }, AUTO_LOGIN_INITIAL_DELAY_MS); } + +/** Тот же тестовый источник +0.02 devnet SOL, что используется обычной регистрацией. + * Экспорт добавлен для FREE_CERT → Solana upgrade; поведение обычной регистрации не изменяется. + * Никогда не используйте этот встроенный devnet-кошелёк для реальных средств. + */ +export async function fundDevnetRegistrationWallet(address) { + if (!isTestRegistrationContour()) throw new Error('Тестовое пополнение разрешено только в devnet'); + const cleanAddress = String(address || '').trim(); + if (!cleanAddress) throw new Error('Не указан адрес пополняемого кошелька'); + const sender = await createSolanaWalletFromPrivateBase58(TEST_TOPUP_SENDER_PRIVATE_32_BASE58); + await transferSol({ + endpoint: DEVNET_ENDPOINT, + fromKeypair: sender.keypair, + toAddress: cleanAddress, + amountSol: TEST_TOPUP_AMOUNT_SOL, + }); + return getBalanceSol({ endpoint: DEVNET_ENDPOINT, address: cleanAddress }); +} diff --git a/shine-UI/js/pages/registration-upgrade-view.js b/shine-UI/js/pages/registration-upgrade-view.js index 7a477535..2fab14db 100644 --- a/shine-UI/js/pages/registration-upgrade-view.js +++ b/shine-UI/js/pages/registration-upgrade-view.js @@ -2,63 +2,342 @@ import { createTopBar } from '../components/topbar.js'; import { authService, state } from '../state.js'; import { getRegistrationStatus } from '../services/registration-v2-api.js'; import { getNamespace } from '../services/shine-namespace-service.js'; -import { upgradeFreeUserOnSolana } from '../services/shine-user-pda-service.js'; +import { readShineUserPda, upgradeFreeUserOnSolana } from '../services/shine-user-pda-service.js'; +import { checkLoginExistsOnSolana, formatSolanaErrorDetails } from '../services/solana-register-service.js'; import { base64ToBytes, bytesToBase58 } from '../services/crypto-utils.js'; +import { getSolanaCluster } from '../services/solana-rpc-gateway.js'; +import { fundDevnetRegistrationWallet } from './registration-payment-view.js'; +import { + getBalanceSol, formatSol, +} from '../services/solana-wallet-service.js'; +import { loadSolanaWeb3 } from '../vendor/solana-web3-loader.js'; +import { + USER_PDA_SPACE, UPGRADE_TEST_TOPUP_SOL, calculateUpgradeFunding, + isUpgradeComplete, solFromLamports, +} from '../services/registration-upgrade-helpers.js'; -export const pageMeta={id:'registration-upgrade-view',title:'Регистрация в Solana'}; -export function render({navigate,chrome}) { - const screen=document.createElement('section');screen.className='stack'; - chrome?.setTopbar(createTopBar({title:'Регистрация в Solana',back:{label:'←',onClick:()=>navigate('settings-view')}})); - const card=document.createElement('div');card.className='card stack'; - const heading=document.createElement('h3');heading.textContent='Закрепить существующий аккаунт в Solana'; - const description=document.createElement('p');description.className='meta-muted'; - description.textContent='Имя, история Arweave, каналы и три публичных ключа не меняются. Создаётся только пользовательский PDA Solana.'; - const price=document.createElement('p');price.className='meta-muted';price.textContent='Читаем стоимость из Solana…'; - const password=document.createElement('input');password.className='input';password.type='password'; - password.autocomplete='current-password';password.placeholder='Пароль существующего аккаунта'; - const action=document.createElement('button');action.className='primary-btn';action.textContent='Зарегистрировать в Solana'; - const status=document.createElement('p');status.className='status-line';status.setAttribute('aria-live','polite'); - card.append(heading,description,price,password,action,status);screen.append(card); - const login=state.session?.login || ''; - let identity=null;let namespace=null;let disposed=false; - async function refresh(){ - if(!login.includes('@'))throw new Error('Нужен полный login@namespace'); - identity=await getRegistrationStatus(login); - if(identity.registrationStatus!=='FREE_CERT') throw new Error('Платная регистрация доступна только для бесплатного аккаунта'); - namespace=await getNamespace({namespace:login.split('@')[1],solanaEndpoint:state.entrySettings.solanaServer}); - if(namespace.type!==2)throw new Error('Сертификат не соответствует namespace'); - if(disposed)return; - price.textContent=`Комиссия namespace: ${(Number(namespace.registrationFeeLamports)/1e9).toFixed(6)} SOL + rent/сетевые комиссии`; - action.disabled=false; +export const pageMeta = { id: 'registration-upgrade-view', title: 'Регистрация в Solana' }; +const SYNC_INTERVAL_MS = 3000; +const SYNC_NOTICE_AFTER_MS = 90000; + +function element(tag, className, content = '') { + const node = document.createElement(tag); + if (className) node.className = className; + node.textContent = content; + return node; +} +function makeButton(label, className = 'primary-btn') { + const button = element('button', className, label); + button.type = 'button'; + return button; +} +function makeExplorerTxLink(signature) { + const tx = String(signature || '').trim(); + if (!tx) return null; + const anchor = element('a', '', tx); + const url = new URL(`https://explorer.solana.com/tx/${encodeURIComponent(tx)}`); + const cluster = getSolanaCluster(); + if (cluster && cluster !== 'mainnet-beta') url.searchParams.set('cluster', cluster); + anchor.href = url.toString(); + anchor.target = '_blank'; + anchor.rel = 'noopener noreferrer'; + anchor.style.overflowWrap = 'anywhere'; + return anchor; +} + +export function render({ navigate, chrome }) { + const login = String(state.session?.login || ''); + const solanaEndpoint = String(state.entrySettings?.solanaServer || ''); + const isDevnet = getSolanaCluster() === 'devnet'; + const screen = element('section', 'stack'); + chrome?.setTopbar(createTopBar({ + title: 'Закрепить аккаунт в Solana', + back: { label: '←', onClick: () => navigate('settings-view') }, + })); + + const intro = element('div', 'card stack'); + intro.append( + element('h3', '', 'Сделайте аккаунт независимым от сервера'), + element('p', 'meta-muted', `Ваш аккаунт ${login} зарегистрирован с помощью бесплатного сертификата Arweave. Запись неизменяема и подписана сервером-регистратором.`), + element('p', 'meta-muted', 'Сейчас управление ключами и переход на другой сервер ограничены: ваша регистрация зависит от сервера и сохранности его ключей.'), + element('p', 'meta-muted', 'После закрепления в Solana у вас появится собственная PDA: вы сможете самостоятельно менять пароль и ключи, а также пользоваться совместимыми серверами.'), + element('p', 'meta-muted', 'Логин, namespace, три публичных ключа, публикации и история Arweave останутся прежними. Для доступности истории на другом сервере требуется её синхронизация.'), + element('p', 'meta-muted', 'Регистрация в Solana оплачивается один раз. Для проведения транзакции на вашем Solana-кошельке должны быть SOL.'), + ); + const introStatus = element('p', 'status-line', 'Проверяем бесплатный сертификат, PDA и актуальную стоимость…'); + introStatus.setAttribute('aria-live', 'polite'); + const continueButton = makeButton('Продолжить и пополнить кошелёк'); + continueButton.disabled = true; + intro.append(continueButton, introStatus); + + const payment = element('div', 'card stack'); + payment.append(element('h3', '', 'Оплата регистрации Solana')); + const walletHint = element('p', 'meta-muted', 'Пополните этот Solana-адрес. Это ваш существующий blockchain key, новый кошелёк не создаётся.'); + const walletLabel = element('label', 'field-label', 'Ваш Solana-кошелёк'); + const wallet = document.createElement('input'); + wallet.className = 'input'; wallet.type = 'text'; wallet.readOnly = true; + wallet.style.width = '100%'; wallet.setAttribute('aria-label', 'Адрес Solana-кошелька'); + const copyButton = makeButton('Скопировать адрес', 'ghost-btn'); + const amount = element('p', 'meta-muted', 'Получаем стоимость регистрации…'); + const balanceLine = element('p', 'meta-muted', 'Баланс: —'); + const refreshButton = makeButton('Обновить баланс', 'ghost-btn'); + const topupButton = makeButton(`Тестовое пополнение (+${UPGRADE_TEST_TOPUP_SOL} SOL)`, 'ghost-btn'); + const testHint = element('p', 'meta-muted', 'Тестовое пополнение доступно только в сети devnet. Тестовые SOL не имеют реальной стоимости.'); + const passwordLabel = element('label', 'field-label', 'Пароль действующего аккаунта'); + const password = document.createElement('input'); + password.className = 'input'; password.type = 'password'; password.autocomplete = 'current-password'; + password.placeholder = 'Введите пароль для подтверждения исходных ключей'; + const payButton = makeButton('Оплатить и закрепить аккаунт'); + const payStatus = element('p', 'status-line'); + payStatus.setAttribute('aria-live', 'polite'); + payment.append(walletHint, walletLabel, wallet, copyButton, amount, balanceLine, refreshButton); + if (isDevnet) payment.append(topupButton, testHint); + payment.append(passwordLabel, password, payButton, payStatus); + + const syncing = element('div', 'card stack'); + syncing.append(element('h3', '', 'Проверяем регистрацию')); + const syncInfo = element('p', 'meta-muted', 'Проверяем PDA в Solana и обновление статуса на сервере…'); + const txLine = element('p', 'meta-muted'); + const syncStatus = element('p', 'status-line'); + syncStatus.setAttribute('aria-live', 'polite'); + const checkButton = makeButton('Проверить ещё раз', 'ghost-btn'); + syncing.append(syncInfo, txLine, syncStatus, checkButton); + + const done = element('div', 'card stack'); + done.append( + element('h3', '', 'Аккаунт зарегистрирован в Solana!'), + element('p', 'meta-muted', `Ваш логин ${login} и namespace не изменились. Регистрация подтверждена PDA Solana. Прежние ключи и история сохранены.`), + element('p', 'meta-muted', 'Теперь вы можете управлять ключами и выбирать совместимые серверы доступа.'), + ); + const settingsButton = makeButton('Вернуться в настройки'); + settingsButton.addEventListener('click', () => navigate('settings-view')); + done.append(settingsButton); + screen.append(intro, payment, syncing, done); + + let disposed = false; + let identity = null; + let namespace = null; + let funding = null; + let walletAddress = ''; + let pollingTimer = null; + let startedPollingAt = 0; + let checking = false; + let sending = false; + + function show(stageName) { + for (const [name, card] of [['intro', intro], ['payment', payment], ['syncing', syncing], ['done', done]]) { + card.style.display = name === stageName ? '' : 'none'; + } } - action.disabled=true; - void refresh().catch(error=>{if(!disposed)status.textContent=error.message;}); - action.addEventListener('click',async()=>{ - action.disabled=true; - try{ - if(!identity || !namespace)throw new Error('Namespace/сертификат ещё не проверены'); - if(!password.value)throw new Error('Введите исходный пароль для восстановления тех же ключей'); - status.textContent='Восстанавливаем первоначальные ключи локально…'; - const keys=await authService.derivePasswordKeyBundle(login,password.value); - for(const [pair,expected] of [[keys.rootPair,identity.rootPublicKey], - [keys.blockchainPair,identity.blockchainPublicKey],[keys.clientPair,identity.clientPublicKey]]) { - if(bytesToBase58(base64ToBytes(pair.publicKeyB64))!==expected) - throw new Error('Пароль не соответствует исходным ключам этого сертификата'); + function message(node, value, error = false) { + if (disposed) return; + node.textContent = value; + node.className = `status-line ${error ? 'is-unavailable' : 'is-available'}`; + } + function stopPolling() { + if (pollingTimer !== null) window.clearInterval(pollingTimer); + pollingTimer = null; + } + function succeed() { + if (disposed) return; + stopPolling(); + password.value = ''; + show('done'); + } + async function balanceUpdate(showError = true) { + if (!walletAddress) return null; + refreshButton.disabled = true; + try { + const balance = await getBalanceSol({ endpoint: solanaEndpoint, address: walletAddress }); + if (disposed) return null; + balanceLine.textContent = `Баланс: ${formatSol(balance.sol, 6)} SOL`; + return BigInt(balance.lamports); + } catch (error) { + if (showError) message(payStatus, `Не удалось прочитать баланс: ${error.message}`, true); + return null; + } finally { + if (!disposed) refreshButton.disabled = false; + } + } + async function hasVerifiedPda(expectedIdentity = identity) { + const presence = await checkLoginExistsOnSolana({ login, solanaEndpoint }); + if (!presence.exists) return false; + const pda = await readShineUserPda({ login, solanaEndpoint }); + if (pda.login !== login) throw new Error('Найденная PDA принадлежит другому логину'); + // Если сервер ещё считает аккаунт бесплатным, проверяем совпадение с исходным сертификатом. + if (expectedIdentity?.registrationStatus === 'FREE_CERT') { + if (bytesToBase58(pda.rootKey) !== expectedIdentity.rootPublicKey || + bytesToBase58(pda.clientKey) !== expectedIdentity.clientPublicKey || + bytesToBase58(pda.forks[0].blockchainKey) !== expectedIdentity.blockchainPublicKey) { + throw new Error('Ключи существующей PDA не соответствуют бесплатному сертификату'); } - const signature=base64ToBytes(identity.innerSignature64B64); - if(signature.length!==64)throw new Error('Не получена проверяемая подпись регистратора'); - status.textContent='Подписываем новую запись PDA существующими ключами…'; - const tx=await upgradeFreeUserOnSolana({ - login,keyBundle:keys,solanaEndpoint:state.entrySettings.solanaServer, - innerSignature64:signature, - accessServers:identity.defaultServerLogin?[identity.defaultServerLogin]:[], - }); - if(disposed)return; - password.value=''; - status.textContent=`Транзакция отправлена (${tx.signature||'успешно'}). Ожидаем синхронизацию статуса Solana; история и ключи сохранены.`; - // UI не делает ложных выводов до фактической синхронизации PDA. - }catch(error){if(!disposed)status.textContent=error.message;} - finally {if(!disposed)action.disabled=false;} + } + return true; + } + async function checkSync() { + if (disposed || checking) return; + checking = true; + checkButton.disabled = true; + try { + const onChainExists = await hasVerifiedPda(); + if (disposed) return; + if (!onChainExists) { + message(syncStatus, 'PDA пока не обнаружена в Solana. Продолжаем проверку…'); + return; + } + const current = await getRegistrationStatus(login); + if (disposed) return; + if (isUpgradeComplete(current.registrationStatus)) { + succeed(); + return; + } + if (current.registrationStatus !== 'FREE_CERT') { + message(syncStatus, `Сервер вернул неожиданный статус: ${current.registrationStatus}.`, true); + return; + } + message(syncStatus, 'PDA создана в Solana. Ожидаем, пока сервер синхронизирует аккаунт…'); + } catch (error) { + message(syncStatus, `Проверка пока не удалась: ${error.message}`, true); + } finally { + checking = false; + if (!disposed) checkButton.disabled = false; + if (!disposed && Date.now() - startedPollingAt > SYNC_NOTICE_AFTER_MS) { + syncInfo.textContent = 'Синхронизация задержалась. Можете вернуться в настройки и открыть этот экран позже: повторная оплата не нужна.'; + } + } + } + function watchSync() { + show('syncing'); + startedPollingAt = Date.now(); + stopPolling(); + void checkSync(); + pollingTimer = window.setInterval(() => void checkSync(), SYNC_INTERVAL_MS); + } + function markTransaction(signature) { + txLine.replaceChildren(); + const anchor = makeExplorerTxLink(signature); + if (anchor) { + txLine.append('Tx ID: ', anchor); + } else { + txLine.textContent = 'Проверяем запись Solana по вашему логину.'; + } + } + async function initialize() { + if (!login.includes('@')) throw new Error('Войдите в существующий аккаунт login@namespace'); + const current = await getRegistrationStatus(login); + if (disposed) return; + if (isUpgradeComplete(current.registrationStatus)) { succeed(); return; } + if (current.registrationStatus !== 'FREE_CERT') throw new Error('Переход доступен только для бесплатного аккаунта'); + // Проверяем наличие PDA до любых новых платежей. Это также позволяет возобновить проверку после перезагрузки. + const onChainExists = await hasVerifiedPda(current); + if (disposed) return; + if (onChainExists) { + markTransaction(''); + watchSync(); + return; + } + const loadedNamespace = await getNamespace({ namespace: login.split('@')[1], solanaEndpoint }); + if (loadedNamespace.type !== 2) throw new Error('Для бесплатного сертификата требуется namespace типа 2'); + if (!current.innerSignature64B64 || !current.blockchainPublicKey) throw new Error('Исходный сертификат отсутствует или неполон'); + const web3 = await loadSolanaWeb3(); + const connection = new web3.Connection(solanaEndpoint, 'confirmed'); + const rentLamports = await connection.getMinimumBalanceForRentExemption(USER_PDA_SPACE, 'confirmed'); + if (disposed) return; + identity = current; + namespace = loadedNamespace; + funding = calculateUpgradeFunding({ namespaceFeeLamports: namespace.registrationFeeLamports, rentLamports }); + walletAddress = identity.blockchainPublicKey; + // Проверяем адрес как настоящий публичный ключ Solana, не используем произвольный текст ответа сервера. + const pubkey = new web3.PublicKey(walletAddress); + walletAddress = pubkey.toBase58(); + wallet.value = walletAddress; + amount.textContent = `Комиссия namespace: ${solFromLamports(funding.namespaceFee)} SOL; депозит PDA: ${solFromLamports(funding.rent)} SOL; минимум с запасом на сеть: ${solFromLamports(funding.requiredLamports)} SOL. Рекомендуется ${solFromLamports(funding.recommendedLamports)} SOL.`; + continueButton.disabled = false; + message(introStatus, 'Данные аккаунта и стоимость проверены.'); + } + + continueButton.addEventListener('click', () => { + show('payment'); + void balanceUpdate(false); }); + copyButton.addEventListener('click', async () => { + try { + await navigator.clipboard.writeText(walletAddress); + message(payStatus, 'Адрес кошелька скопирован.'); + } catch { + message(payStatus, 'Не удалось скопировать адрес. Можно скопировать его вручную.', true); + } + }); + refreshButton.addEventListener('click', () => void balanceUpdate()); + topupButton.addEventListener('click', async () => { + if (!isDevnet || disposed || !walletAddress) return; + topupButton.disabled = true; + try { + message(payStatus, `Переводим ${UPGRADE_TEST_TOPUP_SOL} тестовых SOL в devnet…`); + const result = await fundDevnetRegistrationWallet(walletAddress); + if (disposed) return; + balanceLine.textContent = `Баланс: ${formatSol(result.sol, 6)} SOL`; + message(payStatus, `Тестовое пополнение +${UPGRADE_TEST_TOPUP_SOL} SOL выполнено.`); + } catch (error) { + message(payStatus, `Тестовое пополнение недоступно (${error.message}). Используйте внешний devnet faucet и обновите баланс.`, true); + } finally { + if (!disposed) topupButton.disabled = false; + } + }); + payButton.addEventListener('click', async () => { + if (disposed || sending) return; + sending = true; + payButton.disabled = true; + try { + if (!identity || !namespace || !funding) throw new Error('Данные регистрации ещё не готовы'); + if (!password.value) throw new Error('Введите пароль существующего аккаунта'); + // Повторно сверяем Solana: уже зарегистрированную PDA не оплачиваем второй раз. + const pdaExists = await hasVerifiedPda(); + if (pdaExists) { password.value = ''; markTransaction(''); watchSync(); return; } + const balanceLamports = await balanceUpdate(); + if (balanceLamports === null) return; + if (balanceLamports < funding.requiredLamports) { + const shortage = funding.requiredLamports - balanceLamports; + throw new Error(`Недостаточно SOL. Пополните кошелёк ещё минимум на ${solFromLamports(shortage)} SOL.`); + } + message(payStatus, 'Проверяем исходный пароль и восстанавливаем ваши ключи локально…'); + const keys = await authService.derivePasswordKeyBundle(login, password.value); + if (disposed) return; + for (const [pair, expected] of [ + [keys.rootPair, identity.rootPublicKey], + [keys.blockchainPair, identity.blockchainPublicKey], + [keys.clientPair, identity.clientPublicKey], + ]) { + if (bytesToBase58(base64ToBytes(pair.publicKeyB64)) !== expected) { + throw new Error('Пароль не совпадает с исходными ключами сертификата'); + } + } + const signature = base64ToBytes(identity.innerSignature64B64); + if (signature.length !== 64) throw new Error('Сертификат не содержит подписи регистратора'); + message(payStatus, 'Подписываем транзакцию и создаём вашу PDA в Solana…'); + const result = await upgradeFreeUserOnSolana({ + login, keyBundle: keys, solanaEndpoint, innerSignature64: signature, + accessServers: identity.defaultServerLogin ? [identity.defaultServerLogin] : [], + }); + if (disposed) return; + password.value = ''; + markTransaction(result.signature); + watchSync(); + } catch (error) { + // Если Solana успела подтвердить PDA, а HTTP-клиент потерял ответ, нельзя требовать новую оплату. + try { + const pdaExists = await hasVerifiedPda(); + if (pdaExists) { password.value = ''; markTransaction(''); watchSync(); return; } + } catch { /* Отсутствие связи с RPC не доказывает отсутствие PDA. */ } + message(payStatus, `Регистрация не завершена: ${formatSolanaErrorDetails(error)}. Проверьте статус перед повторной попыткой.`, true); + } finally { + sending = false; + if (!disposed) payButton.disabled = false; + } + }); + checkButton.addEventListener('click', () => void checkSync()); + show('intro'); + void initialize().catch((error) => message(introStatus, `Не удалось подготовить переход: ${error.message}`, true)); + screen.cleanup = () => { disposed = true; stopPolling(); password.value = ''; }; return screen; } diff --git a/shine-UI/js/pages/settings-view.js b/shine-UI/js/pages/settings-view.js index 6c95699b..175cad6f 100644 --- a/shine-UI/js/pages/settings-view.js +++ b/shine-UI/js/pages/settings-view.js @@ -144,18 +144,27 @@ export function render({navigate, chrome}) {
`; - // Кнопка доступна только владельцу действительного бесплатного сертификата. - if (String(state.session?.login||'').includes('@')) { - void getRegistrationStatus(state.session.login).then(info=>{ - if (isDisposed || info.registrationStatus!=='FREE_CERT') return; - const list=card.querySelector('.nav-list'); - if(!list || card.querySelector('#settings-solana-upgrade')) return; - const button=document.createElement('button'); - button.id='settings-solana-upgrade'; button.className='nav-row'; - button.textContent='Зарегистрировать аккаунт в Solana'; - button.addEventListener('click',()=>navigate('registration-upgrade-view')); - list.append(button); - }).catch(()=>{}); + // Бесплатному аккаунту показываем переход, после синхронизации — подтверждённый статус. + if (String(state.session?.login || '').includes('@')) { + void getRegistrationStatus(state.session.login).then(info => { + if (isDisposed) return; + const list = card.querySelector('.nav-list'); + if (!list || card.querySelector('#settings-solana-upgrade') || card.querySelector('#settings-solana-registered')) return; + if (info.registrationStatus === 'FREE_CERT') { + const button = document.createElement('button'); + button.id = 'settings-solana-upgrade'; + button.className = 'nav-row'; + button.textContent = 'Закрепить аккаунт в Solana'; + button.addEventListener('click', () => navigate('registration-upgrade-view')); + list.append(button); + } else if (info.registrationStatus === 'PAID_UPGRADED' || info.registrationStatus === 'PAID_DIRECT') { + const label = document.createElement('div'); + label.id = 'settings-solana-registered'; + label.className = 'nav-row nav-row--static'; + label.textContent = '✓ Аккаунт зарегистрирован в Solana'; + list.append(label); + } + }).catch(() => {}); } card.querySelector('#settings-appearance').addEventListener('click', () => navigate('appearance-view')); card.querySelector('#settings-notifications').addEventListener('click', () => navigate('notification-settings-view')); diff --git a/shine-UI/js/router.js b/shine-UI/js/router.js index 6730747c..797d198e 100644 --- a/shine-UI/js/router.js +++ b/shine-UI/js/router.js @@ -341,6 +341,7 @@ export function parseRouteFromPath(pathname = '') { if (pageId === 'settings') { const sub = decodePart(segments[1] || '').toLowerCase(); + if (sub === 'solana-upgrade') return { pageId: 'registration-upgrade-view', params: {} }; if (sub === 'keys') return { pageId: 'access-keys-view', params: {} }; if (sub === 'server-options') return { pageId: 'settings-servers-view', params: {} }; if (sub === 'access-servers') return { pageId: 'access-servers-view', params: {} }; @@ -572,6 +573,7 @@ function resolveToolbarTab(pageId) { pageId === 'profiles-view' || pageId === 'wallet-view' || pageId === 'settings-view' || + pageId === 'registration-upgrade-view' || pageId === 'access-keys-view' || pageId === 'my-blockchain-view' || pageId === 'my-blockchain-history-view' || diff --git a/shine-UI/js/services/registration-upgrade-helpers.js b/shine-UI/js/services/registration-upgrade-helpers.js new file mode 100644 index 00000000..7c82e111 --- /dev/null +++ b/shine-UI/js/services/registration-upgrade-helpers.js @@ -0,0 +1,23 @@ +/** Расчёт минимального пополнения для перехода FREE_CERT → PAID_UPGRADED. */ +export const USER_PDA_SPACE = 768; // shine-solana/shine/programs/shine_users/src/settings.rs +export const UPGRADE_NETWORK_RESERVE_LAMPORTS = 100_000; // запас на подписи/комиссию сети +export const UPGRADE_TEST_TOPUP_SOL = 0.02; +export const LAMPORTS_PER_SOL = 1_000_000_000; + +export function calculateUpgradeFunding({ namespaceFeeLamports, rentLamports }) { + const namespaceFee = BigInt(namespaceFeeLamports); + const rent = BigInt(rentLamports); + if (namespaceFee < 0n || rent < 0n) throw new Error('Некорректная стоимость регистрации'); + const requiredLamports = namespaceFee + rent + BigInt(UPGRADE_NETWORK_RESERVE_LAMPORTS); + // Рекомендуем небольшой запас на кошельке, но не ограничиваем 0.01 SOL без необходимости. + const recommendedLamports = requiredLamports + 2_000_000n; + return { requiredLamports, recommendedLamports, namespaceFee, rent }; +} + +export function isUpgradeComplete(status) { + return status === 'PAID_UPGRADED'; +} + +export function solFromLamports(lamports) { + return (Number(lamports) / LAMPORTS_PER_SOL).toFixed(6); +} diff --git a/shine-UI/tests/registration-upgrade-flow.test.mjs b/shine-UI/tests/registration-upgrade-flow.test.mjs new file mode 100644 index 00000000..f56cab65 --- /dev/null +++ b/shine-UI/tests/registration-upgrade-flow.test.mjs @@ -0,0 +1,43 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { readFileSync } from 'node:fs'; +import { fileURLToPath } from 'node:url'; +import { dirname, resolve } from 'node:path'; +import { + USER_PDA_SPACE, calculateUpgradeFunding, isUpgradeComplete, solFromLamports, +} from '../js/services/registration-upgrade-helpers.js'; +const root = resolve(dirname(fileURLToPath(import.meta.url)), '../..'); +const read = file => readFileSync(resolve(root, file), 'utf8'); + +test('платный переход оплачивает namespace + депозит PDA + запас на сеть', () => { + assert.equal(USER_PDA_SPACE, 768); + const result = calculateUpgradeFunding({ namespaceFeeLamports: 500_000n, rentLamports: 6_000_000 }); + assert.equal(result.namespaceFee, 500_000n); + assert.equal(result.requiredLamports, 6_600_000n); + assert.equal(solFromLamports(result.requiredLamports), '0.006600'); + assert.ok(result.recommendedLamports > result.requiredLamports); + assert.throws(() => calculateUpgradeFunding({ namespaceFeeLamports: -1, rentLamports: 0 })); +}); +test('успех только после синхронизации PAID_UPGRADED', () => { + assert.equal(isUpgradeComplete('PAID_UPGRADED'), true); + assert.equal(isUpgradeComplete('FREE_CERT'), false); + assert.equal(isUpgradeComplete('PAID_DIRECT'), false); +}); +test('роут settings/solana-upgrade действительно обслуживается', () => { + const router = read('shine-UI/js/router.js'); + assert.match(router, /sub === 'solana-upgrade'\) return \{ pageId: 'registration-upgrade-view'/); +}); +test('переход не переименовывает пользователя и не использует черновик обычной регистрации', () => { + const upgrade = read('shine-UI/js/pages/registration-upgrade-view.js'); + assert.match(upgrade, /upgradeFreeUserOnSolana\(/); + assert.match(upgrade, /checkLoginExistsOnSolana\(/); + assert.match(upgrade, /getRegistrationStatus\(/); + assert.match(upgrade, /isUpgradeComplete\(current.registrationStatus\)/); + assert.match(upgrade, /namespace\.type !== 2|loadedNamespace\.type !== 2/); + assert.match(upgrade, /getSolanaCluster\(\) === 'devnet'/); + assert.match(upgrade, /fundDevnetRegistrationWallet\(/); + assert.match(upgrade, /screen\.cleanup =/); + assert.doesNotMatch(upgrade, /state\.registrationDraft|resetRegistrationFlow|createSessionForExistingUser/); + const originalPayment = read('shine-UI/js/pages/registration-payment-view.js'); + assert.match(originalPayment, /export async function fundDevnetRegistrationWallet\(/); +}); From ce97171d5a32ae0029a173270fbaf717df94c6c16954142d86b9789e72a14805 Mon Sep 17 00:00:00 2001 From: AidarKC Date: Wed, 28 Oct 2026 11:28:59 +0300 Subject: [PATCH 05/82] =?UTF-8?q?=D0=A3=D0=BD=D0=B8=D1=84=D0=B8=D1=86?= =?UTF-8?q?=D0=B8=D1=80=D0=BE=D0=B2=D0=B0=D1=82=D1=8C=20=D0=BF=D0=BB=D0=B0?= =?UTF-8?q?=D1=82=D0=BD=D1=8B=D0=B9=20=D1=81=D1=82=D0=B0=D1=82=D1=83=D1=81?= =?UTF-8?q?=20=D1=80=D0=B5=D0=B3=D0=B8=D1=81=D1=82=D1=80=D0=B0=D1=86=D0=B8?= =?UTF-8?q?=D0=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/shine/db/DatabaseInitializer.java | 10 ++- .../main/resources/postgres/migration_v35.sql | 62 +++++++++++++++++++ VERSION.properties | 4 +- deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md | 19 ++++++ docs/API/09_Operations_Index.md | 10 +++ docs/API/20_Get_My_Blockchain_API.md | 2 +- .../Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md | 2 +- .../PAID_STATUS_UNIFICATION_V35.md | 24 +++++++ .../js/pages/registration-upgrade-view.js | 7 ++- shine-UI/js/pages/settings-view.js | 47 +++++++------- .../services/registration-upgrade-helpers.js | 5 +- .../tests/registration-upgrade-flow.test.mjs | 26 +++++++- 12 files changed, 183 insertions(+), 35 deletions(-) create mode 100644 SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v35.sql create mode 100644 docs/registration-v2/PAID_STATUS_UNIFICATION_V35.md diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java index 718d4636..5fbfc212 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java @@ -25,11 +25,13 @@ public final class DatabaseInitializer { public static final int SCHEMA_VERSION_32 = 32; public static final int SCHEMA_VERSION_33 = 33; public static final int SCHEMA_VERSION_34 = 34; + public static final int SCHEMA_VERSION_35 = 35; public static final String POSTGRES_SCHEMA_RESOURCE = "postgres/schema_v1.sql"; public static final String POSTGRES_MIGRATION_V31_RESOURCE = "postgres/migration_v31.sql"; public static final String POSTGRES_MIGRATION_V32_RESOURCE = "postgres/migration_v32.sql"; public static final String POSTGRES_MIGRATION_V33_RESOURCE = "postgres/migration_v33.sql"; public static final String POSTGRES_MIGRATION_V34_RESOURCE = "postgres/migration_v34.sql"; + public static final String POSTGRES_MIGRATION_V35_RESOURCE = "postgres/migration_v35.sql"; private DatabaseInitializer() {} @@ -137,9 +139,13 @@ public final class DatabaseInitializer { runSqlScript(conn, POSTGRES_MIGRATION_V34_RESOURCE); currentVersion = readCurrentSchemaVersion(conn); } - if (currentVersion != SCHEMA_VERSION_34) { + if (currentVersion == SCHEMA_VERSION_34) { + runSqlScript(conn, POSTGRES_MIGRATION_V35_RESOURCE); + currentVersion = readCurrentSchemaVersion(conn); + } + if (currentVersion != SCHEMA_VERSION_35) { throw new SQLException( - "Unsupported SHiNE DB v2 schema version: expected 34, found " + currentVersion); + "Unsupported SHiNE DB v2 schema version: expected 35, found " + currentVersion); } } } diff --git a/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v35.sql b/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v35.sql new file mode 100644 index 00000000..02cf3b19 --- /dev/null +++ b/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v35.sql @@ -0,0 +1,62 @@ +-- v35: один полноценный статус для всех зарегистрированных в Solana. +-- Старые регистрационные сертификаты Arweave и дата исходной регистрации сохраняются. +BEGIN; + +-- Сначала снимаем старое ограничение, затем переводим существующие строки. +ALTER TABLE user_identity_current + DROP CONSTRAINT user_identity_current_registration_status_check; +UPDATE user_identity_current + SET registration_status = 'PAID' + WHERE registration_status IN ('PAID_DIRECT', 'PAID_UPGRADED'); +ALTER TABLE user_identity_current + ADD CONSTRAINT user_identity_current_registration_status_check + CHECK (registration_status IN ('FREE_CERT', 'PAID')); + +-- Важнее миграции существующих строк: при следующих Solana sync/upsert +-- и обычный платный, и ранее бесплатный пользователь получают тот же PAID. +CREATE OR REPLACE FUNCTION shine_sync_identity_from_solana() +RETURNS TRIGGER LANGUAGE plpgsql AS $$ +DECLARE old_user user_identity_current%ROWTYPE; +BEGIN + -- Если PostgreSQL получил старую запись из replay, она не должна затереть + -- уже принятую более новую логическую идентичность в BEFORE INSERT. + IF TG_OP = 'INSERT' AND EXISTS ( + SELECT 1 FROM solana_user_pda_current prior + WHERE prior.pda_address = NEW.pda_address AND prior.record_number > NEW.record_number + ) THEN + RETURN NEW; + END IF; + SELECT * INTO old_user FROM user_identity_current + WHERE normalized_login = NEW.normalized_login FOR UPDATE; + IF FOUND AND old_user.registration_status = 'FREE_CERT' AND + (old_user.root_key <> NEW.root_key OR old_user.client_key <> NEW.client_key OR old_user.blockchain_key <> NEW.blockchain_key) THEN + RAISE EXCEPTION 'Free certificate keys differ from Solana upgrade for %', NEW.login; + END IF; + IF FOUND AND old_user.solana_pda_address IS NOT NULL AND old_user.solana_pda_address <> NEW.pda_address THEN + RAISE EXCEPTION 'Duplicate on-chain identity for %', NEW.login; + END IF; + INSERT INTO user_identity_current ( + login, normalized_login, namespace, registration_source, registration_status, + solana_pda_address, free_data_item_id, root_key, client_key, blockchain_key, + blockchain_name, is_server, registered_at_ms, updated_at_ms) + VALUES (NEW.login, NEW.normalized_login, + CASE WHEN position('@' in NEW.login) > 0 THEN split_part(NEW.login,'@',2) ELSE NULL END, + 'SOLANA', 'PAID', + NEW.pda_address, old_user.free_data_item_id, NEW.root_key, NEW.client_key, + NEW.blockchain_key, NEW.blockchain_name, NEW.is_server, + COALESCE(old_user.registered_at_ms, NEW.created_at_ms), NEW.updated_at_ms) + ON CONFLICT (login) DO UPDATE SET + registration_source='SOLANA', + registration_status=EXCLUDED.registration_status, + solana_pda_address=EXCLUDED.solana_pda_address, + root_key=EXCLUDED.root_key, client_key=EXCLUDED.client_key, + blockchain_key=EXCLUDED.blockchain_key, blockchain_name=EXCLUDED.blockchain_name, + is_server=EXCLUDED.is_server, updated_at_ms=EXCLUDED.updated_at_ms; + RETURN NEW; +END $$; + +UPDATE db_schema_version + SET schema_version=35, + updated_at_ms=CAST(EXTRACT(EPOCH FROM clock_timestamp())*1000 AS BIGINT) + WHERE id=1; +COMMIT; diff --git a/VERSION.properties b/VERSION.properties index ee17eca9..ee309369 100644 --- a/VERSION.properties +++ b/VERSION.properties @@ -1,2 +1,2 @@ -client.version=1.20.3 -server.version=1.16.2 +client.version=1.20.4 +server.version=1.16.3 diff --git a/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md b/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md index 489f068e..e721fd69 100644 --- a/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md +++ b/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md @@ -130,3 +130,22 @@ Migration v26 добавляет server-local поля `rotation_status` / `rota ## Этапы регистрации V2 4–7: подготовка тестового окружения (23.10.2026) Перед запуском новой синхронизации нужен тестовый `shine_users` (opcode 7, namespace accounts), применённая PostgreSQL v33, бэкап и отдельная БД. Только после этого разрешён импорт namespace в отдельный регистр `shine_namespace_current`. Не совмещать с существующим UI/production. `freeRegistration.enabled` по умолчанию false; `freeRegistration.registrarSeedFile` — локальный secret path (Base64 seed32) вне Git. При несоответствии регистратора публичному ключу on-chain namespace выдача сертификата прекращается. Нет Arweave importer до этапа 8, API/UI до этапов 9–10. Сначала прогоните чистый snapshot, историю, restart/replay, FK и ключевую ротацию на тестовом контуре. + + +## DB v35: единый платный статус (26.10.2026) + +`DatabaseInitializer` при запуске сервера последовательно обновляет схему до v35. Старые +`PAID_DIRECT` и `PAID_UPGRADED` преобразуются в единый `PAID`; `FREE_CERT` не изменяется. +Любой новый пользователь с настоящей PDA Solana получает `PAID` независимо от способа регистрации. +Данные аккаунтов, Arweave-сертификаты, начальная дата регистрации и ключи не удаляются. + +Порядок на тестовом контуре: резервная копия БД → обновление серверного кода с `migration_v35.sql` +→ перезапуск и проверка `db_schema_version=35` → обновление UI → пробная регистрация и upgrade. +До обновления сервера или при неудачной миграции оставьте существующий UI: новое значение `PAID` +должно приходить только от сервера с применённой v35. На production — отдельное согласование. +Для проверки статусов после миграции: + +```sql +SELECT registration_status, count(*) FROM user_identity_current GROUP BY registration_status; +SELECT schema_version FROM db_schema_version WHERE id=1; +``` diff --git a/docs/API/09_Operations_Index.md b/docs/API/09_Operations_Index.md index abbff6b9..b96a47a9 100644 --- a/docs/API/09_Operations_Index.md +++ b/docs/API/09_Operations_Index.md @@ -107,3 +107,13 @@ - `GetRegistrationStatus` — статус и публичные поля сертификата для upgrade. Точный JSON и ограничения: `docs/registration-v2/WS_REGISTRATION_V2_PROPOSED_NOT_ENABLED.md` (имя сохранено для обратных ссылок; внутри утверждённая версия). + +### `GetRegistrationStatus` после DB v35 + +Для существующего пользователя `payload.registrationStatus` имеет одно из **двух** значений: +`FREE_CERT` (бесплатная регистрация Arweave) или `PAID` (подтверждённая PDA Solana). +`PAID` применяется и к первоначально платным, и к ранее бесплатным пользователям; +`NOT_FOUND` остаётся техническим ответом для отсутствующего логина. +Во время поэтапного развертывания старый сервер может ещё возвращать `PAID_DIRECT` +или `PAID_UPGRADED`; обновлённый UI понимает эти устаревшие ответы как платные. +Поля сертификата для `FREE_CERT` и остальные поля API не меняются. diff --git a/docs/API/20_Get_My_Blockchain_API.md b/docs/API/20_Get_My_Blockchain_API.md index edd60c85..b329c452 100644 --- a/docs/API/20_Get_My_Blockchain_API.md +++ b/docs/API/20_Get_My_Blockchain_API.md @@ -2,7 +2,7 @@ `GetMyBlockchain` — авторизованное постраничное чтение **только текущей активной версии собственного блокчейна**. API используется постоянным экраном «Мой блокчейн» и мастером смены ключей для выбора последнего доверенного блока. -Login сервер берёт только из авторизованной пользовательской сессии. Активное `blockchainName` определяется через общий реестр `user_identity_current` (DAO `CurrentUsersDAO`): для `PAID_DIRECT`/`PAID_UPGRADED` он синхронизирован с Solana, для `FREE_CERT` — с проверенным сертификатом Arweave. Наличие пользовательского Solana PDA **не требуется** для чтения собственного блокчейна. Клиент не может запросить этим методом чужую цепочку. +Login сервер берёт только из авторизованной пользовательской сессии. Активное `blockchainName` определяется через общий реестр `user_identity_current` (DAO `CurrentUsersDAO`): для `PAID` он синхронизирован с Solana, для `FREE_CERT` — с проверенным сертификатом Arweave. Наличие пользовательского Solana PDA **не требуется** для чтения собственного блокчейна. Клиент не может запросить этим методом чужую цепочку. У только что зарегистрированного пользователя до первого `HEADER` может отсутствовать запись с блоками: тогда при существующей идентичности возвращается `status=200`, `tipBlockNumber=-1`, `blocks=[]`, а не `BLOCKCHAIN_NOT_FOUND`. Ошибка `BLOCKCHAIN_NOT_FOUND` относится к отсутствующему пользователю или отсутствующему в его записи имени блокчейна; отсутствие блоков само по себе не является ошибкой. Это изменение внутреннего источника поиска, **без изменения JSON-полей, op или кодировки блоков**. diff --git a/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md b/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md index d63ef825..9a51a73f 100644 --- a/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md +++ b/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md @@ -613,6 +613,6 @@ Arweave/Turbo publisher обрабатывает candidate-блоки приор ## V2 регистрация — разработка (2026-10-23, этап 6, без развёртывания) -Для новых `login@namespace` используется `SHA256(UTF8("user_login=" + fullLogin))` как один 32-byte PDA seed; для namespace — `SHA256(UTF8("namespace=" + namespace))`. `IX_CREATE_NAMESPACE=7` читается как отдельное событие. `SolanaUsersSyncService` декодирует namespace независимо от user-PDA и сохраняет снапшоты namespaces в `shine_namespace_current`; paid user-PDA параллельно синхронизируются как прежде. При upsert Solana запись переносит логического пользователя `FREE_CERT → PAID_UPGRADED` без изменения логина и исходной даты в user_identity_current; free-сертификат не превращается в фальшивый Solana PDA. Общий индекс только в миграции DB v33. При запуске standalone sync сначала выполнить v33 migration через Java-сервер. +Для новых `login@namespace` используется `SHA256(UTF8("user_login=" + fullLogin))` как один 32-byte PDA seed; для namespace — `SHA256(UTF8("namespace=" + namespace))`. `IX_CREATE_NAMESPACE=7` читается как отдельное событие. `SolanaUsersSyncService` декодирует namespace независимо от user-PDA и сохраняет снапшоты namespaces в `shine_namespace_current`; paid user-PDA параллельно синхронизируются как прежде. При upsert Solana запись переносит логического пользователя `FREE_CERT → PAID` без изменения логина и исходной даты в `user_identity_current`; free-сертификат не превращается в фальшивый Solana PDA. Общий индекс появляется в DB v33. Миграция DB v35 консолидирует исторические `PAID_DIRECT`/`PAID_UPGRADED` в `PAID` и переопределяет Solana-trigger, чтобы все последующие PDA синхронизировались в одном платном статусе. `free_data_item_id` и `free_registration_certificate` остаются как свидетельства первоначальной бесплатной регистрации, но не создают особый статус. Standalone sync можно запускать только после применения миграций DB v33–v35 через Java-сервер. **ВНИМАНИЕ:** проверить на настоящем PostgreSQL + RPC replay до включения. Read-only economy-PDA остаётся индексом истории через `getSignaturesForAddress`, не гарантирует websocket account notification. diff --git a/docs/registration-v2/PAID_STATUS_UNIFICATION_V35.md b/docs/registration-v2/PAID_STATUS_UNIFICATION_V35.md new file mode 100644 index 00000000..a818dd23 --- /dev/null +++ b/docs/registration-v2/PAID_STATUS_UNIFICATION_V35.md @@ -0,0 +1,24 @@ +# SHiNE — два состояния регистрации (DB v35, 26 октября 2026) + +Актуальное продуктовое правило: **`FREE_CERT`** — есть серверный сертификат в Arweave, +но нет Solana PDA; **`PAID`** — подтверждён пользовательский PDA в Solana. +`PAID` равнозначен для прямой регистрации и перехода `FREE_CERT → PAID`. + +- Логин, namespace и первые три ключа при переходе не меняются. +- `registered_at_ms` у перешедшего пользователя остаётся датой исходной регистрации. + Дата создания PDA остаётся в отдельном on-chain/account snapshot. +- Исходные Arweave DataItem и `free_registration_certificate` сохраняются для проверки + исторических событий; отдельная статистика способа регистрации не добавляется. +- В `migration_v35.sql` старые `PAID_DIRECT`/`PAID_UPGRADED` конвертируются в `PAID`, + статус ограничивается двумя значениями, а Solana sync-триггер при каждом upsert пишет `PAID`. +- `GetRegistrationStatus` возвращает `FREE_CERT`, `PAID` или `NOT_FOUND` для отсутствующего + логина. Новых API-полей или операций нет. +- В настройках предложение закрепить аккаунт видно только для `FREE_CERT`. После подтверждения + Solana PDA и серверной синхронизации пользователь видит поздравление и предложение исчезает. +- Промежуточная совместимость в UI допускает чтение старых платных статусов со старого сервера, + но после DB v35 они не хранятся и больше не генерируются. +- Не изменять исторические миграции v33/v34 и старые планы этапов: они отражают прежние + этапы проекта. Источником актуального состояния является этот документ и DB v35. + +Перед обновлением production необходима резервная копия PostgreSQL и реальное +интеграционное тестирование миграции, синхронизации и повторного входа. diff --git a/shine-UI/js/pages/registration-upgrade-view.js b/shine-UI/js/pages/registration-upgrade-view.js index 2fab14db..efb5eeeb 100644 --- a/shine-UI/js/pages/registration-upgrade-view.js +++ b/shine-UI/js/pages/registration-upgrade-view.js @@ -105,9 +105,9 @@ export function render({ navigate, chrome }) { const done = element('div', 'card stack'); done.append( - element('h3', '', 'Аккаунт зарегистрирован в Solana!'), + element('h3', '', 'Поздравляем! Ваш аккаунт теперь полноценный!'), element('p', 'meta-muted', `Ваш логин ${login} и namespace не изменились. Регистрация подтверждена PDA Solana. Прежние ключи и история сохранены.`), - element('p', 'meta-muted', 'Теперь вы можете управлять ключами и выбирать совместимые серверы доступа.'), + element('p', 'meta-muted', 'Регистрация подтверждена Solana. Теперь вы самостоятельно управляете ключами и можете переходить между совместимыми серверами доступа.'), ); const settingsButton = makeButton('Вернуться в настройки'); settingsButton.addEventListener('click', () => navigate('settings-view')); @@ -226,7 +226,8 @@ export function render({ navigate, chrome }) { if (!login.includes('@')) throw new Error('Войдите в существующий аккаунт login@namespace'); const current = await getRegistrationStatus(login); if (disposed) return; - if (isUpgradeComplete(current.registrationStatus)) { succeed(); return; } + // Уже платный аккаунт не должен повторно попадать в мастер покупки. + if (isUpgradeComplete(current.registrationStatus)) { navigate('settings-view'); return; } if (current.registrationStatus !== 'FREE_CERT') throw new Error('Переход доступен только для бесплатного аккаунта'); // Проверяем наличие PDA до любых новых платежей. Это также позволяет возобновить проверку после перезагрузки. const onChainExists = await hasVerifiedPda(current); diff --git a/shine-UI/js/pages/settings-view.js b/shine-UI/js/pages/settings-view.js index 175cad6f..f968ff0a 100644 --- a/shine-UI/js/pages/settings-view.js +++ b/shine-UI/js/pages/settings-view.js @@ -123,6 +123,7 @@ export function render({navigate, chrome}) { const palette = PALETTE_PRESETS[getPaletteSettings().preset]?.label || ''; const appearanceHint = `Тема: ${THEME_LABELS[getThemeMode()] || 'авто'}${palette ? ` · цвета «${palette}»` : ''}`; card.innerHTML = ` + `; - // Бесплатному аккаунту показываем переход, после синхронизации — подтверждённый статус. - if (String(state.session?.login || '').includes('@')) { - void getRegistrationStatus(state.session.login).then(info => { - if (isDisposed) return; - const list = card.querySelector('.nav-list'); - if (!list || card.querySelector('#settings-solana-upgrade') || card.querySelector('#settings-solana-registered')) return; - if (info.registrationStatus === 'FREE_CERT') { - const button = document.createElement('button'); - button.id = 'settings-solana-upgrade'; - button.className = 'nav-row'; - button.textContent = 'Закрепить аккаунт в Solana'; - button.addEventListener('click', () => navigate('registration-upgrade-view')); - list.append(button); - } else if (info.registrationStatus === 'PAID_UPGRADED' || info.registrationStatus === 'PAID_DIRECT') { - const label = document.createElement('div'); - label.id = 'settings-solana-registered'; - label.className = 'nav-row nav-row--static'; - label.textContent = '✓ Аккаунт зарегистрирован в Solana'; - list.append(label); - } - }).catch(() => {}); + // Плашка показывается только FREE_CERT; у всех пользователей с PDA Solana её нет. + const accountTier = card.querySelector('#settings-account-tier'); + const currentLogin = String(state.session?.login || ''); + if (currentLogin.includes('@')) { + void getRegistrationStatus(currentLogin).then(info => { + // Не отображаем устаревший ответ после смены аккаунта или размонтирования экрана. + if (isDisposed || String(state.session?.login || '') !== currentLogin) return; + if (info.registrationStatus !== 'FREE_CERT') return; + const button = document.createElement('button'); + button.id = 'settings-solana-upgrade'; + button.type = 'button'; + button.className = 'nav-row'; + const title = document.createElement('span'); + title.className = 'nav-row__label'; + title.textContent = '⚠ Бесплатный аккаунт с ограниченными возможностями'; + const hint = document.createElement('span'); + hint.className = 'nav-row__hint'; + hint.textContent = 'Ваша регистрация зависит от сервера. Перейти на полноценный аккаунт Solana →'; + button.append(title, hint); + button.addEventListener('click', () => navigate('registration-upgrade-view')); + accountTier.replaceChildren(button); + accountTier.hidden = false; + }).catch(() => { + // Если статус неизвестен, нельзя ошибочно предлагать новую оплату. + }); } card.querySelector('#settings-appearance').addEventListener('click', () => navigate('appearance-view')); card.querySelector('#settings-notifications').addEventListener('click', () => navigate('notification-settings-view')); diff --git a/shine-UI/js/services/registration-upgrade-helpers.js b/shine-UI/js/services/registration-upgrade-helpers.js index 7c82e111..d54ef12a 100644 --- a/shine-UI/js/services/registration-upgrade-helpers.js +++ b/shine-UI/js/services/registration-upgrade-helpers.js @@ -1,4 +1,4 @@ -/** Расчёт минимального пополнения для перехода FREE_CERT → PAID_UPGRADED. */ +/** Расчёт минимального пополнения для перехода FREE_CERT → PAID. */ export const USER_PDA_SPACE = 768; // shine-solana/shine/programs/shine_users/src/settings.rs export const UPGRADE_NETWORK_RESERVE_LAMPORTS = 100_000; // запас на подписи/комиссию сети export const UPGRADE_TEST_TOPUP_SOL = 0.02; @@ -15,7 +15,8 @@ export function calculateUpgradeFunding({ namespaceFeeLamports, rentLamports }) } export function isUpgradeComplete(status) { - return status === 'PAID_UPGRADED'; + // Старые серверы могут временно вернуть старые значения при последовательном развёртывании. + return status === 'PAID' || status === 'PAID_DIRECT' || status === 'PAID_UPGRADED'; } export function solFromLamports(lamports) { diff --git a/shine-UI/tests/registration-upgrade-flow.test.mjs b/shine-UI/tests/registration-upgrade-flow.test.mjs index f56cab65..24a366d3 100644 --- a/shine-UI/tests/registration-upgrade-flow.test.mjs +++ b/shine-UI/tests/registration-upgrade-flow.test.mjs @@ -18,10 +18,30 @@ test('платный переход оплачивает namespace + депоз assert.ok(result.recommendedLamports > result.requiredLamports); assert.throws(() => calculateUpgradeFunding({ namespaceFeeLamports: -1, rentLamports: 0 })); }); -test('успех только после синхронизации PAID_UPGRADED', () => { - assert.equal(isUpgradeComplete('PAID_UPGRADED'), true); +test('после синхронизации Solana оба типа платных аккаунтов имеют статус PAID', () => { + assert.equal(isUpgradeComplete('PAID'), true); assert.equal(isUpgradeComplete('FREE_CERT'), false); - assert.equal(isUpgradeComplete('PAID_DIRECT'), false); + assert.equal(isUpgradeComplete('NOT_FOUND'), false); + // Совместимость с предыдущим сервером при поэтапном обновлении. + assert.equal(isUpgradeComplete('PAID_UPGRADED'), true); + assert.equal(isUpgradeComplete('PAID_DIRECT'), true); +}); +test('в настройках только бесплатным предлагается платный переход', () => { + const settings = read('shine-UI/js/pages/settings-view.js'); + assert.match(settings, /info.registrationStatus !== 'FREE_CERT'/); + assert.match(settings, /id="settings-account-tier" hidden/); + assert.match(settings, /Бесплатный аккаунт с ограниченными возможностями/); + assert.doesNotMatch(settings, /settings-solana-registered/); +}); +test('миграция БД делает статусы действительно едиными', () => { + const migration = read('SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v35.sql'); + assert.match(migration, /WHERE registration_status IN \('PAID_DIRECT', 'PAID_UPGRADED'\)/); + assert.match(migration, /CHECK \(registration_status IN \('FREE_CERT', 'PAID'\)\)/); + assert.match(migration, /'SOLANA', 'PAID',/); + assert.match(migration, /free_data_item_id=EXCLUDED|old_user.free_data_item_id/); + assert.doesNotMatch(migration, /DELETE FROM user_identity_current/); + const dbInit = read('SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java'); + assert.match(dbInit, /POSTGRES_MIGRATION_V35_RESOURCE/); }); test('роут settings/solana-upgrade действительно обслуживается', () => { const router = read('shine-UI/js/router.js'); From 94d4665185a163ebbfb3ad8d1d852f0f0c6766c4aa3c9633fc6399318184a21b Mon Sep 17 00:00:00 2001 From: AidarKC Date: Wed, 28 Oct 2026 12:19:19 +0300 Subject: [PATCH 06/82] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2?= =?UTF-8?q?=D0=B8=D1=82=D1=8C=20=D1=80=D0=B5=D0=B3=D0=B8=D1=81=D1=82=D1=80?= =?UTF-8?q?=D0=B0=D1=86=D0=B8=D1=8E=20free-=D0=BF=D0=BE=D0=BB=D1=8C=D0=B7?= =?UTF-8?q?=D0=BE=D0=B2=D0=B0=D1=82=D0=B5=D0=BB=D0=B5=D0=B9=20=D0=B1=D0=B5?= =?UTF-8?q?=D0=B7=20=D1=83=D1=87=D1=91=D1=82=D0=B0=20=D1=80=D0=B5=D0=B3?= =?UTF-8?q?=D0=B8=D1=81=D1=82=D1=80=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit НЕ ПРОВЕРЕНО: учтены логины с большими и маленькими буквами. Добавлен временный devnet-смарт-контракт для очистки тестового аккаунта от старых логинов; после сброса его необходимо удалить и восстановить штатный контракт. --- .../archive/ArweaveBlockSyncService.java | 2 +- .../FreeRegistrationCertificateV1.java | 7 +- .../registration/FreeRegistrationIssuer.java | 2 +- .../FreeRegistrationWorkflow.java | 4 +- .../VerifiedFreeRegistrationImporter.java | 6 +- .../FreeRegistrationCertificateV1Check.java | 53 +++--- .../java/blockchain/ShineProtocolTags.java | 2 +- .../java/shine/db/DatabaseInitializer.java | 10 +- .../shine/db/dao/ConnectionsStateDAO.java | 4 +- .../java/shine/db/dao/SubscriptionsDAO.java | 2 +- .../main/resources/postgres/migration_v36.sql | 64 ++++++++ .../src/main/resources/postgres/schema_v1.sql | 28 ++-- .../shine-server-net-protocol/build.gradle | 1 + .../auth/SolanaUserPdaImportService.java | 54 ++----- .../main/java/sync/codec/ShineUsersCodec.java | 2 +- .../main/java/sync/util/SolanaPdaUtil.java | 4 +- .../java/sync/util/SolanaPdaUtilTest.java | 9 ++ .../src/main/resources/application.properties | 2 +- VERSION.properties | 4 +- deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md | 4 + docs/API/04_Add_Block_to_Blockchain_API.md | 4 +- docs/Blockchain/01_Common_Block_Format.md | 4 +- .../Blockchain/17_ANS104_Arweave_Transport.md | 10 +- docs/Blockchain/CASE_INSENSITIVE_LOGIN.md | 9 ++ docs/Blockchain/CHANGELOG.md | 9 ++ .../CODEX_APPLY_ANS104_TEST5590_PATCH.md | 2 +- docs/Blockchain/README.md | 8 +- docs/Blockchain/sync-between-servers.md | 2 +- .../Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md | 4 + .../MASTER_PLAN_V2_2026-10-23.md | 2 +- docs/registration-v2/PATCH_STAGES_8_9_10.md | 2 +- .../SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md | 10 +- shine-UI/js/services/protocol-tags.js | 2 +- .../js/services/shine-namespace-service.js | 4 +- .../static-sites/arweave-viewer/README.md | 4 +- .../static-sites/arweave-viewer/index.html | 2 +- shine-UI/tests/arweave-app-namespace.test.mjs | 19 +++ ...gistration-case-social-projection.test.mjs | 11 ++ .../tests/registration-namespace-v2.test.mjs | 11 +- .../formats/shine-user-pda-format-v.1.2.md | 4 + .../shine/doc/programs/shine_users.md | 10 +- .../shine/programs/shine_users/src/lib.rs | 4 +- .../tools/temporary-pda-cleaner/.gitignore | 7 + .../tools/temporary-pda-cleaner/Cargo.toml | 19 +++ .../DELETE_AFTER_DEVNET_RESET.md | 15 ++ .../temporary-pda-cleaner/README_AGENT_RU.md | 151 ++++++++++++++++++ .../temporary-pda-cleaner/scripts/cleaner.mjs | 118 ++++++++++++++ .../scripts/package.json | 14 ++ .../tools/temporary-pda-cleaner/src/lib.rs | 91 +++++++++++ 49 files changed, 687 insertions(+), 129 deletions(-) create mode 100644 SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v36.sql create mode 100644 docs/Blockchain/CASE_INSENSITIVE_LOGIN.md create mode 100644 shine-UI/tests/arweave-app-namespace.test.mjs create mode 100644 shine-UI/tests/registration-case-social-projection.test.mjs create mode 100644 shine-solana/shine/tools/temporary-pda-cleaner/.gitignore create mode 100644 shine-solana/shine/tools/temporary-pda-cleaner/Cargo.toml create mode 100644 shine-solana/shine/tools/temporary-pda-cleaner/DELETE_AFTER_DEVNET_RESET.md create mode 100644 shine-solana/shine/tools/temporary-pda-cleaner/README_AGENT_RU.md create mode 100644 shine-solana/shine/tools/temporary-pda-cleaner/scripts/cleaner.mjs create mode 100644 shine-solana/shine/tools/temporary-pda-cleaner/scripts/package.json create mode 100644 shine-solana/shine/tools/temporary-pda-cleaner/src/lib.rs diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java index f2e869a1..c3a297a5 100644 --- a/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java @@ -37,7 +37,7 @@ import java.time.Duration; import java.util.*; /** - * Discovers individual App=test5591 DataItems and imports the exact signed ANS-104 bytes. + * Discovers individual App=test5592 DataItems and imports the exact signed ANS-104 bytes. * The importer is transport-agnostic: a DataItem may have reached Arweave through Turbo * or inside a direct server-created ANS-104 bundle. */ diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationCertificateV1.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationCertificateV1.java index 31587542..270f5d7e 100644 --- a/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationCertificateV1.java +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationCertificateV1.java @@ -1,6 +1,7 @@ package server.archive.registration; import blockchain.Ans104DataItem; +import blockchain.ShineProtocolTags; import utils.crypto.Ed25519Util; import java.io.ByteArrayOutputStream; @@ -16,7 +17,7 @@ import java.util.Locale; public final class FreeRegistrationCertificateV1 { private static final byte[] DOMAIN = "SHiNE_FREE_REG_V1\0".getBytes(StandardCharsets.UTF_8); private static final List TAGS = List.of( - new Ans104DataItem.Tag("App", "test5591"), + new Ans104DataItem.Tag(ShineProtocolTags.APP_TAG_NAME, ShineProtocolTags.APP_TAG_VALUE), new Ans104DataItem.Tag("t", "reg"), new Ans104DataItem.Tag("Protocol", "SHiNE-Free-Registration-V1")); @@ -27,8 +28,8 @@ public final class FreeRegistrationCertificateV1 { private FreeRegistrationCertificateV1() {} public static String validateLogin(String login) { - if (login == null || !login.matches("[a-z0-9_]+@[a-z0-9_]+") || login.length() > 30) - throw new IllegalArgumentException("Full login must be lowercase ASCII, <= 30 bytes"); + if (login == null || !login.matches("[A-Za-z0-9_]+@[a-z0-9_]+") || login.length() > 30) + throw new IllegalArgumentException("Full login must use ASCII letters (any local-part case), lowercase namespace, <= 30 bytes"); return login; } diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationIssuer.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationIssuer.java index 9dd2a56f..29518583 100644 --- a/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationIssuer.java +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationIssuer.java @@ -47,7 +47,7 @@ public final class FreeRegistrationIssuer { } try (PreparedStatement ps = conn.prepareStatement( "SELECT 1 FROM user_identity_current WHERE normalized_login = ?")) { - ps.setString(1, fullLogin); + ps.setString(1, fullLogin.toLowerCase(java.util.Locale.ROOT)); try (ResultSet rs = ps.executeQuery()) { if (rs.next()) throw new IllegalArgumentException("Login is already registered"); } diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationWorkflow.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationWorkflow.java index c39ac9ea..59a96e0c 100644 --- a/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationWorkflow.java +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationWorkflow.java @@ -65,7 +65,7 @@ public final class FreeRegistrationWorkflow { } } try (PreparedStatement p=c.prepareStatement("SELECT 1 FROM user_identity_current WHERE normalized_login=?")) { - p.setString(1, login); + p.setString(1, login.toLowerCase(java.util.Locale.ROOT)); try (ResultSet rs=p.executeQuery()) { return new LoginCheck(!rs.next(),type,minimum,fee); } } } @@ -126,7 +126,7 @@ public final class FreeRegistrationWorkflow { LEFT JOIN shine_namespace_current n ON n.namespace=i.namespace WHERE i.normalized_login=? """)) { - p.setString(1,login); + p.setString(1,login.toLowerCase(java.util.Locale.ROOT)); try (ResultSet r=p.executeQuery()) { return r.next()?new State(r.getString(1),r.getString(2),r.getString(3), r.getBytes(4)==null?null:Base64.getEncoder().encodeToString(r.getBytes(4)), diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/VerifiedFreeRegistrationImporter.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/VerifiedFreeRegistrationImporter.java index 4d6e5152..370226aa 100644 --- a/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/VerifiedFreeRegistrationImporter.java +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/VerifiedFreeRegistrationImporter.java @@ -25,7 +25,7 @@ public final class VerifiedFreeRegistrationImporter { var cert = FreeRegistrationCertificateV1.verify(raw, readRegistrar(c, namespace, login)); try (PreparedStatement ps = c.prepareStatement( "SELECT free_data_item_id FROM user_identity_current WHERE normalized_login=?")) { - ps.setString(1, login); + ps.setString(1, login.toLowerCase(java.util.Locale.ROOT)); try (ResultSet rs = ps.executeQuery()) { if (rs.next() && !cert.idBase64Url().equals(rs.getString(1))) throw new IllegalArgumentException("Login is already registered"); @@ -96,11 +96,11 @@ public final class VerifiedFreeRegistrationImporter { blockchain_name, is_server, registered_at_ms, updated_at_ms) VALUES (?, ?, ?, 'ARWEAVE', 'FREE_CERT', NULL, ?, ?, ?, ?, ?, false, ?, ?) """)) { - insert.setString(1, login); insert.setString(2, login); insert.setString(3, namespace); + insert.setString(1, login); insert.setString(2, login.toLowerCase(java.util.Locale.ROOT)); insert.setString(3, namespace); insert.setString(4, id); insert.setString(5, Base58Util.encode(cert.rootKey())); insert.setString(6, Base58Util.encode(cert.clientKey())); insert.setString(7, Base58Util.encode(cert.blockchainKey())); - insert.setString(8, login + "-001"); insert.setLong(9, now); insert.setLong(10, now); + insert.setString(8, login.toLowerCase(java.util.Locale.ROOT) + "-001"); insert.setLong(9, now); insert.setLong(10, now); insert.executeUpdate(); } try (PreparedStatement insert = c.prepareStatement(""" diff --git a/SHiNE-server/shine-server-archive/src/test/java/server/archive/FreeRegistrationCertificateV1Check.java b/SHiNE-server/shine-server-archive/src/test/java/server/archive/FreeRegistrationCertificateV1Check.java index ddc3afed..96247162 100644 --- a/SHiNE-server/shine-server-archive/src/test/java/server/archive/FreeRegistrationCertificateV1Check.java +++ b/SHiNE-server/shine-server-archive/src/test/java/server/archive/FreeRegistrationCertificateV1Check.java @@ -1,42 +1,43 @@ package server.archive; import server.archive.registration.*; +import blockchain.Ans104DataItem; +import blockchain.ShineProtocolTags; import utils.crypto.Ed25519Util; -import java.nio.file.Files; -import java.nio.file.Path; import java.util.Arrays; import java.util.HexFormat; -/** Запуск: java ... server.archive.FreeRegistrationCertificateV1Check file.hex */ +/** Standalone test (no legacy signed fixture): certificate issue/verify for CURRENT App tag. */ public final class FreeRegistrationCertificateV1Check { static final HexFormat HEX = HexFormat.of(); public static void main(String[] args) throws Exception { - byte[] raw = HEX.parseHex(Files.readString(Path.of(args[0])).trim()); - byte[] pub = HEX.parseHex("174553b456dddfc6908ecab1c101fe6ab21e2baa0617795b7d43a63482993fd5"); - var result = FreeRegistrationCertificateV1.verify(raw, pub); - if (!"bob@free".equals(result.login()) || !result.idBase64Url().equals( - java.util.Base64.getUrlEncoder().withoutPadding().encodeToString( - HEX.parseHex("45ef42eda7c7e76d222ecce8a7678edb923ae63f8419ea0899701551c2466770")))) - throw new AssertionError("Wrong fixture identity / DataItem id"); - byte[] corrupted = raw.clone(); corrupted[corrupted.length-1] ^= 1; - try { FreeRegistrationCertificateV1.verify(corrupted, pub); throw new AssertionError("Email bit flip accepted"); } - catch (IllegalArgumentException expected) {} - corrupted = raw.clone(); corrupted[corrupted.length-40] ^= 1; - try { FreeRegistrationCertificateV1.verify(corrupted, pub); throw new AssertionError("Inner signature tampering accepted"); } - catch (IllegalArgumentException expected) {} - byte[] seed = Ed25519Util.generatePrivateKeyFromString("TEST-only-reg-v1-check"); + byte[] root = HEX.parseHex("03a107bff3ce10be1d70dd18e74bc09967e4d6309ba50d5f1ddc8664125531b8"); + byte[] chain = HEX.parseHex("29acbae141bccaf0b22e1a94d34d0bc7361e526d0bfe12c89794bc9322966dd7"); + byte[] client = HEX.parseHex("2543b92ff1095511476adc8369db6ddc933665a11978dda1404ee1066ca9559d"); try (var signer = new LocalRegistrarSigner(seed)) { - byte[] cert = FreeRegistrationCertificateV1.issue("bob@free", - HEX.parseHex("03a107bff3ce10be1d70dd18e74bc09967e4d6309ba50d5f1ddc8664125531b8"), - HEX.parseHex("29acbae141bccaf0b22e1a94d34d0bc7361e526d0bfe12c89794bc9322966dd7"), - HEX.parseHex("2543b92ff1095511476adc8369db6ddc933665a11978dda1404ee1066ca9559d"), - " Alice.Example+Tag@Example.COM ", signer); - var verified = FreeRegistrationCertificateV1.verify(cert, signer.publicKey32()); - if (!Arrays.equals(verified.emailSha256(), - HEX.parseHex("cbc605c49fd774ff4d9ea789d8f6bffa719e9774cb86f62d11fd244121150956"))) + byte[] cert = FreeRegistrationCertificateV1.issue("SuperMan@free", root, chain, client, + " Alice.Example+Tag@Example.COM ", signer); + var item = new Ans104DataItem(cert); + if (!item.hasTag(ShineProtocolTags.APP_TAG_NAME, ShineProtocolTags.APP_TAG_VALUE)) + throw new AssertionError("Current App tag missing"); + var result = FreeRegistrationCertificateV1.verify(cert, signer.publicKey32()); + if (!"SuperMan@free".equals(result.login()) || !Arrays.equals(result.rootKey(), root) + || !Arrays.equals(result.blockchainKey(), chain) || !Arrays.equals(result.clientKey(), client)) + throw new AssertionError("Certificate identity corrupted"); + if (!Arrays.equals(result.emailSha256(), HEX.parseHex( + "cbc605c49fd774ff4d9ea789d8f6bffa719e9774cb86f62d11fd244121150956"))) throw new AssertionError("Email normalization differs"); + byte[] bad = cert.clone(); bad[bad.length - 1] ^= 1; + try { FreeRegistrationCertificateV1.verify(bad, signer.publicKey32()); + throw new AssertionError("Email bit flip accepted"); } + catch (IllegalArgumentException expected) {} + bad = cert.clone(); bad[bad.length - 40] ^= 1; + try { FreeRegistrationCertificateV1.verify(bad, signer.publicKey32()); + throw new AssertionError("Inner signature tampering accepted"); } + catch (IllegalArgumentException expected) {} } - System.out.println("PASS: Java registrar fixture, inner+outer Ed25519, email normalization, tamper rejection"); + System.out.println("PASS: current App=" + ShineProtocolTags.APP_TAG_VALUE + + ", Java registrar inner+outer Ed25519, original case, email, tamper rejection"); } } diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/ShineProtocolTags.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/ShineProtocolTags.java index 1cf59970..d86da821 100644 --- a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/ShineProtocolTags.java +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/ShineProtocolTags.java @@ -9,7 +9,7 @@ package blockchain; public final class ShineProtocolTags { private ShineProtocolTags() {} - public static final String NAMESPACE = "test5591"; + public static final String NAMESPACE = "test5592"; public static final String APP_TAG_NAME = "App"; public static final String APP_TAG_VALUE = NAMESPACE; public static final String CHANNEL_TAG_NAME = "c"; diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java index 5fbfc212..e71cb83c 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java @@ -26,12 +26,14 @@ public final class DatabaseInitializer { public static final int SCHEMA_VERSION_33 = 33; public static final int SCHEMA_VERSION_34 = 34; public static final int SCHEMA_VERSION_35 = 35; + public static final int SCHEMA_VERSION_36 = 36; public static final String POSTGRES_SCHEMA_RESOURCE = "postgres/schema_v1.sql"; public static final String POSTGRES_MIGRATION_V31_RESOURCE = "postgres/migration_v31.sql"; public static final String POSTGRES_MIGRATION_V32_RESOURCE = "postgres/migration_v32.sql"; public static final String POSTGRES_MIGRATION_V33_RESOURCE = "postgres/migration_v33.sql"; public static final String POSTGRES_MIGRATION_V34_RESOURCE = "postgres/migration_v34.sql"; public static final String POSTGRES_MIGRATION_V35_RESOURCE = "postgres/migration_v35.sql"; + public static final String POSTGRES_MIGRATION_V36_RESOURCE = "postgres/migration_v36.sql"; private DatabaseInitializer() {} @@ -143,9 +145,13 @@ public final class DatabaseInitializer { runSqlScript(conn, POSTGRES_MIGRATION_V35_RESOURCE); currentVersion = readCurrentSchemaVersion(conn); } - if (currentVersion != SCHEMA_VERSION_35) { + if (currentVersion == SCHEMA_VERSION_35) { + runSqlScript(conn, POSTGRES_MIGRATION_V36_RESOURCE); + currentVersion = readCurrentSchemaVersion(conn); + } + if (currentVersion != SCHEMA_VERSION_36) { throw new SQLException( - "Unsupported SHiNE DB v2 schema version: expected 35, found " + currentVersion); + "Unsupported SHiNE DB v2 schema version: expected 36, found " + currentVersion); } } } diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ConnectionsStateDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ConnectionsStateDAO.java index 3f980b4f..3f37a2ba 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ConnectionsStateDAO.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ConnectionsStateDAO.java @@ -164,9 +164,9 @@ public final class ConnectionsStateDAO { """; try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, login); + ps.setString(1, login.trim().toLowerCase(java.util.Locale.ROOT)); ps.setInt(2, relType); - ps.setString(3, toLogin); + ps.setString(3, toLogin.trim().toLowerCase(java.util.Locale.ROOT)); if (toBlockNumber == null) ps.setNull(4, java.sql.Types.INTEGER); else ps.setInt(4, toBlockNumber); ps.setBytes(5, toBlockHash); ps.executeUpdate(); diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SubscriptionsDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SubscriptionsDAO.java index d050a27a..bdd89051 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SubscriptionsDAO.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SubscriptionsDAO.java @@ -111,7 +111,7 @@ public final class SubscriptionsDAO { FROM connections_state cs JOIN channel_names_state cn ON LOWER(cn.owner_login)=LOWER(cs.to_login) AND cn.channel_root_block_number=cs.to_block_number AND cn.channel_root_block_hash=cs.to_block_hash - WHERE cs.login = ? AND cs.rel_type = ? + WHERE LOWER(cs.login) = LOWER(?) AND cs.rel_type = ? UNION diff --git a/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v36.sql b/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v36.sql new file mode 100644 index 00000000..a0dc99af --- /dev/null +++ b/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v36.sql @@ -0,0 +1,64 @@ +-- v36: регистрационная запись хранит исходный регистр; все ссылки FK +-- приводятся к её точному login. Исторические строки не мигрируются. +-- На новой базе исходные имена PDA/сертификатов и FK согласованы. +BEGIN; + +CREATE OR REPLACE FUNCTION shine_canonicalize_identity_fk_login() +RETURNS TRIGGER LANGUAGE plpgsql AS $$ +DECLARE + field_name TEXT := TG_ARGV[0]; + requested_login TEXT; + canonical_login TEXT; +BEGIN + requested_login := to_jsonb(NEW)->>field_name; + IF requested_login IS NULL OR btrim(requested_login) = '' THEN + RETURN NEW; + END IF; + SELECT i.login INTO canonical_login + FROM user_identity_current i + WHERE i.normalized_login = lower(btrim(requested_login)) + LIMIT 1; + IF canonical_login IS NOT NULL THEN + -- Меняем только проекцию/связь в SQL, никогда не байты подписанного блока. + NEW := jsonb_populate_record(NEW, jsonb_build_object(field_name, canonical_login)); + END IF; + RETURN NEW; +END $$; + +DO $$ +DECLARE + tab_name TEXT; + col_name TEXT; + spec TEXT; + trigger_name TEXT; +BEGIN + FOREACH spec IN ARRAY ARRAY[ + 'user_access_servers_current:user_login', + 'user_access_servers_current:server_login', + 'active_sessions:login', + 'esp_pairing_settings:login', + 'esp_pairing_requests:login', + 'users_params:login', + 'user_settings:login', + 'channel_read_state:viewer_login', + 'test_free_avatar_uploads:login', + 'blockchain_state:login', + 'user_stats_state:login', + 'user_push_tokens:login', + 'key_rotation_sessions:login' + ] LOOP + tab_name := split_part(spec, ':', 1); + col_name := split_part(spec, ':', 2); + trigger_name := 'trg_canonical_identity_' || tab_name || '_' || col_name; + EXECUTE format('DROP TRIGGER IF EXISTS %I ON %I', trigger_name, tab_name); + EXECUTE format( + 'CREATE TRIGGER %I BEFORE INSERT OR UPDATE OF %I ON %I FOR EACH ROW EXECUTE FUNCTION shine_canonicalize_identity_fk_login(%L)', + trigger_name, col_name, tab_name, col_name + ); + END LOOP; +END $$; + +UPDATE db_schema_version SET schema_version = 36, + updated_at_ms = CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT) +WHERE id = 1; +COMMIT; diff --git a/SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql b/SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql index babd8b39..5116675c 100644 --- a/SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql +++ b/SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql @@ -2334,11 +2334,15 @@ CREATE INDEX idx_message_views_target_v29 ON message_views_state(to_login,to_blo CREATE OR REPLACE FUNCTION shine_refresh_user_stats(p_login TEXT) RETURNS VOID LANGUAGE plpgsql AS $$ DECLARE v_now BIGINT:=CAST(EXTRACT(EPOCH FROM clock_timestamp())*1000 AS BIGINT); + v_canonical_login TEXT; BEGIN IF p_login IS NULL OR btrim(p_login)='' THEN RETURN; END IF; + -- В FK остаётся исходный регистр владельца, но поиск/сопоставления регистронезависимы. + SELECT login INTO v_canonical_login FROM user_identity_current WHERE normalized_login=lower(btrim(p_login)) LIMIT 1; + IF v_canonical_login IS NULL THEN RETURN; END IF; INSERT INTO user_stats_state(login,owned_public_channels_count,following_users_count,following_channels_count,close_friends_count,friends_count, primary_confirmations_received_count,primary_confirmations_given_count,shine_confirmations_received_count,shine_confirmations_given_count,updated_at_ms) - SELECT p_login, + SELECT v_canonical_login, (SELECT COUNT(*)::INT FROM channel_names_state cn WHERE LOWER(cn.owner_login)=LOWER(p_login) AND cn.channel_type_code=1 AND NOT cn.is_deleted), (SELECT COUNT(DISTINCT LOWER(cs.to_login))::INT FROM connections_state cs WHERE LOWER(cs.login)=LOWER(p_login) AND cs.rel_type=30 AND cs.to_block_number=0), (SELECT COUNT(*)::INT FROM connections_state cs JOIN channel_names_state cn ON LOWER(cn.owner_login)=LOWER(cs.to_login) AND cn.channel_root_block_number=cs.to_block_number AND cn.channel_root_block_hash=cs.to_block_hash WHERE LOWER(cs.login)=LOWER(p_login) AND cs.rel_type=30 AND cn.channel_type_code=1 AND NOT cn.is_deleted), @@ -2485,15 +2489,15 @@ DECLARE positive_rel_type INTEGER; channel_bch TEXT; BEGIN IF NEW.msg_type<>3 OR NEW.to_login IS NULL OR NEW.to_block_number IS NULL OR NEW.to_block_hash IS NULL THEN RETURN NEW; END IF; IF NEW.msg_sub_type IN (10,14,20,30,40,50,52,54,60,70,74,80) THEN - DELETE FROM connections_state WHERE login=NEW.login AND rel_type=NEW.msg_sub_type AND to_login=NEW.to_login AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash; + DELETE FROM connections_state WHERE login=lower(NEW.login) AND rel_type=NEW.msg_sub_type AND to_login=lower(NEW.to_login) AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash; INSERT INTO connections_state(login,rel_type,to_login,to_block_number,to_block_hash) - VALUES(NEW.login,NEW.msg_sub_type,NEW.to_login,NEW.to_block_number,NEW.to_block_hash); + VALUES(lower(NEW.login),NEW.msg_sub_type,lower(NEW.to_login),NEW.to_block_number,NEW.to_block_hash); ELSE positive_rel_type := CASE NEW.msg_sub_type WHEN 11 THEN 10 WHEN 15 THEN 14 WHEN 21 THEN 20 WHEN 31 THEN 30 WHEN 41 THEN 40 WHEN 51 THEN 50 WHEN 53 THEN 52 WHEN 55 THEN 54 WHEN 61 THEN 60 WHEN 71 THEN 70 WHEN 75 THEN 74 WHEN 81 THEN 80 ELSE NULL END; - IF positive_rel_type IS NOT NULL THEN DELETE FROM connections_state WHERE login=NEW.login AND rel_type=positive_rel_type AND to_login=NEW.to_login AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash; END IF; + IF positive_rel_type IS NOT NULL THEN DELETE FROM connections_state WHERE login=lower(NEW.login) AND rel_type=positive_rel_type AND to_login=lower(NEW.to_login) AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash; END IF; END IF; - PERFORM shine_refresh_user_stats(NEW.login); - PERFORM shine_refresh_user_stats(NEW.to_login); + PERFORM shine_refresh_user_stats(lower(NEW.login)); + PERFORM shine_refresh_user_stats(lower(NEW.to_login)); IF NEW.msg_sub_type IN (30,31) AND NEW.to_block_number>0 THEN SELECT owner_bch_name INTO channel_bch FROM channel_names_state WHERE LOWER(owner_login)=LOWER(NEW.to_login) AND channel_root_block_number=NEW.to_block_number AND channel_root_block_hash=NEW.to_block_hash LIMIT 1; IF channel_bch IS NOT NULL THEN PERFORM shine_refresh_channel_follow_stats(channel_bch,NEW.to_block_number,NEW.to_block_hash); END IF; @@ -2506,22 +2510,22 @@ DECLARE previous_sub_type INTEGER; BEGIN IF NEW.msg_type<>2 OR NEW.msg_sub_type NOT IN (1,2) THEN RETURN NEW; END IF; IF NEW.to_login IS NULL OR NEW.to_block_number IS NULL OR NEW.to_block_hash IS NULL THEN RETURN NEW; END IF; - INSERT INTO message_stats(to_login,to_block_number,to_block_hash) VALUES(NEW.to_login,NEW.to_block_number,NEW.to_block_hash) + INSERT INTO message_stats(to_login,to_block_number,to_block_hash) VALUES(lower(NEW.to_login),NEW.to_block_number,NEW.to_block_hash) ON CONFLICT(to_login,to_block_number,to_block_hash) DO NOTHING; - SELECT last_sub_type INTO previous_sub_type FROM reactions_state WHERE from_login=NEW.login AND reaction_type=1 AND to_login=NEW.to_login AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash LIMIT 1; + SELECT last_sub_type INTO previous_sub_type FROM reactions_state WHERE from_login=lower(NEW.login) AND reaction_type=1 AND to_login=lower(NEW.to_login) AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash LIMIT 1; IF NEW.msg_sub_type=1 AND previous_sub_type IS DISTINCT FROM 1 THEN UPDATE message_stats SET likes_count=likes_count+1, primary_likes_count=primary_likes_count+CASE WHEN shine_is_primary(NEW.login) THEN 1 ELSE 0 END, shining_likes_count=shining_likes_count+CASE WHEN shine_is_primary(NEW.login) AND shine_is_shining(NEW.login) THEN 1 ELSE 0 END - WHERE to_login=NEW.to_login AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash; + WHERE to_login=lower(NEW.to_login) AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash; ELSIF NEW.msg_sub_type=2 AND previous_sub_type=1 THEN UPDATE message_stats SET likes_count=GREATEST(0,likes_count-1), primary_likes_count=GREATEST(0,primary_likes_count-CASE WHEN shine_is_primary(NEW.login) THEN 1 ELSE 0 END), shining_likes_count=GREATEST(0,shining_likes_count-CASE WHEN shine_is_primary(NEW.login) AND shine_is_shining(NEW.login) THEN 1 ELSE 0 END) - WHERE to_login=NEW.to_login AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash; + WHERE to_login=lower(NEW.to_login) AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash; END IF; INSERT INTO reactions_state(from_login,reaction_type,to_login,to_block_number,to_block_hash,last_sub_type) - VALUES(NEW.login,1,NEW.to_login,NEW.to_block_number,NEW.to_block_hash,NEW.msg_sub_type) + VALUES(lower(NEW.login),1,lower(NEW.to_login),NEW.to_block_number,NEW.to_block_hash,NEW.msg_sub_type) ON CONFLICT(from_login,reaction_type,to_login,to_block_number,to_block_hash) DO UPDATE SET last_sub_type=EXCLUDED.last_sub_type; RETURN NEW; END $$; @@ -2532,7 +2536,7 @@ BEGIN IF NEW.msg_type<>1 OR NEW.msg_sub_type<>20 THEN RETURN NEW; END IF; IF NEW.to_login IS NULL OR NEW.to_block_number IS NULL OR NEW.to_block_hash IS NULL THEN RETURN NEW; END IF; INSERT INTO message_stats(to_login,to_block_number,to_block_hash,replies_count) - VALUES(NEW.to_login,NEW.to_block_number,NEW.to_block_hash,1) + VALUES(lower(NEW.to_login),NEW.to_block_number,NEW.to_block_hash,1) ON CONFLICT(to_login,to_block_number,to_block_hash) DO UPDATE SET replies_count=message_stats.replies_count+1; RETURN NEW; END $$; diff --git a/SHiNE-server/shine-server-net-protocol/build.gradle b/SHiNE-server/shine-server-net-protocol/build.gradle index 838da9b3..fcf8ac7b 100644 --- a/SHiNE-server/shine-server-net-protocol/build.gradle +++ b/SHiNE-server/shine-server-net-protocol/build.gradle @@ -30,6 +30,7 @@ dependencies { implementation project(':shine-server-crypto') // модуль сервера для работы с криптографией implementation project(':shine-server-blockchain') // модуль для работы с блокчейном + implementation project(':shine-server-solana-users-sync') // Нормализованный адрес PDA implementation project(':shine-server-db') // модуль для работы с БД содержит и сущности из БД и саму работу с БД implementation project(':shine-server-geo') // модуль для определения геолокации по IP diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/SolanaUserPdaImportService.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/SolanaUserPdaImportService.java index 843b6136..f08044d2 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/SolanaUserPdaImportService.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/SolanaUserPdaImportService.java @@ -108,54 +108,34 @@ public final class SolanaUserPdaImportService { } private static byte[] fetchRawUserPda(String login) throws Exception { - String loginB58 = toBase58(login.getBytes(StandardCharsets.UTF_8)); - String lenB58 = toBase58(new byte[]{(byte) login.length()}); - - String reqJson = """ - { - "jsonrpc":"2.0", - "id":1, - "method":"getProgramAccounts", - "params":[ - "%s", - { - "encoding":"base64", - "filters":[ - {"memcmp":{"offset":61,"bytes":"%s"}}, - {"memcmp":{"offset":62,"bytes":"%s"}} - ] - } - ] - } - """.formatted(SolanaProgramsConfig.SHINE_USERS_PROGRAM_ID, lenB58, loginB58); - + // Запись хранит исходный регистр, но адрес PDA зависит только от lowercase. + String address = sync.util.SolanaPdaUtil.findUserPdaV2(login, SolanaProgramsConfig.SHINE_USERS_PROGRAM_ID); + String reqJson = MAPPER.writeValueAsString(Map.of( + "jsonrpc", "2.0", "id", 1, + "method", "getAccountInfo", + "params", List.of(address, Map.of("encoding", "base64", "commitment", "confirmed")))); HttpRequest req = HttpRequest.newBuilder() .uri(URI.create(SolanaProgramsConfig.SOLANA_RPC_URL)) .header("Content-Type", "application/json") .POST(HttpRequest.BodyPublishers.ofString(reqJson)) .build(); - HttpResponse resp = HTTP.send(req, HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8)); if (resp.statusCode() < 200 || resp.statusCode() >= 300) { throw new IllegalStateException("Solana RPC HTTP status=" + resp.statusCode()); } - JsonNode root = MAPPER.readTree(resp.body()); if (root.hasNonNull("error")) { - throw new IllegalStateException("Solana RPC error: " + root.get("error").toString()); + throw new IllegalStateException("Solana RPC error: " + root.get("error")); } - - JsonNode result = root.path("result"); - if (!result.isArray() || result.isEmpty()) return null; - - for (JsonNode item : result) { - JsonNode dataNode = item.path("account").path("data"); - if (!dataNode.isArray() || dataNode.size() < 1) continue; - String b64 = dataNode.get(0).asText(""); - if (b64.isBlank()) continue; - return Base64.getDecoder().decode(b64); + JsonNode account = root.path("result").path("value"); + if (account.isMissingNode() || account.isNull()) return null; + if (!SolanaProgramsConfig.SHINE_USERS_PROGRAM_ID.equals(account.path("owner").asText())) { + throw new IllegalStateException("PDA принадлежит другой программе"); } - return null; + JsonNode data = account.path("data"); + if (!data.isArray() || data.isEmpty()) return null; + String b64 = data.get(0).asText(""); + return b64.isBlank() ? null : Base64.getDecoder().decode(b64); } private static ParsedSolanaUser parseUserPda(byte[] raw) { @@ -258,7 +238,7 @@ public final class SolanaUserPdaImportService { } if (blockchainKey32 == null || clientKey32 == null || forkCount <= 0 || forkCount > 999) return null; - String blockchainName = login + "-" + String.format(Locale.ROOT, "%03d", forkCount); + String blockchainName = normalizeLogin(login) + "-" + String.format(Locale.ROOT, "%03d", forkCount); return new ParsedSolanaUser( login, blockchainName, @@ -365,7 +345,7 @@ public final class SolanaUserPdaImportService { return out; } - // Нужен для memcmp.bytes в Solana RPC. + // Вспомогательная base58-конверсия для других совместимых полей. private static String toBase58(byte[] input) { final char[] alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz".toCharArray(); int zeros = 0; diff --git a/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/codec/ShineUsersCodec.java b/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/codec/ShineUsersCodec.java index 7b803adb..1c093509 100644 --- a/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/codec/ShineUsersCodec.java +++ b/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/codec/ShineUsersCodec.java @@ -770,7 +770,7 @@ public final class ShineUsersCodec { if (type == 2) { registrarKey = Base58Util.encode(r.readFixed(32)); serverLogin = r.readStringU8(); - if (!serverLogin.matches("[a-z0-9_]+@[a-z0-9_]+") || serverLogin.length() > 30) { + if (!serverLogin.matches("[A-Za-z0-9_]+@[a-z0-9_]+") || serverLogin.length() > 30) { throw new IllegalArgumentException("Invalid access server login"); } } diff --git a/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/util/SolanaPdaUtil.java b/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/util/SolanaPdaUtil.java index 77f0ece4..46ff776f 100644 --- a/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/util/SolanaPdaUtil.java +++ b/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/util/SolanaPdaUtil.java @@ -63,10 +63,10 @@ public final class SolanaPdaUtil { /** Новый v2 PDA. Старый двух-seed вариант оставлен только для legacy accounts. */ public static String findUserPdaV2(String fullLogin, String programId) { - if (fullLogin == null || !fullLogin.matches("[a-z0-9_]+@[a-z0-9_]+") || fullLogin.length() > 30) { + if (fullLogin == null || !fullLogin.matches("[A-Za-z0-9_]+@[a-z0-9_]+") || fullLogin.length() > 30) { throw new IllegalArgumentException("Invalid full login"); } - return findHashedPda("user_login=" + fullLogin, programId); + return findHashedPda("user_login=" + fullLogin.toLowerCase(java.util.Locale.ROOT), programId); } public static String findNamespacePda(String namespace, String programId) { diff --git a/SHiNE-server/shine-server-solana-users-sync/src/test/java/sync/util/SolanaPdaUtilTest.java b/SHiNE-server/shine-server-solana-users-sync/src/test/java/sync/util/SolanaPdaUtilTest.java index 55fe85a9..46845b4b 100644 --- a/SHiNE-server/shine-server-solana-users-sync/src/test/java/sync/util/SolanaPdaUtilTest.java +++ b/SHiNE-server/shine-server-solana-users-sync/src/test/java/sync/util/SolanaPdaUtilTest.java @@ -24,4 +24,13 @@ class SolanaPdaUtilTest { pda ); } + @Test + void mixedCaseUsesSamePdaButNamespaceMustRemainLowercase() { + String program = "SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6"; + String lower = SolanaPdaUtil.findUserPdaV2("superman@free", program); + assertEquals(lower, SolanaPdaUtil.findUserPdaV2("SuperMan@free", program)); + assertEquals(lower, SolanaPdaUtil.findUserPdaV2("SUPERMAN@free", program)); + org.junit.jupiter.api.Assertions.assertThrows(IllegalArgumentException.class, + () -> SolanaPdaUtil.findUserPdaV2("SuperMan@FREE", program)); + } } diff --git a/SHiNE-server/src/main/resources/application.properties b/SHiNE-server/src/main/resources/application.properties index e40dba6d..9246a094 100644 --- a/SHiNE-server/src/main/resources/application.properties +++ b/SHiNE-server/src/main/resources/application.properties @@ -146,7 +146,7 @@ test.freeAvatar.walletJwkPath= # ============================================================ # Arweave per-user-block transport (ANS-104) -# Test namespace: each user DataItem is signed with App=test5591. +# Test namespace: each user DataItem is signed with App=test5592. # Channel DataItems additionally contain c=. # ============================================================ arweave.blocks.publish.enabled=false diff --git a/VERSION.properties b/VERSION.properties index ee309369..fa7c3171 100644 --- a/VERSION.properties +++ b/VERSION.properties @@ -1,2 +1,2 @@ -client.version=1.20.4 -server.version=1.16.3 +client.version=1.20.5 +server.version=1.16.4 diff --git a/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md b/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md index e721fd69..9c490a34 100644 --- a/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md +++ b/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md @@ -149,3 +149,7 @@ Migration v26 добавляет server-local поля `rotation_status` / `rota SELECT registration_status, count(*) FROM user_identity_current GROUP BY registration_status; SELECT schema_version FROM db_schema_version WHERE id=1; ``` + + +## Регистронезависимый логин (2026-10-28) +Для новых баз важно совместное обновление программы `shine_users`, Java Solana sync/архива и UI. После обновления `login` внутри PDA сохраняет регистр, а адрес и `normalized_login` используют lowercase. Перед проверкой смешанного регистра заново инициализируйте **тестовую** БД и разверните обновлённую Solana-программу в devnet; сам ZIP её не разворачивает. diff --git a/docs/API/04_Add_Block_to_Blockchain_API.md b/docs/API/04_Add_Block_to_Blockchain_API.md index ce2bd0f4..ca8d68f1 100644 --- a/docs/API/04_Add_Block_to_Blockchain_API.md +++ b/docs/API/04_Add_Block_to_Blockchain_API.md @@ -32,14 +32,14 @@ - generic Ed25519 signature type `2`; - Ed25519 signature 64 bytes; - owner 32 bytes и равен текущему blockchain public key; -- обязательный тестовый tag `App=test5591`; +- обязательный тестовый tag `App=test5592`; - для channel block — `c=`; - `TEXT_CHANNEL_DELETE (type=1/subType=92/version=1)` является обычным line-based channel block с пустым text и тем же обязательным `c=`; отдельной операции API для удаления канала нет; - `data` содержит SHiNE Frame v1 (`frameCode=1`). ## Основные ошибки -- `bad_app_tag` — отсутствует/неверен `App=test5591`; +- `bad_app_tag` — отсутствует/неверен `App=test5592`; - `bad_channel_tag` — `c` отсутствует, лишний или не совпадает с canonical slug; - `bad_signature` / `signature_verify_failed` — DataItem не подписан текущим blockchain key; - `bad_block_number` — нарушена последовательность; diff --git a/docs/Blockchain/01_Common_Block_Format.md b/docs/Blockchain/01_Common_Block_Format.md index e220a2c9..93f55746 100644 --- a/docs/Blockchain/01_Common_Block_Format.md +++ b/docs/Blockchain/01_Common_Block_Format.md @@ -74,7 +74,7 @@ blockN.back32Hash32 = (N < 32 ? ZERO_HASH_32 : HASH(block N-32)) Каждый блок: ```text -App = test5591 +App = test5592 ``` Это временное namespace-значение для разработки. Перед реальным запуском оно будет заменено отдельным изменением протокола/кода. @@ -120,7 +120,7 @@ Slug входит в подпись DataItem и не может быть изм Сервер обязан: 1. распарсить полный ANS-104 DataItem; -2. проверить `App=test5591`; +2. проверить `App=test5592`; 3. проверить `t`, если тип блока требует фиксированный индексный поток; 4. проверить `c`, если тип блока требует канал; 5. проверить ANS-104 Ed25519 подпись; diff --git a/docs/Blockchain/17_ANS104_Arweave_Transport.md b/docs/Blockchain/17_ANS104_Arweave_Transport.md index 089ce2c6..f9c4c871 100644 --- a/docs/Blockchain/17_ANS104_Arweave_Transport.md +++ b/docs/Blockchain/17_ANS104_Arweave_Transport.md @@ -1,6 +1,6 @@ # ANS-104 / Arweave transport для пользовательских блоков SHiNE -> **Текущий transport namespace:** `test5591`. Он намеренно хранится отдельно в трёх рабочих местах: сервер (`ShineProtocolTags.java`), UI (`js/services/protocol-tags.js`) и актуальный Viewer (`static-sites/arweave-viewer/index.html`). При смене тестовой эпохи эти три значения меняются синхронно. Имя канального индексного тега постоянно и не зависит от namespace: `c`. +> **Текущий transport namespace:** `test5592`. Он намеренно хранится отдельно в трёх рабочих местах: сервер (`ShineProtocolTags.java`), UI (`js/services/protocol-tags.js`) и актуальный Viewer (`static-sites/arweave-viewer/index.html`). При смене тестовой эпохи эти три значения меняются синхронно. Подписанные бесплатные сертификаты `t=reg` используют ту же серверную константу `ShineProtocolTags.APP_TAG_VALUE` (отдельного жёстко заданного App тега нет). Имя канального индексного тега постоянно и не зависит от namespace: `c`. ## Цель @@ -13,7 +13,7 @@ Для тестового контура обязательно: ```text -App=test5591 +App=test5592 ``` Для фиксированных потоков: @@ -94,7 +94,7 @@ Bundle-Version=2.0.0 Content-Type=application/octet-stream ``` -Специальный `App=test5591-batch` больше не используется. Важны вложенные user DataItems, у которых уже есть `App=test5591`. +Специальный `App=test5592-batch` больше не используется. Важны вложенные user DataItems, у которых уже есть `App=test5592`. ### `none` @@ -114,7 +114,7 @@ Content-Type=application/octet-stream Importer всегда выполняет один discovery-запрос: ```text -App=test5591 +App=test5592 ``` Он **не ищет root bundles** и не зависит от `publish.mode`. @@ -132,7 +132,7 @@ App=test5591 Поэтому importer: -1. получает `data_item_id` через GraphQL `App=test5591`; +1. получает `data_item_id` через GraphQL `App=test5592`; 2. запрашивает `GET /ar-io/offsets/{data_item_id}`; 3. получает `rootTxId`, `rootOffset`, `size`; 4. делает range-read `GET /raw/{rootTxId}` ровно по этому диапазону; diff --git a/docs/Blockchain/CASE_INSENSITIVE_LOGIN.md b/docs/Blockchain/CASE_INSENSITIVE_LOGIN.md new file mode 100644 index 00000000..f29b1362 --- /dev/null +++ b/docs/Blockchain/CASE_INSENSITIVE_LOGIN.md @@ -0,0 +1,9 @@ +# Единый идентификатор пользователя и оригинальный регистр (28.10.2026) + +- `login@namespace`: `login` разрешает ASCII `A-Z`, `a-z`, цифры, `_`; namespace только `a-z`, цифры, `_`. +- Для сравнения, поиска, авторизации, PDA и имени блокчейна (`lower(fullLogin)-001`) используем ASCII lowercase. +- Сертификат Arweave подписывает исходное, неизменяемое написание. PDA хранит исходное написание; seed PDA строится из lowercase. +- В подписанных блоках лайков, ответов и связей формат **не меняется**. `toLogin` может содержать оригинальный регистр; это не создаёт другую идентичность. +- В БД проекция статистики реакций, ответов и связей нормализует ссылки через `lower()`, не изменяя подписанное содержимое `blocks_store`. +- Для показа красивого имени UI использует исходное написание из регистрационной записи (`GetUser`), если оно ещё неизвестно по записи автора. +- Начальная установка делается на новой базе; миграция старых данных не предусмотрена. diff --git a/docs/Blockchain/CHANGELOG.md b/docs/Blockchain/CHANGELOG.md index a0ba47c7..2d3b53f8 100644 --- a/docs/Blockchain/CHANGELOG.md +++ b/docs/Blockchain/CHANGELOG.md @@ -1,3 +1,10 @@ +## 2026-10-28 — Новая тестовая эпоха Arweave `test5592` + +- Текущий ANS-104 `App` изменён с `test5591` на `test5592`: UI, Java-сервер (включая бесплатные `t=reg` сертификаты), Arweave Viewer. +- Старые Arweave DataItem остаются неизменными, но не импортируются новой тестовой эпохой. Система стартует с новой PostgreSQL БД и очищенной программой shine_users на devnet. +- `App` — **тег Arweave**, а НЕ Solana Program ID. Program ID и `c=` не изменены. +- Исторические подписанные криптографические фикстуры `test5591` не переписываются; отдельно тестируется генерация новых `test5592`. + ## 2026-10-06 18:02 +0300 — Soft-delete каналов - Базовый коммит-ориентир: `working tree`; изменение подготовлено как patch без нового git-коммита. @@ -326,3 +333,5 @@ - 2026-10-23 — регистрационные WS операции и UI для отдельного `t=reg` ANS-104 DataItem, пользовательский Frame V1/AddBlock формат не менялся. Commit hash отсутствует (не коммитировалось), перед merge заменить на реальный hash. - 2026-10-23 — исправлена валидация `HeaderBody`: кроме legacy-логинов разрешены `login@namespace` (до 30 ASCII-байт). Это устраняет `BAD_BLOCK_FORMAT` при первом AddBlock новых free/paid пользователей. Порядок байт HEADER, Frame v1, ANS-104 и API без изменений. Commit hash отсутствует (патч без git-коммита); после коммита добавить хэш. + +- 2026-10-28: регистронезависимая идентичность и социальные ссылки; бинарный формат подписанных блоков не менялся. Коммит: не создавался (ZIP-патч). diff --git a/docs/Blockchain/CODEX_APPLY_ANS104_TEST5590_PATCH.md b/docs/Blockchain/CODEX_APPLY_ANS104_TEST5590_PATCH.md index cadd6c8a..3042ccc5 100644 --- a/docs/Blockchain/CODEX_APPLY_ANS104_TEST5590_PATCH.md +++ b/docs/Blockchain/CODEX_APPLY_ANS104_TEST5590_PATCH.md @@ -1,4 +1,4 @@ -> **LEGACY / historical patch note.** Current protocol uses `App=test5591` and the permanent channel tag `c=`. Do not apply the `c_test5590` instructions below to current code. +> **LEGACY / historical patch note.** Current protocol uses `App=test5592` and the permanent channel tag `c=`. Do not apply the `c_test5590` instructions below to current code. # Применение patch: Turbo + direct Arweave для `App=test5590` diff --git a/docs/Blockchain/README.md b/docs/Blockchain/README.md index 8402b687..488fb6c8 100644 --- a/docs/Blockchain/README.md +++ b/docs/Blockchain/README.md @@ -15,7 +15,7 @@ ```text User -> создаёт Frame v1 - -> tags: App=test5591; t=tech/conn/prof для фиксированных потоков; при канале c= + -> tags: App=test5592; t=tech/conn/prof для фиксированных потоков; при канале c= -> Ed25519 подписывает ANS-104 deep-hash -> готовый DataItem -> AddBlock @@ -28,7 +28,7 @@ Server ИЛИ publish.mode=none: наружу не публиковать Other servers - -> GraphQL App=test5591 + -> GraphQL App=test5592 -> скачивают/извлекают DataItem -> verify -> PostgreSQL без повторной публикации @@ -39,7 +39,7 @@ Other servers - SHiNE `prevHash` остаётся SHA-256 предыдущего Frame v1 и не зависит от Arweave. - `data_item_id` нужен для Arweave, поиска и дедупликации. - PostgreSQL — единственное локальное хранилище пользовательских блоков. -- Тестовый namespace `App=test5591` специально отделён от будущего production namespace. +- Тестовый namespace `App=test5592` специально отделён от будущего production namespace. ## Отдельные регистрационные DataItem V1 (test only; импорт реализован в коде, E2E не пройден) @@ -47,3 +47,5 @@ Other servers Новая платформа регистрации `t=reg` использует ANS-104 Ed25519 и независимый payload, **не являющийся пользовательским AddBlock**. Формат определён в [регистрационном протоколе](../Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md). Обычный формат пользовательских блоков не меняется. Новая регистрация отправляет `t=reg` через Turbo и отдельный импортёр, код включён только в тестовом патче; фактический Turbo/GraphQL E2E ещё не пройден. - Регистрационные Arweave ANS-104 DataItem `t=reg` (вне пользовательских блокчейнов): `../Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md`, `../registration-v2/PATCH_STAGES_8_9_10.md`. + +- [Единая идентичность логина без учёта регистра](CASE_INSENSITIVE_LOGIN.md) — правила логинов, PDA и социальных ссылок (2026-10-28). diff --git a/docs/Blockchain/sync-between-servers.md b/docs/Blockchain/sync-between-servers.md index 60034925..508b8114 100644 --- a/docs/Blockchain/sync-between-servers.md +++ b/docs/Blockchain/sync-between-servers.md @@ -40,7 +40,7 @@ blockchain.sync.enabled=false Дополнительно каждый сервер может независимо включить `ArweaveBlockSyncScheduler`. -Он ищет child DataItems по тестовому тегу `App=test5591`, проверяет их и импортирует через ту же бизнес-проверку AddBlock. Импортированные блоки не публикуются повторно. +Он ищет child DataItems по тестовому тегу `App=test5592`, проверяет их и импортирует через ту же бизнес-проверку AddBlock. Импортированные блоки не публикуются повторно. Если блоки обнаружены не по порядку, persistent queue оставляет более поздние блоки pending до появления предыдущих. diff --git a/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md b/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md index 9a51a73f..875f8e41 100644 --- a/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md +++ b/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md @@ -616,3 +616,7 @@ Arweave/Turbo publisher обрабатывает candidate-блоки приор Для новых `login@namespace` используется `SHA256(UTF8("user_login=" + fullLogin))` как один 32-byte PDA seed; для namespace — `SHA256(UTF8("namespace=" + namespace))`. `IX_CREATE_NAMESPACE=7` читается как отдельное событие. `SolanaUsersSyncService` декодирует namespace независимо от user-PDA и сохраняет снапшоты namespaces в `shine_namespace_current`; paid user-PDA параллельно синхронизируются как прежде. При upsert Solana запись переносит логического пользователя `FREE_CERT → PAID` без изменения логина и исходной даты в `user_identity_current`; free-сертификат не превращается в фальшивый Solana PDA. Общий индекс появляется в DB v33. Миграция DB v35 консолидирует исторические `PAID_DIRECT`/`PAID_UPGRADED` в `PAID` и переопределяет Solana-trigger, чтобы все последующие PDA синхронизировались в одном платном статусе. `free_data_item_id` и `free_registration_certificate` остаются как свидетельства первоначальной бесплатной регистрации, но не создают особый статус. Standalone sync можно запускать только после применения миграций DB v33–v35 через Java-сервер. **ВНИМАНИЕ:** проверить на настоящем PostgreSQL + RPC replay до включения. Read-only economy-PDA остаётся индексом истории через `getSignaturesForAddress`, не гарантирует websocket account notification. + + +## Логин с оригинальным регистром (2026-10-28) +При чтении PDA 1.2 `login` сохраняет регистр из подписанного on-chain состояния, а `normalized_login`/имя пользовательского блокчейна формируются из ASCII lowercase. Адрес PDA рассчитывается как `find_program_address(SHA256("user_login=" + ASCII-lowercase(fullLogin)))`; это предотвращает отдельные адреса для `SuperMan@free` и `superman@free`. Никаких переименований исторических данных нет — проект стартует с новой БД. diff --git a/docs/registration-v2/MASTER_PLAN_V2_2026-10-23.md b/docs/registration-v2/MASTER_PLAN_V2_2026-10-23.md index b697bf67..18f6fd09 100644 --- a/docs/registration-v2/MASTER_PLAN_V2_2026-10-23.md +++ b/docs/registration-v2/MASTER_PLAN_V2_2026-10-23.md @@ -72,7 +72,7 @@ Внутренняя подпись нужна для последующей проверки в Solana, внешняя — для удостоверения полного DataItem при его импорте. Это **две разные подписи от разных последовательностей байтов**. -Теги DataItem следует отделять от обычных пользовательских блоков, например существующим `App=test5591` плюс отдельный тег типа `t=reg`; точный набор тегов утвердить в документе протокола, не смешивать с `t=prof|conn|tech`. +Теги DataItem следует отделять от обычных пользовательских блоков, например существующим `App=test5592` плюс отдельный тег типа `t=reg`; точный набор тегов утвердить в документе протокола, не смешивать с `t=prof|conn|tech`. ## А5. Email diff --git a/docs/registration-v2/PATCH_STAGES_8_9_10.md b/docs/registration-v2/PATCH_STAGES_8_9_10.md index 8985f0ba..082a7c5e 100644 --- a/docs/registration-v2/PATCH_STAGES_8_9_10.md +++ b/docs/registration-v2/PATCH_STAGES_8_9_10.md @@ -7,7 +7,7 @@ ## 8 — Arweave и Turbo (реализовано частично) - `VerifiedFreeRegistrationImporter` — новый отдельный путь `t=reg`, отказывается принимать пользовательский BchBlock как сертификат. Проверяет структурный АНS-104, внешнюю Ed25519 и внутреннюю подпись, подписанта из namespace-PDA через реестр, полное имя и минимальную длину, транзакционную уникальность login/email; различает `TURBO_ACCEPTED` и `ARWEAVE_CONFIRMED`; повтор того же сырого DataItem не дублирует личность. - `FreeRegistrationPublisher` предварительно проверяет сертификат и занятость имени/email до HTTP, затем отправляет уже подписанный DataItem через существующий `TurboDataItemUploader`; только после его успешного ACK вызывает тот же локальный importer. При unknown Turbo outcome не заявляет успех. -- `ArweaveBlockSyncService` распознаёт `t=reg` до обычной block queue, отдельно вычитывает GraphQL `App=test5591 AND t=reg` и хранит собственный checkpoint (`migration_v34.sql`). После появления height независимые серверы импортируют сертификат, повторное обнаружение подтверждает `ARWEAVE_CONFIRMED`. +- `ArweaveBlockSyncService` распознаёт `t=reg` до обычной block queue, отдельно вычитывает GraphQL `App=test5592 AND t=reg` и хранит собственный checkpoint (`migration_v34.sql`). После появления height независимые серверы импортируют сертификат, повторное обнаружение подтверждает `ARWEAVE_CONFIRMED`. - **Проверить в реальной сети:** Arweave gateway / GraphQL фильтрация / root-range доступность и работу с несколькими серверами. Нет фактического Turbo upload и PostgreSQL integration; нельзя считать этап завершённым. ## 9 — WS API (подготовка, публичное API не изменено) diff --git a/docs/Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md b/docs/Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md index d2c90b03..028c708f 100644 --- a/docs/Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md +++ b/docs/Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md @@ -4,7 +4,7 @@ ## Байты и нормализация -`full_login` = `localpart@namespace` — **строго ASCII lowercase**, максимум 30 байт, regex `[a-z0-9_]+@[a-z0-9_]+`. Бинарная идентичность: +`full_login` = `localpart@namespace` — **ASCII, с сохранением регистра локальной части**, максимум 30 байт, regex `[A-Za-z0-9_]+@[a-z0-9_]+`. Бинарная идентичность: ```text identity_fields = major:u8(1) || minor:u8(0) || full_login_len:u8 || full_login:utf8 @@ -22,14 +22,16 @@ payload = identity_fields || inner_signature64 || email_sha256:32 Подписанный бинарный DataItem типа Ed25519 (`signature_type=2`, `owner=registrar_pubkey`) создаётся **тем же** приватным ключом регистратора через стандартный `deepHash` ANS-104 от всех полей и всего payload. Теги в точном порядке: -1. `App=test5591` +1. `App=test5592` 2. `t=reg` 3. `Protocol=SHiNE-Free-Registration-V1` Без target/anchor в V1. Внешняя подпись удостоверяет email hash и теги; ID DataItem = `SHA256(outer_signature64)`. Она НЕ равна внутренней, поскольку подписаны разные сообщения. Проверка внешней подписи обязательна при импорте (включая Turbo ACK), хотя Solana при upgrade проверяет только inner signature по публичному ключу из namespace-PDA. Сервер должен отвергать конфликт имени/hash-email и не заменять принятую идентичность иной записью. -`FREE_CERT → PAID_UPGRADED`: при Solana-create повторно предъявляется **та же внутренняя подпись**, созданная для тех же `login`, root, blockchain, client. Клиент не должен генерировать новые ключи. `created_at_ms` новой PDA — время регистрации в Solana, первоначальная дата, история и потраченные лимиты остаются в Arweave/БД; нельзя начислить дважды бесплатный бонус. Solana программа не проверяет наличие публикации ANS-104; её проверяет доверенный сервер. Детали защиты от смены ключа регистратора в этой версии не реализуются. +`FREE_CERT → PAID`: при Solana-create повторно предъявляется **та же внутренняя подпись**, созданная для тех же `login`, root, blockchain, client. Клиент не должен генерировать новые ключи. `created_at_ms` новой PDA — время регистрации в Solana, первоначальная дата, история и потраченные лимиты остаются в Arweave/БД; нельзя начислить дважды бесплатный бонус. Solana программа не проверяет наличие публикации ANS-104; её проверяет доверенный сервер. Детали защиты от смены ключа регистратора в этой версии не реализуются. ## Тестирование -Детерминированные фикстуры: `shine-solana/shine/tests/fixtures/registration-v2.json` (в том числе полноценный signed ANS-104 DataItem, его ID, hex подписи, отрицательные тесты изменения email и тегов). Векторные ключи предназначены только для тестов. Java-подписание и проверка сертификата присутствуют в этапе 7; загрузка через Turbo и доверенный импорт — этап 8. +Детерминированные фикстуры: `shine-solana/shine/tests/fixtures/registration-v2.json` (в том числе ранее подписанный ANS-104 DataItem с историческим `App=test5591`, его ID и подписи). Этот вектор сохранён **исключительно для проверки криптографического формата**, он НЕ является актуальным тегом выпуска. Актуальный `App=test5592` проверяется выпуском нового сертификата через Java `FreeRegistrationCertificateV1Check`. Векторные ключи предназначены только для тестов. Java-подписание и проверка сертификата присутствуют в этапе 7; загрузка через Turbo и доверенный импорт — этап 8. + +Адрес PDA при upgrade вычисляется от **ASCII lowercase** полного логина, но строка логина в сертификате, его подпись и поле `login` в PDA остаются в исходном регистре. Пароль/Argon2id также используют lowercase полного логина. diff --git a/shine-UI/js/services/protocol-tags.js b/shine-UI/js/services/protocol-tags.js index bd9fc0a3..fccffc1f 100644 --- a/shine-UI/js/services/protocol-tags.js +++ b/shine-UI/js/services/protocol-tags.js @@ -1,5 +1,5 @@ // Transport namespace UI. При следующей смене тестовой эпохи менять только эту строку в UI. -export const SHINE_PROTOCOL_NAMESPACE = 'test5591'; +export const SHINE_PROTOCOL_NAMESPACE = 'test5592'; export const SHINE_APP_TAG_NAME = 'App'; export const SHINE_APP_TAG_VALUE = SHINE_PROTOCOL_NAMESPACE; diff --git a/shine-UI/js/services/shine-namespace-service.js b/shine-UI/js/services/shine-namespace-service.js index 7fbcd2fe..e0fcaf78 100644 --- a/shine-UI/js/services/shine-namespace-service.js +++ b/shine-UI/js/services/shine-namespace-service.js @@ -12,13 +12,13 @@ export function normalizeNamespace(value) { export function normalizeFullLogin(value) { const login = String(value ?? ''); const parts = login.split('@'); - if (parts.length !== 2 || !/^[a-z0-9_]+$/.test(parts[0])) throw new Error('Требуется полный login@namespace без автоматического преобразования'); + if (parts.length !== 2 || !/^[A-Za-z0-9_]+$/.test(parts[0])) throw new Error('Требуется полный login@namespace: латинские буквы любого регистра, цифры, _'); normalizeNamespace(parts[1]); if (enc.encode(login).length > 30) throw new Error('Полный логин превышает 30 байт'); return login; } export async function userPdaSeed32(fullLogin) { - return sha256Bytes(enc.encode('user_login=' + normalizeFullLogin(fullLogin))); + return sha256Bytes(enc.encode('user_login=' + normalizeFullLogin(fullLogin).toLowerCase())); } export async function namespacePdaSeed32(namespace) { return sha256Bytes(enc.encode('namespace=' + normalizeNamespace(namespace))); diff --git a/shine-UI/static-sites/arweave-viewer/README.md b/shine-UI/static-sites/arweave-viewer/README.md index 3e17ca94..1b83f399 100644 --- a/shine-UI/static-sites/arweave-viewer/README.md +++ b/shine-UI/static-sites/arweave-viewer/README.md @@ -25,14 +25,14 @@ index.html?key=&channel=books &solanaRpc=https://api.mainnet-beta.solana.com ``` -`channel` можно не передавать. Тогда viewer ищет все DataItem пользователя с `App=test5591` и строит список каналов из найденных блоков. +`channel` можно не передавать. Тогда viewer ищет все DataItem пользователя с `App=test5592` и строит список каналов из найденных блоков. ## Что делает viewer 1. Если передан `login`, вычисляет PDA `user_login=` программы `SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6` и читает `blockchainKey`. 2. Если передан `key`, использует его напрямую и не обращается к Solana. 3. Из Ed25519/Solana public key вычисляет Arweave owner address как `base64url(SHA-256(pubkey32))`. -4. Делает Arweave GraphQL запрос по owner + `App=test5591`; `channel` применяется локально после загрузки авторского блокчейна. +4. Делает Arweave GraphQL запрос по owner + `App=test5592`; `channel` применяется локально после загрузки авторского блокчейна. 5. Загружает payload каждого DataItem через gateway `/`. 6. Разбирает payload как SHiNE Frame v1 (`frameCode=0x0001`, header 88 bytes). 7. Дедуплицирует повторно опубликованные одинаковые пользовательские блоки по SHA-256 Frame v1. diff --git a/shine-UI/static-sites/arweave-viewer/index.html b/shine-UI/static-sites/arweave-viewer/index.html index 41074cba..d8fd11d7 100644 --- a/shine-UI/static-sites/arweave-viewer/index.html +++ b/shine-UI/static-sites/arweave-viewer/index.html @@ -1100,7 +1100,7 @@ var solanaWeb3=function(exports){"use strict";function getDefaultExportFromCjs(x const BCH_FRAME_HEADER_SIZE = 88; const BCH_FRAME_CODE_V1 = 0x0001; // Transport namespace актуального standalone Viewer. - const SHINE_PROTOCOL_NAMESPACE = 'test5591'; + const SHINE_PROTOCOL_NAMESPACE = 'test5592'; const SHINE_ARWEAVE_APP_TAG = SHINE_PROTOCOL_NAMESPACE; const SHINE_ARWEAVE_CHANNEL_TAG = 'c'; const BCH_TYPE_TECH = 0; diff --git a/shine-UI/tests/arweave-app-namespace.test.mjs b/shine-UI/tests/arweave-app-namespace.test.mjs new file mode 100644 index 00000000..16d95ad3 --- /dev/null +++ b/shine-UI/tests/arweave-app-namespace.test.mjs @@ -0,0 +1,19 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import fs from 'node:fs'; +import { fileURLToPath } from 'node:url'; +import path from 'node:path'; +const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..'); +const read = (p) => fs.readFileSync(path.join(root, p), 'utf8'); + +test('Тестовая эпоха Arweave одинакова в UI, Server и Viewer', () => { + const ui = read('shine-UI/js/services/protocol-tags.js'); + const server = read('SHiNE-server/shine-server-blockchain/src/main/java/blockchain/ShineProtocolTags.java'); + const viewer = read('shine-UI/static-sites/arweave-viewer/index.html'); + const reg = read('SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/FreeRegistrationCertificateV1.java'); + assert.match(ui, /SHINE_PROTOCOL_NAMESPACE\s*=\s*'test5592'/); + assert.match(server, /NAMESPACE\s*=\s*"test5592"/); + assert.match(viewer, /SHINE_PROTOCOL_NAMESPACE\s*=\s*'test5592'/); + assert.match(reg, /ShineProtocolTags\.APP_TAG_VALUE/); + for (const txt of [ui, server, viewer, reg]) assert.doesNotMatch(txt, /test5591/); +}); diff --git a/shine-UI/tests/registration-case-social-projection.test.mjs b/shine-UI/tests/registration-case-social-projection.test.mjs new file mode 100644 index 00000000..6772c914 --- /dev/null +++ b/shine-UI/tests/registration-case-social-projection.test.mjs @@ -0,0 +1,11 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import fs from 'node:fs'; +const schema = fs.readFileSync(new URL('../../SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql', import.meta.url), 'utf8'); +const current = schema.slice(schema.lastIndexOf('CREATE OR REPLACE FUNCTION shine_blocks_connection_state_ai() RETURNS TRIGGER')); +test('социальные проекции нормализуют target, не изменяя блоки', () => { + assert.match(current, /VALUES\(lower\(NEW\.login\),1,lower\(NEW\.to_login\),/); + assert.match(current, /WHERE from_login=lower\(NEW\.login\)/); + assert.match(current, /INSERT INTO message_stats\(to_login,to_block_number,to_block_hash,replies_count\)[\s\S]*?VALUES\(lower\(NEW\.to_login\),/); + assert.match(current, /VALUES\(lower\(NEW\.login\),NEW\.msg_sub_type,lower\(NEW\.to_login\),/); +}); diff --git a/shine-UI/tests/registration-namespace-v2.test.mjs b/shine-UI/tests/registration-namespace-v2.test.mjs index e2607adc..63cbc198 100644 --- a/shine-UI/tests/registration-namespace-v2.test.mjs +++ b/shine-UI/tests/registration-namespace-v2.test.mjs @@ -14,7 +14,9 @@ const bh = x => Uint8Array.from(Buffer.from(x, 'hex')); test('строгая нормализация полных логинов', () => { assert.equal(normalizeFullLogin('alice@shine'), 'alice@shine'); - for (const bad of ['alice','ALICE@shine','alice@Shine',' alice@shine','alice@@shine','alice.s@shine','a'.repeat(30)+'@a']) + assert.equal(normalizeFullLogin('ALICE@shine'), 'ALICE@shine'); + assert.equal(normalizeFullLogin('AlIcE@shine'), 'AlIcE@shine'); + for (const bad of ['alice','alice@Shine',' alice@shine','alice@@shine','alice.s@shine','a'.repeat(30)+'@a']) assert.throws(() => normalizeFullLogin(bad)); assert.notEqual(normalizeFullLogin('a_b@shine'), normalizeFullLogin('ab@shine')); }); @@ -31,6 +33,8 @@ test('SHA256 PDA seeds stable and domain separated', async () => { assert.equal(hex(await userPdaSeed32('bob@free')), props.user_bob_free_seed); assert.equal(hex(await namespacePdaSeed32('free')), props.namespace_free_seed); assert.notEqual(hex(await userPdaSeed32('bob@free')), hex(await namespacePdaSeed32('free'))); + assert.equal(hex(await userPdaSeed32('BoB@free')), hex(await userPdaSeed32('bob@free'))); + assert.equal(hex(await userPdaSeed32('BOB@free')), hex(await userPdaSeed32('bob@free'))); }); test('inner message is byte-for-byte fixture', () => { const b = buildFreeCertificateInnerMessage('bob@free', @@ -38,6 +42,11 @@ test('inner message is byte-for-byte fixture', () => { bh('29acbae141bccaf0b22e1a94d34d0bc7361e526d0bfe12c89794bc9322966dd7'), bh('2543b92ff1095511476adc8369db6ddc933665a11978dda1404ee1066ca9559d')); assert.equal(hex(b), props.inner_message_hex); + const mixed = buildFreeCertificateInnerMessage('BoB@free', + bh('03a107bff3ce10be1d70dd18e74bc09967e4d6309ba50d5f1ddc8664125531b8'), + bh('29acbae141bccaf0b22e1a94d34d0bc7361e526d0bfe12c89794bc9322966dd7'), + bh('2543b92ff1095511476adc8369db6ddc933665a11978dda1404ee1066ca9559d')); + assert.notEqual(hex(mixed), hex(b)); // Подпись сертификата включает оригинальный регистр. }); test('create instruction suffix encodes registrar signature, never promo', () => { const common = {login:'bob@free', rootKey32: new Uint8Array(32), createdAtMs:1n, diff --git a/shine-solana/shine/doc/formats/shine-user-pda-format-v.1.2.md b/shine-solana/shine/doc/formats/shine-user-pda-format-v.1.2.md index 0e6b773c..25896d25 100644 --- a/shine-solana/shine/doc/formats/shine-user-pda-format-v.1.2.md +++ b/shine-solana/shine/doc/formats/shine-user-pda-format-v.1.2.md @@ -190,3 +190,7 @@ Legacy migration в 1.2 отсутствует. После удаления те Бинарный user-PDA 1.2 **не изменён**. Меняется seed новых PDA на `SHA256(UTF8("user_login="+normalizedFullLogin))` (32 сырых байта), а полная строка `login@namespace` входит в поле `login` и в существующую подпись. Ограничение полного имени — 30 байт. `created_at_ms` в новой PDA при free→paid соответствует дате on-chain создания и не является датой первого Arweave сертификата. Историческая идентичность и потраченные лимиты остаются за логическим пользователем, их сохраняет сервер/БД последующих этапов. Существующие PDA старых логинов без namespace продолжают принимать `update_user_pda` по старому seed `user_login=` + lowercase login; новых аккаунтов такого типа создать V2 больше нельзя. Новая регистрация **не будет совместима со старым клиентом** до обновления JS/сервера. + + +### Регистронезависимая идентичность (28.10.2026) +Локальная часть полного `login@namespace` допускает латинские буквы `A–Z` и `a–z`, цифры и `_`; `namespace` допускает только нижний ASCII-регистр. Выбранный при регистрации регистр логина неизменяем. Адрес user PDA вычисляется по `SHA256(UTF8("user_login=" + ASCII-lowercase(fullLogin)))` и bump для `find_program_address`. Сама запись PDA 1.2 содержит **оригинальное** написание `login`; подписи записи и регистраторского сертификата проверяются по исходному регистру без нормализации. Это изменение правила seed, не бинарного формата PDA. diff --git a/shine-solana/shine/doc/programs/shine_users.md b/shine-solana/shine/doc/programs/shine_users.md index 483a0ec5..7885feb3 100644 --- a/shine-solana/shine/doc/programs/shine_users.md +++ b/shine-solana/shine/doc/programs/shine_users.md @@ -31,7 +31,7 @@ Legacy 1.0 считается тестовым и не мигрируется. ```text tag:u8 = 3 -login:string_u8 // полный lowercase login@namespace, <= 30 байт +login:string_u8 // исходный регистр localpart, lowercase namespace, <= 30 байт root_key:[32] created_at_ms:u64 LE // новая Solana дата в пределах +-5 мин additional_limit:u64 LE // кратно LIMIT_STEP @@ -49,14 +49,14 @@ registrar_signature_present:u8 // 0 для type 1, 1 для type 2 Accounts в неизменном порядке: 1. `payer` — signer, writable; -2. `user_pda` — writable (SHA-256 полного логина); +2. `user_pda` — writable (SHA-256 нормализованного полного логина); 3. `system_program` — read-only; 4. `shine_payments` inflow vault — writable; 5. `sysvar::instructions` — read-only; 6. `users_economy_config_pda` — **read-only**; 7. `namespace_pda` — read-only, owner `shine_users`. -Проверки: namespace реально существует в программе, `localPart >= min_localpart_len`, общая длина <= 30, обе части ASCII lowercase `[a-z0-9_]+`, PDA соответствует `SHA256("user_login="+fullLogin)`, схема v1.2, root и blockchain Ed25519 proof-of-possession. Цена = `namespace.registration_fee + additional_limit/LIMIT_STEP * economy.lamports_per_limit_step` в существующий `shine_payments` vault. На create сохраняется существующая схема starter quota из economy-PDA: при переходе free→paid внешняя БД обязана учесть уже использованный бонус и не выдать его снова. +Проверки: namespace реально существует в программе, `localPart >= min_localpart_len`, общая длина <= 30, localpart допускает ASCII `[A-Za-z0-9_]+`, namespace остаётся ASCII lowercase `[a-z0-9_]+`, PDA соответствует `SHA256("user_login="+ASCII-lowercase(fullLogin))`, схема v1.2, root и blockchain Ed25519 proof-of-possession. Цена = `namespace.registration_fee + additional_limit/LIMIT_STEP * economy.lamports_per_limit_step` в существующий `shine_payments` vault. На create сохраняется существующая схема starter quota из economy-PDA: при переходе free→paid внешняя БД обязана учесть уже использованный бонус и не выдать его снова. **Ed25519 инструкции перед opcode 3 (строго непосредственно):** @@ -170,3 +170,7 @@ forks[]: - `AccessServersBlock`: 0 или 1 сервер доступа. Позже лимиты можно увеличить без изменения структуры блоков. + + +### Регистронезависимая идентичность (28.10.2026) +Локальная часть полного `login@namespace` допускает латинские буквы `A–Z` и `a–z`, цифры и `_`; `namespace` допускает только нижний ASCII-регистр. Выбранный при регистрации регистр логина неизменяем. Адрес user PDA вычисляется по `SHA256(UTF8("user_login=" + ASCII-lowercase(fullLogin)))` и bump для `find_program_address`. Сама запись PDA 1.2 содержит **оригинальное** написание `login`; подписи записи и регистраторского сертификата проверяются по исходному регистру без нормализации. Это изменение правила seed, не бинарного формата PDA. diff --git a/shine-solana/shine/programs/shine_users/src/lib.rs b/shine-solana/shine/programs/shine_users/src/lib.rs index b2acadb0..462d2278 100644 --- a/shine-solana/shine/programs/shine_users/src/lib.rs +++ b/shine-solana/shine/programs/shine_users/src/lib.rs @@ -1086,7 +1086,7 @@ fn validate_full_login(login: &str) -> Result<&str, ProgramError> { let (local, namespace) = login.split_once('@').ok_or(ShineUsersError::InvalidLogin)?; validate_namespace_name(namespace)?; require!(!local.is_empty(), ShineUsersError::InvalidLogin); - require!(local.bytes().all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'_'), ShineUsersError::InvalidLogin); + require!(local.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_'), ShineUsersError::InvalidLogin); Ok(namespace) } @@ -1151,7 +1151,7 @@ pub fn certificate_inner_message(login: &str, root: &Pubkey, blockchain: &Pubkey } pub fn user_pda_seed(login: &str) -> [u8; 32] { - hash(format!("{}{}", settings::USER_PDA_SEED_PREFIX, login).as_bytes()).to_bytes() + hash(format!("{}{}", settings::USER_PDA_SEED_PREFIX, login.to_ascii_lowercase()).as_bytes()).to_bytes() } fn validate_server_addresses(addresses: &[ServerAddressRecordV12]) -> ProgramResult { diff --git a/shine-solana/shine/tools/temporary-pda-cleaner/.gitignore b/shine-solana/shine/tools/temporary-pda-cleaner/.gitignore new file mode 100644 index 00000000..e7fd72e5 --- /dev/null +++ b/shine-solana/shine/tools/temporary-pda-cleaner/.gitignore @@ -0,0 +1,7 @@ +node_modules/ +target/ +*.json.bak +*.so +*pdas*.json +*keypair*.json +*-authority.json diff --git a/shine-solana/shine/tools/temporary-pda-cleaner/Cargo.toml b/shine-solana/shine/tools/temporary-pda-cleaner/Cargo.toml new file mode 100644 index 00000000..eb82e742 --- /dev/null +++ b/shine-solana/shine/tools/temporary-pda-cleaner/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "shine_users_pda_cleaner" +version = "0.1.0" +edition = "2021" +description = "Временная программа для закрытия PDA shine_users в devnet" + +[lib] +name = "shine_users" +crate-type = ["cdylib", "lib"] + +[dependencies] +solana-program = "2.1.21" + +[features] +default = [] +no-entrypoint = [] + +# Отдельный workspace: временный crate НЕ включается в основной Solana workspace. +[workspace] diff --git a/shine-solana/shine/tools/temporary-pda-cleaner/DELETE_AFTER_DEVNET_RESET.md b/shine-solana/shine/tools/temporary-pda-cleaner/DELETE_AFTER_DEVNET_RESET.md new file mode 100644 index 00000000..bc9fd72b --- /dev/null +++ b/shine-solana/shine/tools/temporary-pda-cleaner/DELETE_AFTER_DEVNET_RESET.md @@ -0,0 +1,15 @@ +# ⚠️ DEV ONLY — ОДНОРАЗОВАЯ ПАПКА. УДАЛИТЬ ПОСЛЕ ОЧИСТКИ + +**Назначение:** исключительно разработка, уничтожение ВСЕХ PDA `shine_users` **только в Solana devnet**. Не часть приложения и не предназначено для production/mainnet. + +Содержимое папки временно подменяет БАЙТКОД существующей тестовой Solana-программы `shine_users` под ТЕМ ЖЕ Program ID. Не путать с `App=test5592` — это тег Arweave, не Program ID. + +**Агенту:** +1. Отключить регистрацию/синхронизацию, удостовериться в devnet и полном праве upgrade authority. Прочитать `README_AGENT_RU.md` целиком. +2. Сделать snapshot PDA, проверить список адресов и возвраты, затем временно обновить программу, закрыть PDA по одному на devnet (невозвратимо). +3. СРАЗУ восстановить ОФИЦИАЛЬНЫЙ `shine_users` из этого патча, подтвердить работоспособность; проинициализировать economy и namespaces заново. +4. После успешной проверки **УДАЛИТЬ ВСЮ ЭТУ ПАПКУ** `shine-solana/shine/tools/temporary-pda-cleaner/` из рабочего проекта, а не только .so-файл. Не включать её в будущие production-сборки, развёртывания, Git-коммиты или release ZIP. + +Не оставлять временный контракт установленным после операции. Восстановление исходной программы в devnet — обязательный отдельный шаг. + +**Не трогать:** Solana Program ID, mainnet, реальные данные пользователей, Arweave DataItem. Удаление PDA не стирает опубликованные записи Arweave. diff --git a/shine-solana/shine/tools/temporary-pda-cleaner/README_AGENT_RU.md b/shine-solana/shine/tools/temporary-pda-cleaner/README_AGENT_RU.md new file mode 100644 index 00000000..5469f36f --- /dev/null +++ b/shine-solana/shine/tools/temporary-pda-cleaner/README_AGENT_RU.md @@ -0,0 +1,151 @@ +> **⛔ РАЗОВАЯ DEV-ПРОЦЕДУРА. ПОСЛЕ УСПЕШНОГО DEVNET RESET УДАЛИТЬ ПАПКУ `shine-solana/shine/tools/temporary-pda-cleaner/` ИЗ ПРОЕКТА. НИКОГДА НЕ ДЕПЛОИТЬ В MAINNET.** + +# SHiNE — временная очистка PDA `shine_users` (ТОЛЬКО DEVNET) + +**Статус:** исходники и сценарий для агента; на реальном devnet ничего не запускалось. **Деструктивная процедура.** + +## Ключевой принцип + +Это НЕ новая программа с новым адресом. Папка содержит **временную замену байткода существующей программы** `shine_users` под **тем же** Program ID: + +`SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6` + +Программа с другим Program ID **не может закрыть** старые PDA, которыми владеет существующая программа. Для очистки требуется текущая `upgrade authority` этого Program ID. Устанавливать новую программу с новым ID ради очистки нельзя. + +**Работать исключительно с devnet.** Временная программа сама не умеет проверить сеть (у программ нет безопасного способа прочитать genesis hash), поэтому оператор ОБЯЗАН до deploy проверить RPC и адрес. Скрипт `cleaner.mjs` отдельно проверяет реальный genesis hash devnet при КАЖДОМ запуске. + +## Что закрываем и куда идут SOL + +`getProgramAccounts(shine_users)` находит ВСЕ аккаунты, которыми владеет программа, в том числе: + +- пользовательские PDA (включая разные версии формата); +- PDA namespaces; +- `users_economy_config` PDA; +- другие вспомогательные аккаунты программы, если они существуют. + +Временная инструкция `close` допускает **только текущую upgrade authority из ProgramData**, проверенную на цепочке. Получатель средств — **этот же кошелёк**, его нельзя подменить. В каждом вызове закрывается ровно один PDA. Возвращается **весь баланс lamports на PDA**. Это может быть не тот кошелёк, который первоначально оплачивал размещение данных. + +**Не закрываем:** исполняемый Program account, ProgramData, PDA программ `shine_payments`, `shine_login_guard` и любые чужие аккаунты. После очистки Program ID остаётся прежним. + +## Перед началом — обязательно + +1. Убедиться, что это тестовые данные, которые можно безвозвратно уничтожить. Остановить регистрацию и фоновую синхронизацию `shine_users`, которая может создавать PDA. +2. Сохранить текущий исходник и байткод развернутой программы, программу **полного обновления** из последнего патча и документировать текущие адреса. +3. Убедиться, что `solana program show -u devnet ` выводит **Upgradeable Program** и правильную `Upgrade Authority` (а не `None`). Если authority отсутствует — остановиться. +4. Перед операцией переключить Solana CLI на devnet, **но команды ниже всё равно всегда передают `-u devnet` явно**. Ключ authority никуда не копировать и не добавлять в Git. +5. Если PDA находятся не в devnet, этот скрипт НЕ использовать; никаких автоматических попыток на mainnet. + +## Шаг 1 — проверить живую программу и сохранить состояние + +```bash +PROGRAM_ID=SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6 +AUTHORITY_JSON=/absolute/private/path/upgrade-authority.json +solana -u devnet program show "$PROGRAM_ID" +solana -u devnet program dump "$PROGRAM_ID" ./shine_users_before_clean.so +solana-keygen pubkey "$AUTHORITY_JSON" +``` + +Нужно вручную сверить authority адрес из `program show` с адресом из `solana-keygen pubkey`. + +## Шаг 2 — до обновления программы сформировать снимок PDA + +Запускать из директории `scripts/`: + +```bash +npm install +node cleaner.mjs inspect \ + --authority "$(solana-keygen pubkey "$AUTHORITY_JSON")" \ + --manifest ./devnet-pdas-before-clean.json +``` + +В снимке видны адреса и возвращаемые lamports; осмотреть **каждый** PDA. Если PDA больше 100, скрипт останавливается, пока вы не разберётесь почему. НЕ размещать снимок, ключи и приватные данные в публичных репозиториях. + +## Шаг 3 — собрать временную программу + +Из папки `temporary-pda-cleaner/`: + +```bash +cargo build-sbf +``` + +Результат: `target/deploy/shine_users.so`. Сборка требует Solana SBF toolchain; просто `cargo build` не подходит для deploy. Компиляция не проверялась в окружении подготовки архива, где Solana/Rust toolchain отсутствует. + +## Шаг 4 — временно обновить **существующую** программу + +**Сверить кластер!** Эта операция оставляет систему без обычной регистрации до восстановления основного байткода. + +```bash +solana -u devnet program deploy \ + --program-id "$PROGRAM_ID" \ + --upgrade-authority "$AUTHORITY_JSON" \ + ./target/deploy/shine_users.so + +solana -u devnet program show "$PROGRAM_ID" +``` + +Если Solana CLI требует ключ программы, использовать исходный program-id keypair из безопасного хранилища, а не генерировать новый. Команду подстроить под установленную версию CLI, не подменяя ID. + +## Шаг 5 — удалить PDA по одному, с проверками + +Из `scripts/`, только после осмотра снимка и шага 4: + +```bash +node cleaner.mjs execute \ + --manifest ./devnet-pdas-before-clean.json \ + --keypair "$AUTHORITY_JSON" \ + --confirm <КОЛИЧЕСТВО_ИЗ_СНИМКА> \ + --i-understand-irreversible + +node cleaner.mjs verify +``` + +Скрипт: + +- проверяет *genesis hash* devnet, Program ID, ProgramData и реальную upgrade authority; +- сверяет PDA с заранее сохранённым снимком (включая SOL); +- перед каждой транзакцией выполняет `simulateTransaction`; +- подтверждает транзакцию и отсутствие PDA по RPC; +- при прерывании допускает повторный `execute`: уже закрытые PDA пропускаются; +- в конце требует **ноль** оставшихся PDA в `shine_users`. + +Если возвращается ошибка, **остановиться** и разобраться. Не менять автоматически списки PDA, адрес кошелька или фильтры. + +## Шаг 6 — немедленно восстановить нормальный контракт + +**Восстанавливать надо НОВУЮ версию из актуального проекта после CASE_INSENSITIVE_LOGIN_PATCH**, а не устаревший байткод из `before_clean` (тот файл только для аварийного отката и диагностики). + +```bash +# В каталоге АКТУАЛЬНОЙ штатной программы из проекта: +cargo build-sbf +solana -u devnet program deploy \ + --program-id "$PROGRAM_ID" \ + --upgrade-authority "$AUTHORITY_JSON" \ + ./target/deploy/shine_users.so +solana -u devnet program show "$PROGRAM_ID" +``` + +После восстановление обязательно удостовериться, что программа отличается от временной и **не принимает** инструкцию `0x01` в формате временного контракта как команду на закрытие произвольного PDA. В актуальной штатной `shine_users` инструкция `0x01` означает инициализацию экономического PDA, а не очистку. + +## Шаг 7 — переинициализировать чистую систему + +- Применить новую серверную схему PostgreSQL; НЕ восстанавливать старую базу. +- Инициализировать `users_economy_config` и создать namespace PDA заново штатными командами/экраном проекта. +- Синхронизатор Solana запустить после проверки валидного кода и PDA. +- Проверить: `SuperMan@free` регистрируется; `superman@free` повторно не регистрируется; PDA вычисляется из lowercase; внутри PDA остаётся оригинальный регистр; переход из Arweave в Solana работает; лайки и ответы работают. +- Проверить, что в исходном коде UI, сервера и Rust **одинаковый Program ID**. + +## Не путать с Arweave `App=test5592` + +`test5591 → test5592` — смена **тестового тега Arweave** (`App`), а не Solana Program ID. Временная программа и штатный `shine_users` используют тот же Program ID, остальные Solana-адреса программы не меняются. Arweave-данные с предыдущим App остаются в сети, но сервер новой эпохи их не импортирует. + +## Удаление этой папки после работ + +После проверки того, что **штатный смарт-контракт восстановлен**, devnet PDA очищены и новые тестовые регистрации работают: удалить весь каталог `shine-solana/shine/tools/temporary-pda-cleaner/` из дерева проекта и из будущих release artifacts. Сам проект (UI/Java/настоящий контракт) после этого будет продолжать работать. + +## Ограничения и безопасность + +- Ни один реальный PDA здесь не удалён; on-chain вызовы, компиляция и деплой не выполнялись. +- Это техническая заготовка, обязательны предварительная ручная проверка кода агентом и тест на localnet/devnet. Нельзя запускать на mainnet. +- **Программа удаления очень опасна, пока развернута:** не оставлять её на сети после очистки. +- `getProgramAccounts` может быть недоступен на публичном RPC из-за лимитов: использовать devnet RPC с поддержкой метода. Не обходить предохранители отключением проверок. +- PDA других программ, записи Arweave, внешние хранилища и PostgreSQL этой процедурой не очищаются. diff --git a/shine-solana/shine/tools/temporary-pda-cleaner/scripts/cleaner.mjs b/shine-solana/shine/tools/temporary-pda-cleaner/scripts/cleaner.mjs new file mode 100644 index 00000000..53450ad1 --- /dev/null +++ b/shine-solana/shine/tools/temporary-pda-cleaner/scripts/cleaner.mjs @@ -0,0 +1,118 @@ +#!/usr/bin/env node +// Временная очистка PDA shine_users. Только devnet, всегда проверять genesis hash. +// Никогда не добавляйте приватный ключ или файл keypair в git/архив. +import { Connection, PublicKey, Keypair, Transaction, TransactionInstruction, sendAndConfirmTransaction, BPF_LOADER_UPGRADEABLE_PROGRAM_ID } from '@solana/web3.js'; +import { readFileSync, writeFileSync, existsSync } from 'node:fs'; + +const PROGRAM_ID = new PublicKey('SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6'); +const DEVNET_GENESIS = 'EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG'; +const RPC = 'https://api.devnet.solana.com'; +const MAX_ACCOUNTS = 100; // Защита от случайной массовой очистки. +const usage = ` +Команды: + node cleaner.mjs inspect --authority --manifest + node cleaner.mjs execute --manifest --keypair --confirm --i-understand-irreversible + node cleaner.mjs verify +Все команды работают ТОЛЬКО с devnet и с фиксированным Program ID: ${PROGRAM_ID.toBase58()} +`; +function arg(name) { + const i = process.argv.indexOf(name); + return i < 0 ? undefined : process.argv[i + 1]; +} +function fatal(msg) { throw new Error(msg); } +const command = process.argv[2]; +if (!['inspect', 'execute', 'verify'].includes(command)) { console.log(usage); process.exit(2); } +const c = new Connection(RPC, 'confirmed'); + +async function checkNetworkAndProgram() { + const genesis = await c.getGenesisHash(); + if (genesis !== DEVNET_GENESIS) fatal(`ОПАСНО: RPC не devnet: ${genesis}`); + const p = await c.getAccountInfo(PROGRAM_ID, 'confirmed'); + if (!p?.executable || !p.owner.equals(BPF_LOADER_UPGRADEABLE_PROGRAM_ID)) fatal('Программа не является upgradeable loader-v3. Остановка.'); + if (p.data.length < 36 || p.data.readUInt32LE(0) !== 2) fatal('Неверный loader-v3 Program account'); + const programdata = new PublicKey(p.data.subarray(4, 36)); + const pd = await c.getAccountInfo(programdata, 'confirmed'); + if (!pd || !pd.owner.equals(BPF_LOADER_UPGRADEABLE_PROGRAM_ID) || pd.data.length < 45 || pd.data.readUInt32LE(0) !== 3 || pd.data[12] !== 1) { + fatal('ProgramData не содержит активную upgrade authority'); + } + const authority = new PublicKey(pd.data.subarray(13, 45)); + return { programdata, authority }; +} +async function listOwned() { + // dataSlice устраняет скачивание всех данных PDA, получаем адрес и lamports. + const a = await c.getProgramAccounts(PROGRAM_ID, { commitment: 'confirmed', dataSlice: { offset: 0, length: 0 } }); + return a.map(x => ({ address: x.pubkey.toBase58(), lamports: x.account.lamports })) + .sort((x, y) => x.address.localeCompare(y.address)); +} +async function main() { + const { programdata, authority } = await checkNetworkAndProgram(); + const rows = await listOwned(); + console.log(`Devnet OK; Program=${PROGRAM_ID}; authority=${authority}; PDA=${rows.length}; SOL=${rows.reduce((s,x)=>s+x.lamports,0)/1e9}`); + if (rows.length > MAX_ACCOUNTS) fatal(`Найдено больше ${MAX_ACCOUNTS} PDA; скрипт намеренно прекращает работу.`); + if (command === 'verify') { + if (rows.length !== 0) fatal(`Осталось ${rows.length} PDA: ${rows.map(x => x.address).join(', ')}`); + console.log('OK: пользовательских и конфигурационных аккаунтов, принадлежащих программе, нет.'); + return; + } + if (command === 'inspect') { + const ownerString = arg('--authority'); + if (!ownerString) fatal('Укажите --authority с публичным адресом владельца.'); + if (!new PublicKey(ownerString).equals(authority)) fatal('Указанный владелец не является upgrade authority.'); + const manifest = arg('--manifest'); + if (!manifest || existsSync(manifest)) fatal('Укажите новый --manifest путь (не перезаписываем существующий файл).'); + const snapshot = { + purpose: 'destructive-devnet-shine-users-cleanup', genesis: DEVNET_GENESIS, + program: PROGRAM_ID.toBase58(), authority: authority.toBase58(), programdata: programdata.toBase58(), + createdAtUtc: new Date().toISOString(), accounts: rows, + }; + writeFileSync(manifest, JSON.stringify(snapshot, null, 2) + '\n', { flag: 'wx', mode: 0o600 }); + console.log('План сохранён:', manifest); + for (const row of rows) console.log(`${row.address} ${(row.lamports / 1e9).toFixed(9)} SOL`); + console.log('Проверьте список и суммы перед деплоем временной программы и перед execute.'); + return; + } + if (command === 'execute') { + if (!process.argv.includes('--i-understand-irreversible')) fatal('Требуется --i-understand-irreversible'); + const path = arg('--manifest'); + const keypath = arg('--keypair'); + if (!path || !keypath) fatal('Нужны --manifest и --keypair'); + const m = JSON.parse(readFileSync(path, 'utf8')); + const wallet = Keypair.fromSecretKey(Uint8Array.from(JSON.parse(readFileSync(keypath, 'utf8')))); + if (!wallet.publicKey.equals(authority)) fatal('Файл keypair не совпадает с текущей upgrade authority'); + if (m.purpose !== 'destructive-devnet-shine-users-cleanup' || m.genesis !== DEVNET_GENESIS || m.program !== PROGRAM_ID.toBase58() || m.programdata !== programdata.toBase58() || m.authority !== authority.toBase58()) fatal('План создан для другой сети, программы или владельца'); + if (!Array.isArray(m.accounts) || new Set(m.accounts.map(x=>x.address)).size !== m.accounts.length || m.accounts.length > MAX_ACCOUNTS) fatal('Неверный список PDA в плане'); + if (String(m.accounts.length) !== arg('--confirm')) fatal(`Неверный --confirm, должно быть ${m.accounts.length}`); + const currentByKey = new Map(rows.map(x => [x.address, x.lamports])); + const expectedByKey = new Map(m.accounts.map(x => [x.address, x.lamports])); + for (const row of rows) { + if (!expectedByKey.has(row.address) || row.lamports !== expectedByKey.get(row.address)) fatal('Состояние devnet отличается от плана: ' + row.address); + } + // Часть PDA может быть уже закрыта после сбоя связи: пропускаем только исчезнувшие. + const pending = m.accounts.filter(x => currentByKey.has(x.address)); + console.log(`Подтверждено ${m.accounts.length} PDA, осталось закрыть ${pending.length}.`); + for (const [i, item] of pending.entries()) { + const target = new PublicKey(item.address); + const ix = new TransactionInstruction({ + programId: PROGRAM_ID, + keys: [ + { pubkey: authority, isSigner: true, isWritable: true }, + { pubkey: PROGRAM_ID, isSigner: false, isWritable: false }, + { pubkey: programdata, isSigner: false, isWritable: false }, + { pubkey: target, isSigner: false, isWritable: true }, + ], + data: Buffer.from([1]), + }); + const tx = new Transaction().add(ix); + const sim = await c.simulateTransaction(tx, [wallet]); + if (sim.value.err) fatal(`Симуляция НЕ прошла для ${item.address}: ${JSON.stringify(sim.value.err)} ${JSON.stringify(sim.value.logs)}`); + const signature = await sendAndConfirmTransaction(c, tx, [wallet], { commitment: 'confirmed', maxRetries: 3 }); + const after = await c.getAccountInfo(target, 'confirmed'); + if (after) fatal(`Транзакция ${signature} подтверждена, но ${item.address} ещё существует. Остановка.`); + console.log(`[${i+1}/${pending.length}] ЗАКРЫТО ${item.address}; +${item.lamports/1e9} SOL → ${authority.toBase58()}; tx=${signature}`); + } + const remaining = await listOwned(); + if (remaining.length) fatal(`После очистки осталось ${remaining.length} аккаунтов`); + console.log('УСПЕХ: PDA shine_users отсутствуют. СРОЧНО ВОССТАНОВИТЕ ШТАТНЫЙ СМАРТ-КОНТРАКТ.'); + } +} +main().catch(e => { console.error('ОШИБКА:', e.message); process.exitCode = 1; }); diff --git a/shine-solana/shine/tools/temporary-pda-cleaner/scripts/package.json b/shine-solana/shine/tools/temporary-pda-cleaner/scripts/package.json new file mode 100644 index 00000000..a11bba9a --- /dev/null +++ b/shine-solana/shine/tools/temporary-pda-cleaner/scripts/package.json @@ -0,0 +1,14 @@ +{ + "name": "shine-users-devnet-cleaner-cli", + "private": true, + "type": "module", + "version": "0.1.0", + "scripts": { + "inspect": "node cleaner.mjs inspect", + "execute": "node cleaner.mjs execute", + "verify": "node cleaner.mjs verify" + }, + "dependencies": { + "@solana/web3.js": "^1.98.0" + } +} diff --git a/shine-solana/shine/tools/temporary-pda-cleaner/src/lib.rs b/shine-solana/shine/tools/temporary-pda-cleaner/src/lib.rs new file mode 100644 index 00000000..88ec3d3d --- /dev/null +++ b/shine-solana/shine/tools/temporary-pda-cleaner/src/lib.rs @@ -0,0 +1,91 @@ +//! ВРЕМЕННАЯ ОПАСНАЯ ПРОГРАММА. Только для полной очистки тестовых PDA shine_users. +//! Не использовать в mainnet. После очистки ОБЯЗАТЕЛЬНО вернуть штатную программу. +//! +//! Важно: программа деплоится как UPGRADE ПОД ТЕМ ЖЕ Program ID. +//! Отдельный Program ID НЕ МОЖЕТ списывать lamports с PDA старой программы. + +use solana_program::{ + account_info::{next_account_info, AccountInfo}, + bpf_loader_upgradeable, + entrypoint, + entrypoint::ProgramResult, + program_error::ProgramError, + pubkey::Pubkey, +}; + +solana_program::declare_id!("SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6"); +entrypoint!(process_instruction); + +// [1] CLOSE_ONE: [authority signer writable, executable program readonly, +// ProgramData readonly, PDA writable]. +const CLOSE_ONE: u8 = 1; + +fn process_instruction( + program_id: &Pubkey, + accounts: &[AccountInfo], + data: &[u8], +) -> ProgramResult { + if *program_id != crate::id() || data != [CLOSE_ONE] { + return Err(ProgramError::InvalidInstructionData); + } + + let mut it = accounts.iter(); + let authority = next_account_info(&mut it)?; + let program = next_account_info(&mut it)?; + let programdata = next_account_info(&mut it)?; + let target = next_account_info(&mut it)?; + if it.next().is_some() { + return Err(ProgramError::InvalidArgument); + } + + // Подписант и получатель lamports — ОДИН аккаунт, всегда upgrade authority. + if !authority.is_signer || !authority.is_writable || authority.key == target.key { + return Err(ProgramError::MissingRequiredSignature); + } + if !target.is_writable || target.executable || target.owner != program_id { + return Err(ProgramError::InvalidAccountOwner); + } + + // Проверяем upgrade authority НАСТОЯЩЕЙ программы по состоянию loader-v3. + if program.key != program_id + || !program.executable + || program.owner != &bpf_loader_upgradeable::id() + || programdata.owner != &bpf_loader_upgradeable::id() + { + return Err(ProgramError::IncorrectProgramId); + } + { + let p = program.try_borrow_data()?; + // UpgradeableLoaderState::Program: u32=2, затем адрес ProgramData (32 байта). + if p.len() < 36 || p[..4] != 2u32.to_le_bytes() || p[4..36] != programdata.key.to_bytes() { + return Err(ProgramError::InvalidAccountData); + } + } + { + let p = programdata.try_borrow_data()?; + // UpgradeableLoaderState::ProgramData: u32=3; slot u64; option=1; authority pubkey. + if p.len() < 45 + || p[..4] != 3u32.to_le_bytes() + || p[12] != 1 + || p[13..45] != authority.key.to_bytes() + { + return Err(ProgramError::MissingRequiredSignature); + } + } + + let amount = target.lamports(); + if amount == 0 { + return Err(ProgramError::UninitializedAccount); + } + // Только программа-владелец списывает lamports с target. + // Сумма полностью поступает authority; исторический плательщик может быть другим. + { + let new_balance = authority.lamports() + .checked_add(amount) + .ok_or(ProgramError::ArithmeticOverflow)?; + **authority.try_borrow_mut_lamports()? = new_balance; + } + **target.try_borrow_mut_lamports()? = 0; + target.realloc(0, false)?; + Ok(()) +} From 219a65ae27f1617428f56e6ff4547ddc60f41a350e85b0ecd806338667e12743 Mon Sep 17 00:00:00 2001 From: AidarKC Date: Wed, 28 Oct 2026 12:45:35 +0300 Subject: [PATCH 07/82] =?UTF-8?q?=D0=9E=D1=87=D0=B8=D1=81=D1=82=D0=B8?= =?UTF-8?q?=D1=82=D1=8C=20=D0=B2=D1=80=D0=B5=D0=BC=D0=B5=D0=BD=D0=BD=D1=8B?= =?UTF-8?q?=D0=B9=20PDA-=D0=BE=D1=87=D0=B8=D1=81=D1=82=D0=B8=D1=82=D0=B5?= =?UTF-8?q?=D0=BB=D1=8C=20=D0=B8=20=D0=BE=D0=B1=D0=BD=D0=BE=D0=B2=D0=B8?= =?UTF-8?q?=D1=82=D1=8C=20T3=20=D0=BB=D0=BE=D0=B3=D0=B8=D0=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- VERSION.properties | 2 +- deploy/scripts/test_t3_ui.sh | 2 +- .../tools/temporary-pda-cleaner/.gitignore | 7 - .../tools/temporary-pda-cleaner/Cargo.toml | 19 --- .../DELETE_AFTER_DEVNET_RESET.md | 15 -- .../temporary-pda-cleaner/README_AGENT_RU.md | 151 ------------------ .../temporary-pda-cleaner/scripts/cleaner.mjs | 118 -------------- .../scripts/package.json | 14 -- .../tools/temporary-pda-cleaner/src/lib.rs | 91 ----------- 9 files changed, 2 insertions(+), 417 deletions(-) delete mode 100644 shine-solana/shine/tools/temporary-pda-cleaner/.gitignore delete mode 100644 shine-solana/shine/tools/temporary-pda-cleaner/Cargo.toml delete mode 100644 shine-solana/shine/tools/temporary-pda-cleaner/DELETE_AFTER_DEVNET_RESET.md delete mode 100644 shine-solana/shine/tools/temporary-pda-cleaner/README_AGENT_RU.md delete mode 100644 shine-solana/shine/tools/temporary-pda-cleaner/scripts/cleaner.mjs delete mode 100644 shine-solana/shine/tools/temporary-pda-cleaner/scripts/package.json delete mode 100644 shine-solana/shine/tools/temporary-pda-cleaner/src/lib.rs diff --git a/VERSION.properties b/VERSION.properties index fa7c3171..8238bb43 100644 --- a/VERSION.properties +++ b/VERSION.properties @@ -1,2 +1,2 @@ -client.version=1.20.5 +client.version=1.20.6 server.version=1.16.4 diff --git a/deploy/scripts/test_t3_ui.sh b/deploy/scripts/test_t3_ui.sh index 108d4f5b..56664d78 100755 --- a/deploy/scripts/test_t3_ui.sh +++ b/deploy/scripts/test_t3_ui.sh @@ -5,7 +5,7 @@ REMOTE_HOST="player@t3.shineup.me" \ REMOTE_UI_DIR="/home/player/t3/UI" \ EXPECTED_CADDY_UI_ROOT="/home/player/t3/UI" \ EXPECTED_CADDY_SITE="t3.shineup.me" \ -DEPLOY_SERVER_LOGIN="server_t3" \ +DEPLOY_SERVER_LOGIN="server_t3@shine" \ DEPLOY_SERVER_ADDRESS="t3.shineup.me" \ DEPLOY_SOLANA_CLUSTER="devnet" \ DEPLOY_SOLANA_ENDPOINT="https://devnet.helius-rpc.com/?api-key=0614c894-52d8-4ddc-bbbc-0947ce5ec3a4" \ diff --git a/shine-solana/shine/tools/temporary-pda-cleaner/.gitignore b/shine-solana/shine/tools/temporary-pda-cleaner/.gitignore deleted file mode 100644 index e7fd72e5..00000000 --- a/shine-solana/shine/tools/temporary-pda-cleaner/.gitignore +++ /dev/null @@ -1,7 +0,0 @@ -node_modules/ -target/ -*.json.bak -*.so -*pdas*.json -*keypair*.json -*-authority.json diff --git a/shine-solana/shine/tools/temporary-pda-cleaner/Cargo.toml b/shine-solana/shine/tools/temporary-pda-cleaner/Cargo.toml deleted file mode 100644 index eb82e742..00000000 --- a/shine-solana/shine/tools/temporary-pda-cleaner/Cargo.toml +++ /dev/null @@ -1,19 +0,0 @@ -[package] -name = "shine_users_pda_cleaner" -version = "0.1.0" -edition = "2021" -description = "Временная программа для закрытия PDA shine_users в devnet" - -[lib] -name = "shine_users" -crate-type = ["cdylib", "lib"] - -[dependencies] -solana-program = "2.1.21" - -[features] -default = [] -no-entrypoint = [] - -# Отдельный workspace: временный crate НЕ включается в основной Solana workspace. -[workspace] diff --git a/shine-solana/shine/tools/temporary-pda-cleaner/DELETE_AFTER_DEVNET_RESET.md b/shine-solana/shine/tools/temporary-pda-cleaner/DELETE_AFTER_DEVNET_RESET.md deleted file mode 100644 index bc9fd72b..00000000 --- a/shine-solana/shine/tools/temporary-pda-cleaner/DELETE_AFTER_DEVNET_RESET.md +++ /dev/null @@ -1,15 +0,0 @@ -# ⚠️ DEV ONLY — ОДНОРАЗОВАЯ ПАПКА. УДАЛИТЬ ПОСЛЕ ОЧИСТКИ - -**Назначение:** исключительно разработка, уничтожение ВСЕХ PDA `shine_users` **только в Solana devnet**. Не часть приложения и не предназначено для production/mainnet. - -Содержимое папки временно подменяет БАЙТКОД существующей тестовой Solana-программы `shine_users` под ТЕМ ЖЕ Program ID. Не путать с `App=test5592` — это тег Arweave, не Program ID. - -**Агенту:** -1. Отключить регистрацию/синхронизацию, удостовериться в devnet и полном праве upgrade authority. Прочитать `README_AGENT_RU.md` целиком. -2. Сделать snapshot PDA, проверить список адресов и возвраты, затем временно обновить программу, закрыть PDA по одному на devnet (невозвратимо). -3. СРАЗУ восстановить ОФИЦИАЛЬНЫЙ `shine_users` из этого патча, подтвердить работоспособность; проинициализировать economy и namespaces заново. -4. После успешной проверки **УДАЛИТЬ ВСЮ ЭТУ ПАПКУ** `shine-solana/shine/tools/temporary-pda-cleaner/` из рабочего проекта, а не только .so-файл. Не включать её в будущие production-сборки, развёртывания, Git-коммиты или release ZIP. - -Не оставлять временный контракт установленным после операции. Восстановление исходной программы в devnet — обязательный отдельный шаг. - -**Не трогать:** Solana Program ID, mainnet, реальные данные пользователей, Arweave DataItem. Удаление PDA не стирает опубликованные записи Arweave. diff --git a/shine-solana/shine/tools/temporary-pda-cleaner/README_AGENT_RU.md b/shine-solana/shine/tools/temporary-pda-cleaner/README_AGENT_RU.md deleted file mode 100644 index 5469f36f..00000000 --- a/shine-solana/shine/tools/temporary-pda-cleaner/README_AGENT_RU.md +++ /dev/null @@ -1,151 +0,0 @@ -> **⛔ РАЗОВАЯ DEV-ПРОЦЕДУРА. ПОСЛЕ УСПЕШНОГО DEVNET RESET УДАЛИТЬ ПАПКУ `shine-solana/shine/tools/temporary-pda-cleaner/` ИЗ ПРОЕКТА. НИКОГДА НЕ ДЕПЛОИТЬ В MAINNET.** - -# SHiNE — временная очистка PDA `shine_users` (ТОЛЬКО DEVNET) - -**Статус:** исходники и сценарий для агента; на реальном devnet ничего не запускалось. **Деструктивная процедура.** - -## Ключевой принцип - -Это НЕ новая программа с новым адресом. Папка содержит **временную замену байткода существующей программы** `shine_users` под **тем же** Program ID: - -`SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6` - -Программа с другим Program ID **не может закрыть** старые PDA, которыми владеет существующая программа. Для очистки требуется текущая `upgrade authority` этого Program ID. Устанавливать новую программу с новым ID ради очистки нельзя. - -**Работать исключительно с devnet.** Временная программа сама не умеет проверить сеть (у программ нет безопасного способа прочитать genesis hash), поэтому оператор ОБЯЗАН до deploy проверить RPC и адрес. Скрипт `cleaner.mjs` отдельно проверяет реальный genesis hash devnet при КАЖДОМ запуске. - -## Что закрываем и куда идут SOL - -`getProgramAccounts(shine_users)` находит ВСЕ аккаунты, которыми владеет программа, в том числе: - -- пользовательские PDA (включая разные версии формата); -- PDA namespaces; -- `users_economy_config` PDA; -- другие вспомогательные аккаунты программы, если они существуют. - -Временная инструкция `close` допускает **только текущую upgrade authority из ProgramData**, проверенную на цепочке. Получатель средств — **этот же кошелёк**, его нельзя подменить. В каждом вызове закрывается ровно один PDA. Возвращается **весь баланс lamports на PDA**. Это может быть не тот кошелёк, который первоначально оплачивал размещение данных. - -**Не закрываем:** исполняемый Program account, ProgramData, PDA программ `shine_payments`, `shine_login_guard` и любые чужие аккаунты. После очистки Program ID остаётся прежним. - -## Перед началом — обязательно - -1. Убедиться, что это тестовые данные, которые можно безвозвратно уничтожить. Остановить регистрацию и фоновую синхронизацию `shine_users`, которая может создавать PDA. -2. Сохранить текущий исходник и байткод развернутой программы, программу **полного обновления** из последнего патча и документировать текущие адреса. -3. Убедиться, что `solana program show -u devnet ` выводит **Upgradeable Program** и правильную `Upgrade Authority` (а не `None`). Если authority отсутствует — остановиться. -4. Перед операцией переключить Solana CLI на devnet, **но команды ниже всё равно всегда передают `-u devnet` явно**. Ключ authority никуда не копировать и не добавлять в Git. -5. Если PDA находятся не в devnet, этот скрипт НЕ использовать; никаких автоматических попыток на mainnet. - -## Шаг 1 — проверить живую программу и сохранить состояние - -```bash -PROGRAM_ID=SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6 -AUTHORITY_JSON=/absolute/private/path/upgrade-authority.json -solana -u devnet program show "$PROGRAM_ID" -solana -u devnet program dump "$PROGRAM_ID" ./shine_users_before_clean.so -solana-keygen pubkey "$AUTHORITY_JSON" -``` - -Нужно вручную сверить authority адрес из `program show` с адресом из `solana-keygen pubkey`. - -## Шаг 2 — до обновления программы сформировать снимок PDA - -Запускать из директории `scripts/`: - -```bash -npm install -node cleaner.mjs inspect \ - --authority "$(solana-keygen pubkey "$AUTHORITY_JSON")" \ - --manifest ./devnet-pdas-before-clean.json -``` - -В снимке видны адреса и возвращаемые lamports; осмотреть **каждый** PDA. Если PDA больше 100, скрипт останавливается, пока вы не разберётесь почему. НЕ размещать снимок, ключи и приватные данные в публичных репозиториях. - -## Шаг 3 — собрать временную программу - -Из папки `temporary-pda-cleaner/`: - -```bash -cargo build-sbf -``` - -Результат: `target/deploy/shine_users.so`. Сборка требует Solana SBF toolchain; просто `cargo build` не подходит для deploy. Компиляция не проверялась в окружении подготовки архива, где Solana/Rust toolchain отсутствует. - -## Шаг 4 — временно обновить **существующую** программу - -**Сверить кластер!** Эта операция оставляет систему без обычной регистрации до восстановления основного байткода. - -```bash -solana -u devnet program deploy \ - --program-id "$PROGRAM_ID" \ - --upgrade-authority "$AUTHORITY_JSON" \ - ./target/deploy/shine_users.so - -solana -u devnet program show "$PROGRAM_ID" -``` - -Если Solana CLI требует ключ программы, использовать исходный program-id keypair из безопасного хранилища, а не генерировать новый. Команду подстроить под установленную версию CLI, не подменяя ID. - -## Шаг 5 — удалить PDA по одному, с проверками - -Из `scripts/`, только после осмотра снимка и шага 4: - -```bash -node cleaner.mjs execute \ - --manifest ./devnet-pdas-before-clean.json \ - --keypair "$AUTHORITY_JSON" \ - --confirm <КОЛИЧЕСТВО_ИЗ_СНИМКА> \ - --i-understand-irreversible - -node cleaner.mjs verify -``` - -Скрипт: - -- проверяет *genesis hash* devnet, Program ID, ProgramData и реальную upgrade authority; -- сверяет PDA с заранее сохранённым снимком (включая SOL); -- перед каждой транзакцией выполняет `simulateTransaction`; -- подтверждает транзакцию и отсутствие PDA по RPC; -- при прерывании допускает повторный `execute`: уже закрытые PDA пропускаются; -- в конце требует **ноль** оставшихся PDA в `shine_users`. - -Если возвращается ошибка, **остановиться** и разобраться. Не менять автоматически списки PDA, адрес кошелька или фильтры. - -## Шаг 6 — немедленно восстановить нормальный контракт - -**Восстанавливать надо НОВУЮ версию из актуального проекта после CASE_INSENSITIVE_LOGIN_PATCH**, а не устаревший байткод из `before_clean` (тот файл только для аварийного отката и диагностики). - -```bash -# В каталоге АКТУАЛЬНОЙ штатной программы из проекта: -cargo build-sbf -solana -u devnet program deploy \ - --program-id "$PROGRAM_ID" \ - --upgrade-authority "$AUTHORITY_JSON" \ - ./target/deploy/shine_users.so -solana -u devnet program show "$PROGRAM_ID" -``` - -После восстановление обязательно удостовериться, что программа отличается от временной и **не принимает** инструкцию `0x01` в формате временного контракта как команду на закрытие произвольного PDA. В актуальной штатной `shine_users` инструкция `0x01` означает инициализацию экономического PDA, а не очистку. - -## Шаг 7 — переинициализировать чистую систему - -- Применить новую серверную схему PostgreSQL; НЕ восстанавливать старую базу. -- Инициализировать `users_economy_config` и создать namespace PDA заново штатными командами/экраном проекта. -- Синхронизатор Solana запустить после проверки валидного кода и PDA. -- Проверить: `SuperMan@free` регистрируется; `superman@free` повторно не регистрируется; PDA вычисляется из lowercase; внутри PDA остаётся оригинальный регистр; переход из Arweave в Solana работает; лайки и ответы работают. -- Проверить, что в исходном коде UI, сервера и Rust **одинаковый Program ID**. - -## Не путать с Arweave `App=test5592` - -`test5591 → test5592` — смена **тестового тега Arweave** (`App`), а не Solana Program ID. Временная программа и штатный `shine_users` используют тот же Program ID, остальные Solana-адреса программы не меняются. Arweave-данные с предыдущим App остаются в сети, но сервер новой эпохи их не импортирует. - -## Удаление этой папки после работ - -После проверки того, что **штатный смарт-контракт восстановлен**, devnet PDA очищены и новые тестовые регистрации работают: удалить весь каталог `shine-solana/shine/tools/temporary-pda-cleaner/` из дерева проекта и из будущих release artifacts. Сам проект (UI/Java/настоящий контракт) после этого будет продолжать работать. - -## Ограничения и безопасность - -- Ни один реальный PDA здесь не удалён; on-chain вызовы, компиляция и деплой не выполнялись. -- Это техническая заготовка, обязательны предварительная ручная проверка кода агентом и тест на localnet/devnet. Нельзя запускать на mainnet. -- **Программа удаления очень опасна, пока развернута:** не оставлять её на сети после очистки. -- `getProgramAccounts` может быть недоступен на публичном RPC из-за лимитов: использовать devnet RPC с поддержкой метода. Не обходить предохранители отключением проверок. -- PDA других программ, записи Arweave, внешние хранилища и PostgreSQL этой процедурой не очищаются. diff --git a/shine-solana/shine/tools/temporary-pda-cleaner/scripts/cleaner.mjs b/shine-solana/shine/tools/temporary-pda-cleaner/scripts/cleaner.mjs deleted file mode 100644 index 53450ad1..00000000 --- a/shine-solana/shine/tools/temporary-pda-cleaner/scripts/cleaner.mjs +++ /dev/null @@ -1,118 +0,0 @@ -#!/usr/bin/env node -// Временная очистка PDA shine_users. Только devnet, всегда проверять genesis hash. -// Никогда не добавляйте приватный ключ или файл keypair в git/архив. -import { Connection, PublicKey, Keypair, Transaction, TransactionInstruction, sendAndConfirmTransaction, BPF_LOADER_UPGRADEABLE_PROGRAM_ID } from '@solana/web3.js'; -import { readFileSync, writeFileSync, existsSync } from 'node:fs'; - -const PROGRAM_ID = new PublicKey('SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6'); -const DEVNET_GENESIS = 'EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG'; -const RPC = 'https://api.devnet.solana.com'; -const MAX_ACCOUNTS = 100; // Защита от случайной массовой очистки. -const usage = ` -Команды: - node cleaner.mjs inspect --authority --manifest - node cleaner.mjs execute --manifest --keypair --confirm --i-understand-irreversible - node cleaner.mjs verify -Все команды работают ТОЛЬКО с devnet и с фиксированным Program ID: ${PROGRAM_ID.toBase58()} -`; -function arg(name) { - const i = process.argv.indexOf(name); - return i < 0 ? undefined : process.argv[i + 1]; -} -function fatal(msg) { throw new Error(msg); } -const command = process.argv[2]; -if (!['inspect', 'execute', 'verify'].includes(command)) { console.log(usage); process.exit(2); } -const c = new Connection(RPC, 'confirmed'); - -async function checkNetworkAndProgram() { - const genesis = await c.getGenesisHash(); - if (genesis !== DEVNET_GENESIS) fatal(`ОПАСНО: RPC не devnet: ${genesis}`); - const p = await c.getAccountInfo(PROGRAM_ID, 'confirmed'); - if (!p?.executable || !p.owner.equals(BPF_LOADER_UPGRADEABLE_PROGRAM_ID)) fatal('Программа не является upgradeable loader-v3. Остановка.'); - if (p.data.length < 36 || p.data.readUInt32LE(0) !== 2) fatal('Неверный loader-v3 Program account'); - const programdata = new PublicKey(p.data.subarray(4, 36)); - const pd = await c.getAccountInfo(programdata, 'confirmed'); - if (!pd || !pd.owner.equals(BPF_LOADER_UPGRADEABLE_PROGRAM_ID) || pd.data.length < 45 || pd.data.readUInt32LE(0) !== 3 || pd.data[12] !== 1) { - fatal('ProgramData не содержит активную upgrade authority'); - } - const authority = new PublicKey(pd.data.subarray(13, 45)); - return { programdata, authority }; -} -async function listOwned() { - // dataSlice устраняет скачивание всех данных PDA, получаем адрес и lamports. - const a = await c.getProgramAccounts(PROGRAM_ID, { commitment: 'confirmed', dataSlice: { offset: 0, length: 0 } }); - return a.map(x => ({ address: x.pubkey.toBase58(), lamports: x.account.lamports })) - .sort((x, y) => x.address.localeCompare(y.address)); -} -async function main() { - const { programdata, authority } = await checkNetworkAndProgram(); - const rows = await listOwned(); - console.log(`Devnet OK; Program=${PROGRAM_ID}; authority=${authority}; PDA=${rows.length}; SOL=${rows.reduce((s,x)=>s+x.lamports,0)/1e9}`); - if (rows.length > MAX_ACCOUNTS) fatal(`Найдено больше ${MAX_ACCOUNTS} PDA; скрипт намеренно прекращает работу.`); - if (command === 'verify') { - if (rows.length !== 0) fatal(`Осталось ${rows.length} PDA: ${rows.map(x => x.address).join(', ')}`); - console.log('OK: пользовательских и конфигурационных аккаунтов, принадлежащих программе, нет.'); - return; - } - if (command === 'inspect') { - const ownerString = arg('--authority'); - if (!ownerString) fatal('Укажите --authority с публичным адресом владельца.'); - if (!new PublicKey(ownerString).equals(authority)) fatal('Указанный владелец не является upgrade authority.'); - const manifest = arg('--manifest'); - if (!manifest || existsSync(manifest)) fatal('Укажите новый --manifest путь (не перезаписываем существующий файл).'); - const snapshot = { - purpose: 'destructive-devnet-shine-users-cleanup', genesis: DEVNET_GENESIS, - program: PROGRAM_ID.toBase58(), authority: authority.toBase58(), programdata: programdata.toBase58(), - createdAtUtc: new Date().toISOString(), accounts: rows, - }; - writeFileSync(manifest, JSON.stringify(snapshot, null, 2) + '\n', { flag: 'wx', mode: 0o600 }); - console.log('План сохранён:', manifest); - for (const row of rows) console.log(`${row.address} ${(row.lamports / 1e9).toFixed(9)} SOL`); - console.log('Проверьте список и суммы перед деплоем временной программы и перед execute.'); - return; - } - if (command === 'execute') { - if (!process.argv.includes('--i-understand-irreversible')) fatal('Требуется --i-understand-irreversible'); - const path = arg('--manifest'); - const keypath = arg('--keypair'); - if (!path || !keypath) fatal('Нужны --manifest и --keypair'); - const m = JSON.parse(readFileSync(path, 'utf8')); - const wallet = Keypair.fromSecretKey(Uint8Array.from(JSON.parse(readFileSync(keypath, 'utf8')))); - if (!wallet.publicKey.equals(authority)) fatal('Файл keypair не совпадает с текущей upgrade authority'); - if (m.purpose !== 'destructive-devnet-shine-users-cleanup' || m.genesis !== DEVNET_GENESIS || m.program !== PROGRAM_ID.toBase58() || m.programdata !== programdata.toBase58() || m.authority !== authority.toBase58()) fatal('План создан для другой сети, программы или владельца'); - if (!Array.isArray(m.accounts) || new Set(m.accounts.map(x=>x.address)).size !== m.accounts.length || m.accounts.length > MAX_ACCOUNTS) fatal('Неверный список PDA в плане'); - if (String(m.accounts.length) !== arg('--confirm')) fatal(`Неверный --confirm, должно быть ${m.accounts.length}`); - const currentByKey = new Map(rows.map(x => [x.address, x.lamports])); - const expectedByKey = new Map(m.accounts.map(x => [x.address, x.lamports])); - for (const row of rows) { - if (!expectedByKey.has(row.address) || row.lamports !== expectedByKey.get(row.address)) fatal('Состояние devnet отличается от плана: ' + row.address); - } - // Часть PDA может быть уже закрыта после сбоя связи: пропускаем только исчезнувшие. - const pending = m.accounts.filter(x => currentByKey.has(x.address)); - console.log(`Подтверждено ${m.accounts.length} PDA, осталось закрыть ${pending.length}.`); - for (const [i, item] of pending.entries()) { - const target = new PublicKey(item.address); - const ix = new TransactionInstruction({ - programId: PROGRAM_ID, - keys: [ - { pubkey: authority, isSigner: true, isWritable: true }, - { pubkey: PROGRAM_ID, isSigner: false, isWritable: false }, - { pubkey: programdata, isSigner: false, isWritable: false }, - { pubkey: target, isSigner: false, isWritable: true }, - ], - data: Buffer.from([1]), - }); - const tx = new Transaction().add(ix); - const sim = await c.simulateTransaction(tx, [wallet]); - if (sim.value.err) fatal(`Симуляция НЕ прошла для ${item.address}: ${JSON.stringify(sim.value.err)} ${JSON.stringify(sim.value.logs)}`); - const signature = await sendAndConfirmTransaction(c, tx, [wallet], { commitment: 'confirmed', maxRetries: 3 }); - const after = await c.getAccountInfo(target, 'confirmed'); - if (after) fatal(`Транзакция ${signature} подтверждена, но ${item.address} ещё существует. Остановка.`); - console.log(`[${i+1}/${pending.length}] ЗАКРЫТО ${item.address}; +${item.lamports/1e9} SOL → ${authority.toBase58()}; tx=${signature}`); - } - const remaining = await listOwned(); - if (remaining.length) fatal(`После очистки осталось ${remaining.length} аккаунтов`); - console.log('УСПЕХ: PDA shine_users отсутствуют. СРОЧНО ВОССТАНОВИТЕ ШТАТНЫЙ СМАРТ-КОНТРАКТ.'); - } -} -main().catch(e => { console.error('ОШИБКА:', e.message); process.exitCode = 1; }); diff --git a/shine-solana/shine/tools/temporary-pda-cleaner/scripts/package.json b/shine-solana/shine/tools/temporary-pda-cleaner/scripts/package.json deleted file mode 100644 index a11bba9a..00000000 --- a/shine-solana/shine/tools/temporary-pda-cleaner/scripts/package.json +++ /dev/null @@ -1,14 +0,0 @@ -{ - "name": "shine-users-devnet-cleaner-cli", - "private": true, - "type": "module", - "version": "0.1.0", - "scripts": { - "inspect": "node cleaner.mjs inspect", - "execute": "node cleaner.mjs execute", - "verify": "node cleaner.mjs verify" - }, - "dependencies": { - "@solana/web3.js": "^1.98.0" - } -} diff --git a/shine-solana/shine/tools/temporary-pda-cleaner/src/lib.rs b/shine-solana/shine/tools/temporary-pda-cleaner/src/lib.rs deleted file mode 100644 index 88ec3d3d..00000000 --- a/shine-solana/shine/tools/temporary-pda-cleaner/src/lib.rs +++ /dev/null @@ -1,91 +0,0 @@ -//! ВРЕМЕННАЯ ОПАСНАЯ ПРОГРАММА. Только для полной очистки тестовых PDA shine_users. -//! Не использовать в mainnet. После очистки ОБЯЗАТЕЛЬНО вернуть штатную программу. -//! -//! Важно: программа деплоится как UPGRADE ПОД ТЕМ ЖЕ Program ID. -//! Отдельный Program ID НЕ МОЖЕТ списывать lamports с PDA старой программы. - -use solana_program::{ - account_info::{next_account_info, AccountInfo}, - bpf_loader_upgradeable, - entrypoint, - entrypoint::ProgramResult, - program_error::ProgramError, - pubkey::Pubkey, -}; - -solana_program::declare_id!("SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6"); -entrypoint!(process_instruction); - -// [1] CLOSE_ONE: [authority signer writable, executable program readonly, -// ProgramData readonly, PDA writable]. -const CLOSE_ONE: u8 = 1; - -fn process_instruction( - program_id: &Pubkey, - accounts: &[AccountInfo], - data: &[u8], -) -> ProgramResult { - if *program_id != crate::id() || data != [CLOSE_ONE] { - return Err(ProgramError::InvalidInstructionData); - } - - let mut it = accounts.iter(); - let authority = next_account_info(&mut it)?; - let program = next_account_info(&mut it)?; - let programdata = next_account_info(&mut it)?; - let target = next_account_info(&mut it)?; - if it.next().is_some() { - return Err(ProgramError::InvalidArgument); - } - - // Подписант и получатель lamports — ОДИН аккаунт, всегда upgrade authority. - if !authority.is_signer || !authority.is_writable || authority.key == target.key { - return Err(ProgramError::MissingRequiredSignature); - } - if !target.is_writable || target.executable || target.owner != program_id { - return Err(ProgramError::InvalidAccountOwner); - } - - // Проверяем upgrade authority НАСТОЯЩЕЙ программы по состоянию loader-v3. - if program.key != program_id - || !program.executable - || program.owner != &bpf_loader_upgradeable::id() - || programdata.owner != &bpf_loader_upgradeable::id() - { - return Err(ProgramError::IncorrectProgramId); - } - { - let p = program.try_borrow_data()?; - // UpgradeableLoaderState::Program: u32=2, затем адрес ProgramData (32 байта). - if p.len() < 36 || p[..4] != 2u32.to_le_bytes() || p[4..36] != programdata.key.to_bytes() { - return Err(ProgramError::InvalidAccountData); - } - } - { - let p = programdata.try_borrow_data()?; - // UpgradeableLoaderState::ProgramData: u32=3; slot u64; option=1; authority pubkey. - if p.len() < 45 - || p[..4] != 3u32.to_le_bytes() - || p[12] != 1 - || p[13..45] != authority.key.to_bytes() - { - return Err(ProgramError::MissingRequiredSignature); - } - } - - let amount = target.lamports(); - if amount == 0 { - return Err(ProgramError::UninitializedAccount); - } - // Только программа-владелец списывает lamports с target. - // Сумма полностью поступает authority; исторический плательщик может быть другим. - { - let new_balance = authority.lamports() - .checked_add(amount) - .ok_or(ProgramError::ArithmeticOverflow)?; - **authority.try_borrow_mut_lamports()? = new_balance; - } - **target.try_borrow_mut_lamports()? = 0; - target.realloc(0, false)?; - Ok(()) -} From ab61787ee7c328abb2a03132a624847a93b8ea0596b3e929c4e382d78d727e2b Mon Sep 17 00:00:00 2001 From: AidarKC Date: Wed, 28 Oct 2026 12:51:43 +0300 Subject: [PATCH 08/82] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2?= =?UTF-8?q?=D0=B8=D1=82=D1=8C=20=D1=87=D0=B8=D1=81=D1=82=D1=8B=D0=B9=20?= =?UTF-8?q?=D1=81=D1=82=D0=B0=D1=80=D1=82=20PostgreSQL=20=D0=B8=20Solana?= =?UTF-8?q?=20sync?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../src/main/resources/postgres/migration_v36.sql | 4 +++- SHiNE-server/src/main/java/server/ws/WsServer.java | 10 +++++++++- VERSION.properties | 2 +- deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md | 4 ++-- docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md | 2 +- 5 files changed, 16 insertions(+), 6 deletions(-) diff --git a/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v36.sql b/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v36.sql index a0dc99af..f28cbe8e 100644 --- a/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v36.sql +++ b/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v36.sql @@ -42,7 +42,9 @@ BEGIN 'user_settings:login', 'channel_read_state:viewer_login', 'test_free_avatar_uploads:login', - 'blockchain_state:login', + -- blockchain_state — compatibility view; trigger может существовать + -- только на физической таблице хранения. + 'blockchain_state_store:login', 'user_stats_state:login', 'user_push_tokens:login', 'key_rotation_sessions:login' diff --git a/SHiNE-server/src/main/java/server/ws/WsServer.java b/SHiNE-server/src/main/java/server/ws/WsServer.java index 1c7abac7..2cb16c2d 100644 --- a/SHiNE-server/src/main/java/server/ws/WsServer.java +++ b/SHiNE-server/src/main/java/server/ws/WsServer.java @@ -19,6 +19,7 @@ import server.sync.PeriodicDmDeliveryService; import server.sync.SolanaUsersSyncStartupService; import server.sync.SyncServersBootstrapService; import server.sync.ServerConnectionPool; +import shine.db.DbController; import utils.config.AppConfig; import java.time.Duration; @@ -35,7 +36,14 @@ public final class WsServer { public static void main(String[] args) throws Exception { // ============================================================ - // 1.0) Синхронизация пользовательских Solana PDA + // 1.0) Сначала создаём полную runtime-схему SHiNE. + // Solana sync использует ту же БД и создаёт собственные таблицы; + // без этого порядка чистая БД ошибочно выглядит для runtime как legacy. + // ============================================================ + DbController.getInstance(); + + // ============================================================ + // 1.1) Синхронизация пользовательских Solana PDA // ============================================================ SolanaUsersSyncStartupService.startOrThrow(); diff --git a/VERSION.properties b/VERSION.properties index 8238bb43..b9386650 100644 --- a/VERSION.properties +++ b/VERSION.properties @@ -1,2 +1,2 @@ client.version=1.20.6 -server.version=1.16.4 +server.version=1.16.5 diff --git a/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md b/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md index 9c490a34..0dc57d3b 100644 --- a/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md +++ b/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md @@ -5,7 +5,7 @@ ## Что уже есть -- основной сервер запускает `SolanaUsersSyncStartupService` до продолжения startup; +- основной сервер сначала инициализирует полную PostgreSQL runtime-схему SHiNE, затем запускает `SolanaUsersSyncStartupService` до продолжения startup; - модуль синхронизации держит актуальными таблицы: - `solana_sync_state` - `solana_sync_tx_history` @@ -56,7 +56,7 @@ psql \ -f SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql ``` -Скрипт предназначен **только для полностью пустой PostgreSQL схемы**. На старой/непустой базе он завершится ошибкой и не выполняет in-place migration. +Скрипт предназначен **только для полностью пустой PostgreSQL схемы**. На старой/непустой базе он завершится ошибкой и не выполняет in-place migration. При обычном первом запуске вручную выполнять его не нужно: сервер сам первым создаёт полную runtime-схему, и только затем стартует Solana sync; это не даёт sync-таблицам ошибочно выглядеть как legacy-БД. Скрипт: diff --git a/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md b/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md index 875f8e41..66e90926 100644 --- a/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md +++ b/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md @@ -17,7 +17,7 @@ На дату `2026-07-24` в основном сервере SHiNE уже есть серверная интеграция startup-уровня: -- сервер запускает sync-модуль до продолжения собственного startup; +- сервер сначала инициализирует полную PostgreSQL runtime-схему, затем запускает sync-модуль до продолжения собственного startup; - server startup ждёт входа модуля в состояние `READY`; - актуальный источник истины по пользователям для нового PostgreSQL runtime-слоя: `solana_user_pda_current`. - для быстрого локального lookup единственного сервера доступа поддерживается From 7b88b61b22249c4d490f410f962af3b3f980083069375440b2bd9993878856d6 Mon Sep 17 00:00:00 2001 From: AidarKC Date: Wed, 28 Oct 2026 19:00:46 +0300 Subject: [PATCH 09/82] =?UTF-8?q?=D0=A1=D0=BC=D0=B5=D0=BD=D0=B0=20=D0=BF?= =?UTF-8?q?=D0=B0=D1=80=D0=BE=D0=BB=D1=8F=20=D1=80=D0=B0=D0=B1=D0=BE=D1=82?= =?UTF-8?q?=D0=B0=D0=B5=D1=82:=20=D0=B2=D0=BE=D1=81=D1=81=D1=82=D0=B0?= =?UTF-8?q?=D0=BD=D0=BE=D0=B2=D0=B8=D1=82=D1=8C=20=D1=80=D0=BE=D1=82=D0=B0?= =?UTF-8?q?=D1=86=D0=B8=D1=8E=20=D0=BA=D0=BB=D1=8E=D1=87=D0=B5=D0=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Net_KeyRotationRotatePda_Handler.java | 13 ++++- VERSION.properties | 4 +- docs/API/19_Key_Rotation_API.md | 2 +- shine-UI/js/app.js | 15 ++++- shine-UI/js/pages/key-rotation-view.js | 48 ++++++++++------ shine-UI/js/services/key-rotation-service.js | 57 +++++++++++++++---- .../tests/key-rotation-resume-lock.test.mjs | 40 +++++++++++++ 7 files changed, 144 insertions(+), 35 deletions(-) create mode 100644 shine-UI/tests/key-rotation-resume-lock.test.mjs diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationRotatePda_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationRotatePda_Handler.java index 8ba85c3d..329122e1 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationRotatePda_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationRotatePda_Handler.java @@ -41,7 +41,18 @@ public final class Net_KeyRotationRotatePda_Handler implements JsonMessageHandle return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_NOT_ACTIVE", "Активная ротация отсутствует"); } - if (current.getStatus() == KeyRotationStatus.PDA_ROTATED) { + // Solana sync и rebuild работают независимо от уведомления клиента. + // При повторе после подтверждённой PDA возвращаем реальный этап, а не 409. + if (current.getStatus() == KeyRotationStatus.PDA_ROTATED + || current.getStatus() == KeyRotationStatus.REBUILDING_SERVER + || current.getStatus() == KeyRotationStatus.WALLET_MIGRATION + || current.getStatus() == KeyRotationStatus.MESSAGE_MIGRATION + || current.getStatus() == KeyRotationStatus.FINALIZING) { + String stored = current.getPdaRotationSignature(); + if (stored != null && !stored.isBlank() && !stored.equals(signature)) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_PDA_SIGNATURE_CONFLICT", + "Для этой ротации уже сохранена другая Solana transaction signature"); + } var fresh = CurrentUsersDAO.getInstance().getByLogin(login); if (fresh != null) ctx.setCurrentUser(fresh); return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), current); diff --git a/VERSION.properties b/VERSION.properties index b9386650..8e37a7f3 100644 --- a/VERSION.properties +++ b/VERSION.properties @@ -1,2 +1,2 @@ -client.version=1.20.6 -server.version=1.16.5 +client.version=1.20.7 +server.version=1.16.6 diff --git a/docs/API/19_Key_Rotation_API.md b/docs/API/19_Key_Rotation_API.md index afc7aa1d..6458ae1c 100644 --- a/docs/API/19_Key_Rotation_API.md +++ b/docs/API/19_Key_Rotation_API.md @@ -248,7 +248,7 @@ Если Solana sync успел увидеть новое PDA раньше вызова `KeyRotationRotatePda`, он умеет подтвердить ожидаемые ключи прямо из `CHAIN_READY`. Поэтому потеря клиентского запроса после уже подтверждённой Solana-транзакции не оставляет ротацию зависшей. Если API-вызов всё же приходит, handler идемпотентно возвращает текущее подтверждённое состояние. -Повтор с той же signature идемпотентен. Другая signature для уже начатого `ROTATING_PDA` возвращает conflict. +Повтор с той же signature идемпотентен: при `PDA_ROTATED`, `REBUILDING_SERVER`, `WALLET_MIGRATION`, `MESSAGE_MIGRATION` и `FINALIZING` возвращается актуальное состояние без ошибки 409. Это закрывает гонку Solana sync с уведомлением UI. Если signature ранее сохранена, конфликтующая signature возвращает conflict. ### Основные ошибки diff --git a/shine-UI/js/app.js b/shine-UI/js/app.js index 7c8a4842..b50d8c5d 100644 --- a/shine-UI/js/app.js +++ b/shine-UI/js/app.js @@ -1463,12 +1463,15 @@ function attachPageScrollToBottom(pageId, screen) { }); } +let keyRotationRouteLock = false; + async function redirectToActiveKeyRotationIfNeeded() { if (!state.session.isAuthorized || state.session.isLocalDemo) return false; try { const rotation = await new KeyRotationClient(authService).status(); const status = String(rotation?.rotationStatus || 'NONE'); - if (status !== 'NONE' && getRoute().pageId !== 'key-rotation-view') { + keyRotationRouteLock = status !== 'NONE' && status !== 'COMPLETE'; + if (keyRotationRouteLock && getRoute().pageId !== 'key-rotation-view') { navigate('key-rotation-view'); return true; } @@ -1479,6 +1482,11 @@ async function redirectToActiveKeyRotationIfNeeded() { } function renderApp() { + if (keyRotationRouteLock && state.session.isAuthorized && getRoute().pageId !== 'key-rotation-view') { + // Нельзя покинуть начатую ротацию через browser back, прямую ссылку или меню. + navigate('key-rotation-view'); + return; + } syncTrackedRouteHistory(window.location.pathname || '/'); const route = getRoute(); if (state.session.isAuthorized) { @@ -1666,6 +1674,7 @@ async function init() { }); setSessionResetHandler(() => { + keyRotationRouteLock = false; sessionRuntimeStarted = false; stopChannelsPrefetch(); startConnectionMonitor(); @@ -1677,6 +1686,10 @@ async function init() { navigate('start-view'); }); + window.addEventListener('shine-key-rotation-active', event => { + keyRotationRouteLock = Boolean(event.detail?.active); + }); + setSessionAuthorizedHandler(() => { void ensureSessionRuntimeStarted(); void processPendingCallPushActionIfPossible(); diff --git a/shine-UI/js/pages/key-rotation-view.js b/shine-UI/js/pages/key-rotation-view.js index 068d9080..46f0aed2 100644 --- a/shine-UI/js/pages/key-rotation-view.js +++ b/shine-UI/js/pages/key-rotation-view.js @@ -15,7 +15,14 @@ function input(label,type='password'){const wrap=document.createElement('label') export function render({navigate,chrome}){ const screen=document.createElement('section');screen.className='stack'; - chrome?.setTopbar(createTopBar({title:'Смена ключей',back:{label:'←',onClick:()=>navigate('access-keys-view')}})); + // До запуска смену можно закрыть; после старта выход назад запрещён. + function updateTopbar(status){ + const canExit=status==='NONE' || status==='COMPLETE'; + chrome?.setTopbar(createTopBar({title:'Смена ключей',...(canExit?{back:{label:'←',onClick:()=>navigate('access-keys-view')}}:{})})); + window.dispatchEvent(new CustomEvent('shine-key-rotation-active',{detail:{active:!canExit}})); + } + // Пока статус с сервера не прочитан, не разблокируем навигацию преждевременно. + chrome?.setTopbar(createTopBar({title:'Смена ключей'})); const root=document.createElement('div');root.className='stack';screen.append(root); const client=new KeyRotationClient(authService);let disposed=false;let timer=null;let cachedOldBundle=null;let cachedNewBundle=null; const login=String(state.session.login||'').trim(); const storagePwd=String(state.session.storagePwdInMemory||'').trim(); @@ -27,6 +34,7 @@ export function render({navigate,chrome}){ if(bundle.rootPair.publicKeyB64!==bytesToBase64(pda.rootKey) || bundle.blockchainPair.publicKeyB64!==bytesToBase64(pda.blockchain.blockchainPublicKey) || bundle.clientPair.publicKeyB64!==bytesToBase64(pda.clientKey)) throw new Error('Текущий пароль не соответствует ключам PDA'); } function setRoot(...nodes){root.replaceChildren(...nodes);} + function exitAfterComplete(){updateTopbar('COMPLETE');navigate('access-keys-view');} function statusCard(s){const card=document.createElement('div');card.className='card stack';card.innerHTML=`${h(stageText(s.rotationStatus))}${h(s.sourceBlockchainName||'')} → ${h(s.candidateBlockchainName||'')}Прогресс: ${Number(s.progressCurrent||0)} / ${Number(s.progressTotal||0)}${s.lastError?`${h(s.lastError)}`:''}`;return card;} function note(text){const c=document.createElement('div');c.className='card';c.textContent=text;return c;} @@ -42,12 +50,12 @@ export function render({navigate,chrome}){ more.addEventListener('click',()=>void load()); const start=document.createElement('button');start.className='primary-btn';start.type='button';start.textContent='Начать смену ключей'; const error=document.createElement('div');error.className='meta-muted'; - start.addEventListener('click',async()=>{start.disabled=true;error.textContent='';try{if(!selected)throw new Error('Выберите последний доверенный блок');if(!oldP.el.value||!newP.el.value)throw new Error('Введите текущий и новый пароль');if(newP.el.value!==new2.el.value)throw new Error('Новые пароли не совпадают');if(oldP.el.value===newP.el.value)throw new Error('Новый пароль должен отличаться');if(!window.confirm('После запуска все остальные сеансы этого аккаунта будут закрыты. Продолжить?')){start.disabled=false;return;}cachedOldBundle=await derive(oldP.el.value);await verifyOldPassword(cachedOldBundle);cachedNewBundle=await derive(newP.el.value);const stateNow=await client.start({newRootKey:cachedNewBundle.rootPair.publicKeyB64,newBlockchainKey:cachedNewBundle.blockchainPair.publicKeyB64,newClientKey:cachedNewBundle.clientPair.publicKeyB64,forkFromBlock:selected.blockNumber,forkFromHash:selected.blockHash,reasonCode:Number(reason.value),comment:comment.value});await runCopy(stateNow); }catch(e){error.textContent=e?.message||String(e);start.disabled=false;}}); + start.addEventListener('click',async()=>{start.disabled=true;error.textContent='';try{if(!selected)throw new Error('Выберите последний доверенный блок');if(!oldP.el.value||!newP.el.value)throw new Error('Введите текущий и новый пароль');if(newP.el.value!==new2.el.value)throw new Error('Новые пароли не совпадают');if(oldP.el.value===newP.el.value)throw new Error('Новый пароль должен отличаться');if(!window.confirm('После запуска все остальные сеансы этого аккаунта будут закрыты. Продолжить?')){start.disabled=false;return;}cachedOldBundle=await derive(oldP.el.value);await verifyOldPassword(cachedOldBundle);cachedNewBundle=await derive(newP.el.value);const stateNow=await client.start({newRootKey:cachedNewBundle.rootPair.publicKeyB64,newBlockchainKey:cachedNewBundle.blockchainPair.publicKeyB64,newClientKey:cachedNewBundle.clientPair.publicKeyB64,forkFromBlock:selected.blockNumber,forkFromHash:selected.blockHash,reasonCode:Number(reason.value),comment:comment.value});updateTopbar(stateNow.rotationStatus);await runCopy(stateNow); }catch(e){error.textContent=e?.message||String(e);start.disabled=false;}}); setRoot(head,oldP.wrap,newP.wrap,new2.wrap,reasonWrap,comment,list,more,start,error);void load(); } async function askNewPasswordAndCopy(s){ - const card=statusCard(s), p=input('Новый пароль');const go=document.createElement('button');go.className='primary-btn';go.textContent='Продолжить публикацию TECH_FORK';const err=document.createElement('div');err.className='meta-muted';go.addEventListener('click',async()=>{go.disabled=true;try{cachedNewBundle=await derive(p.el.value);if(cachedNewBundle.blockchainPair.publicKeyB64!==s.newBlockchainKey)throw new Error('Этот пароль выводит другой новый blockchain key');await runCopy(s);}catch(e){err.textContent=e?.message||e;go.disabled=false;}});const abort=document.createElement('button');abort.className='secondary-btn';abort.textContent='Прервать смену ключей';abort.addEventListener('click',async()=>{await client.abort();await refresh();});setRoot(card,note('Для продолжения на этом устройстве введите тот же новый пароль, который использовался при запуске.'),p.wrap,go,abort,err); + const card=statusCard(s), p=input('Новый пароль');const go=document.createElement('button');go.className='primary-btn';go.textContent='Продолжить публикацию TECH_FORK';const err=document.createElement('div');err.className='meta-muted';go.addEventListener('click',async()=>{go.disabled=true;try{cachedNewBundle=await derive(p.el.value);if(cachedNewBundle.blockchainPair.publicKeyB64!==s.newBlockchainKey)throw new Error('Этот пароль выводит другой новый blockchain key');await runCopy(s);}catch(e){err.textContent=e?.message||e;go.disabled=false;}});setRoot(card,note('Для продолжения введите новый пароль, использованный при начале ротации. Пока смена ключей активна, выйти из процедуры нельзя.'),p.wrap,go,err); } async function runCopy(s){ @@ -58,10 +66,10 @@ export function render({navigate,chrome}){ async function renderChainReady(s){ if(cachedOldBundle&&cachedNewBundle){ setRoot(statusCard(s),note('Новая цепочка готова. Ключи в Solana меняются автоматически в рамках той же процедуры.')); - try{await client.rotatePda({login,solanaEndpoint,oldBundle:cachedOldBundle,newBundle:cachedNewBundle,storagePwd});await refresh();return;}catch(e){root.append(note(e?.message||String(e)));} + try{const next=await client.rotatePda({login,solanaEndpoint,oldBundle:cachedOldBundle,newBundle:cachedNewBundle,storagePwd});if(next?.rotationStatus==='CHAIN_READY'){pollView(next);return;}await refresh();return;}catch(e){const latest=await client.status().catch(()=>null);if(latest?.rotationStatus!==s.rotationStatus&&latest?.rotationStatus){await refresh();return;}root.append(note(e?.message||String(e)));} } - const oldP=input('Текущий пароль');const newP=input('Новый пароль');const go=document.createElement('button');go.className='primary-btn';go.textContent='Продолжить смену ключей';const abort=document.createElement('button');abort.className='secondary-btn';abort.textContent='Прервать смену ключей';const err=document.createElement('div');err.className='meta-muted'; - go.addEventListener('click',async()=>{go.disabled=true;try{cachedOldBundle=await derive(oldP.el.value);cachedNewBundle=await derive(newP.el.value);await client.rotatePda({login,solanaEndpoint,oldBundle:cachedOldBundle,newBundle:cachedNewBundle,storagePwd});await refresh();}catch(e){err.textContent=e?.message||String(e);go.disabled=false;}});abort.addEventListener('click',async()=>{await client.abort();await refresh();});setRoot(statusCard(s),note('Процедура была перезапущена на другом этапе. Введите старый и новый пароль, чтобы продолжить автоматическую смену ключей в Solana.'),oldP.wrap,newP.wrap,go,abort,err); + const oldP=input('Текущий пароль');const newP=input('Новый пароль');const go=document.createElement('button');go.className='primary-btn';go.textContent='Продолжить смену ключей';const err=document.createElement('div');err.className='meta-muted'; + go.addEventListener('click',async()=>{go.disabled=true;try{const oldCandidate=await derive(oldP.el.value);const newCandidate=await derive(newP.el.value);const next=await client.rotatePda({login,solanaEndpoint,oldBundle:oldCandidate,newBundle:newCandidate,storagePwd});cachedOldBundle=oldCandidate;cachedNewBundle=newCandidate;if(next?.rotationStatus==='CHAIN_READY'){pollView(next);return;}await refresh();}catch(e){err.textContent=e?.message||String(e);go.disabled=false;void client.status().then(latest=>{if(latest.rotationStatus!==s.rotationStatus)void refresh();}).catch(()=>{});}});setRoot(statusCard(s),note('Введите старый и новый пароль. Мы восстановим ключи и продолжим существующую процедуру с актуального этапа.'),oldP.wrap,newP.wrap,go,err); } function pollView(s){setRoot(statusCard(s),note(s.rotationStatus==='REBUILDING_SERVER'?'Сервер перестраивает текущую рабочую историю по новому fork.':'Ожидаем подтверждение нового состояния PDA в Solana.'));timer=setTimeout(()=>void refresh(),POLL_MS);} @@ -86,10 +94,12 @@ export function render({navigate,chrome}){ }; const resolveBundles=async()=>{ - if(!cachedOldBundle){if(!oldP?.el.value)throw new Error('Введите старый пароль');cachedOldBundle=await derive(oldP.el.value);} - if(!cachedNewBundle){if(!newP?.el.value)throw new Error('Введите новый пароль');cachedNewBundle=await derive(newP.el.value);} - if(String(cachedOldBundle?.blockchainPair?.publicKeyB64||'')!==String(s.oldBlockchainKey||''))throw new Error('Старый пароль выводит другой blockchain key'); - if(String(cachedNewBundle?.blockchainPair?.publicKeyB64||'')!==String(s.newBlockchainKey||''))throw new Error('Новый пароль выводит другой blockchain key'); + const oldCandidate=cachedOldBundle||(oldP?.el.value?await derive(oldP.el.value):null); + const newCandidate=cachedNewBundle||(newP?.el.value?await derive(newP.el.value):null); + if(!oldCandidate||!newCandidate)throw new Error('Введите старый и новый пароли'); + if(String(oldCandidate.blockchainPair?.publicKeyB64||'')!==String(s.oldBlockchainKey||''))throw new Error('Старый пароль выводит другой blockchain key'); + if(String(newCandidate.blockchainPair?.publicKeyB64||'')!==String(s.newBlockchainKey||''))throw new Error('Новый пароль выводит другой blockchain key'); + cachedOldBundle=oldCandidate;cachedNewBundle=newCandidate; }; const prepareWallets=async()=>{ @@ -119,12 +129,12 @@ export function render({navigate,chrome}){ }catch(e){err.textContent=e?.message||String(e);transfer.disabled=false;skip.disabled=false;}finally{refreshBalance.disabled=false;}}); continueButton.addEventListener('click',async()=>{continueButton.disabled=true;refreshBalance.disabled=true;err.textContent='';try{ const next=await client.continueRotation({walletMigrationStatus:'COMPLETE'}); - if(String(next?.rotationStatus||'')==='COMPLETE'){navigate('access-keys-view');return;} + if(String(next?.rotationStatus||'')==='COMPLETE'){exitAfterComplete();return;} await refresh(); }catch(e){err.textContent=e?.message||String(e);continueButton.disabled=false;refreshBalance.disabled=false;}}); skip.addEventListener('click',async()=>{skip.disabled=true;transfer.disabled=true;refreshBalance.disabled=true;err.textContent='';try{ const next=await client.continueRotation({walletMigrationStatus:'SKIPPED'}); - if(String(next?.rotationStatus||'')==='COMPLETE'){navigate('access-keys-view');return;} + if(String(next?.rotationStatus||'')==='COMPLETE'){exitAfterComplete();return;} await refresh(); }catch(e){err.textContent=e?.message||String(e);skip.disabled=false;transfer.disabled=!oldWallet;refreshBalance.disabled=false;}}); @@ -140,10 +150,12 @@ export function render({navigate,chrome}){ const go=document.createElement('button');go.className='primary-btn';go.type='button';go.textContent='Продолжить перешифрование'; const err=document.createElement('div');err.className='meta-muted'; const resolveBundles=async()=>{ - if(!cachedOldBundle){if(!oldP?.el.value)throw new Error('Введите старый пароль');cachedOldBundle=await derive(oldP.el.value);} - if(!cachedNewBundle){if(!newP?.el.value)throw new Error('Введите новый пароль');cachedNewBundle=await derive(newP.el.value);} - if(String(cachedOldBundle?.clientPair?.publicKeyB64||'')!==String(s.oldClientKey||''))throw new Error('Старый пароль выводит другой client key'); - if(String(cachedNewBundle?.clientPair?.publicKeyB64||'')!==String(s.newClientKey||''))throw new Error('Новый пароль выводит другой client key'); + const oldCandidate=cachedOldBundle||(oldP?.el.value?await derive(oldP.el.value):null); + const newCandidate=cachedNewBundle||(newP?.el.value?await derive(newP.el.value):null); + if(!oldCandidate||!newCandidate)throw new Error('Введите старый и новый пароли'); + if(String(oldCandidate.clientPair?.publicKeyB64||'')!==String(s.oldClientKey||''))throw new Error('Старый пароль выводит другой client key'); + if(String(newCandidate.clientPair?.publicKeyB64||'')!==String(s.newClientKey||''))throw new Error('Новый пароль выводит другой client key'); + cachedOldBundle=oldCandidate;cachedNewBundle=newCandidate; }; const run=async()=>{ go.disabled=true;err.textContent='';await resolveBundles(); @@ -172,7 +184,7 @@ export function render({navigate,chrome}){ } } const next=await client.continueRotation({}); - if(String(next?.rotationStatus||'')==='COMPLETE'){navigate('access-keys-view');return;} + if(String(next?.rotationStatus||'')==='COMPLETE'){exitAfterComplete();return;} await refresh(); }; go.addEventListener('click',()=>void run().catch(e=>{err.textContent=e?.message||String(e);go.disabled=false;})); @@ -180,6 +192,6 @@ export function render({navigate,chrome}){ if(cachedOldBundle&&cachedNewBundle)void run().catch(e=>{err.textContent=e?.message||String(e);go.disabled=false;}); } - async function refresh(){if(disposed)return;if(timer){clearTimeout(timer);timer=null;}try{const s=await client.status();const st=String(s.rotationStatus||'NONE');if(st==='NONE'){await renderNone();return;}if(st==='COPYING_CHAIN'){if(cachedNewBundle)await runCopy(s);else await askNewPasswordAndCopy(s);return;}if(st==='CHAIN_READY'){await renderChainReady(s);return;}if(['ROTATING_PDA','PDA_ROTATED','REBUILDING_SERVER'].includes(st)){pollView(s);return;}if(st==='WALLET_MIGRATION'){await renderWalletMigration(s);return;}if(st==='MESSAGE_MIGRATION'){await renderMessageMigration(s);return;}if(st==='FINALIZING'){const next=await client.continueRotation({});if(String(next?.rotationStatus||'')==='COMPLETE'){navigate('access-keys-view');return;}await refresh();return;}if(st==='COMPLETE'){setRoot(note('Смена ключей завершена.'));return;}setRoot(note(`Неизвестное состояние ротации: ${st}`));}catch(e){setRoot(note(`Не удалось прочитать состояние смены ключей: ${e?.message||e}`));}} + async function refresh(){if(disposed)return;if(timer){clearTimeout(timer);timer=null;}try{const s=await client.status();const st=String(s.rotationStatus||'NONE');updateTopbar(st);if(st==='NONE'){await renderNone();return;}if(st==='COPYING_CHAIN'){if(cachedNewBundle)await runCopy(s);else await askNewPasswordAndCopy(s);return;}if(st==='CHAIN_READY'){await renderChainReady(s);return;}if(['ROTATING_PDA','PDA_ROTATED','REBUILDING_SERVER'].includes(st)){pollView(s);return;}if(st==='WALLET_MIGRATION'){await renderWalletMigration(s);return;}if(st==='MESSAGE_MIGRATION'){await renderMessageMigration(s);return;}if(st==='FINALIZING'){const next=await client.continueRotation({});if(String(next?.rotationStatus||'')==='COMPLETE'){exitAfterComplete();return;}await refresh();return;}if(st==='COMPLETE'){setRoot(note('Смена ключей завершена.'),Object.assign(document.createElement('button'),{className:'primary-btn',textContent:'Вернуться в настройки ключей',onclick:exitAfterComplete}));return;}setRoot(note(`Неизвестное состояние ротации: ${st}`));}catch(e){const retry=document.createElement('button');retry.type='button';retry.className='primary-btn';retry.textContent='Повторить проверку и продолжить';retry.addEventListener('click',()=>void refresh());setRoot(note(`Не удалось прочитать состояние смены ключей: ${e?.message||e}. Не начинайте новую ротацию — восстановим текущую.`),retry);timer=setTimeout(()=>void refresh(),5000);}} void refresh();screen.cleanup=()=>{disposed=true;if(timer)clearTimeout(timer);};return screen; } diff --git a/shine-UI/js/services/key-rotation-service.js b/shine-UI/js/services/key-rotation-service.js index a8f61961..71057adf 100644 --- a/shine-UI/js/services/key-rotation-service.js +++ b/shine-UI/js/services/key-rotation-service.js @@ -1,6 +1,6 @@ import { createAns104DataItem, createAns104DataItemWithRawParts, parseAns104DataItem } from './ans104-data-item.js'; import { base64ToBytes, bytesToBase64 } from './crypto-utils.js'; -import { updateShineUserPdaOnSolana } from './shine-user-pda-service.js'; +import { updateShineUserPdaOnSolana, readShineUserPda } from './shine-user-pda-service.js'; import { updateEncryptedUserSecrets } from './key-vault.js'; import { SHINE_APP_TAG_NAME, SHINE_APP_TAG_VALUE, SHINE_TYPE_TAG_NAME } from './protocol-tags.js'; @@ -161,11 +161,44 @@ export class KeyRotationClient { async rotatePda({ login, solanaEndpoint, oldBundle, newBundle, storagePwd }) { const rotation=await this.status(); - if(rotation.rotationStatus!=='CHAIN_READY' && rotation.rotationStatus!=='ROTATING_PDA') throw new Error('Новая цепочка ещё не готова к смене PDA'); + const stage=String(rotation.rotationStatus||'NONE'); + const advanced=['PDA_ROTATED','REBUILDING_SERVER','WALLET_MIGRATION','MESSAGE_MIGRATION','FINALIZING','COMPLETE']; + if(!['CHAIN_READY','ROTATING_PDA',...advanced].includes(stage)) { + throw new Error(`Продолжение ротации недоступно на этапе ${stage}. Обновите состояние.`); + } const checks=[['root',oldBundle?.rootPair?.publicKeyB64,rotation.oldRootKey],['blockchain',oldBundle?.blockchainPair?.publicKeyB64,rotation.oldBlockchainKey],['client',oldBundle?.clientPair?.publicKeyB64,rotation.oldClientKey],['new root',newBundle?.rootPair?.publicKeyB64,rotation.newRootKey],['new blockchain',newBundle?.blockchainPair?.publicKeyB64,rotation.newBlockchainKey],['new client',newBundle?.clientPair?.publicKeyB64,rotation.newClientKey]]; for(const [name,actual,expected] of checks) if(String(actual||'')!==String(expected||'')) throw new Error(`Ключ «${name}» не соответствует начатой ротации`); + + const saveNewKeys=async()=>{ + if(storagePwd) await updateEncryptedUserSecrets(login, storagePwd, current=>({ + ...(current||{}), + blockchainKey:newBundle.blockchainPair.privatePkcs8B64, + clientKey:newBundle.clientPair.privatePkcs8B64, + })); + }; + // В первую очередь выясняем реальное состояние PDA. Если sync опередил UI, + // повторная Solana-транзакция не нужна (старый ключ уже недействителен). + const pda=await readShineUserPda({login,solanaEndpoint}); + const actual=[bytesToBase64(pda.rootKey),bytesToBase64(pda.blockchain.blockchainPublicKey),bytesToBase64(pda.clientKey)]; + const expectedNew=[rotation.newRootKey,rotation.newBlockchainKey,rotation.newClientKey]; + const expectedOld=[rotation.oldRootKey,rotation.oldBlockchainKey,rotation.oldClientKey]; + const matchesNew=actual.every((key,i)=>key===expectedNew[i]); + const matchesOld=actual.every((key,i)=>key===expectedOld[i]); + if(matchesNew){ + await saveNewKeys(); + // Сервер сам увидит PDA. Если уже находится на следующем этапе, просто продолжим. + // При ROTATING_PDA с известной signature безопасно повторяем уведомление. + if(stage==='ROTATING_PDA' && rotation.pdaRotationSignature){ + try{return await this.notifyPdaRotation(rotation.pdaRotationSignature);} + catch(e){const latest=await this.status();if(advanced.includes(latest.rotationStatus))return latest;throw e;} + } + return this.status(); + } + if(!matchesOld)throw new Error('Ключи в Solana PDA не соответствуют ни старому, ни новому набору. Повторная транзакция запрещена.'); + if(advanced.includes(stage))throw new Error('Сервер уже подтвердил смену PDA, но RPC вернул старые ключи. Проверьте Solana RPC и повторите проверку.'); + let signature=String(rotation.pdaRotationSignature||''); - if(!signature) { + if(!signature){ const tx=await updateShineUserPdaOnSolana({ login, solanaEndpoint, rootPrivatePkcs8B64:oldBundle.rootPair.privatePkcs8B64, @@ -179,17 +212,17 @@ export class KeyRotationClient { newBlockchainPrivatePkcs8B64:newBundle.blockchainPair.privatePkcs8B64, }); signature=String(tx.signature||''); - if(!signature) throw new Error('Solana не вернула signature ротации'); + if(!signature)throw new Error('Solana не вернула signature ротации'); } - const state=await this.notifyPdaRotation(signature); - if(storagePwd) { - await updateEncryptedUserSecrets(login, storagePwd, (current)=>({ - ...(current||{}), - blockchainKey:newBundle.blockchainPair.privatePkcs8B64, - clientKey:newBundle.clientPair.privatePkcs8B64, - })); + // После подтверждённой транзакции сначала сохраняем новые ключи локально; + // ответ сервера может потеряться при гонке с Solana sync. + await saveNewKeys(); + try{return await this.notifyPdaRotation(signature);} + catch(e){ + const latest=await this.status(); + if(advanced.includes(latest.rotationStatus))return latest; + throw e; } - return state; } } diff --git a/shine-UI/tests/key-rotation-resume-lock.test.mjs b/shine-UI/tests/key-rotation-resume-lock.test.mjs new file mode 100644 index 00000000..5eb46f9b --- /dev/null +++ b/shine-UI/tests/key-rotation-resume-lock.test.mjs @@ -0,0 +1,40 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { readFileSync } from 'node:fs'; +const read = p => readFileSync(new URL(`../../${p}`, import.meta.url), 'utf8'); +const ui = read('shine-UI/js/pages/key-rotation-view.js'); +const app = read('shine-UI/js/app.js'); +const client = read('shine-UI/js/services/key-rotation-service.js'); +const server = read('SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationRotatePda_Handler.java'); + +test('после начала смены в шапке нет кнопки назад и нет abort в UI', () => { + assert.match(ui, /const canExit=status==='NONE' \|\| status==='COMPLETE'/); + assert.match(ui, /updateTopbar\(stateNow\.rotationStatus\)/); + assert.doesNotMatch(ui, /client\.abort\(/); + assert.match(app, /keyRotationRouteLock && state\.session\.isAuthorized/); + assert.match(app, /navigate\('key-rotation-view'\)/); +}); +test('при восстановлении проверяются оба введённых пароля относительно ключей ротации', () => { + assert.match(ui, /await derive\(oldP\.el\.value\)/); + assert.match(ui, /await derive\(newP\.el\.value\)/); + assert.match(ui, /Старый пароль выводит другой blockchain key/); + assert.match(ui, /Новый пароль выводит другой client key/); +}); +test('серверное уведомление PDA идемпотентно на всех этапах после PDA', () => { + for (const stage of ['PDA_ROTATED','REBUILDING_SERVER','WALLET_MIGRATION','MESSAGE_MIGRATION','FINALIZING']) { + assert.match(server, new RegExp('KeyRotationStatus\\.' + stage)); + } + assert.match(server, /KEY_ROTATION_PDA_SIGNATURE_CONFLICT/); +}); +test('повторное обращение не отправляет новый Solana tx, если PDA уже обновлена', () => { + assert.match(client, /const pda=await readShineUserPda/); + assert.match(client, /if\(matchesNew\)/); + assert.match(client, /if\(!matchesOld\)throw new Error/); + assert.ok(client.indexOf('if(matchesNew)') < client.indexOf('updateShineUserPdaOnSolana({')); + assert.ok(client.indexOf('await saveNewKeys();\n try{return await this.notifyPdaRotation(signature)') > 0); +}); +test('полное завершение снимает блокировку навигации', () => { + assert.match(ui, /function exitAfterComplete\(\)\{updateTopbar\('COMPLETE'\);navigate\('access-keys-view'\);\}/); + assert.match(ui, /shine-key-rotation-active/); + assert.match(app, /keyRotationRouteLock = Boolean\(event\.detail\?\.active\)/); +}); From c0257f4be22bf20213e0142ab296913fc6147b3a7cf8ee792ce4d7302542c9b6 Mon Sep 17 00:00:00 2001 From: AidarKC Date: Wed, 28 Oct 2026 19:16:01 +0300 Subject: [PATCH 10/82] =?UTF-8?q?=D0=92=D0=BE=D1=81=D1=81=D1=82=D0=B0?= =?UTF-8?q?=D0=BD=D0=B0=D0=B2=D0=BB=D0=B8=D0=B2=D0=B0=D1=82=D1=8C=20blockc?= =?UTF-8?q?hain=20state=20free-=D0=BF=D0=BE=D0=BB=D1=8C=D0=B7=D0=BE=D0=B2?= =?UTF-8?q?=D0=B0=D1=82=D0=B5=D0=BB=D0=B5=D0=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../VerifiedFreeRegistrationImporter.java | 15 ++++++++ .../blockchain/Net_AddBlock_Handler.java | 36 ++++++++++++++++++- VERSION.properties | 2 +- 3 files changed, 51 insertions(+), 2 deletions(-) diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/VerifiedFreeRegistrationImporter.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/VerifiedFreeRegistrationImporter.java index 370226aa..12cf3b9f 100644 --- a/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/VerifiedFreeRegistrationImporter.java +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/VerifiedFreeRegistrationImporter.java @@ -103,6 +103,21 @@ public final class VerifiedFreeRegistrationImporter { insert.setString(8, login.toLowerCase(java.util.Locale.ROOT) + "-001"); insert.setLong(9, now); insert.setLong(10, now); insert.executeUpdate(); } + // blockchain_state — обязательная runtime-проекция новой цепочки. + // Без неё первый пользовательский AddBlock (например, «О себе») будет + // отклонён ещё до проверки подписи. + try (PreparedStatement insert = c.prepareStatement(""" + INSERT INTO blockchain_state_store ( + login, fork_number, blockchain_key, size_limit, file_size_bytes, + last_block_number, last_block_hash, updated_at_ms) + VALUES (?, 1, ?, 100000, 0, -1, ?, ?) + """)) { + insert.setString(1, login); + insert.setString(2, Base58Util.encode(cert.blockchainKey())); + insert.setBytes(3, new byte[32]); + insert.setLong(4, now); + insert.executeUpdate(); + } try (PreparedStatement insert = c.prepareStatement(""" INSERT INTO free_registration_certificate ( data_item_id, login, namespace, email_sha256, inner_signature, diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler.java index d1005a46..27e586d6 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler.java @@ -37,11 +37,13 @@ import shine.db.dao.BlockchainStateDAO; import shine.db.dao.BlocksDAO; import shine.db.dao.CanonicalChainResolver; import shine.db.dao.ChannelNameStateDAO; +import shine.db.dao.CurrentUsersDAO; import shine.db.dao.UserNotificationsStateDAO; import shine.db.dao.UserParamsDAO; import shine.db.entities.BlockchainStateEntry; import shine.db.entities.BlockEntry; import shine.db.entities.ChannelNameStateEntry; +import shine.db.entities.CurrentUserEntry; import shine.db.entities.UserNotificationEntry; import shine.db.entities.UserParamEntry; import utils.blockchain.BlockchainNameUtil; @@ -68,6 +70,7 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { private final BlocksDAO blocksDAO = BlocksDAO.getInstance(); private final CanonicalChainResolver canonicalChain = CanonicalChainResolver.getInstance(); private final BlockchainStateDAO stateDAO = BlockchainStateDAO.getInstance(); + private final CurrentUsersDAO currentUsersDAO = CurrentUsersDAO.getInstance(); private final UserParamsDAO userParamsDAO = UserParamsDAO.getInstance(); private final ChannelNameStateDAO channelNameStateDAO = ChannelNameStateDAO.getInstance(); @@ -255,7 +258,7 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { } // 1) state обязателен - final BlockchainStateEntry st; + BlockchainStateEntry st; try { st = stateDAO.getByBlockchainName(blockchainName); } catch (Exception e) { @@ -264,6 +267,37 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { return new AddBlockResult(WireCodes.Status.INTERNAL_ERROR, "db_error", 0, ""); } + if (st == null) { + // Runtime-проекция могла отсутствовать у пользователей, зарегистрированных + // ранней версией free-регистрации. Восстанавливаем только для точно + // существующего владельца этой цепочки; сам блок всё равно проходит + // полную проверку ключа и подписи ниже. + try { + CurrentUserEntry user = currentUsersDAO.getByBlockchainName(blockchainName); + if (user != null) { + BlockchainStateEntry recovered = new BlockchainStateEntry(); + recovered.setBlockchainName(user.getBlockchainName()); + recovered.setLogin(user.getLogin()); + recovered.setBlockchainKey(user.getBlockchainKey()); + recovered.setSizeLimit(100_000L); + recovered.setFileSizeBytes(0L); + recovered.setLastBlockNumber(-1); + recovered.setLastBlockHash(new byte[32]); + recovered.setUpdatedAtMs(System.currentTimeMillis()); + stateDAO.insertIfMissing(recovered); + st = stateDAO.getByBlockchainName(blockchainName); + if (st != null) { + log.warn("AddBlock: восстановлена отсутствующая blockchain_state для login={}, blockchainName={}", + user.getLogin(), blockchainName); + } + } + } catch (Exception e) { + log.error("AddBlock: не удалось восстановить blockchain_state (login={}, blockchainName={})", + login, blockchainName, e); + return new AddBlockResult(WireCodes.Status.INTERNAL_ERROR, "db_error", 0, ""); + } + } + if (st == null) { log.warn("AddBlock: blockchain_state_not_found (login={}, blockchainName={}, reqGlobalNumber={})", login, blockchainName, globalNumberFromReq); diff --git a/VERSION.properties b/VERSION.properties index 8e37a7f3..f86340c3 100644 --- a/VERSION.properties +++ b/VERSION.properties @@ -1,2 +1,2 @@ client.version=1.20.7 -server.version=1.16.6 +server.version=1.16.7 From e296217f2196ec0cee05081e35db44c81297ed1a62729d6054909e2490f32248 Mon Sep 17 00:00:00 2001 From: AidarKC Date: Wed, 28 Oct 2026 19:21:33 +0300 Subject: [PATCH 11/82] =?UTF-8?q?=D0=A3=D1=87=D0=B8=D1=82=D1=8B=D0=B2?= =?UTF-8?q?=D0=B0=D1=82=D1=8C=20=D1=80=D0=B5=D0=B3=D0=B8=D1=81=D1=82=D1=80?= =?UTF-8?q?=20=D0=BB=D0=BE=D0=B3=D0=B8=D0=BD=D0=B0=20=D0=B2=20=D1=81=D0=BE?= =?UTF-8?q?=D1=81=D1=82=D0=BE=D1=8F=D0=BD=D0=B8=D0=B8=20=D0=B1=D0=BB=D0=BE?= =?UTF-8?q?=D0=BA=D1=87=D0=B5=D0=B9=D0=BD=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../src/main/java/shine/db/dao/BlockchainStateDAO.java | 4 ++-- VERSION.properties | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlockchainStateDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlockchainStateDAO.java index 7f52aed1..e5d9fffe 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlockchainStateDAO.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlockchainStateDAO.java @@ -43,7 +43,7 @@ public final class BlockchainStateDAO { last_block_hash, updated_at_ms FROM blockchain_state - WHERE login = ? AND fork_number = ? + WHERE LOWER(login) = LOWER(?) AND fork_number = ? """; try (PreparedStatement ps = c.prepareStatement(sql)) { @@ -197,7 +197,7 @@ public final class BlockchainStateDAO { file_size_bytes = file_size_bytes + ?, updated_at_ms = ? WHERE - login = ? AND fork_number = ? + LOWER(login) = LOWER(?) AND fork_number = ? AND (file_size_bytes + ?) <= size_limit """; diff --git a/VERSION.properties b/VERSION.properties index f86340c3..31f35db4 100644 --- a/VERSION.properties +++ b/VERSION.properties @@ -1,2 +1,2 @@ client.version=1.20.7 -server.version=1.16.7 +server.version=1.16.8 From 8bb7d39c76a6b30a2fd7afd00d536500b000c075067b7dc0b6b82faba7569b98 Mon Sep 17 00:00:00 2001 From: AidarKC Date: Wed, 28 Oct 2026 19:30:07 +0300 Subject: [PATCH 12/82] =?UTF-8?q?=D0=9D=D0=B5=D0=B4=D0=BE=D0=B4=D0=B5?= =?UTF-8?q?=D0=BB=D0=B0=D0=BD=D0=BE:=20=D0=BA=D0=B0=D0=BD=D0=BE=D0=BD?= =?UTF-8?q?=D0=B8=D0=B7=D0=B8=D1=80=D0=BE=D0=B2=D0=B0=D1=82=D1=8C=20login?= =?UTF-8?q?=20=D0=B2=20=D0=B7=D0=B0=D0=B3=D0=BE=D0=BB=D0=BE=D0=B2=D0=BA?= =?UTF-8?q?=D0=B5=20=D0=B1=D0=BB=D0=BE=D0=BA=D1=87=D0=B5=D0=B9=D0=BD=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- VERSION.properties | 2 +- shine-UI/js/services/auth-service.js | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/VERSION.properties b/VERSION.properties index 31f35db4..8d10199f 100644 --- a/VERSION.properties +++ b/VERSION.properties @@ -1,2 +1,2 @@ -client.version=1.20.7 +client.version=1.20.8 server.version=1.16.8 diff --git a/shine-UI/js/services/auth-service.js b/shine-UI/js/services/auth-service.js index 8578b585..68db04ae 100644 --- a/shine-UI/js/services/auth-service.js +++ b/shine-UI/js/services/auth-service.js @@ -1890,7 +1890,9 @@ export class AuthService { msgType: MSG_TYPE_TECH, msgSubType: MSG_SUBTYPE_TECH_HEADER, msgVersion: 1, - bodyBytes: makeHeaderBodyBytes({ login: cleanLogin, initialBlockchainKey32 }), + // Идентификатор цепочки и формат HEADER используют canonical login. + // Отображаемый login может сохранять исходный регистр. + bodyBytes: makeHeaderBodyBytes({ login: cleanLogin.toLowerCase(), initialBlockchainKey32 }), _skipHeaderEnsure: true, }); From d2b2876a79e5522629d1fc8b6cf048c660a36464aa7cf0c4bad8b803be631c61 Mon Sep 17 00:00:00 2001 From: AidarKC Date: Wed, 28 Oct 2026 20:03:34 +0300 Subject: [PATCH 13/82] =?UTF-8?q?=D0=9E=D0=B1=D0=BD=D0=BE=D0=B2=D0=B8?= =?UTF-8?q?=D1=82=D1=8C=20=D0=BF=D1=83=D0=B1=D0=BB=D0=B8=D1=87=D0=BD=D1=8B?= =?UTF-8?q?=D0=B5=20=D1=81=D1=81=D1=8B=D0=BB=D0=BA=D0=B8=20=D0=B8=20=D0=B0?= =?UTF-8?q?=D0=B2=D0=B0=D1=82=D0=B0=D1=80=D1=8B=20=D0=BA=D0=B0=D0=BD=D0=B0?= =?UTF-8?q?=D0=BB=D0=BE=D0=B2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- VERSION.properties | 2 +- shine-UI/index.html | 4 +- shine-UI/js/components/profile-card.js | 4 +- shine-UI/js/pages/channel-view.js | 32 +++-- shine-UI/js/pages/profile-view.js | 6 +- shine-UI/js/router.js | 11 ++ shine-UI/js/services/shine-routes.js | 10 +- shine-UI/styles/features/channel-thread.css | 2 +- shine-UI/styles/features/channel.css | 9 +- shine-UI/styles/features/channels-common.css | 4 +- shine-UI/styles/features/channels-list.css | 4 +- .../channel-avatar-profile-share.test.mjs | 114 ++++++++++++++++++ 12 files changed, 174 insertions(+), 28 deletions(-) create mode 100644 shine-UI/tests/channel-avatar-profile-share.test.mjs diff --git a/VERSION.properties b/VERSION.properties index 8d10199f..9a77ea37 100644 --- a/VERSION.properties +++ b/VERSION.properties @@ -1,2 +1,2 @@ -client.version=1.20.8 +client.version=1.20.9 server.version=1.16.8 diff --git a/shine-UI/index.html b/shine-UI/index.html index eaf17559..d6498165 100644 --- a/shine-UI/index.html +++ b/shine-UI/index.html @@ -39,8 +39,8 @@ }());