From c97df825383f28ce23007c46e0b4bda2b26a8524c131cfa3a16703a7f0ecc15b Mon Sep 17 00:00:00 2001 From: AidarKC Date: Thu, 12 Nov 2026 11:01:31 +0300 Subject: [PATCH] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8=D1=82?= =?UTF-8?q?=D1=8C=20=D1=81=D0=B8=D1=81=D1=82=D0=B5=D0=BC=D1=83=20=D0=BF?= =?UTF-8?q?=D0=BE=D0=B4=D0=B4=D0=B5=D1=80=D0=B6=D0=BA=D0=B8=20SHiNE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ws_protocol/JSON/JsonHandlerRegistry.java | 4 + .../Net_GetSupportTotals_Handler.java | 99 +++++++++ .../Net_GetSupportTotals_Request.java | 13 ++ .../Net_GetSupportTotals_Response.java | 14 ++ .../main/java/sync/codec/ShineUsersCodec.java | 39 ++++ .../sync/service/SolanaUsersSyncService.java | 5 + .../sync/service/SupportHistoryIndexer.java | 202 ++++++++++++++++++ .../service/SupportHistoryIndexerTest.java | 48 +++++ VERSION.properties | 4 +- docs/API/06_Channels_Read_API.md | 11 + docs/API/09_Operations_Index.md | 1 + .../Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md | 18 ++ .../js/components/shine-support-dialog.js | 125 +++++++++++ shine-UI/js/components/support-stats.js | 50 +++++ shine-UI/js/i18n/locales/en.json | 41 ++++ shine-UI/js/i18n/locales/ru.json | 41 ++++ shine-UI/js/pages/channel-donate-view.js | 130 +++++++---- shine-UI/js/pages/channel-thread-view.js | 33 +++ shine-UI/js/pages/channel-view.js | 36 ++++ shine-UI/js/pages/profile-view.js | 2 + shine-UI/js/pages/user-profile-view.js | 8 + shine-UI/js/pages/wallet-view.js | 3 + shine-UI/js/services/auth-service.js | 10 + .../shine-blockchain-wallet-service.js | 2 + shine-UI/js/services/shine-support-amount.js | 20 ++ .../js/services/shine-user-pda-service.js | 60 +++++- shine-UI/js/services/solana-wallet-service.js | 15 ++ .../js/services/support-totals-service.js | 34 +++ .../tests/support-channel-phase1.test.mjs | 30 +++ shine-UI/tests/support-phase2.test.mjs | 43 ++++ .../formats/shine-user-pda-format-v.1.2.md | 17 ++ .../shine/doc/programs/shine_users.md | 18 ++ .../shine/programs/shine_users/src/lib.rs | 197 ++++++++++++++++- .../programs/shine_users/src/settings.rs | 2 + 34 files changed, 1323 insertions(+), 52 deletions(-) create mode 100644 SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetSupportTotals_Handler.java create mode 100644 SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_GetSupportTotals_Request.java create mode 100644 SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_GetSupportTotals_Response.java create mode 100644 SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/service/SupportHistoryIndexer.java create mode 100644 SHiNE-server/shine-server-solana-users-sync/src/test/java/sync/service/SupportHistoryIndexerTest.java create mode 100644 shine-UI/js/components/shine-support-dialog.js create mode 100644 shine-UI/js/components/support-stats.js create mode 100644 shine-UI/js/services/shine-support-amount.js create mode 100644 shine-UI/js/services/support-totals-service.js create mode 100644 shine-UI/tests/support-channel-phase1.test.mjs create mode 100644 shine-UI/tests/support-phase2.test.mjs 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 e99b4153..4451589e 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 @@ -91,6 +91,7 @@ import server.logic.ws_protocol.JSON.handlers.channels.ChannelNamesStateBootstra import server.logic.ws_protocol.JSON.handlers.channels.Net_GetChannelMessages_Handler; import server.logic.ws_protocol.JSON.handlers.channels.Net_GetMessageThread_Handler; import server.logic.ws_protocol.JSON.handlers.channels.Net_GetMessageLikes_Handler; +import server.logic.ws_protocol.JSON.handlers.channels.Net_GetSupportTotals_Handler; import server.logic.ws_protocol.JSON.handlers.channels.Net_GetPersonalDiary_Handler; import server.logic.ws_protocol.JSON.handlers.channels.Net_GetGroupDialog_Handler; import server.logic.ws_protocol.JSON.handlers.channels.Net_GetChannelsCounters_Handler; @@ -104,6 +105,7 @@ import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_GetChannelMe import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_GetGroupDialog_Request; import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_GetMessageThread_Request; import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_GetMessageLikes_Request; +import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_GetSupportTotals_Request; import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_GetPersonalDiary_Request; import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_ListGroupChats200_Request; import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_ListSubscriptionsFeed_Request; @@ -254,6 +256,7 @@ public final class JsonHandlerRegistry { Map.entry("GetPersonalDiary", new Net_GetPersonalDiary_Handler()), Map.entry("GetMessageThread", new Net_GetMessageThread_Handler()), Map.entry("GetMessageLikes", new Net_GetMessageLikes_Handler()), + Map.entry("GetSupportTotals", new Net_GetSupportTotals_Handler()), Map.entry("GetGroupDialog", new Net_GetGroupDialog_Handler()), Map.entry("ListGroupChats200", new Net_ListGroupChats200_Handler()), Map.entry("GetChannelsCounters", new Net_GetChannelsCounters_Handler()), @@ -367,6 +370,7 @@ public final class JsonHandlerRegistry { Map.entry("GetPersonalDiary", Net_GetPersonalDiary_Request.class), Map.entry("GetMessageThread", Net_GetMessageThread_Request.class), Map.entry("GetMessageLikes", Net_GetMessageLikes_Request.class), + Map.entry("GetSupportTotals", Net_GetSupportTotals_Request.class), Map.entry("GetGroupDialog", Net_GetGroupDialog_Request.class), Map.entry("ListGroupChats200", Net_ListGroupChats200_Request.class), Map.entry("GetChannelsCounters", Net_GetChannelsCounters_Request.class), diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetSupportTotals_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetSupportTotals_Handler.java new file mode 100644 index 00000000..cb3299c6 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetSupportTotals_Handler.java @@ -0,0 +1,99 @@ +package server.logic.ws_protocol.JSON.handlers.channels; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +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.handlers.channels.entyties.Net_GetSupportTotals_Request; +import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_GetSupportTotals_Response; +import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory; +import server.logic.ws_protocol.WireCodes; +import shine.db.DbController; +import java.sql.*; +import java.util.*; + +/** + * Публичные итоги только после проверки канала, автора и фактических блоков. + * Сырые идентификаторы из Solana-инструкций НЕ являются доказательством авторства. + */ +public final class Net_GetSupportTotals_Handler implements JsonMessageHandler { + private static final Logger log = LoggerFactory.getLogger(Net_GetSupportTotals_Handler.class); + @Override public Net_Response handle(Net_Request baseRequest, ConnectionContext ctx) { + var request = (Net_GetSupportTotals_Request) baseRequest; + String hash = request.getChannelRootBlockHash(); + Long number = request.getChannelRootBlockNumber(); + if (hash == null || !hash.matches("(?i)[0-9a-f]{64}") || number == null || number < 0 || number > Integer.MAX_VALUE) { + return NetExceptionResponseFactory.error(request, WireCodes.Status.BAD_REQUEST, + "bad_selector", "Некорректный идентификатор канала"); + } + var response = new Net_GetSupportTotals_Response(); + response.setOp(request.getOp()); + response.setRequestId(request.getRequestId()); + response.setStatus(WireCodes.Status.OK); + response.setChannelReceivedLamports("0"); + response.setMessages(List.of()); + try (Connection c = DbController.getInstance().getConnection()) { + // Для каждой транзакции проверяем существование канала и соответствие + // получателя оригинальному владельцу или автору блока публикации. + String sql = """ + SELECT COALESCE(SUM(t.recipient_lamports),0) AS total + FROM solana_support_transfers t + JOIN channel_names_state cn + ON cn.channel_root_block_number = ? + AND encode(cn.channel_root_block_hash,'hex') = ? + AND t.channel_block_number = cn.channel_root_block_number + AND t.channel_block_hash = encode(cn.channel_root_block_hash,'hex') + WHERE t.kind='USER' AND ( + (t.target_type = 1 AND lower(t.recipient_login)=lower(cn.owner_login)) + OR (t.target_type = 2 AND EXISTS ( + SELECT 1 FROM blocks b WHERE b.block_number = t.message_block_number + AND encode(b.block_hash,'hex')=t.message_block_hash + AND lower(b.login)=lower(t.recipient_login) + AND b.bch_name=cn.owner_bch_name + )) + ) + """; + try (PreparedStatement p = c.prepareStatement(sql)) { + p.setLong(1, number); p.setString(2, hash.toLowerCase(Locale.ROOT)); + try (ResultSet r = p.executeQuery()) { + if (r.next()) response.setChannelReceivedLamports(r.getBigDecimal(1).toBigIntegerExact().toString()); + } + } + String messagesSql = """ + SELECT t.message_block_number, t.message_block_hash, + SUM(t.recipient_lamports) AS total + FROM solana_support_transfers t + JOIN channel_names_state cn + ON cn.channel_root_block_number = ? + AND encode(cn.channel_root_block_hash,'hex') = ? + AND t.channel_block_number=cn.channel_root_block_number + AND t.channel_block_hash=encode(cn.channel_root_block_hash,'hex') + WHERE t.kind='USER' AND t.target_type=2 + AND EXISTS (SELECT 1 FROM blocks b + WHERE b.block_number=t.message_block_number + AND encode(b.block_hash,'hex')=t.message_block_hash + AND lower(b.login)=lower(t.recipient_login) + AND b.bch_name=cn.owner_bch_name) + GROUP BY t.message_block_number,t.message_block_hash + ORDER BY total DESC LIMIT 2000 + """; + List items = new ArrayList<>(); + try (PreparedStatement p = c.prepareStatement(messagesSql)) { + p.setLong(1, number); p.setString(2, hash.toLowerCase(Locale.ROOT)); + try (ResultSet r = p.executeQuery()) { + while (r.next()) items.add(new Net_GetSupportTotals_Response.MessageTotal( + r.getBigDecimal(1).toBigIntegerExact().toString(), r.getString(2), + r.getBigDecimal(3).toBigIntegerExact().toString())); + } + } + response.setMessages(items); + return response; + } catch (SQLException e) { + log.error("GetSupportTotals failed", e); + return NetExceptionResponseFactory.error(request, WireCodes.Status.INTERNAL_ERROR, + "support_totals_unavailable", "Статистика поддержки пока недоступна"); + } + } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_GetSupportTotals_Request.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_GetSupportTotals_Request.java new file mode 100644 index 00000000..3225b14a --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_GetSupportTotals_Request.java @@ -0,0 +1,13 @@ +package server.logic.ws_protocol.JSON.handlers.channels.entyties; + +import server.logic.ws_protocol.JSON.entyties.Net_Request; + +/** Агрегаты поддержки только по проверенной корневой ссылке канала. */ +public class Net_GetSupportTotals_Request extends Net_Request { + private String channelRootBlockHash; + private Long channelRootBlockNumber; + public String getChannelRootBlockHash() { return channelRootBlockHash; } + public void setChannelRootBlockHash(String value) { channelRootBlockHash = value; } + public Long getChannelRootBlockNumber() { return channelRootBlockNumber; } + public void setChannelRootBlockNumber(Long value) { channelRootBlockNumber = value; } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_GetSupportTotals_Response.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_GetSupportTotals_Response.java new file mode 100644 index 00000000..39084611 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_GetSupportTotals_Response.java @@ -0,0 +1,14 @@ +package server.logic.ws_protocol.JSON.handlers.channels.entyties; + +import server.logic.ws_protocol.JSON.entyties.Net_Response; +import java.util.List; + +public class Net_GetSupportTotals_Response extends Net_Response { + private String channelReceivedLamports; + private List messages; + public String getChannelReceivedLamports() { return channelReceivedLamports; } + public void setChannelReceivedLamports(String value) { channelReceivedLamports = value; } + public List getMessages() { return messages; } + public void setMessages(List value) { messages = value; } + public record MessageTotal(String blockNumber, String blockHash, String receivedLamports) {} +} 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 89ac3964..427392d3 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 @@ -32,6 +32,8 @@ public final class ShineUsersCodec { public static final int IX_CREATE_NAMESPACE = 7; public static final int IX_UPDATE_NAMESPACE_PRICE = 8; + public static final int IX_SUPPORT_USER = 9; + public static final int IX_SUPPORT_DAO = 10; public static final long START_REGISTRATION_FEE_LAMPORTS = 10_000_000L; @@ -195,6 +197,22 @@ public final class ShineUsersCodec { null ); + // Поддержки индексируются по экономическому PDA. Из параметров не + // восстанавливается PDA: истина о счётчиках всегда читается из Solana. + case IX_SUPPORT_USER -> { + String senderLogin = reader.readStringU8(); + reader.readStringU8(); + reader.readU64(); + int target = reader.readU8(); + if (target == 1) { reader.readU64(); reader.readFixed(32); } + else if (target == 2) { reader.readU64(); reader.readFixed(32); reader.readU64(); reader.readFixed(32); } + else if (target != 0) throw new IllegalArgumentException("Invalid support target"); + yield new ParsedInstruction(TxKind.SUPPORT_USER, false, null, senderLogin, null, null); + } + + case IX_SUPPORT_DAO -> new ParsedInstruction( + TxKind.SUPPORT_DAO, false, null, reader.readStringU8(), null, null); + default -> new ParsedInstruction( TxKind.OTHER, @@ -255,6 +273,23 @@ public final class ShineUsersCodec { throw new IllegalArgumentException("Unsupported PDA format " + formatMajor + "." + formatMinor); } + /** Неподписанный блок после record_len; v0 совместим с ранее созданными PDA. */ + public static SupportStats parseSupportStats(byte[] raw) { + if (raw == null || raw.length < 9) throw new IllegalArgumentException("PDA record too short"); + int recordLen = u16le(raw, 7); + if (recordLen > raw.length) throw new IllegalArgumentException("Invalid record_len"); + if (recordLen == raw.length || raw[recordLen] == 0) return new SupportStats(0, 0L, 0L, 0L); + if ((raw[recordLen] & 0xFF) != 1) throw new IllegalArgumentException("Unsupported support stats version"); + if (recordLen + 25 > raw.length) throw new IllegalArgumentException("Truncated support stats"); + return new SupportStats(1, u64le(raw, recordLen + 1), u64le(raw, recordLen + 9), u64le(raw, recordLen + 17)); + } + + private static long u64le(byte[] bytes, int offset) { + long value = 0L; + for (int i = 0; i < 8; i++) value |= (long) (bytes[offset + i] & 0xFF) << (8 * i); + return value; + } + private static UserPdaSnapshot parseUserPdaAccountV10( String pdaAddress, long slot, @@ -809,6 +844,8 @@ public final class ShineUsersCodec { CREATE_NAMESPACE, UPDATE_NAMESPACE_PRICE, UPDATE_USER_PDA, + SUPPORT_USER, + SUPPORT_DAO, CLOSE_LEGACY_USER_PDA, OTHER } @@ -839,6 +876,8 @@ public final class ShineUsersCodec { } } + public record SupportStats(int version, long supportSent, long supportReceived, long daoDirect) {} + public record UserSessionSnapshot( int sessionType, int sessionVersion, 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 eb4d4cbc..7f191c24 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 @@ -48,6 +48,7 @@ public final class SolanaUsersSyncService private final AtomicBoolean syncWorkerScheduled = new AtomicBoolean(false); private final String economyConfigPda; + private final SupportHistoryIndexer supportHistoryIndexer; private volatile boolean initialSyncCompleted = false; @@ -118,6 +119,7 @@ public final class SolanaUsersSyncService ), config.programId() ); + this.supportHistoryIndexer = new SupportHistoryIndexer(config, economyConfigPda); } public void start() @@ -302,6 +304,9 @@ public final class SolanaUsersSyncService long nowMs = System.currentTimeMillis(); + // Финансовый checkpoint независим от snapshot PDA. Историю не пропускаем. + supportHistoryIndexer.sync(); + PostgresStorageRepository.SyncStateSnapshot state = storage.loadState(); diff --git a/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/service/SupportHistoryIndexer.java b/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/service/SupportHistoryIndexer.java new file mode 100644 index 00000000..9650a7a5 --- /dev/null +++ b/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/service/SupportHistoryIndexer.java @@ -0,0 +1,202 @@ +package sync.service; + +import com.fasterxml.jackson.databind.JsonNode; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import sync.config.AppConfig; +import sync.source.rpc.SolanaRpcClient; +import sync.util.Base58Util; + +import java.math.BigInteger; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.charset.StandardCharsets; +import java.sql.*; +import java.util.*; +import java.util.HexFormat; + +/** + * Независимый журнал финансовой поддержки. Не использует checkpoint синхронизации + * PDA: он может быть создан из full snapshot и не содержит старых донатов. + * Обновление журнала и checkpoint выполняются в одной транзакции PostgreSQL. + */ +public final class SupportHistoryIndexer { + private static final Logger log = LoggerFactory.getLogger(SupportHistoryIndexer.class); + private final AppConfig config; + private final String economyPda; + private final SolanaRpcClient rpc; + + public SupportHistoryIndexer(AppConfig config, String economyPda) { + this.config = config; + this.economyPda = economyPda; + this.rpc = new SolanaRpcClient(config.rpcUrl(), config.programId(), "finalized"); + } + + public void sync() throws Exception { + try (Connection connection = DriverManager.getConnection( + config.databaseUrl(), config.databaseUser(), config.databasePassword())) { + migrate(connection); + String checkpoint = checkpoint(connection); + var result = rpc.getSignaturesForAddressSince(economyPda, checkpoint); + if (checkpoint != null && !result.anchorFound()) { + throw new IllegalStateException("Support history checkpoint not found by RPC: " + checkpoint + + ". Use archival Helius RPC; checkpoint will NOT be skipped."); + } + List signatures = new ArrayList<>(result.signatures()); + Collections.reverse(signatures); + int indexed = 0; + for (var signature : signatures) { + // Ошибочные транзакции не содержат успешных переводов; checkpoint всё равно сдвигаем. + JsonNode transaction = signature.failed() ? null : rpc.getTransactionJsonParsed(signature.signature()); + if (!signature.failed() && transaction == null) { + throw new IllegalStateException("Historical transaction unavailable: " + signature.signature() + + ". An archival RPC is required, checkpoint unchanged."); + } + List events = signature.failed() ? List.of() + : decodeTransaction(transaction, config.programId()); + connection.setAutoCommit(false); + try { + for (SupportEvent event : events) { + insert(connection, signature, event); + indexed++; + } + try (PreparedStatement stmt = connection.prepareStatement( + "UPDATE solana_support_sync_state SET last_signature=?, last_slot=?, updated_at=now() WHERE id=1")) { + stmt.setString(1, signature.signature()); + stmt.setLong(2, signature.slot()); + stmt.executeUpdate(); + } + connection.commit(); + } catch (Exception failure) { + connection.rollback(); + throw failure; + } finally { + connection.setAutoCommit(true); + } + } + log.info("Support history synchronized: scanned={} newEvents={} checkpoint={}", + signatures.size(), indexed, signatures.isEmpty() ? checkpoint : signatures.get(signatures.size()-1).signature()); + } + } + + private static String checkpoint(Connection c) throws SQLException { + try (Statement s = c.createStatement(); ResultSet r = s.executeQuery( + "SELECT last_signature FROM solana_support_sync_state WHERE id=1")) { + if (!r.next()) throw new SQLException("Support checkpoint missing"); + return r.getString(1); + } + } + + private static void migrate(Connection c) throws SQLException { + try (Statement s = c.createStatement()) { + s.executeUpdate("CREATE TABLE IF NOT EXISTS solana_support_sync_state (" + + "id INT PRIMARY KEY CHECK(id=1), last_signature TEXT, last_slot BIGINT, updated_at TIMESTAMPTZ NOT NULL DEFAULT now())"); + s.executeUpdate("INSERT INTO solana_support_sync_state(id) VALUES(1) ON CONFLICT DO NOTHING"); + s.executeUpdate("CREATE TABLE IF NOT EXISTS solana_support_transfers (" + + "signature TEXT NOT NULL, instruction_index INT NOT NULL, slot BIGINT NOT NULL, " + + "block_time BIGINT, kind TEXT NOT NULL, sender_login TEXT NOT NULL, recipient_login TEXT, " + + "amount_lamports NUMERIC(20,0) NOT NULL, recipient_lamports NUMERIC(20,0) NOT NULL, " + + "inflow_lamports NUMERIC(20,0) NOT NULL, target_type SMALLINT NOT NULL, " + + "channel_block_number NUMERIC(20,0), channel_block_hash TEXT, " + + "message_block_number NUMERIC(20,0), message_block_hash TEXT, " + + "PRIMARY KEY(signature, instruction_index))"); + s.executeUpdate("CREATE INDEX IF NOT EXISTS solana_support_by_channel ON solana_support_transfers(channel_block_hash, channel_block_number)"); + s.executeUpdate("CREATE INDEX IF NOT EXISTS solana_support_by_message ON solana_support_transfers(message_block_hash, message_block_number)"); + s.executeUpdate("CREATE INDEX IF NOT EXISTS solana_support_by_sender ON solana_support_transfers(sender_login)"); + s.executeUpdate("CREATE INDEX IF NOT EXISTS solana_support_by_recipient ON solana_support_transfers(recipient_login)"); + s.executeUpdate("CREATE OR REPLACE VIEW solana_support_channel_totals AS SELECT channel_block_number, channel_block_hash, " + + "SUM(recipient_lamports) AS received_lamports, COUNT(*) AS transfers FROM solana_support_transfers " + + "WHERE kind='USER' AND target_type IN (1,2) GROUP BY channel_block_number, channel_block_hash"); + s.executeUpdate("CREATE OR REPLACE VIEW solana_support_message_totals AS SELECT channel_block_number, channel_block_hash, " + + "message_block_number, message_block_hash, SUM(recipient_lamports) AS received_lamports, COUNT(*) AS transfers " + + "FROM solana_support_transfers WHERE kind='USER' AND target_type=2 " + + "GROUP BY channel_block_number, channel_block_hash, message_block_number, message_block_hash"); + } + } + + private static void insert(Connection c, SolanaRpcClient.SignatureRecord signature, SupportEvent event) throws SQLException { + try (PreparedStatement s = c.prepareStatement("INSERT INTO solana_support_transfers (" + + "signature,instruction_index,slot,block_time,kind,sender_login,recipient_login,amount_lamports," + + "recipient_lamports,inflow_lamports,target_type,channel_block_number,channel_block_hash," + + "message_block_number,message_block_hash) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT DO NOTHING")) { + s.setString(1, signature.signature()); + s.setInt(2, event.index()); + s.setLong(3, signature.slot()); + if (signature.blockTime() == null) s.setNull(4, Types.BIGINT); else s.setLong(4, signature.blockTime()); + s.setString(5, event.kind()); + s.setString(6, event.sender()); + s.setString(7, event.recipient()); + s.setBigDecimal(8, new java.math.BigDecimal(event.amount())); + s.setBigDecimal(9, new java.math.BigDecimal(event.recipientAmount())); + s.setBigDecimal(10, new java.math.BigDecimal(event.inflowAmount())); + s.setInt(11, event.target()); + if (event.channelNumber() == null) s.setNull(12, Types.NUMERIC); else s.setBigDecimal(12, new java.math.BigDecimal(event.channelNumber())); + s.setString(13, event.channelHash()); + if (event.messageNumber() == null) s.setNull(14, Types.NUMERIC); else s.setBigDecimal(14, new java.math.BigDecimal(event.messageNumber())); + s.setString(15, event.messageHash()); + s.executeUpdate(); + } + } + + /** Decode ALL top-level instructions: one transaction may contain several donations. */ + public static List decodeTransaction(JsonNode transaction, String programId) { + if (transaction.path("meta").hasNonNull("err")) return List.of(); + JsonNode instructions = transaction.path("transaction").path("message").path("instructions"); + if (!instructions.isArray()) throw new IllegalArgumentException("Transaction instructions missing"); + List result = new ArrayList<>(); + for (int index = 0; index < instructions.size(); index++) { + JsonNode instruction = instructions.get(index); + if (!programId.equals(instruction.path("programId").asText())) continue; + String encoded = instruction.path("data").asText(""); + if (encoded.isBlank()) continue; + byte[] bytes = Base58Util.decode(encoded); + if (bytes.length == 0 || ((bytes[0] & 0xff) != 9 && (bytes[0] & 0xff) != 10)) continue; + result.add(decodeInstruction(bytes, index)); + } + return result; + } + + public static SupportEvent decodeInstruction(byte[] bytes, int index) { + ByteBuffer b = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN); + int ix = b.get() & 255; + if (ix != 9 && ix != 10) throw new IllegalArgumentException("Not a support instruction"); + String sender = readLogin(b); + String recipient = ix == 9 ? readLogin(b) : null; + BigInteger amount = readUnsigned64(b); + if (amount.signum() <= 0) throw new IllegalArgumentException("Invalid amount"); + int target = ix == 9 ? (b.get() & 255) : 0; + String channelNumber = null, messageNumber = null, channelHash = null, messageHash = null; + if (target == 1 || target == 2) { + channelNumber = readUnsigned64(b).toString(); + byte[] hash = new byte[32]; b.get(hash); channelHash = HexFormat.of().formatHex(hash); + } + if (target == 2) { + messageNumber = readUnsigned64(b).toString(); + byte[] hash = new byte[32]; b.get(hash); messageHash = HexFormat.of().formatHex(hash); + } + if (target > 2 || b.hasRemaining()) throw new IllegalArgumentException("Malformed support instruction"); + if (ix == 9 && (!amount.mod(BigInteger.TEN).equals(BigInteger.ZERO) || sender.equals(recipient))) { + throw new IllegalArgumentException("Invalid support split or self-support"); + } + BigInteger inflow = ix == 9 ? amount.divide(BigInteger.TEN) : amount; + BigInteger received = ix == 9 ? amount.subtract(inflow) : BigInteger.ZERO; + return new SupportEvent(index, ix == 9 ? "USER" : "DAO", sender, recipient, + amount, received, inflow, target, channelNumber, channelHash, messageNumber, messageHash); + } + + private static String readLogin(ByteBuffer b) { + int length = b.get() & 255; + if (length == 0 || length > b.remaining()) throw new IllegalArgumentException("Invalid login length"); + byte[] str = new byte[length]; b.get(str); + return new String(str, StandardCharsets.UTF_8); + } + + private static BigInteger readUnsigned64(ByteBuffer b) { + long value = b.getLong(); + return new BigInteger(Long.toUnsignedString(value)); + } + + public record SupportEvent(int index, String kind, String sender, String recipient, + BigInteger amount, BigInteger recipientAmount, BigInteger inflowAmount, int target, + String channelNumber, String channelHash, String messageNumber, String messageHash) {} +} diff --git a/SHiNE-server/shine-server-solana-users-sync/src/test/java/sync/service/SupportHistoryIndexerTest.java b/SHiNE-server/shine-server-solana-users-sync/src/test/java/sync/service/SupportHistoryIndexerTest.java new file mode 100644 index 00000000..5fc8e548 --- /dev/null +++ b/SHiNE-server/shine-server-solana-users-sync/src/test/java/sync/service/SupportHistoryIndexerTest.java @@ -0,0 +1,48 @@ +package sync.service; + +import org.junit.jupiter.api.Test; +import java.io.ByteArrayOutputStream; +import java.math.BigInteger; +import java.nio.charset.StandardCharsets; +import java.util.HexFormat; +import static org.junit.jupiter.api.Assertions.*; + +class SupportHistoryIndexerTest { + private static void str(ByteArrayOutputStream out, String value) { + byte[] bytes = value.getBytes(StandardCharsets.UTF_8); + out.write(bytes.length); + out.writeBytes(bytes); + } + private static void u64(ByteArrayOutputStream out, long value) { + for (int i=0;i<8;i++) out.write((int)(value >>> (8*i)) & 255); + } + @Test void userSplitAndMessageHash() { + var out = new ByteArrayOutputStream(); + out.write(9); str(out, "alice@namespace"); str(out, "bob@namespace"); u64(out, 1000); + out.write(2); u64(out, 11); out.writeBytes(new byte[32]); u64(out, 19); + byte[] hash = new byte[32]; hash[0] = 42; out.writeBytes(hash); + var event = SupportHistoryIndexer.decodeInstruction(out.toByteArray(), 3); + assertEquals("1000", event.amount().toString()); + assertEquals("900", event.recipientAmount().toString()); + assertEquals("100", event.inflowAmount().toString()); + assertEquals("19", event.messageNumber()); + assertEquals(HexFormat.of().formatHex(hash), event.messageHash()); + assertEquals(3, event.index()); + } + @Test void directDaoNoFee() { + var out = new ByteArrayOutputStream(); out.write(10); str(out,"alice@ns"); u64(out, 12345); + var event = SupportHistoryIndexer.decodeInstruction(out.toByteArray(), 0); + assertEquals(BigInteger.valueOf(12345), event.inflowAmount()); + assertEquals(BigInteger.ZERO, event.recipientAmount()); + assertNull(event.recipient()); + } + @Test void malformedIsRejected() { + var out = new ByteArrayOutputStream(); out.write(9); str(out,"alice@ns");str(out,"alice@ns");u64(out,100); + out.write(0); + assertThrows(IllegalArgumentException.class, () -> SupportHistoryIndexer.decodeInstruction(out.toByteArray(),0)); + } + @Test void unsignedU64Preserved() { + var out = new ByteArrayOutputStream();out.write(10);str(out,"alice@ns");u64(out,-1L); + assertEquals("18446744073709551615", SupportHistoryIndexer.decodeInstruction(out.toByteArray(),0).amount().toString()); + } +} diff --git a/VERSION.properties b/VERSION.properties index 682a96d6..eba31d07 100644 --- a/VERSION.properties +++ b/VERSION.properties @@ -1,2 +1,2 @@ -client.version=1.20.34 -server.version=1.16.19 +client.version=1.20.35 +server.version=1.16.20 diff --git a/docs/API/06_Channels_Read_API.md b/docs/API/06_Channels_Read_API.md index b6b0798b..5d409b35 100644 --- a/docs/API/06_Channels_Read_API.md +++ b/docs/API/06_Channels_Read_API.md @@ -648,3 +648,14 @@ Changing `account_role` or `shine` does not alter the raw reaction. The two qual ## 2026-10-28 — Официальный регистр логинов при чтении В ответах `GetChannelMessages`, `GetMessageThread`, `ListSubscriptionsFeed` поля `authorLogin` и `ownerLogin` показывают **регистрационное написание** из `user_identity_current`, например `AlexSmith@shine`. В БД блока и в `blockchainName` по-прежнему возможен lowercase, используемый как нормализованный идентификатор. Это не меняет имена JSON-полей или типы значений, а уточняет их семантику. Для поиска и переходов разные варианты регистра по-прежнему ссылаются на одну идентичность; байты уже подписанных блоков не переписываются. + + +## GetSupportTotals — проверенная поддержка канала + +Запрос: `{"op":"GetSupportTotals", "channelRootBlockNumber":12, "channelRootBlockHash":"<64 hex>"}`. + +Ответ (при `status=200`): `channelReceivedLamports` — десятичная строка суммы реально полученных авторами средств (90% донатов); `messages` — массив `{blockNumber,blockHash,receivedLamports}`. Все значения в lamports представлены **строками**, не JavaScript Number. В результате возвращаются не более 2000 сообщений с максимальными суммами, агрегат канала включает все проверенные операции. + +API считает только `support_user` из таблицы `solana_support_transfers`. Для CHANNEL проверяет, что адресат равен владельцу существующего канала. Для MESSAGE проверяет наличие блока с точным номером/хешем, авторство получателя и принадлежность блока цепочке владельца канала. Не соответствующие этим условиям донаты остаются в истории, но не включаются в публичные суммы. Поддержка ответов в других пользовательских цепочках не попадает в агрегат до добавления полной проверки принадлежности обсуждению. + +Таблицы истории автоматически создаются финансовым индексатором. Пока он не синхронизирован, операция может возвращать `support_totals_unavailable` — клиент не должен подменять отсутствие данных нулями. diff --git a/docs/API/09_Operations_Index.md b/docs/API/09_Operations_Index.md index 50300f58..cd0e7d33 100644 --- a/docs/API/09_Operations_Index.md +++ b/docs/API/09_Operations_Index.md @@ -68,6 +68,7 @@ | `GetChannelMessages` | `06_Channels_Read_API.md` | сообщения канала | | `GetMessageThread` | `06_Channels_Read_API.md` | тред сообщения | | `GetMessageLikes` | `06_Channels_Read_API.md` | списки пользователей, поставивших лайк сообщению | +| `GetSupportTotals` | `06_Channels_Read_API.md` | подтверждённые суммы поддержки канала и публикаций | | `GetPersonalDiary` | `06_Channels_Read_API.md` | виртуальный канал `Личный дневник` из STATUS_ACTION | | `ListUserProfileChannels` | `06_Channels_Read_API.md` | публичные каналы профиля | | `ListUserProfileRelations` | `11_Connections_API.md` | связи пользователя в профиле | diff --git a/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md b/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md index f45ed3a5..9fcd5c34 100644 --- a/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md +++ b/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md @@ -638,3 +638,21 @@ Arweave/Turbo publisher обрабатывает candidate-блоки приор Instruction `shine_users` opcode 8 (`update_namespace_price`) передаёт economy PDA в метах (read-only). Исторический скан этого PDA обнаруживает транзакцию и загружает актуальный снимок затронутого namespace PDA через getMultipleAccounts. Декодер принимает namespace v1.0 (`currency_code=1` по умолчанию) и v1.1 (добавлен один байт currency code после u64 fee), только код 1. Postgres v40: `shine_namespace_current.currency_code SMALLINT DEFAULT 1`; `UPSERT` обновляет `registration_fee_lamports` и `currency_code` при slot не старее существующего. `GetNamespaces` и `CheckRegistrationLogin` получают цену из БД после sync. Важное условие: history sync запускается по economy PDA. Поскольку она read-only, subscription по изменению данных economy PDA не сработает; нужен регулярный history polling, а перед фактической оплатой клиент читает namespace напрямую из сети. +# Операции поддержки + +Синхронизатор распознаёт инструкции `shine_users` 9 (`SUPPORT_USER`) и 10 +(`SUPPORT_DAO`) в истории подтверждённых транзакций. Их параметры остаются +бинарными данными инструкции; окончательные пользовательские счётчики всегда +считываются из PDA Solana, а не пересчитываются из PostgreSQL. + +## Финансовый журнал поддержки (12.11.2026) + +`SupportHistoryIndexer` работает внутри цикла `SolanaUsersSyncService` и имеет **отдельный checkpoint** `solana_support_sync_state`. Это важно: основной user-PDA синхронизатор при первом запуске использует snapshot и может не воспроизводить старые транзакции. + +Индексатор опрашивает `getSignaturesForAddress(shine_users_economy_config)` на **finalized** RPC (рекомендуется архивный Helius endpoint), при первом запуске читает все доступные подписи до начала истории, затем обрабатывает от старых к новым. Для успешных транзакций считывает `getTransaction(jsonParsed)` и все инструкции `shine_users.support_user` (tag 9) и `shine_users.support_dao` (tag 10). Учитывает несколько инструкций в одной транзакции. Суммы сохраняются в PostgreSQL `NUMERIC(20,0)`, поскольку Solana `u64` может превышать Java `long`. + +Таблицы: `solana_support_sync_state`, `solana_support_transfers`; представления: `solana_support_channel_totals`, `solana_support_message_totals`. В SQL-представлениях суммы **без проверки авторства**: нельзя публично показывать их напрямую! Для API `GetSupportTotals` добавлена проверка через таблицы `channel_names_state` и `blocks`. Пользовательский профиль продолжает читать ончейн-счётчики из PDA. + +Checkpoint обновляется в той же PostgreSQL-транзакции, что и запись всех донатов из Solana-транзакции. Повторный запуск продолжает с последней успешно обработанной подписи. При недоступной исторической транзакции или исчезнувшей checkpoint-подписи синхронизация **останавливается с ошибкой**, а не перескакивает вперёд; требуется RPC с полной историей. Наличие `getSignaturesForAddress` само по себе НЕ гарантирует архивную полноту Helius/RPC. Начальные транзакции должны быть доступны провайдеру. + +Индексатор включается вместе с `solana.users.sync.enabled=true`, использует те же PostgreSQL credentials и RPC URL. Реальный прогон полной архивной истории, тестирование с живым Helius и публичный API проверенных агрегатов требуют отдельной интеграционной проверки перед production. diff --git a/shine-UI/js/components/shine-support-dialog.js b/shine-UI/js/components/shine-support-dialog.js new file mode 100644 index 00000000..ee39331a --- /dev/null +++ b/shine-UI/js/components/shine-support-dialog.js @@ -0,0 +1,125 @@ +import { t } from '../i18n/index.js'; +import { authService, state } from '../state.js'; +import { readShineUserPda, supportShineUserOnSolana, supportShineDaoOnSolana } from '../services/shine-user-pda-service.js'; +import { loadEncryptedUserSecrets } from '../services/key-vault.js'; +import { getWalletFromStoredBlockchainKey, transferSolLamports, solanaAddressFromPublicKeyBase64 } from '../services/solana-wallet-service.js'; +import { bytesToBase58 } from '../services/crypto-utils.js'; +import { parseSolLamports, formatLamportsSol } from '../services/shine-support-amount.js'; +import { toUserMessage } from '../services/ui-error-texts.js'; + +/** One shared payment dialog for profiles, posts and donations to the SHiNE economy. */ +export function openShineSupportDialog({ recipientLogin = '', target = { type: 0 }, onSuccess = () => {} } = {}) { + const dao = !recipientLogin; + const login = String(state.session.login || '').trim(); + if (!login) { window.alert(t('screens.support_phase2.login_required')); return; } + if (!dao && login.toLowerCase() === String(recipientLogin).trim().toLowerCase()) { + window.alert(t('screens.support_phase2.self_support')); return; + } + const overlay = document.createElement('div'); + overlay.className = 'shine-support-dialog-overlay'; + overlay.style.cssText = 'position:fixed;inset:0;z-index:9999;background:rgba(0,0,0,.66);display:flex;align-items:center;justify-content:center;padding:16px;'; + const panel = document.createElement('section'); + panel.className = 'card stack shine-support-dialog'; + panel.style.cssText = 'width:min(100%,440px);max-height:90vh;overflow:auto;padding:20px;gap:12px;'; + const header = document.createElement('h2'); + header.textContent = dao ? t('screens.support_phase2.donate_shine') : t('screens.support_phase2.donate'); + const description = document.createElement('p'); + description.className = 'meta-muted'; + description.textContent = dao ? t('screens.support_phase2.dao_info') : `${t('screens.support_phase2.to')} ${recipientLogin}`; + const amountLabel = document.createElement('label'); + amountLabel.textContent = t('screens.support_phase2.amount'); + const input = document.createElement('input'); + input.className = 'input'; + input.type = 'text'; + input.inputMode = 'decimal'; + input.autocomplete = 'off'; + input.placeholder = '0.01'; + const details = document.createElement('p'); + details.className = 'meta-muted'; + const status = document.createElement('p'); + status.setAttribute('role', 'status'); + status.className = 'meta-muted'; + const donate = document.createElement('button'); + donate.type = 'button'; + donate.className = 'primary-btn'; + donate.textContent = t('screens.support_phase2.donate'); + const direct = document.createElement('button'); + direct.type = 'button'; + direct.className = 'secondary-btn'; + direct.textContent = t('screens.support_phase2.direct'); + const cancel = document.createElement('button'); + cancel.type = 'button'; + cancel.className = 'text-btn'; + cancel.textContent = t('screens.support_phase2.close'); + panel.append(header, description, amountLabel, input, details, status, donate); + if (!dao) panel.append(direct); + panel.append(cancel); + overlay.append(panel); + document.body.append(overlay); + let busy = false; + let closed = false; + const close = () => { if (busy) return; closed = true; overlay.remove(); }; + cancel.addEventListener('click', close); + overlay.addEventListener('click', (event) => { if (event.target === overlay) close(); }); + const update = () => { + if (dao) { details.textContent = t('screens.support_phase2.dao_info'); return; } + try { + const amount = parseSolLamports(input.value); + details.textContent = amount % 10n === 0n + ? `${t('screens.support_phase2.recipient')}: ${formatLamportsSol(amount * 9n / 10n)} SOL · ${t('screens.support_phase2.fund')}: ${formatLamportsSol(amount / 10n)} SOL` + : t('screens.support_phase2.divisible'); + } catch { details.textContent = t('screens.support_phase2.explanation'); } + }; + input.addEventListener('input', update); + update(); + const send = async (isDirect) => { + if (busy || closed) return; + let amount; + try { + amount = parseSolLamports(input.value); + if (!dao && !isDirect && amount % 10n !== 0n) throw new Error(t('screens.support_phase2.divisible')); + } catch (error) { status.textContent = error.message; return; } + if (isDirect && !window.confirm(t('screens.support_phase2.direct_warning'))) return; + busy = true; + donate.disabled = direct.disabled = cancel.disabled = input.disabled = true; + status.textContent = t('screens.support_phase2.sending'); + try { + const { storagePwdInMemory: password } = state.session; + const endpoint = state.entrySettings.solanaServer; + let result; + if (isDirect) { + let address = ''; + try { + const pda = await readShineUserPda({ login: recipientLogin, solanaEndpoint: endpoint }); + address = bytesToBase58(pda.forks.at(-1).blockchainKey); + } catch { + const recipient = await authService.getUser(recipientLogin); + if (!recipient?.exists) throw new Error(t('screens.support_phase2.unavailable')); + address = solanaAddressFromPublicKeyBase64(recipient.blockchainKey); + } + const wallet = await getWalletFromStoredBlockchainKey({ login, storagePwd: password }); + result = await transferSolLamports({ endpoint, fromKeypair: wallet.keypair, toAddress: address, amountLamports: amount }); + } else { + const secrets = await loadEncryptedUserSecrets(login, password); + if (!secrets?.blockchainKey || !secrets?.clientKey) throw new Error(t('screens.support_phase2.keys_required')); + const args = { senderLogin: login, amountLamports: amount, solanaEndpoint: endpoint, blockchainPrivatePkcs8B64: secrets.blockchainKey, clientPrivatePkcs8B64: secrets.clientKey }; + result = dao ? await supportShineDaoOnSolana(args) : await supportShineUserOnSolana({ ...args, recipientLogin, target }); + } + status.textContent = `${t('screens.support_phase2.success')} ${result.signature || ''}`; + try { onSuccess(result); } catch { /* page may have been closed */ } + donate.hidden = true; + direct.hidden = true; + cancel.disabled = false; + cancel.textContent = t('screens.support_phase2.close'); + } catch (error) { + status.textContent = toUserMessage(error, t('screens.support_phase2.failed')); + } finally { + busy = false; + donate.disabled = direct.disabled = cancel.disabled = input.disabled = false; + } + }; + donate.addEventListener('click', () => void send(false)); + direct.addEventListener('click', () => void send(true)); + input.focus(); + return overlay; +} diff --git a/shine-UI/js/components/support-stats.js b/shine-UI/js/components/support-stats.js new file mode 100644 index 00000000..740d2996 --- /dev/null +++ b/shine-UI/js/components/support-stats.js @@ -0,0 +1,50 @@ +import { t } from '../i18n/index.js'; +import { readShineUserPda } from '../services/shine-user-pda-service.js'; +import { formatLamportsSol } from '../services/shine-support-amount.js'; + +export function supportStatsValues(stats = {}) { + const sent = BigInt(stats.supportSent ?? 0); + const received = BigInt(stats.supportReceived ?? 0); + const daoDirect = BigInt(stats.daoDirect ?? 0); + return [sent, received, sent / 10n + daoDirect]; +} + +/** Adds an independent asynchronous block; failure/Free accounts do not get fictitious statistics. */ +export function attachSupportStats(parent, { login, solanaEndpoint, isActive = () => true }) { + const section = document.createElement('section'); + section.className = 'card stack profile-support-stats'; + section.style.cssText = 'margin-top:12px;gap:8px;'; + const title = document.createElement('strong'); + title.textContent = t('screens.support_phase2.statistics'); + const content = document.createElement('div'); + content.className = 'meta-muted'; + content.textContent = t('screens.support_phase2.loading'); + section.append(title, content); + parent.append(section); + const refresh = async () => { + try { + const pda = await readShineUserPda({ login, solanaEndpoint }); + if (!isActive() || !section.isConnected) return; + const values = supportStatsValues(pda.supportStats ?? {}); + content.replaceChildren(); + content.className = 'stack'; + [t('screens.support_phase2.sent'), t('screens.support_phase2.received'), t('screens.support_phase2.shine')].forEach((label, idx) => { + const row = document.createElement('div'); + row.className = 'row'; + row.style.cssText = 'display:flex;justify-content:space-between;gap:8px;'; + const name = document.createElement('span'); + const amount = document.createElement('strong'); + name.textContent = label; + amount.textContent = `${formatLamportsSol(values[idx])} SOL`; + row.append(name, amount); + content.append(row); + }); + } catch { + if (!isActive() || !section.isConnected) return; + // A missing Paid PDA means Free, but network errors must not be displayed as zero. + content.textContent = t('screens.support_phase2.unavailable'); + } + }; + void refresh(); + return { element: section, refresh }; +} diff --git a/shine-UI/js/i18n/locales/en.json b/shine-UI/js/i18n/locales/en.json index 9b988c87..c3e05676 100644 --- a/shine-UI/js/i18n/locales/en.json +++ b/shine-UI/js/i18n/locales/en.json @@ -4211,6 +4211,47 @@ "error": "Could not load connections. Check your connection or try another user.", "clearing": "Clearing cache…", "a11y": "Center: {value1}. {value2} users shown on the map." + }, + "support_flow": { + "donate": "Donate · 90% to creator", + "direct": "Transfer directly · 100%", + "recipient": "To creator", + "fund": "To SHiNE economy", + "explanation": "10% goes to the SHiNE economy fund. This transfer counts toward public support statistics.", + "paid_required": "The recipient needs a paid Solana PDA for tracked support. Direct transfers remain available.", + "divisible": "The amount must be divisible by 10 lamports.", + "direct_warning": "The recipient will get 100%. Direct transfers are NOT counted in SHiNE support statistics because they bypass anti-manipulation checks. Continue?", + "keys_required": "Saved blockchain and client keys are required on this device for tracked support." + }, + "support_phase2": { + "statistics": "Support", + "loading": "Loading support totals…", + "sent": "❤️ Supported others", + "received": "💚 Support received", + "shine": "✨ Supported SHiNE", + "unavailable": "Totals unavailable (Free account or Solana error)", + "donate_shine": "✨ Support SHiNE", + "donate": "Donate", + "to": "Recipient:", + "amount": "Amount, SOL", + "recipient": "Recipient", + "fund": "SHiNE economy", + "dao_info": "100% of your donation goes to the SHiNE economic fund and participates in its existing payout system.", + "direct": "Direct transfer — 100%", + "direct_warning": "The recipient gets 100%. Direct transfers are not included in SHiNE support totals because they bypass the verified anti-manipulation mechanism. Continue?", + "divisible": "Tracked support must be divisible by 10 lamports", + "explanation": "90% to recipient, 10% to the SHiNE economy; included in public support totals.", + "login_required": "Sign in to SHiNE to transfer", + "self_support": "You cannot support yourself", + "keys_required": "Cannot find keys needed for tracked support", + "sending": "Sending transfer…", + "success": "Transfer confirmed:", + "failed": "Transfer failed", + "close": "Close", + "invalid_target": "This post has no verified block number or hash" + }, + "support_phase3": { + "channel_total": "Channel support received" } }, "errors": { diff --git a/shine-UI/js/i18n/locales/ru.json b/shine-UI/js/i18n/locales/ru.json index f3976235..8483f18e 100644 --- a/shine-UI/js/i18n/locales/ru.json +++ b/shine-UI/js/i18n/locales/ru.json @@ -4211,6 +4211,47 @@ "error": "Не удалось загрузить связи. Проверьте соединение или попробуйте другого пользователя.", "clearing": "Очистка кэша…", "a11y": "Центр: {value1}. На карте {value2} пользователей." + }, + "support_flow": { + "donate": "Пожертвовать · 90% автору", + "direct": "Перевести напрямую · 100%", + "recipient": "Автору", + "fund": "Экономике SHiNE", + "explanation": "10% поступает в экономический фонд SHiNE. Перевод учитывается в статистике поддержки.", + "paid_required": "Для учитываемой поддержки автору нужен платный Solana PDA. Прямой перевод доступен.", + "divisible": "Сумма должна быть кратна 10 lamports.", + "direct_warning": "Получатель получит 100% суммы. Прямой перевод НЕ учитывается в статистике поддержки SHiNE, так как не проходит проверяемую защиту от накруток. Продолжить?", + "keys_required": "Для учитываемой поддержки нужны сохранённые blockchain и client ключи на этом устройстве." + }, + "support_phase2": { + "statistics": "Поддержка", + "loading": "Загрузка статистики…", + "sent": "❤️ Поддержал других", + "received": "💚 Получил поддержку", + "shine": "✨ Поддержал SHiNE", + "unavailable": "Статистика недоступна (Free или ошибка Solana)", + "donate_shine": "✨ Поддержать SHiNE", + "donate": "Пожертвовать", + "to": "Получатель:", + "amount": "Сумма, SOL", + "recipient": "Получателю", + "fund": "Экономике SHiNE", + "dao_info": "100% пожертвования поступает в экономический фонд SHiNE и участвует в действующей системе выплат.", + "direct": "Перевести напрямую — 100%", + "direct_warning": "Получатель получит всю сумму. Прямой перевод не учитывается в статистике поддержки SHiNE, поскольку не проходит проверяемую защиту от накруток. Продолжить?", + "divisible": "Для учитываемого перевода сумма должна быть кратной 10 lamports", + "explanation": "90% получателю, 10% на развитие экономики SHiNE; учитывается в статистике.", + "login_required": "Войдите в SHiNE, чтобы отправить перевод", + "self_support": "Нельзя поддерживать самого себя", + "keys_required": "Не найдены ключи для отправки учитываемой поддержки", + "sending": "Отправка перевода…", + "success": "Перевод подтверждён:", + "failed": "Не удалось отправить перевод", + "close": "Закрыть", + "invalid_target": "Для этой публикации отсутствует проверенный номер или хеш блока" + }, + "support_phase3": { + "channel_total": "Канал получил поддержку" } }, "errors": { diff --git a/shine-UI/js/pages/channel-donate-view.js b/shine-UI/js/pages/channel-donate-view.js index 91d33785..6b24c017 100644 --- a/shine-UI/js/pages/channel-donate-view.js +++ b/shine-UI/js/pages/channel-donate-view.js @@ -9,10 +9,15 @@ import { getSolanaWalletFromStoredSecret, getWalletFromStoredBlockchainKey, solanaAddressFromPublicKeyBase64, - transferSol, } from '../services/solana-wallet-service.js'; import { showToast } from '../services/channels-ux.js'; import { toUserMessage } from '../services/ui-error-texts.js'; +import { bytesToBase58 } from '../services/crypto-utils.js'; +import { loadEncryptedUserSecrets } from '../services/key-vault.js'; +import { readShineUserPda, supportShineUserOnSolana } from '../services/shine-user-pda-service.js'; +import { parseSolLamports, formatLamportsSol, hexHash32 } from '../services/shine-support-amount.js'; +import { transferSolLamports } from '../services/solana-wallet-service.js'; +import { loadVerifiedSupportTotals, formatVerifiedSupportLamports } from '../services/support-totals-service.js'; export const pageMeta = { id: 'channel-donate-view', get title() { return t('screens.channel_donate_view.text_001'); } }; @@ -135,12 +140,14 @@ export function render({ navigate, route, chrome }) { walletCache.clear(); }; - const renderDonationForm = ({ channel, selector, ownerUser }) => { + const renderDonationForm = ({ channel, selector, ownerUser, recipientPda }) => { const ownerLogin = String(channel?.ownerLogin || extractLoginFromBlockchainName(selector?.ownerBlockchainName) || '').trim(); const channelTitle = String(channel?.displayTitle || channel?.displayName || channel?.channelName || t('screens.channel_donate_view.text_018')).trim(); const channelName = String(channel?.channelName || selector?.channelName || '').trim(); const recipientChoices = [ - publicKeyChoice(ownerUser, 'blockchainKey', 'blockchain-key', 'Blockchain key'), + recipientPda?.forks?.length + ? { id: 'blockchain-key', label: 'Blockchain key', address: bytesToBase58(recipientPda.forks.at(-1).blockchainKey) } + : publicKeyChoice(ownerUser, 'blockchainKey', 'blockchain-key', 'Blockchain key'), ].filter(Boolean); content.innerHTML = ` @@ -149,6 +156,7 @@ export function render({ navigate, route, chrome }) { ${escapeHtml(channelTitle)} ${escapeHtml(formatChannelAddress({ ownerLogin, channelName }))} +
@@ -180,14 +188,17 @@ export function render({ navigate, route, chrome }) {
- + SOL
+

+

- + + `; const recipientSelect = content.querySelector('#channel-donate-recipient-key'); @@ -200,10 +211,14 @@ export function render({ navigate, route, chrome }) { const resultEl = content.querySelector('#channel-donate-result'); const submitEl = content.querySelector('#channel-donate-submit'); const refreshEl = content.querySelector('#channel-donate-refresh'); + const directEl = content.querySelector('#channel-donate-direct'); + const splitEl = content.querySelector('#channel-donate-split'); + const explanationEl = content.querySelector('#channel-donate-explanation'); const setBusy = (nextBusy) => { busy = Boolean(nextBusy); - if (submitEl) submitEl.disabled = busy || recipientChoices.length === 0; + if (submitEl) submitEl.disabled = busy || recipientChoices.length === 0 || !recipientPda; + if (directEl) directEl.disabled = busy || recipientChoices.length === 0; if (refreshEl) refreshEl.disabled = busy; if (recipientSelect) recipientSelect.disabled = busy || recipientChoices.length === 0; if (senderSelect) senderSelect.disabled = busy; @@ -274,60 +289,83 @@ export function render({ navigate, route, chrome }) { }); refreshEl?.addEventListener('click', () => void refreshBalance()); - submitEl?.addEventListener('click', async () => { + const renderSplit = () => { + try { + const amount = parseSolLamports(amountEl?.value || ''); + if (splitEl) splitEl.textContent = `${t('screens.support_flow.recipient')}: ${formatLamportsSol(amount * 9n / 10n)} SOL · ${t('screens.support_flow.fund')}: ${formatLamportsSol(amount / 10n)} SOL`; + } catch { if (splitEl) splitEl.textContent = ''; } + }; + if (explanationEl) explanationEl.textContent = recipientPda + ? t('screens.support_flow.explanation') + : t('screens.support_flow.paid_required'); + amountEl?.addEventListener('input', renderSplit); + + const submitTransfer = async (direct) => { if (busy || disposed) return; const recipient = selectedRecipient(); - if (!recipient?.address) { - setStatus(t('screens.channel_donate_view.text_007'), 'error'); - return; - } - - const amount = Number(String(amountEl?.value || '').replace(',', '.')); - if (!Number.isFinite(amount) || amount <= 0) { - setStatus(t('screens.channel_donate_view.text_008'), 'error'); - return; - } + if (!recipient?.address) { setStatus(t('screens.channel_donate_view.text_007'), 'error'); return; } + let amount; + try { + amount = parseSolLamports(amountEl?.value || ''); + if (!direct && amount % 10n !== 0n) throw new Error(t('screens.support_flow.divisible')); + } catch (error) { setStatus(error.message || t('screens.channel_donate_view.text_008'), 'error'); return; } + if (direct && !window.confirm(t('screens.support_flow.direct_warning'))) return; setBusy(true); setStatus(t('screens.channel_donate_view.text_009')); - if (resultEl) { - resultEl.hidden = true; - resultEl.innerHTML = ''; - } - + if (resultEl) { resultEl.hidden = true; resultEl.innerHTML = ''; } try { const wallet = await resolveSenderWallet(); - const result = await transferSol({ - endpoint: state.entrySettings.solanaServer, - fromKeypair: wallet.keypair, - toAddress: recipient.address, - amountSol: amount, - }); + let result; + if (direct) { + // Свежий ключ читается перед отправкой; если PDA есть, он приоритетнее серверного профиля. + let address = recipient.address; + if (recipientPda) { + const fresh = await readShineUserPda({ login: ownerLogin, solanaEndpoint: state.entrySettings.solanaServer }); + const key = fresh.forks.at(-1).blockchainKey; + address = bytesToBase58(key); + } else { + const latest = await authService.getUser(ownerLogin); + address = publicKeyChoice(latest, 'blockchainKey', 'blockchain-key', 'Blockchain key')?.address || ''; + if (!address) throw new Error(t('screens.channel_donate_view.text_007')); + } + result = await transferSolLamports({ endpoint: state.entrySettings.solanaServer, fromKeypair: wallet.keypair, toAddress: address, amountLamports: amount }); + } else { + if (!recipientPda) throw new Error(t('screens.support_flow.paid_required')); + const { login, storagePwdInMemory: storagePwd } = state.session; + const secrets = await loadEncryptedUserSecrets(login, storagePwd); + if (!secrets?.blockchainKey || !secrets?.clientKey) throw new Error(t('screens.support_flow.keys_required')); + result = await supportShineUserOnSolana({ + senderLogin: login, recipientLogin: ownerLogin, amountLamports: amount, + target: { type: 1, channelBlockNumber: BigInt(selector.channelRootBlockNumber), channelBlockHash: hexHash32(selector.channelRootBlockHash) }, + solanaEndpoint: state.entrySettings.solanaServer, + blockchainPrivatePkcs8B64: secrets.blockchainKey, + clientPrivatePkcs8B64: secrets.clientKey, + }); + } if (disposed) return; - setStatus(''); if (resultEl) { resultEl.hidden = false; - resultEl.innerHTML = ` - ${th('screens.channel_donate_view.text_031')} - ${escapeHtml(formatSol(amount))} SOL → ${escapeHtml(recipient.label)} - ${escapeHtml(String(result.signature || ''))} - `; + resultEl.innerHTML = `${th('screens.channel_donate_view.text_031')}${escapeHtml(formatLamportsSol(amount))} SOL → ${escapeHtml(recipient.label)}${escapeHtml(String(result.signature || ''))}`; } showToast(t('screens.channel_donate_view.text_010')); - - const balance = await getBalanceSol({ - endpoint: state.entrySettings.solanaServer, - address: wallet.address, - }); + const balance = await getBalanceSol({ endpoint: state.entrySettings.solanaServer, address: wallet.address }); if (!disposed && balanceEl) balanceEl.textContent = `${formatSol(balance.sol)} SOL`; } catch (error) { if (!disposed) setStatus(toUserMessage(error, t('screens.channel_donate_view.text_011')), 'error'); - } finally { - if (!disposed) setBusy(false); - } - }); + } finally { if (!disposed) setBusy(false); } + }; + submitEl?.addEventListener('click', () => void submitTransfer(false)); + directEl?.addEventListener('click', () => void submitTransfer(true)); + renderSplit(); + void loadVerifiedSupportTotals(selector).then((totals) => { + if (disposed) return; + const label = content.querySelector('#channel-donate-verified-total'); + const total = totals && formatVerifiedSupportLamports(totals.channelReceivedLamports); + if (label && total) label.textContent = `${t('screens.support_phase3.channel_total')}: ${total}`; + }); updateRecipientAddress(); if (!recipientChoices.length) { setStatus(t('screens.channel_donate_view.text_012'), 'error'); @@ -351,7 +389,11 @@ export function render({ navigate, route, chrome }) { if (disposed || seq !== refreshSeq) return; if (!ownerUser?.exists) throw new Error(t('screens.channel_donate_view.text_022')); - renderDonationForm({ channel, selector, ownerUser }); + let recipientPda = null; + try { recipientPda = await readShineUserPda({ login: ownerLogin, solanaEndpoint: state.entrySettings.solanaServer }); } + catch { /* Free пользователь: доступен только прямой перевод. */ } + if (disposed || seq !== refreshSeq) return; + renderDonationForm({ channel, selector, ownerUser, recipientPda }); } catch (error) { if (disposed || seq !== refreshSeq) return; content.innerHTML = ` diff --git a/shine-UI/js/pages/channel-thread-view.js b/shine-UI/js/pages/channel-thread-view.js index df9526ef..e3a91296 100644 --- a/shine-UI/js/pages/channel-thread-view.js +++ b/shine-UI/js/pages/channel-thread-view.js @@ -1,3 +1,5 @@ +import { openShineSupportDialog } from '../components/shine-support-dialog.js'; +import { hexHash32 } from '../services/shine-support-amount.js'; import { formatDateTime } from '../i18n/format.js'; import { t, th } from '../i18n/index.js'; import { appendShineMessageLinks } from '../services/shine-message-links.js'; @@ -954,6 +956,14 @@ function renderNodeCard(node, heading, handlers, localNumber, { focusPost = fals }); if (threadsLayout) actions.append(likeButton, ...(likes > 0 ? [likesStatsButton] : []), discussionButton, repostButton, shareButton); else actions.append(likeButton, ...(likes > 0 ? [likesStatsButton] : []), shareButton, discussionButton); + const supportBtn = document.createElement('button'); + supportBtn.type = 'button'; + supportBtn.className = 'ui-button channel-action-item channel-action-support'; + supportBtn.textContent = '♥ SOL'; + supportBtn.title = t('screens.support_phase2.donate'); + supportBtn.addEventListener('click', (event) => { event.stopPropagation(); handlers.onSupport?.(node, target); }); + + actions.append(supportBtn); menuItems.unshift({ label: t('screens.channel_thread_view.text_009'), iconHtml: iconHtml('reply'), action: () => replyButton.click() }); // Те же действия, что у ответов в обсуждении. menuItems.splice(1, 0, { label: t('screens.channel_thread_view.text_010'), iconHtml: iconHtml('copy'), action: async () => { @@ -1257,6 +1267,14 @@ function renderComment({ node, parent, focus, channelOwner, handlers, nested = f // Ряд действий как у записи канала: лайк, ответы, репост, поделиться. actions.append(like, ...(likes > 0 ? [commentLikeStats] : []), reply, repost, share); + const supportBtn = document.createElement('button'); + supportBtn.type = 'button'; + supportBtn.className = 'channel-action-item thread-comment__support'; + supportBtn.textContent = '♥ SOL'; + supportBtn.title = t('screens.support_phase2.donate'); + supportBtn.addEventListener('click', (event) => { event.stopPropagation(); handlers.onSupport?.(node, target); }); + actions.append(supportBtn); + main.append(actions); item.append(who, main); // Как в Threads: нажатие на ответ открывает его обсуждение (кнопки, ссылки и вложения работают сами по себе). @@ -1678,6 +1696,21 @@ export function render({ navigate, route, chrome }) { // Пришли по «Обсуждение» из ленты – после первой загрузки сразу открыть редактор ответа. let openEditorOnLoad = consumeReplyEditorOnOpen(window.location.pathname); const handlers = { + onSupport: (node, target) => { + const rootNumber = selector?.channel?.channelRootBlockNumber; + const rootHash = String(selector?.channel?.channelRootBlockHash || '').trim(); + const messageHash = String(target?.blockHash || '').trim(); + const recipientLogin = String(node?.authorLogin || '').trim(); + if (!recipientLogin || !Number.isSafeInteger(Number(rootNumber)) + || !/^[0-9a-f]{64}$/i.test(rootHash) || !/^[0-9a-f]{64}$/i.test(messageHash)) { + showToast(t('screens.support_phase2.invalid_target'), { kind: 'error' }); + return; + } + openShineSupportDialog({ recipientLogin, target: { + type: 2, channelBlockNumber: BigInt(rootNumber), channelBlockHash: hexHash32(rootHash), + messageBlockNumber: BigInt(target.blockNumber), messageBlockHash: hexHash32(messageHash), + } }); + }, navigate, isActive: () => !disposed, openReplyEditor: (node) => replyEditorOpener?.(node), diff --git a/shine-UI/js/pages/channel-view.js b/shine-UI/js/pages/channel-view.js index 0237d54d..addfefbc 100644 --- a/shine-UI/js/pages/channel-view.js +++ b/shine-UI/js/pages/channel-view.js @@ -1,3 +1,6 @@ +import { openShineSupportDialog } from '../components/shine-support-dialog.js'; +import { hexHash32 } from '../services/shine-support-amount.js'; +import { loadVerifiedSupportTotals, formatVerifiedSupportLamports } from '../services/support-totals-service.js'; import { formatDateTime, getIntlLocale } from '../i18n/format.js'; import { t, th } from '../i18n/index.js'; import { appendShineMessageLinks } from '../services/shine-message-links.js'; @@ -2155,9 +2158,42 @@ function renderPostCard(post, { if (!REPOSTS_ENABLED) { notifyRepostSoon(); return; } void onRepost?.(post.messageRef); }); + // Support posts through the verified on-chain 90/10 flow (separate from likes). + const supportButton = document.createElement('button'); + supportButton.type = 'button'; + supportButton.className = 'ui-button channel-action-item channel-action-support'; + supportButton.textContent = '♥ SOL'; + supportButton.title = t('screens.support_phase2.donate'); + // Проверенные сервером суммы; если индексатор не готов, число не показываем. + if (post.messageRef?.blockNumber != null && post.messageRef?.blockHash) { + const messageId = `${String(post.messageRef.blockNumber)}:${String(post.messageRef.blockHash).toLowerCase()}`; + void loadVerifiedSupportTotals(selector).then((totals) => { + if (!totals || !supportButton.isConnected) return; + const formatted = formatVerifiedSupportLamports(totals.messages.get(messageId)); + if (formatted) supportButton.textContent = `♥ ${formatted}`; + }); + } + + supportButton.addEventListener('click', (event) => { + event.stopPropagation(); + const messageRef = post.messageRef; + const rootHash = String(selector?.channelRootBlockHash || ''); + const msgHash = String(messageRef?.blockHash || ''); + const recipient = String(post.authorLogin || '').trim(); + if (!recipient || !/^[0-9a-f]{64}$/i.test(rootHash) || !/^[0-9a-f]{64}$/i.test(msgHash)) { + showToast(t('screens.support_phase2.invalid_target'), { kind: 'error' }); + return; + } + openShineSupportDialog({ recipientLogin: recipient, target: { + type: 2, + channelBlockNumber: BigInt(selector.channelRootBlockNumber), channelBlockHash: hexHash32(rootHash), + messageBlockNumber: BigInt(messageRef.blockNumber), messageBlockHash: hexHash32(msgHash), + } }); + }); // Четыре кнопки как в Threads: лайк, ответы, репост, поделиться. if (threadsLayout) actions.append(likeButton, ...(Number(post.likesCount) > 0 ? [likesStatsButton] : []), discussionButton, repostButton, shareButton); else actions.append(likeButton, ...(Number(post.likesCount) > 0 ? [likesStatsButton] : []), shareButton, discussionButton); + actions.append(supportButton); if (selector?.publicOrdinalUrlsAllowed && post.messageRef?.blockNumber != null) { const streamRoute = makeShineChannelStreamRoute({ ownerBlockchainName: selector?.ownerBlockchainName, diff --git a/shine-UI/js/pages/profile-view.js b/shine-UI/js/pages/profile-view.js index 42e900d4..5d1bfd45 100644 --- a/shine-UI/js/pages/profile-view.js +++ b/shine-UI/js/pages/profile-view.js @@ -1,3 +1,4 @@ +import { attachSupportStats } from '../components/support-stats.js'; import { t, th } from '../i18n/index.js'; import { profile } from '../mock-data.js'; import { state } from '../state.js'; @@ -66,6 +67,7 @@ export function render({ navigate, chrome }) { `; + attachSupportStats(body, { login: card.login || login, solanaEndpoint: state.entrySettings.solanaServer, isActive: () => !disposed }); avatarPreview = attachProfileAvatarPreview(body.querySelector('.user-profile-avatar-slot'), card); status.replaceChildren(); diff --git a/shine-UI/js/pages/user-profile-view.js b/shine-UI/js/pages/user-profile-view.js index ab9ff053..7e5d08f6 100644 --- a/shine-UI/js/pages/user-profile-view.js +++ b/shine-UI/js/pages/user-profile-view.js @@ -1,3 +1,5 @@ +import { openShineSupportDialog } from '../components/shine-support-dialog.js'; +import { attachSupportStats } from '../components/support-stats.js'; import { t } from '../i18n/index.js'; import { createTopBar } from '../components/topbar.js'; import { SHINE_CONNECTIONS_LOGO_SRC } from '../components/shine-logo.js'; @@ -61,9 +63,11 @@ export function render({ navigate, route, chrome }) { profileTileHtml({ icon: 'user-plus', label: t('screens.user_profile_view.text_004'), attrs: 'data-profile-action="add"' }), profileTileHtml({ label: t('screens.user_profile_view.text_005'), attrs: 'data-profile-action="links"', iconMarkup: `` }), profileTileHtml({ icon: 'message', label: t('screens.user_profile_view.text_006'), attrs: 'data-profile-action="chat"' }), + profileTileHtml({ icon: 'heart', label: t('screens.support_phase2.donate'), attrs: 'data-profile-action="support"' }), ].join(''), }); + attachSupportStats(body, { login: card.login, solanaEndpoint: state.entrySettings.solanaServer, isActive: () => !disposed }); syncRelationTile(); avatarPreview = attachProfileAvatarPreview(body.querySelector('.user-profile-avatar-slot'), card); @@ -121,6 +125,10 @@ export function render({ navigate, route, chrome }) { navigate(makeProfileLinksRoute(card.login)); return; } + if (action === 'support') { + openShineSupportDialog({ recipientLogin: card.login, onSuccess: () => { if (!disposed) renderProfile(); } }); + return; + } if (action === 'chat') { navigate(`chat/${encodeURIComponent(card.login)}`); } diff --git a/shine-UI/js/pages/wallet-view.js b/shine-UI/js/pages/wallet-view.js index 8348c237..9ac4d260 100644 --- a/shine-UI/js/pages/wallet-view.js +++ b/shine-UI/js/pages/wallet-view.js @@ -1,3 +1,4 @@ +import { openShineSupportDialog } from '../components/shine-support-dialog.js'; import { formatDateTime, formatNumber } from '../i18n/format.js'; import { t, th } from '../i18n/index.js'; import { getSolanaCluster, confirmSolanaTransactionHttp } from '../services/solana-rpc-gateway.js'; @@ -1867,10 +1868,12 @@ export function render({navigate, chrome}) { + `; const refreshBtn = actions.querySelector('#refresh-balance'); const sendBtn = actions.querySelector('#send-sol'); + actions.querySelector('#donate-shine')?.addEventListener('click', () => openShineSupportDialog({ onSuccess: () => void refreshBalance() })); const refreshBalance = async () => { if (!walletAddress) { diff --git a/shine-UI/js/services/auth-service.js b/shine-UI/js/services/auth-service.js index dd2f03b2..ca782be8 100644 --- a/shine-UI/js/services/auth-service.js +++ b/shine-UI/js/services/auth-service.js @@ -1598,6 +1598,16 @@ export class AuthService { return response.payload || {}; } + async getSupportTotals(channel) { + const payload = { + channelRootBlockNumber: Number(channel?.channelRootBlockNumber), + channelRootBlockHash: String(channel?.channelRootBlockHash || '').trim(), + }; + const response = await this.ws.request('GetSupportTotals', payload); + if (response.status !== 200) throw opError('GetSupportTotals', response); + return response.payload || {}; + } + async getMessageThread(message, depthUp = 20, depthDown = 2, limitChildrenPerNode = 50, login = '') { const normalizedMessage = { blockchainName: String(message?.blockchainName || '').trim(), diff --git a/shine-UI/js/services/shine-blockchain-wallet-service.js b/shine-UI/js/services/shine-blockchain-wallet-service.js index c425ae18..a776c210 100644 --- a/shine-UI/js/services/shine-blockchain-wallet-service.js +++ b/shine-UI/js/services/shine-blockchain-wallet-service.js @@ -4,4 +4,6 @@ export { getShineBlockchainUsage, getShineUsersEconomyConfig, updateShineUserPdaOnSolana, + supportShineUserOnSolana, + supportShineDaoOnSolana, } from './shine-user-pda-service.js'; diff --git a/shine-UI/js/services/shine-support-amount.js b/shine-UI/js/services/shine-support-amount.js new file mode 100644 index 00000000..747eb7d2 --- /dev/null +++ b/shine-UI/js/services/shine-support-amount.js @@ -0,0 +1,20 @@ +/** Точная денежная арифметика для пожертвований SHiNE: без Number. */ +export function parseSolLamports(input) { + const text = String(input ?? '').trim().replace(',', '.'); + if (!/^(?:0|[1-9]\d*)(?:\.\d{1,9})?$/.test(text)) throw new Error('Введите положительную сумму SOL (не более 9 знаков после запятой)'); + const [whole, fraction = ''] = text.split('.'); + const amount = BigInt(whole) * 1_000_000_000n + BigInt(fraction.padEnd(9, '0') || '0'); + if (amount <= 0n || amount > 0xffff_ffff_ffff_ffffn) throw new Error('Сумма SOL вне допустимого диапазона'); + return amount; +} +export function formatLamportsSol(value) { + const n = BigInt(value); + const sign = n < 0n ? '-' : ''; + const abs = n < 0n ? -n : n; + return sign + String(abs / 1_000_000_000n) + (abs % 1_000_000_000n ? '.' + String(abs % 1_000_000_000n).padStart(9, '0').replace(/0+$/, '') : ''); +} +export function hexHash32(value) { + const hex = String(value || '').trim().toLowerCase(); + if (!/^[0-9a-f]{64}$/.test(hex)) throw new Error('Некорректный 32-байтовый хеш блока канала'); + return Uint8Array.from({ length: 32 }, (_, i) => parseInt(hex.slice(i * 2, i * 2 + 2), 16)); +} diff --git a/shine-UI/js/services/shine-user-pda-service.js b/shine-UI/js/services/shine-user-pda-service.js index c9b5180f..4fcbbbdc 100644 --- a/shine-UI/js/services/shine-user-pda-service.js +++ b/shine-UI/js/services/shine-user-pda-service.js @@ -33,6 +33,8 @@ const AUTH_MODE_ROOT = 1; const IX_CREATE_USER_PDA = 3; const IX_UPDATE_USER_PDA = 4; const IX_CLOSE_LEGACY_USER_PDA = 6; +const IX_SUPPORT_USER = 9; +const IX_SUPPORT_DAO = 10; const DAY_MS = 86_400_000n; const FORK_COOLDOWN_MS = 3n * DAY_MS; const MAX_EFFECTIVE_ACCESS_SERVERS = 1; @@ -288,7 +290,14 @@ export function parseShineUserPda(dataBytes) { const blocksOffset = reader.offset; const signature = bytes.slice(recordLen - 64, recordLen); const unsignedBytes = bytes.slice(0, recordLen - 64); - const header = { formatMajor, formatMinor, recordLen, createdAtMs, updatedAtMs, recordNumber, prevRecordHash, login, blocksCount, blocksOffset, signature, unsignedBytes }; + let supportStats = { version: 0, supportSent: 0n, supportReceived: 0n, daoDirect: 0n }; + if (recordLen < bytes.length && bytes[recordLen] !== 0) { + if (bytes[recordLen] !== 1) throw new Error('Неподдерживаемая версия статистики поддержки'); + if (recordLen + 25 > bytes.length) throw new Error('Обрезан блок статистики поддержки'); + const statsReader = makeReader(bytes.slice(recordLen + 1, recordLen + 25)); + supportStats = { version: 1, supportSent: statsReader.readU64(), supportReceived: statsReader.readU64(), daoDirect: statsReader.readU64() }; + } + const header = { formatMajor, formatMinor, recordLen, createdAtMs, updatedAtMs, recordNumber, prevRecordHash, login, blocksCount, blocksOffset, signature, unsignedBytes, supportStats }; return parseV12Pda(bytes, header); } @@ -815,3 +824,52 @@ export function calcLimitTopupPriceLamports(additionalLimitBytes, lamportsPerLim } export function getLimitStepBytes() { return LIMIT_STEP; } + +function supportData(tag, senderLogin, recipientLogin, amountLamports, target) { + const out = [tag]; + const putString = (value) => { const bytes = new TextEncoder().encode(String(value)); if (bytes.length > 255) throw new Error('Слишком длинный login'); out.push(bytes.length, ...bytes); }; + putString(senderLogin); + if (recipientLogin != null) putString(recipientLogin); + pushU64LE(out, amountLamports); + if (target != null) { + out.push(target.type); + if (target.type === 1 || target.type === 2) { pushU64LE(out, target.channelBlockNumber); out.push(...toUint8Array(target.channelBlockHash, 32)); } + if (target.type === 2) { pushU64LE(out, target.messageBlockNumber); out.push(...toUint8Array(target.messageBlockHash, 32)); } + } + return new Uint8Array(out); +} + +/** Выполняет учитываемую поддержку через shine_users без Number и округлений. */ +export async function supportShineUserOnSolana({ senderLogin, recipientLogin, amountLamports, target = { type: 0 }, solanaEndpoint, blockchainPrivatePkcs8B64, clientPrivatePkcs8B64 }) { + const amount = BigInt(amountLamports); + if (amount <= 0n || amount % 10n !== 0n) throw new Error('Сумма учитываемой поддержки должна быть положительной и кратной 10 lamports'); + const sender = await readShineUserPda({ login: senderLogin, solanaEndpoint }); + const recipient = await readShineUserPda({ login: recipientLogin, solanaEndpoint }); + const ctx = await buildCommonContext({ login: sender.login, solanaEndpoint, clientPrivatePkcs8B64, payerPrivatePkcs8B64: blockchainPrivatePkcs8B64 }); + const recipientSeed = await userPdaSeed32(recipient.login); + const [recipientPda] = await ctx.solana.PublicKey.findProgramAddress([recipientSeed], new ctx.solana.PublicKey(SHINE_USERS_PROGRAM_ID)); + const recipientKey = new ctx.solana.PublicKey(recipient.forks.at(-1).blockchainKey); + if (!ctx.payerKeypair.publicKey.equals(new ctx.solana.PublicKey(sender.forks.at(-1).blockchainKey))) throw new Error('Подписант должен быть актуальным blockchain key отправителя'); + const ix = new ctx.solana.TransactionInstruction({ programId: new ctx.solana.PublicKey(SHINE_USERS_PROGRAM_ID), keys: [ + { pubkey: ctx.payerKeypair.publicKey, isSigner: true, isWritable: true }, { pubkey: ctx.userPda, isSigner: false, isWritable: true }, + { pubkey: recipientKey, isSigner: false, isWritable: true }, { pubkey: recipientPda, isSigner: false, isWritable: true }, + { pubkey: ctx.inflowVault, isSigner: false, isWritable: true }, { pubkey: ctx.economyConfigPda, isSigner: false, isWritable: false }, + { pubkey: ctx.solana.SystemProgram.programId, isSigner: false, isWritable: false }, + ], data: supportData(IX_SUPPORT_USER, sender.login, recipient.login, amount, target) }); + const signature = await sendAndConfirmSolanaHttp(ctx.connection, new ctx.solana.Transaction().add(ix), [ctx.payerKeypair]); + return { signature, amountLamports: amount, recipientLamports: amount * 9n / 10n, inflowLamports: amount / 10n }; +} + +export async function supportShineDaoOnSolana({ senderLogin, amountLamports, solanaEndpoint, blockchainPrivatePkcs8B64, clientPrivatePkcs8B64 }) { + const amount = BigInt(amountLamports); + if (amount <= 0n) throw new Error('Сумма пожертвования должна быть положительной'); + const sender = await readShineUserPda({ login: senderLogin, solanaEndpoint }); + const ctx = await buildCommonContext({ login: sender.login, solanaEndpoint, clientPrivatePkcs8B64, payerPrivatePkcs8B64: blockchainPrivatePkcs8B64 }); + const ix = new ctx.solana.TransactionInstruction({ programId: new ctx.solana.PublicKey(SHINE_USERS_PROGRAM_ID), keys: [ + { pubkey: ctx.payerKeypair.publicKey, isSigner: true, isWritable: true }, { pubkey: ctx.userPda, isSigner: false, isWritable: true }, + { pubkey: ctx.inflowVault, isSigner: false, isWritable: true }, { pubkey: ctx.economyConfigPda, isSigner: false, isWritable: false }, + { pubkey: ctx.solana.SystemProgram.programId, isSigner: false, isWritable: false }, + ], data: supportData(IX_SUPPORT_DAO, sender.login, null, amount, null) }); + const signature = await sendAndConfirmSolanaHttp(ctx.connection, new ctx.solana.Transaction().add(ix), [ctx.payerKeypair]); + return { signature, amountLamports: amount }; +} diff --git a/shine-UI/js/services/solana-wallet-service.js b/shine-UI/js/services/solana-wallet-service.js index ac5413f3..6b85aaa5 100644 --- a/shine-UI/js/services/solana-wallet-service.js +++ b/shine-UI/js/services/solana-wallet-service.js @@ -290,6 +290,21 @@ export async function transferSol({ endpoint, fromKeypair, toAddress, amountSol return { endpoint: rpc, signature, lamports }; } +/** Прямой перевод точной суммы в lamports, без преобразований через дробный SOL. */ +export async function transferSolLamports({ endpoint, fromKeypair, toAddress, amountLamports }) { + const solana = await loadSolanaLib(); + const amount = BigInt(amountLamports); + if (amount <= 0n || amount > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error('Сумма вне безопасного диапазона прямого перевода'); + const connection = new solana.Connection(normalizeEndpoint(endpoint), 'confirmed'); + const tx = new solana.Transaction().add(solana.SystemProgram.transfer({ + fromPubkey: fromKeypair.publicKey, + toPubkey: new solana.PublicKey(String(toAddress || '').trim()), + lamports: Number(amount), + })); + const signature = await sendAndConfirmSolanaHttp(connection, tx, [fromKeypair]); + return { signature, lamports: amount }; +} + export async function transferAllSol({ endpoint, fromKeypair, toAddress }) { const solana = await loadSolanaLib(); const rpc = normalizeEndpoint(endpoint); diff --git a/shine-UI/js/services/support-totals-service.js b/shine-UI/js/services/support-totals-service.js new file mode 100644 index 00000000..948dd94e --- /dev/null +++ b/shine-UI/js/services/support-totals-service.js @@ -0,0 +1,34 @@ +import { authService } from '../state.js'; + +// Один запрос на канал; только сервер проверяет привязку транзакции к блоку. +const cache = new Map(); +export function loadVerifiedSupportTotals(selector) { + const number = Number(selector?.channelRootBlockNumber); + const hash = String(selector?.channelRootBlockHash || '').toLowerCase(); + if (!Number.isSafeInteger(number) || !/^[0-9a-f]{64}$/.test(hash)) return Promise.resolve(null); + const key = `${number}:${hash}`; + if (!cache.has(key)) { + const promise = authService.getSupportTotals({ channelRootBlockNumber: number, channelRootBlockHash: hash }) + .then((response) => { + const messages = new Map(); + for (const row of response?.messages || []) { + const id = `${String(row.blockNumber)}:${String(row.blockHash).toLowerCase()}`; + messages.set(id, String(row.receivedLamports)); + } + return { channelReceivedLamports: String(response?.channelReceivedLamports || '0'), messages }; + }) + .catch(() => { cache.delete(key); return null; }); + cache.set(key, promise); + } + return cache.get(key); +} + +export function formatVerifiedSupportLamports(value) { + try { + const n = BigInt(value); + if (n <= 0n) return null; + const whole = n / 1_000_000_000n; + const fraction = String(n % 1_000_000_000n).padStart(9, '0').replace(/0+$/, ''); + return `${whole}${fraction ? '.' + fraction : ''} SOL`; + } catch { return null; } +} diff --git a/shine-UI/tests/support-channel-phase1.test.mjs b/shine-UI/tests/support-channel-phase1.test.mjs new file mode 100644 index 00000000..a2dc32cc --- /dev/null +++ b/shine-UI/tests/support-channel-phase1.test.mjs @@ -0,0 +1,30 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { readFileSync } from 'node:fs'; +import { parseSolLamports, formatLamportsSol, hexHash32 } from '../js/services/shine-support-amount.js'; + +const source = (path) => readFileSync(new URL(path, import.meta.url), 'utf8'); +test('десятичная сумма SOL обрабатывается точно без Number', () => { + assert.equal(parseSolLamports('0.000000010'), 10n); + assert.equal(parseSolLamports('1,25'), 1250000000n); + assert.equal(formatLamportsSol(1250000001n), '1.250000001'); + assert.equal(parseSolLamports('0.000000001'), 1n); + for (const value of ['0', '-1', '1.1234567890', '1e3', 'NaN', '']) { + assert.throws(() => parseSolLamports(value), undefined, value); + } +}); +test('идентификаторы канала требуют ровно 32 байта hex', () => { + assert.equal(hexHash32('ab'.repeat(32)).length, 32); + assert.equal(hexHash32('ab'.repeat(32))[0], 171); + assert.throws(() => hexHash32('0')); + assert.throws(() => hexHash32('x'.repeat(64))); +}); +test('страница канала использует контракт 90/10 и прямой перевод с подтверждением', () => { + const page = source('../js/pages/channel-donate-view.js'); + assert.match(page, /supportShineUserOnSolana\(/); + assert.match(page, /transferSolLamports\(/); + assert.match(page, /window\.confirm\(t\('screens\.support_flow\.direct_warning'\)\)/); + assert.match(page, /target: \{ type: 1, channelBlockNumber:/); + assert.match(page, /readShineUserPda\(/); + assert.match(source('../js/services/solana-wallet-service.js'), /export async function transferSolLamports/); +}); diff --git a/shine-UI/tests/support-phase2.test.mjs b/shine-UI/tests/support-phase2.test.mjs new file mode 100644 index 00000000..095dfcb5 --- /dev/null +++ b/shine-UI/tests/support-phase2.test.mjs @@ -0,0 +1,43 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { readFileSync } from 'node:fs'; +import { supportStatsValues } from '../js/components/support-stats.js'; + +function file(path) { return readFileSync(new URL(path, import.meta.url), 'utf8'); } + +test('three displayed counters: full sent, net received, sent/10 + direct', () => { + assert.deepEqual(supportStatsValues({ supportSent: 1_000_000_000n, supportReceived: 900_000_000n, daoDirect: 200_000_000n }), [1_000_000_000n, 900_000_000n, 300_000_000n]); + assert.deepEqual(supportStatsValues({}), [0n, 0n, 0n]); +}); + +test('profile views attach counters from Solana PDA and support user action', () => { + assert.match(file('../js/pages/profile-view.js'), /attachSupportStats\(body/); + const other = file('../js/pages/user-profile-view.js'); + assert.match(other, /attachSupportStats\(body/); + assert.match(other, /data-profile-action=\\?"support/); + assert.match(other, /openShineSupportDialog\(\{ recipientLogin: card\.login/); +}); + +test('wallet supports direct SHiNE economy donation', () => { + const wallet = file('../js/pages/wallet-view.js'); + assert.match(wallet, /id="donate-shine"/); + assert.match(wallet, /openShineSupportDialog\(\{ onSuccess/); +}); + +test('message buttons pass checked block hashes, not message text', () => { + for (const page of ['channel-view.js', 'channel-thread-view.js']) { + const src = file(`../js/pages/${page}`); + assert.match(src, /hexHash32\(rootHash\)/); + assert.match(src, /hexHash32\(msgHash\)|hexHash32\(messageHash\)/); + assert.match(src, /type: 2/); + } +}); + +test('shared modal protects direct and tracked workflows', () => { + const src = file('../js/components/shine-support-dialog.js'); + assert.match(src, /supportShineUserOnSolana/); + assert.match(src, /supportShineDaoOnSolana/); + assert.match(src, /transferSolLamports/); + assert.match(src, /window\.confirm\(t\('screens\.support_phase2\.direct_warning'\)\)/); + assert.match(src, /amount % 10n/); +}); 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 25896d25..e846c0c5 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 @@ -194,3 +194,20 @@ Legacy migration в 1.2 отсутствует. После удаления те ### Регистронезависимая идентичность (28.10.2026) Локальная часть полного `login@namespace` допускает латинские буквы `A–Z` и `a–z`, цифры и `_`; `namespace` допускает только нижний ASCII-регистр. Выбранный при регистрации регистр логина неизменяем. Адрес user PDA вычисляется по `SHA256(UTF8("user_login=" + ASCII-lowercase(fullLogin)))` и bump для `find_program_address`. Сама запись PDA 1.2 содержит **оригинальное** написание `login`; подписи записи и регистраторского сертификата проверяются по исходному регистру без нормализации. Это изменение правила seed, не бинарного формата PDA. +# Блок статистики поддержки + +После `record_len` байтов основной подписанной записи располагается необязательный +неподписанный блок `SupportStats`. Он **не входит** в `record_len` и не участвует +в хеше или цифровой подписи `UserRecordV12`. + +| Смещение | Поле | Формат | +| --- | --- | --- | +| 0 | version | `u8` (`1`) | +| 1 | support_sent | `u64 LE` | +| 9 | support_received | `u64 LE` | +| 17 | dao_direct | `u64 LE` | + +Полный размер v1 — 25 байт. Если за `record_len` нет байтов либо первый байт +равен `0`, это v0 и все значения равны нулю. Неизвестная версия или неполный +v1 являются повреждённым форматом. Программа вправе обновлять этот блок без +пользовательской подписи; при update старой записи v0 он создаётся автоматически. diff --git a/shine-solana/shine/doc/programs/shine_users.md b/shine-solana/shine/doc/programs/shine_users.md index fcdb73d5..5d9f69c2 100644 --- a/shine-solana/shine/doc/programs/shine_users.md +++ b/shine-solana/shine/doc/programs/shine_users.md @@ -184,3 +184,21 @@ forks[]: Accounts: signer/current upgrade authority writable, namespace PDA writable, system program read-only, economy PDA read-only, `shine_users` executable read-only, ProgramData read-only. Проверяется реальная текущая upgrade authority, а не ключ по умолчанию. У старого namespace 1.0 цена обновляется с миграцией бинарной записи до v1.1 и возможной доплатой rent за 1 байт. Изменение полей registrar/server/type не допускается. Синхронизатор получает новую цену по истории economy PDA с разбором opcode 8 и чтением обновлённого namespace PDA. Новые регистрации в обоих сценариях всегда проверяют стоимость по on-chain namespace непосредственно перед отправкой транзакции. +# Поддержка и комиссия обновления + +`update_user_pda` после успешной проверки и записи взимает фиксированные +`20_000` lamports в существующий `shine_payments_inflow_vault`, дополнительно к +оплате увеличения лимита и rent. Ошибка инструкции откатывает и запись, и перевод. + +Инструкция `9` (`support_user`) принимает sender/recipient login, `u64 LE` +сумму, target (`USER=0`, `CHANNEL=1`, `MESSAGE=2`) и соответствующие бинарные +идентификаторы блоков/хешей. Сумма положительна и кратна 10; 90% переводится +актуальному blockchain-key получателя, 10% — только в inflow vault. Отправитель +и получатель обязаны быть разными paid PDA с актуальными ключами. В транзакции +read-only присутствует economy PDA для индексирования. Обновляются +`support_sent` и `support_received`. + +Инструкция `10` (`support_dao`) принимает login и положительную сумму, переводит +100% в тот же inflow vault и увеличивает `dao_direct`. Она также требует paid PDA, +актуальный blockchain key и read-only economy PDA. Ни одна из инструкций не +переводит средства непосредственно в `dao_wallet`. diff --git a/shine-solana/shine/programs/shine_users/src/lib.rs b/shine-solana/shine/programs/shine_users/src/lib.rs index 93ec4c38..1771845c 100644 --- a/shine-solana/shine/programs/shine_users/src/lib.rs +++ b/shine-solana/shine/programs/shine_users/src/lib.rs @@ -47,6 +47,13 @@ const IX_UPDATE_USER_PDA: u8 = 4; const IX_CLOSE_LEGACY_USER_PDA: u8 = 6; const IX_CREATE_NAMESPACE: u8 = 7; const IX_UPDATE_NAMESPACE_PRICE: u8 = 8; +const IX_SUPPORT_USER: u8 = 9; +const IX_SUPPORT_DAO: u8 = 10; +const SUPPORT_STATS_VERSION: u8 = 1; +const SUPPORT_STATS_LEN: usize = 25; +const SUPPORT_TARGET_USER: u8 = 0; +const SUPPORT_TARGET_CHANNEL: u8 = 1; +const SUPPORT_TARGET_MESSAGE: u8 = 2; const NAMESPACE_CURRENCY_SOL: u8 = 1; // 2 зарезервировано под USDT, пока запрещено const CERTIFICATE_DOMAIN: &[u8] = b"SHiNE_FREE_REG_V1\0"; @@ -99,6 +106,8 @@ enum ShineUsersError { CertificateRequired = 44, RegistrationFeeBelowRent = 45, UnsupportedNamespaceCurrency = 46, + InvalidSupport = 47, + UnsupportedSupportStats = 48, } impl From for ProgramError { @@ -152,6 +161,29 @@ pub struct UserRecordV12 { pub signature: [u8; 64], } +/// Блок располагается сразу после подписанной записи и не входит в record_len. +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub struct SupportStats { + pub support_sent: u64, + pub support_received: u64, + pub dao_direct: u64, +} + +#[derive(Clone, Debug)] +struct SupportUserArgs { + sender_login: String, + recipient_login: String, + amount_lamports: u64, + target_type: u8, + channel_block_number: Option, + channel_block_hash: Option<[u8; 32]>, + message_block_number: Option, + message_block_hash: Option<[u8; 32]>, +} + +#[derive(Clone, Debug)] +struct SupportDaoArgs { sender_login: String, amount_lamports: u64 } + impl UserRecordV12 { fn active_fork(&self) -> Result<&ForkRecordV12, ProgramError> { self.forks.last().ok_or(ProgramError::from(ShineUsersError::InvalidRecordData)) @@ -297,6 +329,8 @@ 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_SUPPORT_USER => dispatch_support_user(program_id, accounts, r), + IX_SUPPORT_DAO => dispatch_support_dao(program_id, accounts, r), IX_CREATE_NAMESPACE => { let args = parse_namespace_args(&mut r)?; r.finish()?; @@ -314,6 +348,27 @@ fn process_instruction<'a>(program_id: &Pubkey, accounts: &'a [AccountInfo<'a>], } } +fn dispatch_support_user(program_id: &Pubkey, accounts: &[AccountInfo], mut r: Reader<'_>) -> ProgramResult { + let sender_login = r.read_string_u8()?; + let recipient_login = r.read_string_u8()?; + let amount_lamports = r.read_u64()?; + let target_type = r.read_u8()?; + let (channel_block_number, channel_block_hash, message_block_number, message_block_hash) = match target_type { + SUPPORT_TARGET_USER => (None, None, None, None), + SUPPORT_TARGET_CHANNEL => (Some(r.read_u64()?), Some(r.read_fixed_32()?), None, None), + SUPPORT_TARGET_MESSAGE => (Some(r.read_u64()?), Some(r.read_fixed_32()?), Some(r.read_u64()?), Some(r.read_fixed_32()?)), + _ => return Err(ShineUsersError::InvalidSupport.into()), + }; + r.finish()?; + process_support_user(program_id, accounts, SupportUserArgs { sender_login, recipient_login, amount_lamports, target_type, channel_block_number, channel_block_hash, message_block_number, message_block_hash }) +} + +fn dispatch_support_dao(program_id: &Pubkey, accounts: &[AccountInfo], mut r: Reader<'_>) -> ProgramResult { + let args = SupportDaoArgs { sender_login: r.read_string_u8()?, amount_lamports: r.read_u64()? }; + r.finish()?; + process_support_dao(program_id, accounts, args) +} + fn dispatch_create_user_pda<'a>(program_id: &Pubkey, accounts: &'a [AccountInfo<'a>], mut r: Reader<'_>) -> ProgramResult { let args = Box::new(parse_create_args(&mut r)?); r.finish()?; @@ -626,7 +681,8 @@ fn process_create_user_pda<'a>(program_id: &Pubkey, accounts: &'a [AccountInfo<' verify_ed25519_instruction_pubkey_message(instructions_sysvar, -2, &record.root_key, unsigned_hash.as_ref())?; record.signature = verify_record_signature_hash_at(instructions_sysvar, -1, &record.active_fork()?.blockchain_key, &args.signature, unsigned_hash.as_ref())?; - let serialized = pad_to_fixed_size(serialize_full_record_v12(&record)?, settings::USER_PDA_SPACE)?; + let serialized = serialize_record_with_stats(&record, SupportStats::default())?; + let serialized = pad_to_fixed_size(serialized, settings::USER_PDA_SPACE)?; // Цена namespace включает депозит PDA: пользователь оплачивает rent из своей // фиксированной суммы, а в inflow_vault поступает лишь её остаток. // Для заранее пополненного system-owned адреса учитываем только фактический top-up. @@ -759,17 +815,100 @@ fn process_update_user_pda(program_id: &Pubkey, accounts: &[AccountInfo], args: verify_ed25519_instruction_pubkey_message(instructions_sysvar, -2, &old_authority, unsigned_hash.as_ref())?; new_record.signature = verify_record_signature_hash_at(instructions_sysvar, -1, &record_signer, &args.signature, unsigned_hash.as_ref())?; - let serialized = serialize_full_record_v12(&new_record)?; + let stats = read_support_stats(&raw)?; + let serialized = serialize_record_with_stats(&new_record, stats)?; ensure_pda_size_and_rent(user_pda, signer, system_program_ai, serialized.len())?; write_pda_exact(user_pda, &serialized)?; let topup_fee = limit_fee_lamports(args.additional_limit, economy.lamports_per_limit_step)?; - if topup_fee > 0 { - transfer_lamports(signer, inflow_vault, system_program_ai, topup_fee)?; - } + let total_fee = topup_fee.checked_add(settings::UPDATE_FEE_LAMPORTS).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?; + transfer_lamports(signer, inflow_vault, system_program_ai, total_fee)?; Ok(()) } +/// Accounts: signer(sender wallet), sender PDA, recipient wallet, recipient PDA, +/// inflow vault, economy config (readonly), system program. Экономический PDA +/// намеренно присутствует в каждой операции для индексирования истории. +fn process_support_user(program_id: &Pubkey, accounts: &[AccountInfo], args: SupportUserArgs) -> ProgramResult { + let mut it = accounts.iter(); + let sender = next_account_info(&mut it)?; + let sender_pda = next_account_info(&mut it)?; + let recipient = next_account_info(&mut it)?; + let recipient_pda = next_account_info(&mut it)?; + let inflow_vault = next_account_info(&mut it)?; + let economy_config = next_account_info(&mut it)?; + let system_program_ai = next_account_info(&mut it)?; + require!(it.next().is_none(), ShineUsersError::InvalidInstruction); + require!(sender.is_signer && sender.is_writable && recipient.is_writable && sender_pda.is_writable && recipient_pda.is_writable, ShineUsersError::InvalidSigner); + require_keys_eq!(*system_program_ai.key, system_program::id(), ShineUsersError::InvalidSystemProgram); + validate_full_login(&args.sender_login)?; + validate_full_login(&args.recipient_login)?; + require!(args.sender_login != args.recipient_login && args.amount_lamports > 0 && args.amount_lamports % 10 == 0, ShineUsersError::InvalidSupport); + validate_inflow_vault(inflow_vault)?; + validate_users_economy_config_pda(program_id, economy_config)?; + require!(!economy_config.is_writable, ShineUsersError::InvalidAccountData); + require_keys_eq!(find_user_pda(program_id, &args.sender_login).0, *sender_pda.key, ShineUsersError::InvalidPdaAddress); + require_keys_eq!(find_user_pda(program_id, &args.recipient_login).0, *recipient_pda.key, ShineUsersError::InvalidPdaAddress); + require!(sender_pda.owner == program_id && recipient_pda.owner == program_id, ShineUsersError::InvalidAccountOwner); + let sender_raw = read_pda_all(sender_pda)?; + let recipient_raw = read_pda_all(recipient_pda)?; + require!(record_format_minor(&sender_raw)? == FORMAT_MINOR && record_format_minor(&recipient_raw)? == FORMAT_MINOR, ShineUsersError::InvalidRecordFormat); + let sender_record = deserialize_record_v12_from_pda(&sender_raw)?; + let recipient_record = deserialize_record_v12_from_pda(&recipient_raw)?; + require!(sender_record.login == args.sender_login && recipient_record.login == args.recipient_login, ShineUsersError::InvalidRecordData); + let sender_key = sender_record.active_fork()?.blockchain_key; + let recipient_key = recipient_record.active_fork()?.blockchain_key; + require_keys_eq!(sender_key, *sender.key, ShineUsersError::InvalidSigner); + require_keys_eq!(recipient_key, *recipient.key, ShineUsersError::InvalidSupport); + require!(sender_key != recipient_key, ShineUsersError::InvalidSupport); + let recipient_amount = args.amount_lamports.checked_mul(9).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?.checked_div(10).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?; + let inflow_amount = args.amount_lamports.checked_div(10).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?; + let mut sender_stats = read_support_stats(&sender_raw)?; + let mut recipient_stats = read_support_stats(&recipient_raw)?; + sender_stats.support_sent = sender_stats.support_sent.checked_add(args.amount_lamports).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?; + recipient_stats.support_received = recipient_stats.support_received.checked_add(recipient_amount).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?; + let sender_data = serialize_record_with_stats(&sender_record, sender_stats)?; + let recipient_data = serialize_record_with_stats(&recipient_record, recipient_stats)?; + ensure_pda_size_and_rent(sender_pda, sender, system_program_ai, sender_data.len())?; + ensure_pda_size_and_rent(recipient_pda, sender, system_program_ai, recipient_data.len())?; + transfer_lamports(sender, recipient, system_program_ai, recipient_amount)?; + transfer_lamports(sender, inflow_vault, system_program_ai, inflow_amount)?; + write_pda_exact(sender_pda, &sender_data)?; + write_pda_exact(recipient_pda, &recipient_data)?; + Ok(()) +} + +/// Accounts: signer, sender PDA, inflow vault, economy config (readonly), system. +fn process_support_dao(program_id: &Pubkey, accounts: &[AccountInfo], args: SupportDaoArgs) -> ProgramResult { + let mut it = accounts.iter(); + let sender = next_account_info(&mut it)?; + let sender_pda = next_account_info(&mut it)?; + let inflow_vault = next_account_info(&mut it)?; + let economy_config = next_account_info(&mut it)?; + let system_program_ai = next_account_info(&mut it)?; + require!(it.next().is_none(), ShineUsersError::InvalidInstruction); + require!(sender.is_signer && sender.is_writable && sender_pda.is_writable, ShineUsersError::InvalidSigner); + require_keys_eq!(*system_program_ai.key, system_program::id(), ShineUsersError::InvalidSystemProgram); + validate_full_login(&args.sender_login)?; + require!(args.amount_lamports > 0, ShineUsersError::InvalidSupport); + validate_inflow_vault(inflow_vault)?; + validate_users_economy_config_pda(program_id, economy_config)?; + require!(!economy_config.is_writable, ShineUsersError::InvalidAccountData); + require_keys_eq!(find_user_pda(program_id, &args.sender_login).0, *sender_pda.key, ShineUsersError::InvalidPdaAddress); + require!(sender_pda.owner == program_id, ShineUsersError::InvalidAccountOwner); + let raw = read_pda_all(sender_pda)?; + require!(record_format_minor(&raw)? == FORMAT_MINOR, ShineUsersError::InvalidRecordFormat); + let record = deserialize_record_v12_from_pda(&raw)?; + require!(record.login == args.sender_login, ShineUsersError::InvalidRecordData); + require_keys_eq!(record.active_fork()?.blockchain_key, *sender.key, ShineUsersError::InvalidSigner); + let mut stats = read_support_stats(&raw)?; + stats.dao_direct = stats.dao_direct.checked_add(args.amount_lamports).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?; + let data = serialize_record_with_stats(&record, stats)?; + ensure_pda_size_and_rent(sender_pda, sender, system_program_ai, data.len())?; + transfer_lamports(sender, inflow_vault, system_program_ai, args.amount_lamports)?; + write_pda_exact(sender_pda, &data) +} + fn process_close_legacy_user_pda(program_id: &Pubkey, accounts: &[AccountInfo], args: CloseLegacyUserPdaArgs) -> ProgramResult { let mut it = accounts.iter(); let caller = next_account_info(&mut it)?; @@ -1023,6 +1162,30 @@ fn serialize_full_record_v12(record: &UserRecordV12) -> Result, ProgramE Ok(out) } +fn read_support_stats(raw: &[u8]) -> Result { + require!(raw.len() >= 9, ShineUsersError::InvalidRecordData); + let record_len = u16::from_le_bytes([raw[7], raw[8]]) as usize; + if record_len >= raw.len() || raw[record_len] == 0 { return Ok(SupportStats::default()); } + require!(raw[record_len] == SUPPORT_STATS_VERSION, ShineUsersError::UnsupportedSupportStats); + let end = record_len.checked_add(SUPPORT_STATS_LEN).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?; + require!(end <= raw.len(), ShineUsersError::InvalidRecordLength); + let mut cursor = record_len + 1; + Ok(SupportStats { + support_sent: read_u64_from(raw, &mut cursor)?, + support_received: read_u64_from(raw, &mut cursor)?, + dao_direct: read_u64_from(raw, &mut cursor)?, + }) +} + +fn serialize_record_with_stats(record: &UserRecordV12, stats: SupportStats) -> Result, ProgramError> { + let mut out = serialize_full_record_v12(record)?; + out.push(SUPPORT_STATS_VERSION); + out.extend_from_slice(&stats.support_sent.to_le_bytes()); + out.extend_from_slice(&stats.support_received.to_le_bytes()); + out.extend_from_slice(&stats.dao_direct.to_le_bytes()); + Ok(out) +} + fn hash_unsigned_record_v12(record: &UserRecordV12) -> Result<[u8; 32], ProgramError> { let unsigned = serialize_unsigned_record_v12(record)?; let digest = hashv(&[&unsigned]); @@ -1317,6 +1480,9 @@ fn limit_fee_lamports(limit_delta: u64, lamports_per_limit_step: u64) -> Result< 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) } fn read_pda_all(pda: &AccountInfo) -> Result, ProgramError> { Ok(pda.try_borrow_data().map_err(|_| ProgramError::from(ShineUsersError::InvalidAccountData))?.to_vec()) } +/// Запись пользовательского PDA всегда идёт вместе со статистикой. Хвост очищается +/// только после уже записанного статистического блока, поэтому смена длины записи +/// не может уничтожить SupportStats. fn write_pda_exact(pda: &AccountInfo, data: &[u8]) -> ProgramResult { let mut dst = pda.try_borrow_mut_data().map_err(|_| ProgramError::from(ShineUsersError::InvalidAccountData))?; require!(data.len() <= dst.len(), ShineUsersError::RecordTooLarge); dst[..data.len()].copy_from_slice(data); for b in &mut dst[data.len()..] { *b = 0; } Ok(()) } fn write_pda_prefix(pda: &AccountInfo, data: &[u8]) -> ProgramResult { let mut dst = pda.try_borrow_mut_data().map_err(|_| ProgramError::from(ShineUsersError::InvalidAccountData))?; require!(data.len() <= dst.len(), ShineUsersError::RecordTooLarge); dst[..data.len()].copy_from_slice(data); Ok(()) } @@ -1327,3 +1493,24 @@ fn read_u64_from(data: &[u8], cursor: &mut usize) -> Result { fn read_fixed_32_from(data: &[u8], cursor: &mut usize) -> Result<[u8; 32], ProgramError> { let end = cursor.checked_add(32).ok_or(ProgramError::from(ShineUsersError::InvalidRecordData))?; let s = data.get(*cursor..end).ok_or(ProgramError::from(ShineUsersError::InvalidRecordData))?; *cursor = end; <[u8; 32]>::try_from(s).map_err(|_| ProgramError::from(ShineUsersError::InvalidRecordData)) } fn read_fixed_64_from(data: &[u8], cursor: &mut usize) -> Result<[u8; 64], ProgramError> { let end = cursor.checked_add(64).ok_or(ProgramError::from(ShineUsersError::InvalidRecordData))?; let s = data.get(*cursor..end).ok_or(ProgramError::from(ShineUsersError::InvalidRecordData))?; *cursor = end; <[u8; 64]>::try_from(s).map_err(|_| ProgramError::from(ShineUsersError::InvalidRecordData)) } fn read_len_prefixed_string_from(data: &[u8], cursor: &mut usize) -> Result { let len = read_u8_from(data, cursor)? as usize; let end = cursor.checked_add(len).ok_or(ProgramError::from(ShineUsersError::InvalidRecordData))?; let s = data.get(*cursor..end).ok_or(ProgramError::from(ShineUsersError::InvalidRecordData))?; *cursor = end; std::str::from_utf8(s).map(|v| v.to_string()).map_err(|_| ProgramError::from(ShineUsersError::InvalidRecordData)) } + +#[cfg(test)] +mod support_stats_tests { + use super::*; + + #[test] + fn v0_and_v1_support_stats_are_read_without_touching_record_len() { + let mut v0 = vec![0u8; 100]; + v0[7..9].copy_from_slice(&80u16.to_le_bytes()); + assert_eq!(read_support_stats(&v0).unwrap(), SupportStats::default()); + let mut v1 = v0; + v1[80] = 1; + v1[81..89].copy_from_slice(&100u64.to_le_bytes()); + v1[89..97].copy_from_slice(&90u64.to_le_bytes()); + // Отдельный полный буфер проверяет нормальный v1; укороченный v1 обязан отвергаться. + assert!(read_support_stats(&v1).is_err()); + v1.resize(105, 0); + v1[97..105].copy_from_slice(&7u64.to_le_bytes()); + assert_eq!(read_support_stats(&v1).unwrap(), SupportStats { support_sent: 100, support_received: 90, dao_direct: 7 }); + } +} diff --git a/shine-solana/shine/programs/shine_users/src/settings.rs b/shine-solana/shine/programs/shine_users/src/settings.rs index 5e7f34e8..c19e887e 100644 --- a/shine-solana/shine/programs/shine_users/src/settings.rs +++ b/shine-solana/shine/programs/shine_users/src/settings.rs @@ -21,3 +21,5 @@ pub const LIMIT_STEP: u64 = 10_000; pub const START_LAMPORTS_PER_LIMIT_STEP: u64 = 100_000; /// Стартовый бонус лимита. pub const START_BONUS_LIMIT: u64 = 100_000; +/// Обязательная комиссия за каждое успешно завершённое обновление user PDA. +pub const UPDATE_FEE_LAMPORTS: u64 = 20_000;