From cab26bbf417e9295d300581004d0509d0b9e5b2ea7e494df4d1e9f1e738a99c9 Mon Sep 17 00:00:00 2001 From: AidarKC Date: Fri, 23 Oct 2026 19:21:52 +0300 Subject: [PATCH] =?UTF-8?q?=D0=A0=D0=B5=D0=B3=D0=B8=D1=81=D1=82=D1=80?= =?UTF-8?q?=D0=B0=D1=86=D0=B8=D1=8F=20V2:=20=D0=BD=D0=B5=20=D0=BF=D1=80?= =?UTF-8?q?=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); +}