SHA256
ESP32 wallet RPC, browser wallet provider, and side panel
This commit is contained in:
AidarKC
@@ -10,7 +10,7 @@ Chrome-compatible Manifest V3 plugin for SHiNE wallet-session login.
|
||||
- принять `session-only` payload без передачи `deviceKey/rootKey/blockchainKey`;
|
||||
- сохранить `sessionPriv/sessionKey/sessionId` в локальном хранилище plugin;
|
||||
- восстанавливать session через `SessionChallenge -> SessionLogin`;
|
||||
- держать wallet-state в `background service worker`, а popup использовать как UI.
|
||||
- держать wallet-state в `background service worker`, а side panel использовать как UI.
|
||||
- принимать не адрес сервера, а логин серверного аккаунта SHiNE и находить точный `https://...` / `wss://...` адрес через его PDA.
|
||||
|
||||
## Как загрузить локально
|
||||
@@ -19,13 +19,15 @@ Chrome-compatible Manifest V3 plugin for SHiNE wallet-session login.
|
||||
2. Включи `Developer mode`
|
||||
3. Нажми `Load unpacked`
|
||||
4. Выбери папку `SHiNE-browser-plugin-wallet/`
|
||||
5. Нажми на иконку расширения в toolbar: откроется side panel SHiNE Wallet
|
||||
|
||||
## Ограничения текущего этапа
|
||||
|
||||
- plugin пока не держит постоянный фоновый WS-канал после закрытия popup, но хранит wallet-state в `background`;
|
||||
- plugin пока не держит постоянный фоновый WS-канал без активного действия пользователя, но хранит wallet-state в `background`;
|
||||
- на этом этапе реализован только `session-only login`;
|
||||
- запросы на подпись будут следующим этапом.
|
||||
- pairing-пароль, если он используется, должен генерироваться в формате `sha256$<hex>` от строки `shine-pairing|loginLower|password`.
|
||||
- сторона side panel в Chromium выбирается самим браузером/пользователем; extension не закрепляет панель принудительно слева.
|
||||
|
||||
## Сборка crypto bundle
|
||||
|
||||
|
||||
@@ -26,14 +26,44 @@ const state = {
|
||||
connectionOnline: false,
|
||||
walletProfile: null,
|
||||
signing: {
|
||||
selectedKeyId: 'device',
|
||||
selectedDeviceName: '',
|
||||
devicesResolvedAtMs: 0,
|
||||
},
|
||||
currentWallet: null,
|
||||
statusText: '',
|
||||
statusKind: 'info',
|
||||
};
|
||||
|
||||
const WALLET_RPC_REQUEST_TYPE = 9100;
|
||||
const WALLET_RPC_RESPONSE_TYPE = 9101;
|
||||
|
||||
async function configureSidePanelBehavior() {
|
||||
if (!chrome.sidePanel?.setPanelBehavior) {
|
||||
return;
|
||||
}
|
||||
try {
|
||||
await chrome.sidePanel.setPanelBehavior({ openPanelOnActionClick: true });
|
||||
} catch (error) {
|
||||
console.warn('Failed to configure SHiNE side panel behavior:', error);
|
||||
}
|
||||
}
|
||||
|
||||
function normalizeOrigin(value = '') {
|
||||
const raw = String(value || '').trim();
|
||||
if (!raw) return '';
|
||||
try {
|
||||
return new URL(raw).origin;
|
||||
} catch {
|
||||
return raw;
|
||||
}
|
||||
}
|
||||
|
||||
function makeCodeError(message, code) {
|
||||
const error = new Error(String(message || 'Wallet error'));
|
||||
error.code = String(code || '').trim().toUpperCase();
|
||||
return error;
|
||||
}
|
||||
|
||||
function setStatus(message = '', kind = 'info') {
|
||||
state.statusText = String(message || '');
|
||||
state.statusKind = kind === 'error' ? 'error' : 'info';
|
||||
@@ -71,14 +101,15 @@ async function loadStateFromStorage() {
|
||||
serverHttp: String(settings?.serverHttp || state.settings.serverHttp || buildHttpBase('shineup.me')).trim() || buildHttpBase('shineup.me'),
|
||||
serverUrl: String(settings?.serverUrl || state.settings.serverUrl || 'wss://shineup.me/ws').trim() || 'wss://shineup.me/ws',
|
||||
login: String(settings?.login || '').trim(),
|
||||
connectedOrigins: Array.isArray(settings?.connectedOrigins) ? settings.connectedOrigins.map((item) => normalizeOrigin(item)).filter(Boolean) : [],
|
||||
};
|
||||
state.activeSession = await loadSessionMaterial();
|
||||
state.walletProfile = state.activeSession?.walletProfile || null;
|
||||
state.signing = {
|
||||
selectedKeyId: String(state.activeSession?.selectedKeyId || 'device'),
|
||||
selectedDeviceName: String(state.activeSession?.selectedDeviceName || ''),
|
||||
devicesResolvedAtMs: Number(state.activeSession?.devicesResolvedAtMs || 0),
|
||||
};
|
||||
state.currentWallet = state.activeSession?.currentWallet || null;
|
||||
}
|
||||
|
||||
async function persistSettings(nextSettings = {}) {
|
||||
@@ -86,10 +117,29 @@ async function persistSettings(nextSettings = {}) {
|
||||
...state.settings,
|
||||
...nextSettings,
|
||||
};
|
||||
if (!Array.isArray(state.settings.connectedOrigins)) {
|
||||
state.settings.connectedOrigins = [];
|
||||
}
|
||||
await savePluginSettings(state.settings);
|
||||
return state.settings;
|
||||
}
|
||||
|
||||
function isOriginApproved(origin) {
|
||||
const normalized = normalizeOrigin(origin);
|
||||
return !!normalized && Array.isArray(state.settings.connectedOrigins) && state.settings.connectedOrigins.includes(normalized);
|
||||
}
|
||||
|
||||
async function setOriginApproved(origin, approved) {
|
||||
const normalized = normalizeOrigin(origin);
|
||||
const current = new Set(Array.isArray(state.settings.connectedOrigins) ? state.settings.connectedOrigins : []);
|
||||
if (approved) {
|
||||
if (normalized) current.add(normalized);
|
||||
} else if (normalized) {
|
||||
current.delete(normalized);
|
||||
}
|
||||
await persistSettings({ connectedOrigins: [...current] });
|
||||
}
|
||||
|
||||
async function resolveServerForLogin(login) {
|
||||
const cleanLogin = String(login || state.settings.login || '').trim();
|
||||
if (!cleanLogin) {
|
||||
@@ -119,9 +169,9 @@ async function saveActiveSessionRecord() {
|
||||
const nextRecord = {
|
||||
...state.activeSession,
|
||||
walletProfile: state.walletProfile,
|
||||
selectedKeyId: state.signing.selectedKeyId,
|
||||
selectedDeviceName: state.signing.selectedDeviceName,
|
||||
devicesResolvedAtMs: state.signing.devicesResolvedAtMs,
|
||||
currentWallet: state.currentWallet,
|
||||
};
|
||||
state.activeSession = nextRecord;
|
||||
await saveSessionMaterial(nextRecord);
|
||||
@@ -152,27 +202,10 @@ function toWalletErrorMessage(error, fallback = 'Не удалось выпол
|
||||
return raw || fallback;
|
||||
}
|
||||
|
||||
function buildSigningKeyOptions(walletProfile) {
|
||||
const rootKey = String(walletProfile?.publicKeys?.rootKeyBase58 || '').trim();
|
||||
const deviceKey = String(walletProfile?.publicKeys?.deviceKeyBase58 || '').trim();
|
||||
const options = [];
|
||||
if (rootKey) {
|
||||
options.push({
|
||||
id: 'root',
|
||||
label: `rootKey (ed25519, ${shortKey(rootKey)})`,
|
||||
keyType: 'ed25519',
|
||||
publicKeyBase58: rootKey,
|
||||
});
|
||||
}
|
||||
if (deviceKey) {
|
||||
options.push({
|
||||
id: 'device',
|
||||
label: `deviceKey (ed25519, ${shortKey(deviceKey)})`,
|
||||
keyType: 'ed25519',
|
||||
publicKeyBase58: deviceKey,
|
||||
});
|
||||
}
|
||||
return options;
|
||||
function homeserverSessionNameFromClientInfo(value = '') {
|
||||
const raw = String(value || '').trim();
|
||||
const match = raw.match(/^ESP32 homeserver:(.+)$/i);
|
||||
return match ? String(match[1] || '').trim() : '';
|
||||
}
|
||||
|
||||
function mergeHomeserverStatuses(publishedHomeservers = [], serverSessions = []) {
|
||||
@@ -181,18 +214,25 @@ function mergeHomeserverStatuses(publishedHomeservers = [], serverSessions = [])
|
||||
? serverSessions.filter((item) => Number(item?.sessionType || 0) === 100)
|
||||
: [];
|
||||
const onlineHomeservers = homeserverSessions.filter((item) => !!item?.onlineOnThisServer);
|
||||
const byName = new Map();
|
||||
onlineHomeservers.forEach((item) => {
|
||||
const sessionName = homeserverSessionNameFromClientInfo(item?.clientInfoFromClient);
|
||||
if (sessionName) {
|
||||
byName.set(sessionName, item);
|
||||
}
|
||||
});
|
||||
|
||||
return published.map((item) => {
|
||||
let onlineState = 'unknown';
|
||||
if (published.length === 1) {
|
||||
onlineState = onlineHomeservers.length > 0 ? 'online' : 'offline';
|
||||
} else if (onlineHomeservers.length === 0) {
|
||||
onlineState = 'offline';
|
||||
} else if (onlineHomeservers.length === published.length) {
|
||||
const matched = byName.get(String(item?.sessionName || '').trim()) || null;
|
||||
let onlineState = matched ? 'online' : 'offline';
|
||||
let activeSessionId = matched?.sessionId ? String(matched.sessionId) : '';
|
||||
if (!matched && published.length === 1 && onlineHomeservers.length === 1) {
|
||||
onlineState = 'online';
|
||||
activeSessionId = String(onlineHomeservers[0]?.sessionId || '');
|
||||
}
|
||||
return {
|
||||
...item,
|
||||
activeSessionId,
|
||||
onlineState,
|
||||
onlineLabel: onlineState === 'online' ? 'online' : onlineState === 'offline' ? 'offline' : 'unknown',
|
||||
};
|
||||
@@ -203,25 +243,20 @@ async function hydrateWalletProfile(login) {
|
||||
const cleanLogin = String(login || state.activeSession?.login || state.settings.login || '').trim();
|
||||
if (!cleanLogin) throw new Error('Нет логина для чтения PDA кошелька.');
|
||||
const profile = await readWalletProfileByLogin(cleanLogin);
|
||||
const signingKeyOptions = buildSigningKeyOptions(profile);
|
||||
const selectedKeyId = signingKeyOptions.some((item) => item.id === state.signing.selectedKeyId)
|
||||
? state.signing.selectedKeyId
|
||||
: (signingKeyOptions[0]?.id || '');
|
||||
const selectedDeviceName = state.signing.selectedDeviceName
|
||||
|| String(profile?.homeserverSessions?.[0]?.sessionName || '');
|
||||
|
||||
state.walletProfile = {
|
||||
...profile,
|
||||
signingKeyOptions,
|
||||
homeserverSessions: Array.isArray(profile.homeserverSessions) ? profile.homeserverSessions.map((item) => ({
|
||||
...item,
|
||||
onlineState: 'unknown',
|
||||
onlineLabel: 'unknown',
|
||||
activeSessionId: '',
|
||||
})) : [],
|
||||
};
|
||||
state.signing = {
|
||||
...state.signing,
|
||||
selectedKeyId,
|
||||
selectedDeviceName,
|
||||
};
|
||||
await saveActiveSessionRecord();
|
||||
@@ -293,6 +328,7 @@ async function attachApprovedSession(payload) {
|
||||
serverUrl: sessionRecord.serverUrl,
|
||||
});
|
||||
state.connectionOnline = false;
|
||||
state.currentWallet = null;
|
||||
}
|
||||
|
||||
async function pollPairingStatus() {
|
||||
@@ -400,10 +436,10 @@ async function disconnectSession() {
|
||||
state.connectionOnline = false;
|
||||
state.walletProfile = null;
|
||||
state.signing = {
|
||||
selectedKeyId: 'device',
|
||||
selectedDeviceName: '',
|
||||
devicesResolvedAtMs: 0,
|
||||
};
|
||||
state.currentWallet = null;
|
||||
setStatus('Сохранённая wallet-session удалена из plugin.', 'info');
|
||||
return { ok: true };
|
||||
}
|
||||
@@ -440,37 +476,199 @@ async function refreshWalletDevices() {
|
||||
}
|
||||
}
|
||||
|
||||
async function updateSigningSelection({ selectedKeyId, selectedDeviceName } = {}) {
|
||||
async function updateSigningSelection({ selectedDeviceName } = {}) {
|
||||
state.signing = {
|
||||
...state.signing,
|
||||
selectedKeyId: String(selectedKeyId || state.signing.selectedKeyId || ''),
|
||||
selectedDeviceName: String(selectedDeviceName || state.signing.selectedDeviceName || ''),
|
||||
};
|
||||
await saveActiveSessionRecord();
|
||||
return { ok: true };
|
||||
}
|
||||
|
||||
async function prepareSignSignal() {
|
||||
async function resolveSelectedHomeserverSession() {
|
||||
if (!state.activeSession?.login) {
|
||||
throw new Error('Сначала подключите wallet-session.');
|
||||
}
|
||||
if (!state.signing.selectedKeyId) {
|
||||
throw new Error('Не выбран ключ подписи.');
|
||||
}
|
||||
if (!state.signing.selectedDeviceName) {
|
||||
throw new Error('Не выбрано устройство homeserver.');
|
||||
}
|
||||
const selectedDevice = (state.walletProfile?.homeserverSessions || []).find((item) => item.sessionName === state.signing.selectedDeviceName);
|
||||
let selectedDevice = (state.walletProfile?.homeserverSessions || []).find((item) => item.sessionName === state.signing.selectedDeviceName);
|
||||
if (!selectedDevice) {
|
||||
throw new Error('Выбранное устройство не найдено в PDA аккаунта.');
|
||||
}
|
||||
setStatus(
|
||||
`Каркас готов: запрос подписи должен идти через ${selectedDevice.sessionName}. Сам signaling подписи ещё не доделан.`,
|
||||
'info',
|
||||
);
|
||||
if (!selectedDevice.activeSessionId) {
|
||||
await refreshWalletDevices();
|
||||
selectedDevice = (state.walletProfile?.homeserverSessions || []).find((item) => item.sessionName === state.signing.selectedDeviceName);
|
||||
}
|
||||
if (!selectedDevice?.activeSessionId) {
|
||||
throw new Error('Выбранный homeserver сейчас не найден онлайн на сервере SHiNE.');
|
||||
}
|
||||
return selectedDevice;
|
||||
}
|
||||
|
||||
async function callWalletRpc(requestData, timeoutMs = 8000) {
|
||||
const selectedDevice = await resolveSelectedHomeserverSession();
|
||||
const resumed = await resumeActiveSession({ keepConnected: true });
|
||||
if (!resumed.ok) {
|
||||
throw new Error(resumed.error || 'Не удалось открыть wallet-session.');
|
||||
}
|
||||
|
||||
const requestId = String(requestData?.requestId || `${Date.now()}-${Math.random().toString(16).slice(2, 8)}`);
|
||||
const callId = `wallet-rpc-${requestId}`;
|
||||
const payload = {
|
||||
...requestData,
|
||||
requestId,
|
||||
timeMs: Number(requestData?.timeMs || Date.now()),
|
||||
};
|
||||
|
||||
try {
|
||||
const response = await new Promise((resolve, reject) => {
|
||||
const timeoutId = setTimeout(() => {
|
||||
off();
|
||||
reject(new Error('Таймаут ответа от ESP32.'));
|
||||
}, timeoutMs);
|
||||
const off = ensureApi().onEvent('IncomingCallSignal', (evt) => {
|
||||
const eventPayload = evt?.payload || {};
|
||||
if (String(eventPayload?.callId || '') !== callId) return;
|
||||
if (Number(eventPayload?.type || 0) !== WALLET_RPC_RESPONSE_TYPE) return;
|
||||
clearTimeout(timeoutId);
|
||||
off();
|
||||
try {
|
||||
resolve(JSON.parse(String(eventPayload?.data || '{}')));
|
||||
} catch {
|
||||
reject(new Error('ESP32 вернул некорректный JSON.'));
|
||||
}
|
||||
});
|
||||
ensureApi().callSignalToSession({
|
||||
toLogin: state.activeSession.login,
|
||||
targetSessionId: selectedDevice.activeSessionId,
|
||||
callId,
|
||||
type: WALLET_RPC_REQUEST_TYPE,
|
||||
data: JSON.stringify(payload),
|
||||
}).catch((error) => {
|
||||
clearTimeout(timeoutId);
|
||||
off();
|
||||
reject(error);
|
||||
});
|
||||
});
|
||||
return { response, selectedDevice, requestId };
|
||||
} finally {
|
||||
ensureApi().close();
|
||||
state.api = null;
|
||||
state.connectionOnline = false;
|
||||
}
|
||||
}
|
||||
|
||||
function verifyWalletAgainstPda(wallet) {
|
||||
const type = String(wallet?.type || '').trim();
|
||||
const pub = String(wallet?.publicKeyBase58 || '').trim();
|
||||
const rootKey = String(state.walletProfile?.publicKeys?.rootKeyBase58 || '').trim();
|
||||
const deviceKey = String(state.walletProfile?.publicKeys?.deviceKeyBase58 || '').trim();
|
||||
if (type === 'dev.key') {
|
||||
return {
|
||||
verified: !!deviceKey && deviceKey === pub,
|
||||
verificationText: deviceKey === pub ? 'Совпадает с deviceKey из PDA.' : 'Не совпадает с deviceKey из PDA.',
|
||||
};
|
||||
}
|
||||
if (type === 'root.key') {
|
||||
return {
|
||||
verified: !!rootKey && rootKey === pub,
|
||||
verificationText: rootKey === pub ? 'Совпадает с rootKey из PDA.' : 'Не совпадает с rootKey из PDA.',
|
||||
};
|
||||
}
|
||||
return {
|
||||
verified: null,
|
||||
verificationText: 'Для custom-кошелька проверка через PDA пока не выполняется.',
|
||||
};
|
||||
}
|
||||
|
||||
async function requestCurrentWallet() {
|
||||
const { response, selectedDevice, requestId } = await callWalletRpc({
|
||||
v: 1,
|
||||
operation: 'get_wallet_public_key',
|
||||
requestId: `${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
|
||||
});
|
||||
if (!response?.ok) {
|
||||
throw new Error(`ESP32 отклонил запрос: ${String(response?.error || 'unknown_error')}`);
|
||||
}
|
||||
state.currentWallet = {
|
||||
type: String(response?.wallet?.type || '').trim(),
|
||||
publicKeyBase58: String(response?.wallet?.publicKeyBase58 || '').trim(),
|
||||
homeserverName: selectedDevice.sessionName,
|
||||
requestId: String(response?.requestId || requestId),
|
||||
timeMs: Number(response?.timeMs || 0),
|
||||
...verifyWalletAgainstPda(response?.wallet || {}),
|
||||
};
|
||||
await saveActiveSessionRecord();
|
||||
setStatus(`Кошелёк получен с ${selectedDevice.sessionName}.`, 'info');
|
||||
return { ok: true, wallet: state.currentWallet };
|
||||
}
|
||||
|
||||
async function siteConnect({ origin, onlyIfTrusted = false } = {}) {
|
||||
const normalizedOrigin = normalizeOrigin(origin);
|
||||
if (!normalizedOrigin) {
|
||||
throw makeCodeError('Site origin is missing.', 'BAD_ORIGIN');
|
||||
}
|
||||
if (onlyIfTrusted && !isOriginApproved(normalizedOrigin)) {
|
||||
throw makeCodeError('Site is not trusted yet.', 'NOT_TRUSTED');
|
||||
}
|
||||
const result = await requestCurrentWallet();
|
||||
const publicKeyBase58 = String(result?.wallet?.publicKeyBase58 || '').trim();
|
||||
if (!publicKeyBase58) {
|
||||
throw makeCodeError('Wallet public key is not available.', 'WALLET_UNAVAILABLE');
|
||||
}
|
||||
if (!isOriginApproved(normalizedOrigin)) {
|
||||
await setOriginApproved(normalizedOrigin, true);
|
||||
}
|
||||
setStatus(`Site ${normalizedOrigin} connected to ${shortKey(publicKeyBase58, 8)}.`, 'info');
|
||||
return {
|
||||
ok: true,
|
||||
pending: true,
|
||||
publicKeyBase58,
|
||||
walletType: String(result?.wallet?.type || '').trim(),
|
||||
};
|
||||
}
|
||||
|
||||
async function siteDisconnect({ origin } = {}) {
|
||||
const normalizedOrigin = normalizeOrigin(origin);
|
||||
setStatus(normalizedOrigin ? `Site ${normalizedOrigin} disconnected.` : 'Site disconnected.', 'info');
|
||||
return { ok: true };
|
||||
}
|
||||
|
||||
async function siteSignTransaction({ origin, publicKeyBase58, transactionBase64, comment } = {}) {
|
||||
const normalizedOrigin = normalizeOrigin(origin);
|
||||
if (!normalizedOrigin) {
|
||||
throw makeCodeError('Site origin is missing.', 'BAD_ORIGIN');
|
||||
}
|
||||
if (!isOriginApproved(normalizedOrigin)) {
|
||||
throw makeCodeError('Site is not trusted yet.', 'NOT_TRUSTED');
|
||||
}
|
||||
const cleanPub = String(publicKeyBase58 || '').trim();
|
||||
const cleanTx = String(transactionBase64 || '').trim();
|
||||
if (!cleanPub || !cleanTx) {
|
||||
throw makeCodeError('Transaction payload is incomplete.', 'BAD_REQUEST');
|
||||
}
|
||||
const requestId = `${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
|
||||
const signComment = String(comment || '').trim() || `Site ${normalizedOrigin} requested transaction signature`;
|
||||
const { response } = await callWalletRpc({
|
||||
v: 1,
|
||||
operation: 'sign_transaction',
|
||||
requestId,
|
||||
publicKeyBase58: cleanPub,
|
||||
transactionBase64: cleanTx,
|
||||
comment: signComment,
|
||||
}, 120000);
|
||||
if (!response?.ok) {
|
||||
const errorCode = String(response?.error || 'unknown_error').trim().toUpperCase();
|
||||
if (errorCode === 'REJECTED_BY_USER') {
|
||||
throw makeCodeError('User rejected transaction signature on ESP32.', 'USER_REJECTED');
|
||||
}
|
||||
throw makeCodeError(`ESP32 rejected transaction signature: ${String(response?.error || 'unknown_error')}`, errorCode || 'RPC_REJECTED');
|
||||
}
|
||||
return {
|
||||
ok: true,
|
||||
publicKeyBase58: String(response?.publicKeyBase58 || cleanPub).trim(),
|
||||
signedTransactionBase64: String(response?.signedTransactionBase64 || '').trim(),
|
||||
signatureBase58: String(response?.signatureBase58 || '').trim(),
|
||||
};
|
||||
}
|
||||
|
||||
@@ -485,8 +683,9 @@ function snapshot() {
|
||||
trustedSessionOnline: state.trustedSessionOnline,
|
||||
},
|
||||
session: state.activeSession ? { ...state.activeSession } : null,
|
||||
connectionOnline: state.connectionOnline,
|
||||
connectionOnline: !!state.activeSession,
|
||||
walletProfile: state.walletProfile ? { ...state.walletProfile } : null,
|
||||
currentWallet: state.currentWallet ? { ...state.currentWallet } : null,
|
||||
signing: { ...state.signing },
|
||||
status: {
|
||||
text: state.statusText,
|
||||
@@ -538,8 +737,8 @@ chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
|
||||
sendResponse({ ok: true, result, state: snapshot() });
|
||||
return;
|
||||
}
|
||||
if (type === 'wallet:prepareSignSignal') {
|
||||
const result = await prepareSignSignal();
|
||||
if (type === 'wallet:requestCurrentWallet') {
|
||||
const result = await requestCurrentWallet();
|
||||
sendResponse({ ok: true, result, state: snapshot() });
|
||||
return;
|
||||
}
|
||||
@@ -548,15 +747,40 @@ chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
|
||||
sendResponse({ ok: true, result, state: snapshot() });
|
||||
return;
|
||||
}
|
||||
if (type === 'wallet:siteConnect') {
|
||||
const result = await siteConnect(message?.payload || {});
|
||||
sendResponse({ ok: true, result, state: snapshot() });
|
||||
return;
|
||||
}
|
||||
if (type === 'wallet:siteDisconnect') {
|
||||
const result = await siteDisconnect(message?.payload || {});
|
||||
sendResponse({ ok: true, result, state: snapshot() });
|
||||
return;
|
||||
}
|
||||
if (type === 'wallet:siteSignTransaction') {
|
||||
const result = await siteSignTransaction(message?.payload || {});
|
||||
sendResponse({ ok: true, result, state: snapshot() });
|
||||
return;
|
||||
}
|
||||
sendResponse({ ok: false, error: 'UNKNOWN_MESSAGE' });
|
||||
})().catch((error) => {
|
||||
const message = toWalletErrorMessage(error, 'Unknown error');
|
||||
setStatus(message, 'error');
|
||||
sendResponse({ ok: false, error: message, state: snapshot() });
|
||||
sendResponse({ ok: false, error: message, code: String(error?.code || ''), state: snapshot() });
|
||||
});
|
||||
return true;
|
||||
});
|
||||
|
||||
chrome.runtime.onInstalled.addListener(() => {
|
||||
void configureSidePanelBehavior();
|
||||
});
|
||||
|
||||
chrome.runtime.onStartup.addListener(() => {
|
||||
void configureSidePanelBehavior();
|
||||
});
|
||||
|
||||
void configureSidePanelBehavior();
|
||||
|
||||
void loadStateFromStorage().then(async () => {
|
||||
if (state.activeSession?.login) {
|
||||
await hydrateWalletProfile(state.activeSession.login).catch(() => {});
|
||||
|
||||
@@ -0,0 +1,84 @@
|
||||
const PAGE_REQUEST = 'shine-wallet-page-request';
|
||||
const PAGE_RESPONSE = 'shine-wallet-page-response';
|
||||
|
||||
function injectProviderBridge() {
|
||||
const root = document.head || document.documentElement;
|
||||
if (!root) return;
|
||||
const script = document.createElement('script');
|
||||
script.type = 'module';
|
||||
script.src = chrome.runtime.getURL('provider-bridge.js');
|
||||
script.dataset.shineWalletProvider = '1';
|
||||
root.appendChild(script);
|
||||
script.remove();
|
||||
}
|
||||
|
||||
function respondToPage(id, ok, result, error, code) {
|
||||
window.postMessage({
|
||||
target: PAGE_RESPONSE,
|
||||
id: String(id || ''),
|
||||
ok: !!ok,
|
||||
result: result || null,
|
||||
error: error ? String(error) : '',
|
||||
code: code ? String(code) : '',
|
||||
}, window.location.origin);
|
||||
}
|
||||
|
||||
function sendRuntimeMessage(type, payload = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
chrome.runtime.sendMessage({ type, payload }, (response) => {
|
||||
if (chrome.runtime.lastError) {
|
||||
reject(new Error(chrome.runtime.lastError.message || 'Runtime message failed'));
|
||||
return;
|
||||
}
|
||||
if (!response?.ok) {
|
||||
const error = new Error(String(response?.error || 'Wallet operation failed'));
|
||||
error.code = String(response?.code || '');
|
||||
reject(error);
|
||||
return;
|
||||
}
|
||||
resolve(response);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
window.addEventListener('message', (event) => {
|
||||
if (event.source !== window) return;
|
||||
const data = event.data || {};
|
||||
if (data?.target !== PAGE_REQUEST) return;
|
||||
|
||||
const id = String(data?.id || '');
|
||||
const method = String(data?.method || '');
|
||||
const params = data?.params || {};
|
||||
const origin = window.location.origin;
|
||||
|
||||
(async () => {
|
||||
if (method === 'connect') {
|
||||
const response = await sendRuntimeMessage('wallet:siteConnect', {
|
||||
origin,
|
||||
onlyIfTrusted: !!params?.onlyIfTrusted,
|
||||
});
|
||||
respondToPage(id, true, response.result || null);
|
||||
return;
|
||||
}
|
||||
if (method === 'disconnect') {
|
||||
const response = await sendRuntimeMessage('wallet:siteDisconnect', { origin });
|
||||
respondToPage(id, true, response.result || null);
|
||||
return;
|
||||
}
|
||||
if (method === 'signTransaction') {
|
||||
const response = await sendRuntimeMessage('wallet:siteSignTransaction', {
|
||||
origin,
|
||||
publicKeyBase58: String(params?.publicKeyBase58 || '').trim(),
|
||||
transactionBase64: String(params?.transactionBase64 || '').trim(),
|
||||
comment: String(params?.comment || '').trim(),
|
||||
});
|
||||
respondToPage(id, true, response.result || null);
|
||||
return;
|
||||
}
|
||||
respondToPage(id, false, null, 'Unsupported provider method', 'UNSUPPORTED_METHOD');
|
||||
})().catch((error) => {
|
||||
respondToPage(id, false, null, error?.message || 'Wallet bridge error', error?.code || '');
|
||||
});
|
||||
});
|
||||
|
||||
injectProviderBridge();
|
||||
@@ -75,6 +75,22 @@ export class ShineApiClient {
|
||||
return Array.isArray(response?.payload?.sessions) ? response.payload.sessions : [];
|
||||
}
|
||||
|
||||
async callSignalToSession({ toLogin, targetSessionId, callId, type, data = '' }) {
|
||||
const response = await this.ws.request('CallSignalToSession', {
|
||||
toLogin: String(toLogin || '').trim(),
|
||||
targetSessionId: String(targetSessionId || '').trim(),
|
||||
callId: String(callId || '').trim(),
|
||||
type: Number(type) || 0,
|
||||
data: String(data || ''),
|
||||
});
|
||||
if (response.status !== 200) throw opError('CallSignalToSession', response);
|
||||
return response.payload || {};
|
||||
}
|
||||
|
||||
onEvent(op, handler) {
|
||||
return this.ws.on(op, handler);
|
||||
}
|
||||
|
||||
async resumeSession(sessionRecord) {
|
||||
const login = String(sessionRecord?.login || '').trim();
|
||||
const sessionId = String(sessionRecord?.sessionId || '').trim();
|
||||
|
||||
@@ -12136,8 +12136,8 @@ function weierstrass(curveDef) {
|
||||
return drbg(seed, k2sig);
|
||||
}
|
||||
Point2.BASE._setWindowSize(8);
|
||||
function verify2(signature, msgHash, publicKey2, opts = defaultVerOpts) {
|
||||
const sg = signature;
|
||||
function verify2(signature2, msgHash, publicKey2, opts = defaultVerOpts) {
|
||||
const sg = signature2;
|
||||
msgHash = ensureBytes("msgHash", msgHash);
|
||||
publicKey2 = ensureBytes("publicKey", publicKey2);
|
||||
if ("strict" in opts)
|
||||
@@ -12515,30 +12515,30 @@ var PACKET_DATA_SIZE = 1280 - 40 - 8;
|
||||
var VERSION_PREFIX_MASK = 127;
|
||||
var SIGNATURE_LENGTH_IN_BYTES = 64;
|
||||
var TransactionExpiredBlockheightExceededError = class extends Error {
|
||||
constructor(signature) {
|
||||
super(`Signature ${signature} has expired: block height exceeded.`);
|
||||
constructor(signature2) {
|
||||
super(`Signature ${signature2} has expired: block height exceeded.`);
|
||||
this.signature = void 0;
|
||||
this.signature = signature;
|
||||
this.signature = signature2;
|
||||
}
|
||||
};
|
||||
Object.defineProperty(TransactionExpiredBlockheightExceededError.prototype, "name", {
|
||||
value: "TransactionExpiredBlockheightExceededError"
|
||||
});
|
||||
var TransactionExpiredTimeoutError = class extends Error {
|
||||
constructor(signature, timeoutSeconds) {
|
||||
super(`Transaction was not confirmed in ${timeoutSeconds.toFixed(2)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`);
|
||||
constructor(signature2, timeoutSeconds) {
|
||||
super(`Transaction was not confirmed in ${timeoutSeconds.toFixed(2)} seconds. It is unknown if it succeeded or failed. Check signature ${signature2} using the Solana Explorer or CLI tools.`);
|
||||
this.signature = void 0;
|
||||
this.signature = signature;
|
||||
this.signature = signature2;
|
||||
}
|
||||
};
|
||||
Object.defineProperty(TransactionExpiredTimeoutError.prototype, "name", {
|
||||
value: "TransactionExpiredTimeoutError"
|
||||
});
|
||||
var TransactionExpiredNonceInvalidError = class extends Error {
|
||||
constructor(signature) {
|
||||
super(`Signature ${signature} has expired: the nonce is no longer valid.`);
|
||||
constructor(signature2) {
|
||||
super(`Signature ${signature2} has expired: the nonce is no longer valid.`);
|
||||
this.signature = void 0;
|
||||
this.signature = signature;
|
||||
this.signature = signature2;
|
||||
}
|
||||
};
|
||||
Object.defineProperty(TransactionExpiredNonceInvalidError.prototype, "name", {
|
||||
@@ -12598,6 +12598,9 @@ var MessageAccountKeys = class {
|
||||
var publicKey = (property = "publicKey") => {
|
||||
return BufferLayout.blob(32, property);
|
||||
};
|
||||
var signature = (property = "signature") => {
|
||||
return BufferLayout.blob(64, property);
|
||||
};
|
||||
var rustString = (property = "string") => {
|
||||
const rsl = BufferLayout.struct([BufferLayout.u32("length"), BufferLayout.u32("lengthPadding"), BufferLayout.blob(BufferLayout.offset(BufferLayout.u32(), -8), "chars")], property);
|
||||
const _decode = rsl.decode.bind(rsl);
|
||||
@@ -12954,6 +12957,260 @@ var Message = class _Message {
|
||||
return new _Message(messageArgs);
|
||||
}
|
||||
};
|
||||
var MessageV0 = class _MessageV0 {
|
||||
constructor(args) {
|
||||
this.header = void 0;
|
||||
this.staticAccountKeys = void 0;
|
||||
this.recentBlockhash = void 0;
|
||||
this.compiledInstructions = void 0;
|
||||
this.addressTableLookups = void 0;
|
||||
this.header = args.header;
|
||||
this.staticAccountKeys = args.staticAccountKeys;
|
||||
this.recentBlockhash = args.recentBlockhash;
|
||||
this.compiledInstructions = args.compiledInstructions;
|
||||
this.addressTableLookups = args.addressTableLookups;
|
||||
}
|
||||
get version() {
|
||||
return 0;
|
||||
}
|
||||
get numAccountKeysFromLookups() {
|
||||
let count = 0;
|
||||
for (const lookup of this.addressTableLookups) {
|
||||
count += lookup.readonlyIndexes.length + lookup.writableIndexes.length;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
getAccountKeys(args) {
|
||||
let accountKeysFromLookups;
|
||||
if (args && "accountKeysFromLookups" in args && args.accountKeysFromLookups) {
|
||||
if (this.numAccountKeysFromLookups != args.accountKeysFromLookups.writable.length + args.accountKeysFromLookups.readonly.length) {
|
||||
throw new Error("Failed to get account keys because of a mismatch in the number of account keys from lookups");
|
||||
}
|
||||
accountKeysFromLookups = args.accountKeysFromLookups;
|
||||
} else if (args && "addressLookupTableAccounts" in args && args.addressLookupTableAccounts) {
|
||||
accountKeysFromLookups = this.resolveAddressTableLookups(args.addressLookupTableAccounts);
|
||||
} else if (this.addressTableLookups.length > 0) {
|
||||
throw new Error("Failed to get account keys because address table lookups were not resolved");
|
||||
}
|
||||
return new MessageAccountKeys(this.staticAccountKeys, accountKeysFromLookups);
|
||||
}
|
||||
isAccountSigner(index) {
|
||||
return index < this.header.numRequiredSignatures;
|
||||
}
|
||||
isAccountWritable(index) {
|
||||
const numSignedAccounts = this.header.numRequiredSignatures;
|
||||
const numStaticAccountKeys = this.staticAccountKeys.length;
|
||||
if (index >= numStaticAccountKeys) {
|
||||
const lookupAccountKeysIndex = index - numStaticAccountKeys;
|
||||
const numWritableLookupAccountKeys = this.addressTableLookups.reduce((count, lookup) => count + lookup.writableIndexes.length, 0);
|
||||
return lookupAccountKeysIndex < numWritableLookupAccountKeys;
|
||||
} else if (index >= this.header.numRequiredSignatures) {
|
||||
const unsignedAccountIndex = index - numSignedAccounts;
|
||||
const numUnsignedAccounts = numStaticAccountKeys - numSignedAccounts;
|
||||
const numWritableUnsignedAccounts = numUnsignedAccounts - this.header.numReadonlyUnsignedAccounts;
|
||||
return unsignedAccountIndex < numWritableUnsignedAccounts;
|
||||
} else {
|
||||
const numWritableSignedAccounts = numSignedAccounts - this.header.numReadonlySignedAccounts;
|
||||
return index < numWritableSignedAccounts;
|
||||
}
|
||||
}
|
||||
resolveAddressTableLookups(addressLookupTableAccounts) {
|
||||
const accountKeysFromLookups = {
|
||||
writable: [],
|
||||
readonly: []
|
||||
};
|
||||
for (const tableLookup of this.addressTableLookups) {
|
||||
const tableAccount = addressLookupTableAccounts.find((account) => account.key.equals(tableLookup.accountKey));
|
||||
if (!tableAccount) {
|
||||
throw new Error(`Failed to find address lookup table account for table key ${tableLookup.accountKey.toBase58()}`);
|
||||
}
|
||||
for (const index of tableLookup.writableIndexes) {
|
||||
if (index < tableAccount.state.addresses.length) {
|
||||
accountKeysFromLookups.writable.push(tableAccount.state.addresses[index]);
|
||||
} else {
|
||||
throw new Error(`Failed to find address for index ${index} in address lookup table ${tableLookup.accountKey.toBase58()}`);
|
||||
}
|
||||
}
|
||||
for (const index of tableLookup.readonlyIndexes) {
|
||||
if (index < tableAccount.state.addresses.length) {
|
||||
accountKeysFromLookups.readonly.push(tableAccount.state.addresses[index]);
|
||||
} else {
|
||||
throw new Error(`Failed to find address for index ${index} in address lookup table ${tableLookup.accountKey.toBase58()}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
return accountKeysFromLookups;
|
||||
}
|
||||
static compile(args) {
|
||||
const compiledKeys = CompiledKeys.compile(args.instructions, args.payerKey);
|
||||
const addressTableLookups = new Array();
|
||||
const accountKeysFromLookups = {
|
||||
writable: new Array(),
|
||||
readonly: new Array()
|
||||
};
|
||||
const lookupTableAccounts = args.addressLookupTableAccounts || [];
|
||||
for (const lookupTable of lookupTableAccounts) {
|
||||
const extractResult = compiledKeys.extractTableLookup(lookupTable);
|
||||
if (extractResult !== void 0) {
|
||||
const [addressTableLookup, {
|
||||
writable,
|
||||
readonly
|
||||
}] = extractResult;
|
||||
addressTableLookups.push(addressTableLookup);
|
||||
accountKeysFromLookups.writable.push(...writable);
|
||||
accountKeysFromLookups.readonly.push(...readonly);
|
||||
}
|
||||
}
|
||||
const [header, staticAccountKeys] = compiledKeys.getMessageComponents();
|
||||
const accountKeys = new MessageAccountKeys(staticAccountKeys, accountKeysFromLookups);
|
||||
const compiledInstructions = accountKeys.compileInstructions(args.instructions);
|
||||
return new _MessageV0({
|
||||
header,
|
||||
staticAccountKeys,
|
||||
recentBlockhash: args.recentBlockhash,
|
||||
compiledInstructions,
|
||||
addressTableLookups
|
||||
});
|
||||
}
|
||||
serialize() {
|
||||
const encodedStaticAccountKeysLength = Array();
|
||||
encodeLength(encodedStaticAccountKeysLength, this.staticAccountKeys.length);
|
||||
const serializedInstructions = this.serializeInstructions();
|
||||
const encodedInstructionsLength = Array();
|
||||
encodeLength(encodedInstructionsLength, this.compiledInstructions.length);
|
||||
const serializedAddressTableLookups = this.serializeAddressTableLookups();
|
||||
const encodedAddressTableLookupsLength = Array();
|
||||
encodeLength(encodedAddressTableLookupsLength, this.addressTableLookups.length);
|
||||
const messageLayout = BufferLayout.struct([BufferLayout.u8("prefix"), BufferLayout.struct([BufferLayout.u8("numRequiredSignatures"), BufferLayout.u8("numReadonlySignedAccounts"), BufferLayout.u8("numReadonlyUnsignedAccounts")], "header"), BufferLayout.blob(encodedStaticAccountKeysLength.length, "staticAccountKeysLength"), BufferLayout.seq(publicKey(), this.staticAccountKeys.length, "staticAccountKeys"), publicKey("recentBlockhash"), BufferLayout.blob(encodedInstructionsLength.length, "instructionsLength"), BufferLayout.blob(serializedInstructions.length, "serializedInstructions"), BufferLayout.blob(encodedAddressTableLookupsLength.length, "addressTableLookupsLength"), BufferLayout.blob(serializedAddressTableLookups.length, "serializedAddressTableLookups")]);
|
||||
const serializedMessage = new Uint8Array(PACKET_DATA_SIZE);
|
||||
const MESSAGE_VERSION_0_PREFIX = 1 << 7;
|
||||
const serializedMessageLength = messageLayout.encode({
|
||||
prefix: MESSAGE_VERSION_0_PREFIX,
|
||||
header: this.header,
|
||||
staticAccountKeysLength: new Uint8Array(encodedStaticAccountKeysLength),
|
||||
staticAccountKeys: this.staticAccountKeys.map((key) => key.toBytes()),
|
||||
recentBlockhash: import_bs58.default.decode(this.recentBlockhash),
|
||||
instructionsLength: new Uint8Array(encodedInstructionsLength),
|
||||
serializedInstructions,
|
||||
addressTableLookupsLength: new Uint8Array(encodedAddressTableLookupsLength),
|
||||
serializedAddressTableLookups
|
||||
}, serializedMessage);
|
||||
return serializedMessage.slice(0, serializedMessageLength);
|
||||
}
|
||||
serializeInstructions() {
|
||||
let serializedLength = 0;
|
||||
const serializedInstructions = new Uint8Array(PACKET_DATA_SIZE);
|
||||
for (const instruction of this.compiledInstructions) {
|
||||
const encodedAccountKeyIndexesLength = Array();
|
||||
encodeLength(encodedAccountKeyIndexesLength, instruction.accountKeyIndexes.length);
|
||||
const encodedDataLength = Array();
|
||||
encodeLength(encodedDataLength, instruction.data.length);
|
||||
const instructionLayout = BufferLayout.struct([BufferLayout.u8("programIdIndex"), BufferLayout.blob(encodedAccountKeyIndexesLength.length, "encodedAccountKeyIndexesLength"), BufferLayout.seq(BufferLayout.u8(), instruction.accountKeyIndexes.length, "accountKeyIndexes"), BufferLayout.blob(encodedDataLength.length, "encodedDataLength"), BufferLayout.blob(instruction.data.length, "data")]);
|
||||
serializedLength += instructionLayout.encode({
|
||||
programIdIndex: instruction.programIdIndex,
|
||||
encodedAccountKeyIndexesLength: new Uint8Array(encodedAccountKeyIndexesLength),
|
||||
accountKeyIndexes: instruction.accountKeyIndexes,
|
||||
encodedDataLength: new Uint8Array(encodedDataLength),
|
||||
data: instruction.data
|
||||
}, serializedInstructions, serializedLength);
|
||||
}
|
||||
return serializedInstructions.slice(0, serializedLength);
|
||||
}
|
||||
serializeAddressTableLookups() {
|
||||
let serializedLength = 0;
|
||||
const serializedAddressTableLookups = new Uint8Array(PACKET_DATA_SIZE);
|
||||
for (const lookup of this.addressTableLookups) {
|
||||
const encodedWritableIndexesLength = Array();
|
||||
encodeLength(encodedWritableIndexesLength, lookup.writableIndexes.length);
|
||||
const encodedReadonlyIndexesLength = Array();
|
||||
encodeLength(encodedReadonlyIndexesLength, lookup.readonlyIndexes.length);
|
||||
const addressTableLookupLayout = BufferLayout.struct([publicKey("accountKey"), BufferLayout.blob(encodedWritableIndexesLength.length, "encodedWritableIndexesLength"), BufferLayout.seq(BufferLayout.u8(), lookup.writableIndexes.length, "writableIndexes"), BufferLayout.blob(encodedReadonlyIndexesLength.length, "encodedReadonlyIndexesLength"), BufferLayout.seq(BufferLayout.u8(), lookup.readonlyIndexes.length, "readonlyIndexes")]);
|
||||
serializedLength += addressTableLookupLayout.encode({
|
||||
accountKey: lookup.accountKey.toBytes(),
|
||||
encodedWritableIndexesLength: new Uint8Array(encodedWritableIndexesLength),
|
||||
writableIndexes: lookup.writableIndexes,
|
||||
encodedReadonlyIndexesLength: new Uint8Array(encodedReadonlyIndexesLength),
|
||||
readonlyIndexes: lookup.readonlyIndexes
|
||||
}, serializedAddressTableLookups, serializedLength);
|
||||
}
|
||||
return serializedAddressTableLookups.slice(0, serializedLength);
|
||||
}
|
||||
static deserialize(serializedMessage) {
|
||||
let byteArray = [...serializedMessage];
|
||||
const prefix = guardedShift(byteArray);
|
||||
const maskedPrefix = prefix & VERSION_PREFIX_MASK;
|
||||
assert2(prefix !== maskedPrefix, `Expected versioned message but received legacy message`);
|
||||
const version2 = maskedPrefix;
|
||||
assert2(version2 === 0, `Expected versioned message with version 0 but found version ${version2}`);
|
||||
const header = {
|
||||
numRequiredSignatures: guardedShift(byteArray),
|
||||
numReadonlySignedAccounts: guardedShift(byteArray),
|
||||
numReadonlyUnsignedAccounts: guardedShift(byteArray)
|
||||
};
|
||||
const staticAccountKeys = [];
|
||||
const staticAccountKeysLength = decodeLength(byteArray);
|
||||
for (let i2 = 0; i2 < staticAccountKeysLength; i2++) {
|
||||
staticAccountKeys.push(new PublicKey(guardedSplice(byteArray, 0, PUBLIC_KEY_LENGTH)));
|
||||
}
|
||||
const recentBlockhash = import_bs58.default.encode(guardedSplice(byteArray, 0, PUBLIC_KEY_LENGTH));
|
||||
const instructionCount = decodeLength(byteArray);
|
||||
const compiledInstructions = [];
|
||||
for (let i2 = 0; i2 < instructionCount; i2++) {
|
||||
const programIdIndex = guardedShift(byteArray);
|
||||
const accountKeyIndexesLength = decodeLength(byteArray);
|
||||
const accountKeyIndexes = guardedSplice(byteArray, 0, accountKeyIndexesLength);
|
||||
const dataLength = decodeLength(byteArray);
|
||||
const data = new Uint8Array(guardedSplice(byteArray, 0, dataLength));
|
||||
compiledInstructions.push({
|
||||
programIdIndex,
|
||||
accountKeyIndexes,
|
||||
data
|
||||
});
|
||||
}
|
||||
const addressTableLookupsCount = decodeLength(byteArray);
|
||||
const addressTableLookups = [];
|
||||
for (let i2 = 0; i2 < addressTableLookupsCount; i2++) {
|
||||
const accountKey = new PublicKey(guardedSplice(byteArray, 0, PUBLIC_KEY_LENGTH));
|
||||
const writableIndexesLength = decodeLength(byteArray);
|
||||
const writableIndexes = guardedSplice(byteArray, 0, writableIndexesLength);
|
||||
const readonlyIndexesLength = decodeLength(byteArray);
|
||||
const readonlyIndexes = guardedSplice(byteArray, 0, readonlyIndexesLength);
|
||||
addressTableLookups.push({
|
||||
accountKey,
|
||||
writableIndexes,
|
||||
readonlyIndexes
|
||||
});
|
||||
}
|
||||
return new _MessageV0({
|
||||
header,
|
||||
staticAccountKeys,
|
||||
recentBlockhash,
|
||||
compiledInstructions,
|
||||
addressTableLookups
|
||||
});
|
||||
}
|
||||
};
|
||||
var VersionedMessage = {
|
||||
deserializeMessageVersion(serializedMessage) {
|
||||
const prefix = serializedMessage[0];
|
||||
const maskedPrefix = prefix & VERSION_PREFIX_MASK;
|
||||
if (maskedPrefix === prefix) {
|
||||
return "legacy";
|
||||
}
|
||||
return maskedPrefix;
|
||||
},
|
||||
deserialize: (serializedMessage) => {
|
||||
const version2 = VersionedMessage.deserializeMessageVersion(serializedMessage);
|
||||
if (version2 === "legacy") {
|
||||
return Message.from(serializedMessage);
|
||||
}
|
||||
if (version2 === 0) {
|
||||
return MessageV0.deserialize(serializedMessage);
|
||||
} else {
|
||||
throw new Error(`Transaction message version ${version2} deserialization is not supported`);
|
||||
}
|
||||
}
|
||||
};
|
||||
var DEFAULT_SIGNATURE = import_buffer2.Buffer.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
|
||||
var TransactionInstruction = class {
|
||||
constructor(opts) {
|
||||
@@ -13196,9 +13453,9 @@ var Transaction = class _Transaction {
|
||||
isWritable: true
|
||||
});
|
||||
}
|
||||
for (const signature of this.signatures) {
|
||||
for (const signature2 of this.signatures) {
|
||||
const uniqueIndex = uniqueMetas.findIndex((x) => {
|
||||
return x.pubkey.equals(signature.publicKey);
|
||||
return x.pubkey.equals(signature2.publicKey);
|
||||
});
|
||||
if (uniqueIndex > -1) {
|
||||
if (!uniqueMetas[uniqueIndex].isSigner) {
|
||||
@@ -13206,7 +13463,7 @@ var Transaction = class _Transaction {
|
||||
console.warn("Transaction references a signature that is unnecessary, only the fee payer and instruction signer accounts should sign a transaction. This behavior is deprecated and will throw an error in the next major version release.");
|
||||
}
|
||||
} else {
|
||||
throw new Error(`unknown signer: ${signature.publicKey.toString()}`);
|
||||
throw new Error(`unknown signer: ${signature2.publicKey.toString()}`);
|
||||
}
|
||||
}
|
||||
let numRequiredSignatures = 0;
|
||||
@@ -13392,8 +13649,8 @@ var Transaction = class _Transaction {
|
||||
_partialSign(message, ...signers) {
|
||||
const signData = message.serialize();
|
||||
signers.forEach((signer) => {
|
||||
const signature = sign(signData, signer.secretKey);
|
||||
this._addSignature(signer.publicKey, toBuffer(signature));
|
||||
const signature2 = sign(signData, signer.secretKey);
|
||||
this._addSignature(signer.publicKey, toBuffer(signature2));
|
||||
});
|
||||
}
|
||||
/**
|
||||
@@ -13404,20 +13661,20 @@ var Transaction = class _Transaction {
|
||||
* @param {PublicKey} pubkey Public key that will be added to the transaction.
|
||||
* @param {Buffer} signature An externally created signature to add to the transaction.
|
||||
*/
|
||||
addSignature(pubkey, signature) {
|
||||
addSignature(pubkey, signature2) {
|
||||
this._compile();
|
||||
this._addSignature(pubkey, signature);
|
||||
this._addSignature(pubkey, signature2);
|
||||
}
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
_addSignature(pubkey, signature) {
|
||||
assert2(signature.length === 64);
|
||||
_addSignature(pubkey, signature2) {
|
||||
assert2(signature2.length === 64);
|
||||
const index = this.signatures.findIndex((sigpair) => pubkey.equals(sigpair.publicKey));
|
||||
if (index < 0) {
|
||||
throw new Error(`unknown signer: ${pubkey.toString()}`);
|
||||
}
|
||||
this.signatures[index].signature = import_buffer2.Buffer.from(signature);
|
||||
this.signatures[index].signature = import_buffer2.Buffer.from(signature2);
|
||||
}
|
||||
/**
|
||||
* Verify signatures of a Transaction
|
||||
@@ -13436,15 +13693,15 @@ var Transaction = class _Transaction {
|
||||
_getMessageSignednessErrors(message, requireAllSignatures) {
|
||||
const errors = {};
|
||||
for (const {
|
||||
signature,
|
||||
signature: signature2,
|
||||
publicKey: publicKey2
|
||||
} of this.signatures) {
|
||||
if (signature === null) {
|
||||
if (signature2 === null) {
|
||||
if (requireAllSignatures) {
|
||||
(errors.missing ||= []).push(publicKey2);
|
||||
}
|
||||
} else {
|
||||
if (!verify(signature, message, publicKey2.toBytes())) {
|
||||
if (!verify(signature2, message, publicKey2.toBytes())) {
|
||||
(errors.invalid ||= []).push(publicKey2);
|
||||
}
|
||||
}
|
||||
@@ -13498,11 +13755,11 @@ Missing signature for public key${sigErrors.missing.length === 1 ? "" : "(s)"} [
|
||||
assert2(signatures.length < 256);
|
||||
import_buffer2.Buffer.from(signatureCount).copy(wireTransaction, 0);
|
||||
signatures.forEach(({
|
||||
signature
|
||||
signature: signature2
|
||||
}, index) => {
|
||||
if (signature !== null) {
|
||||
assert2(signature.length === 64, `signature has invalid length`);
|
||||
import_buffer2.Buffer.from(signature).copy(wireTransaction, signatureCount.length + index * 64);
|
||||
if (signature2 !== null) {
|
||||
assert2(signature2.length === 64, `signature has invalid length`);
|
||||
import_buffer2.Buffer.from(signature2).copy(wireTransaction, signatureCount.length + index * 64);
|
||||
}
|
||||
});
|
||||
signData.copy(wireTransaction, signatureCount.length + signatures.length * 64);
|
||||
@@ -13545,8 +13802,8 @@ Missing signature for public key${sigErrors.missing.length === 1 ? "" : "(s)"} [
|
||||
const signatureCount = decodeLength(byteArray);
|
||||
let signatures = [];
|
||||
for (let i2 = 0; i2 < signatureCount; i2++) {
|
||||
const signature = guardedSplice(byteArray, 0, SIGNATURE_LENGTH_IN_BYTES);
|
||||
signatures.push(import_bs58.default.encode(import_buffer2.Buffer.from(signature)));
|
||||
const signature2 = guardedSplice(byteArray, 0, SIGNATURE_LENGTH_IN_BYTES);
|
||||
signatures.push(import_bs58.default.encode(import_buffer2.Buffer.from(signature2)));
|
||||
}
|
||||
return _Transaction.populate(Message.from(byteArray), signatures);
|
||||
}
|
||||
@@ -13564,9 +13821,9 @@ Missing signature for public key${sigErrors.missing.length === 1 ? "" : "(s)"} [
|
||||
if (message.header.numRequiredSignatures > 0) {
|
||||
transaction.feePayer = message.accountKeys[0];
|
||||
}
|
||||
signatures.forEach((signature, index) => {
|
||||
signatures.forEach((signature2, index) => {
|
||||
const sigPubkeyPair = {
|
||||
signature: signature == import_bs58.default.encode(DEFAULT_SIGNATURE) ? null : import_bs58.default.decode(signature),
|
||||
signature: signature2 == import_bs58.default.encode(DEFAULT_SIGNATURE) ? null : import_bs58.default.decode(signature2),
|
||||
publicKey: message.accountKeys[index]
|
||||
};
|
||||
transaction.signatures.push(sigPubkeyPair);
|
||||
@@ -13591,6 +13848,65 @@ Missing signature for public key${sigErrors.missing.length === 1 ? "" : "(s)"} [
|
||||
return transaction;
|
||||
}
|
||||
};
|
||||
var VersionedTransaction = class _VersionedTransaction {
|
||||
get version() {
|
||||
return this.message.version;
|
||||
}
|
||||
constructor(message, signatures) {
|
||||
this.signatures = void 0;
|
||||
this.message = void 0;
|
||||
if (signatures !== void 0) {
|
||||
assert2(signatures.length === message.header.numRequiredSignatures, "Expected signatures length to be equal to the number of required signatures");
|
||||
this.signatures = signatures;
|
||||
} else {
|
||||
const defaultSignatures = [];
|
||||
for (let i2 = 0; i2 < message.header.numRequiredSignatures; i2++) {
|
||||
defaultSignatures.push(new Uint8Array(SIGNATURE_LENGTH_IN_BYTES));
|
||||
}
|
||||
this.signatures = defaultSignatures;
|
||||
}
|
||||
this.message = message;
|
||||
}
|
||||
serialize() {
|
||||
const serializedMessage = this.message.serialize();
|
||||
const encodedSignaturesLength = Array();
|
||||
encodeLength(encodedSignaturesLength, this.signatures.length);
|
||||
const transactionLayout = BufferLayout.struct([BufferLayout.blob(encodedSignaturesLength.length, "encodedSignaturesLength"), BufferLayout.seq(signature(), this.signatures.length, "signatures"), BufferLayout.blob(serializedMessage.length, "serializedMessage")]);
|
||||
const serializedTransaction = new Uint8Array(2048);
|
||||
const serializedTransactionLength = transactionLayout.encode({
|
||||
encodedSignaturesLength: new Uint8Array(encodedSignaturesLength),
|
||||
signatures: this.signatures,
|
||||
serializedMessage
|
||||
}, serializedTransaction);
|
||||
return serializedTransaction.slice(0, serializedTransactionLength);
|
||||
}
|
||||
static deserialize(serializedTransaction) {
|
||||
let byteArray = [...serializedTransaction];
|
||||
const signatures = [];
|
||||
const signaturesLength = decodeLength(byteArray);
|
||||
for (let i2 = 0; i2 < signaturesLength; i2++) {
|
||||
signatures.push(new Uint8Array(guardedSplice(byteArray, 0, SIGNATURE_LENGTH_IN_BYTES)));
|
||||
}
|
||||
const message = VersionedMessage.deserialize(new Uint8Array(byteArray));
|
||||
return new _VersionedTransaction(message, signatures);
|
||||
}
|
||||
sign(signers) {
|
||||
const messageData = this.message.serialize();
|
||||
const signerPubkeys = this.message.staticAccountKeys.slice(0, this.message.header.numRequiredSignatures);
|
||||
for (const signer of signers) {
|
||||
const signerIndex = signerPubkeys.findIndex((pubkey) => pubkey.equals(signer.publicKey));
|
||||
assert2(signerIndex >= 0, `Cannot sign with non signer key ${signer.publicKey.toBase58()}`);
|
||||
this.signatures[signerIndex] = sign(messageData, signer.secretKey);
|
||||
}
|
||||
}
|
||||
addSignature(publicKey2, signature2) {
|
||||
assert2(signature2.byteLength === 64, "Signature must be 64 bytes long");
|
||||
const signerPubkeys = this.message.staticAccountKeys.slice(0, this.message.header.numRequiredSignatures);
|
||||
const signerIndex = signerPubkeys.findIndex((pubkey) => pubkey.equals(publicKey2));
|
||||
assert2(signerIndex >= 0, `Can not add signature; \`${publicKey2.toBase58()}\` is not required to sign this transaction`);
|
||||
this.signatures[signerIndex] = signature2;
|
||||
}
|
||||
};
|
||||
var NUM_TICKS_PER_SECOND = 160;
|
||||
var DEFAULT_TICKS_PER_SLOT = 64;
|
||||
var NUM_SLOTS_PER_SECOND = NUM_TICKS_PER_SECOND / DEFAULT_TICKS_PER_SLOT;
|
||||
@@ -13607,7 +13923,7 @@ var SYSVAR_STAKE_HISTORY_PUBKEY = new PublicKey("SysvarStakeHistory1111111111111
|
||||
var SendTransactionError = class extends Error {
|
||||
constructor({
|
||||
action,
|
||||
signature,
|
||||
signature: signature2,
|
||||
transactionMessage,
|
||||
logs
|
||||
}) {
|
||||
@@ -13617,7 +13933,7 @@ ${JSON.stringify(logs.slice(-10), null, 2)}. ` : "";
|
||||
let message;
|
||||
switch (action) {
|
||||
case "send":
|
||||
message = `Transaction ${signature} resulted in an error.
|
||||
message = `Transaction ${signature2} resulted in an error.
|
||||
${transactionMessage}. ` + maybeLogsOutput + guideText;
|
||||
break;
|
||||
case "simulate":
|
||||
@@ -13633,7 +13949,7 @@ Message: ${transactionMessage}.
|
||||
this.signature = void 0;
|
||||
this.transactionMessage = void 0;
|
||||
this.transactionLogs = void 0;
|
||||
this.signature = signature;
|
||||
this.signature = signature2;
|
||||
this.transactionMessage = transactionMessage;
|
||||
this.transactionLogs = logs ? logs : void 0;
|
||||
}
|
||||
@@ -13675,12 +13991,12 @@ async function sendAndConfirmTransaction(connection, transaction, signers, optio
|
||||
maxRetries: options.maxRetries,
|
||||
minContextSlot: options.minContextSlot
|
||||
};
|
||||
const signature = await connection.sendTransaction(transaction, signers, sendOptions);
|
||||
const signature2 = await connection.sendTransaction(transaction, signers, sendOptions);
|
||||
let status;
|
||||
if (transaction.recentBlockhash != null && transaction.lastValidBlockHeight != null) {
|
||||
status = (await connection.confirmTransaction({
|
||||
abortSignal: options?.abortSignal,
|
||||
signature,
|
||||
signature: signature2,
|
||||
blockhash: transaction.recentBlockhash,
|
||||
lastValidBlockHeight: transaction.lastValidBlockHeight
|
||||
}, options && options.commitment)).value;
|
||||
@@ -13694,25 +14010,25 @@ async function sendAndConfirmTransaction(connection, transaction, signers, optio
|
||||
minContextSlot: transaction.minNonceContextSlot,
|
||||
nonceAccountPubkey,
|
||||
nonceValue: transaction.nonceInfo.nonce,
|
||||
signature
|
||||
signature: signature2
|
||||
}, options && options.commitment)).value;
|
||||
} else {
|
||||
if (options?.abortSignal != null) {
|
||||
console.warn("sendAndConfirmTransaction(): A transaction with a deprecated confirmation strategy was supplied along with an `abortSignal`. Only transactions having `lastValidBlockHeight` or a combination of `nonceInfo` and `minNonceContextSlot` are abortable.");
|
||||
}
|
||||
status = (await connection.confirmTransaction(signature, options && options.commitment)).value;
|
||||
status = (await connection.confirmTransaction(signature2, options && options.commitment)).value;
|
||||
}
|
||||
if (status.err) {
|
||||
if (signature != null) {
|
||||
if (signature2 != null) {
|
||||
throw new SendTransactionError({
|
||||
action: "send",
|
||||
signature,
|
||||
signature: signature2,
|
||||
transactionMessage: `Status: (${JSON.stringify(status)})`
|
||||
});
|
||||
}
|
||||
throw new Error(`Transaction ${signature} failed (${JSON.stringify(status)})`);
|
||||
throw new Error(`Transaction ${signature2} failed (${JSON.stringify(status)})`);
|
||||
}
|
||||
return signature;
|
||||
return signature2;
|
||||
}
|
||||
function sleep(ms) {
|
||||
return new Promise((resolve) => setTimeout(resolve, ms));
|
||||
@@ -15218,14 +15534,14 @@ var Ed25519Program = class _Ed25519Program {
|
||||
const {
|
||||
publicKey: publicKey2,
|
||||
message,
|
||||
signature,
|
||||
signature: signature2,
|
||||
instructionIndex
|
||||
} = params;
|
||||
assert2(publicKey2.length === PUBLIC_KEY_BYTES$1, `Public Key must be ${PUBLIC_KEY_BYTES$1} bytes but received ${publicKey2.length} bytes`);
|
||||
assert2(signature.length === SIGNATURE_BYTES, `Signature must be ${SIGNATURE_BYTES} bytes but received ${signature.length} bytes`);
|
||||
assert2(signature2.length === SIGNATURE_BYTES, `Signature must be ${SIGNATURE_BYTES} bytes but received ${signature2.length} bytes`);
|
||||
const publicKeyOffset = ED25519_INSTRUCTION_LAYOUT.span;
|
||||
const signatureOffset = publicKeyOffset + publicKey2.length;
|
||||
const messageDataOffset = signatureOffset + signature.length;
|
||||
const messageDataOffset = signatureOffset + signature2.length;
|
||||
const numSignatures = 1;
|
||||
const instructionData = import_buffer2.Buffer.alloc(messageDataOffset + message.length);
|
||||
const index = instructionIndex == null ? 65535 : instructionIndex;
|
||||
@@ -15241,7 +15557,7 @@ var Ed25519Program = class _Ed25519Program {
|
||||
messageInstructionIndex: index
|
||||
}, instructionData);
|
||||
instructionData.fill(publicKey2, publicKeyOffset);
|
||||
instructionData.fill(signature, signatureOffset);
|
||||
instructionData.fill(signature2, signatureOffset);
|
||||
instructionData.fill(message, messageDataOffset);
|
||||
return new TransactionInstruction({
|
||||
keys: [],
|
||||
@@ -15263,11 +15579,11 @@ var Ed25519Program = class _Ed25519Program {
|
||||
try {
|
||||
const keypair = Keypair.fromSecretKey(privateKey);
|
||||
const publicKey2 = keypair.publicKey.toBytes();
|
||||
const signature = sign(message, keypair.secretKey);
|
||||
const signature2 = sign(message, keypair.secretKey);
|
||||
return this.createInstructionWithPublicKey({
|
||||
publicKey: publicKey2,
|
||||
message,
|
||||
signature,
|
||||
signature: signature2,
|
||||
instructionIndex
|
||||
});
|
||||
} catch (error) {
|
||||
@@ -15277,8 +15593,8 @@ var Ed25519Program = class _Ed25519Program {
|
||||
};
|
||||
Ed25519Program.programId = new PublicKey("Ed25519SigVerify111111111111111111111111111");
|
||||
var ecdsaSign = (msgHash, privKey) => {
|
||||
const signature = secp256k1.sign(msgHash, privKey);
|
||||
return [signature.toCompactRawBytes(), signature.recovery];
|
||||
const signature2 = secp256k1.sign(msgHash, privKey);
|
||||
return [signature2.toCompactRawBytes(), signature2.recovery];
|
||||
};
|
||||
secp256k1.utils.isValidPrivateKey;
|
||||
var publicKeyCreate = secp256k1.getPublicKey;
|
||||
@@ -15316,14 +15632,14 @@ var Secp256k1Program = class _Secp256k1Program {
|
||||
const {
|
||||
publicKey: publicKey2,
|
||||
message,
|
||||
signature,
|
||||
signature: signature2,
|
||||
recoveryId,
|
||||
instructionIndex
|
||||
} = params;
|
||||
return _Secp256k1Program.createInstructionWithEthAddress({
|
||||
ethAddress: _Secp256k1Program.publicKeyToEthAddress(publicKey2),
|
||||
message,
|
||||
signature,
|
||||
signature: signature2,
|
||||
recoveryId,
|
||||
instructionIndex
|
||||
});
|
||||
@@ -15336,7 +15652,7 @@ var Secp256k1Program = class _Secp256k1Program {
|
||||
const {
|
||||
ethAddress: rawAddress,
|
||||
message,
|
||||
signature,
|
||||
signature: signature2,
|
||||
recoveryId,
|
||||
instructionIndex = 0
|
||||
} = params;
|
||||
@@ -15354,7 +15670,7 @@ var Secp256k1Program = class _Secp256k1Program {
|
||||
const dataStart = 1 + SIGNATURE_OFFSETS_SERIALIZED_SIZE;
|
||||
const ethAddressOffset = dataStart;
|
||||
const signatureOffset = dataStart + ethAddress.length;
|
||||
const messageDataOffset = signatureOffset + signature.length + 1;
|
||||
const messageDataOffset = signatureOffset + signature2.length + 1;
|
||||
const numSignatures = 1;
|
||||
const instructionData = import_buffer2.Buffer.alloc(SECP256K1_INSTRUCTION_LAYOUT.span + message.length);
|
||||
SECP256K1_INSTRUCTION_LAYOUT.encode({
|
||||
@@ -15366,7 +15682,7 @@ var Secp256k1Program = class _Secp256k1Program {
|
||||
messageDataOffset,
|
||||
messageDataSize: message.length,
|
||||
messageInstructionIndex: instructionIndex,
|
||||
signature: toBuffer(signature),
|
||||
signature: toBuffer(signature2),
|
||||
ethAddress: toBuffer(ethAddress),
|
||||
recoveryId
|
||||
}, instructionData);
|
||||
@@ -15396,11 +15712,11 @@ var Secp256k1Program = class _Secp256k1Program {
|
||||
/* isCompressed */
|
||||
).slice(1);
|
||||
const messageHash = import_buffer2.Buffer.from(keccak_256(toBuffer(message)));
|
||||
const [signature, recoveryId] = ecdsaSign(messageHash, privateKey);
|
||||
const [signature2, recoveryId] = ecdsaSign(messageHash, privateKey);
|
||||
return this.createInstructionWithPublicKey({
|
||||
publicKey: publicKey2,
|
||||
message,
|
||||
signature,
|
||||
signature: signature2,
|
||||
recoveryId,
|
||||
instructionIndex
|
||||
});
|
||||
@@ -16179,7 +16495,9 @@ var VoteAccountLayout = BufferLayout.struct([
|
||||
BufferLayout.struct([BufferLayout.nu64("slot"), BufferLayout.nu64("timestamp")], "lastTimestamp")
|
||||
]);
|
||||
export {
|
||||
PublicKey
|
||||
PublicKey,
|
||||
Transaction,
|
||||
VersionedTransaction
|
||||
};
|
||||
/*! Bundled license information:
|
||||
|
||||
|
||||
@@ -1,3 +1,3 @@
|
||||
import { PublicKey } from '@solana/web3.js';
|
||||
import { PublicKey, Transaction, VersionedTransaction } from '@solana/web3.js';
|
||||
|
||||
export { PublicKey };
|
||||
export { PublicKey, Transaction, VersionedTransaction };
|
||||
|
||||
@@ -24,6 +24,7 @@ export class WsJsonClient {
|
||||
this.ws = null;
|
||||
this.openPromise = null;
|
||||
this.pending = new Map();
|
||||
this.listeners = new Map();
|
||||
}
|
||||
|
||||
async open() {
|
||||
@@ -78,14 +79,53 @@ export class WsJsonClient {
|
||||
} catch {
|
||||
return;
|
||||
}
|
||||
if (data?.event) {
|
||||
this.emit(String(data?.op || ''), data);
|
||||
return;
|
||||
}
|
||||
const requestId = data?.requestId;
|
||||
if (!requestId) return;
|
||||
if (!requestId) {
|
||||
this.emit(String(data?.op || ''), data);
|
||||
return;
|
||||
}
|
||||
const slot = this.pending.get(requestId);
|
||||
if (!slot) return;
|
||||
if (!slot) {
|
||||
this.emit(String(data?.op || ''), data);
|
||||
return;
|
||||
}
|
||||
this.pending.delete(requestId);
|
||||
slot.resolve(data);
|
||||
}
|
||||
|
||||
on(op, handler) {
|
||||
const key = String(op || '').trim();
|
||||
if (!key || typeof handler !== 'function') {
|
||||
return () => {};
|
||||
}
|
||||
if (!this.listeners.has(key)) {
|
||||
this.listeners.set(key, new Set());
|
||||
}
|
||||
this.listeners.get(key).add(handler);
|
||||
return () => {
|
||||
const bucket = this.listeners.get(key);
|
||||
if (!bucket) return;
|
||||
bucket.delete(handler);
|
||||
if (!bucket.size) {
|
||||
this.listeners.delete(key);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
emit(op, payload) {
|
||||
const bucket = this.listeners.get(String(op || '').trim());
|
||||
if (!bucket?.size) return;
|
||||
for (const handler of [...bucket]) {
|
||||
try {
|
||||
handler(payload);
|
||||
} catch {}
|
||||
}
|
||||
}
|
||||
|
||||
failPending(message) {
|
||||
const error = new Error(message);
|
||||
for (const slot of this.pending.values()) slot.reject(error);
|
||||
|
||||
@@ -4,7 +4,8 @@
|
||||
"version": "0.1.0",
|
||||
"description": "Wallet-session plugin for SHiNE with session-only login via trusted device.",
|
||||
"permissions": [
|
||||
"storage"
|
||||
"storage",
|
||||
"sidePanel"
|
||||
],
|
||||
"host_permissions": [
|
||||
"<all_urls>"
|
||||
@@ -13,8 +14,32 @@
|
||||
"service_worker": "background.js",
|
||||
"type": "module"
|
||||
},
|
||||
"content_scripts": [
|
||||
{
|
||||
"matches": [
|
||||
"<all_urls>"
|
||||
],
|
||||
"js": [
|
||||
"content-script.js"
|
||||
],
|
||||
"run_at": "document_start"
|
||||
}
|
||||
],
|
||||
"web_accessible_resources": [
|
||||
{
|
||||
"resources": [
|
||||
"provider-bridge.js",
|
||||
"js/lib/vendor/solana-publickey-bundle.js"
|
||||
],
|
||||
"matches": [
|
||||
"<all_urls>"
|
||||
]
|
||||
}
|
||||
],
|
||||
"action": {
|
||||
"default_title": "SHiNE Wallet",
|
||||
"default_popup": "popup.html"
|
||||
"default_title": "Open SHiNE Wallet"
|
||||
},
|
||||
"side_panel": {
|
||||
"default_path": "popup.html"
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,22 +2,34 @@
|
||||
box-sizing: border-box;
|
||||
}
|
||||
|
||||
html {
|
||||
min-height: 100%;
|
||||
}
|
||||
|
||||
body {
|
||||
margin: 0;
|
||||
min-width: 360px;
|
||||
min-width: 320px;
|
||||
max-width: none;
|
||||
min-height: 100vh;
|
||||
background: #0f1720;
|
||||
color: #e8eef6;
|
||||
font: 14px/1.4 system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
|
||||
}
|
||||
|
||||
.side-panel-body {
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
.layout {
|
||||
padding: 12px;
|
||||
min-height: 100vh;
|
||||
}
|
||||
|
||||
.panel {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 12px;
|
||||
min-height: calc(100vh - 24px);
|
||||
}
|
||||
|
||||
.panel-header {
|
||||
@@ -140,9 +152,9 @@ select {
|
||||
}
|
||||
|
||||
.code {
|
||||
font-size: 34px;
|
||||
font-size: 30px;
|
||||
font-weight: 700;
|
||||
letter-spacing: 0.18em;
|
||||
letter-spacing: 0.12em;
|
||||
}
|
||||
|
||||
.summary-row {
|
||||
@@ -153,7 +165,7 @@ select {
|
||||
}
|
||||
|
||||
.summary-row code {
|
||||
max-width: 180px;
|
||||
max-width: 140px;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
@@ -209,3 +221,15 @@ select {
|
||||
.device-state-unknown {
|
||||
color: #f8e2a0;
|
||||
}
|
||||
|
||||
.wallet-pubkey {
|
||||
display: block;
|
||||
width: 100%;
|
||||
padding: 10px 12px;
|
||||
border: 1px solid #314459;
|
||||
border-radius: 8px;
|
||||
background: #0d141d;
|
||||
color: #bed5f5;
|
||||
white-space: normal;
|
||||
line-break: anywhere;
|
||||
}
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
<title>SHiNE Wallet</title>
|
||||
<link rel="stylesheet" href="./popup.css" />
|
||||
</head>
|
||||
<body>
|
||||
<body class="side-panel-body">
|
||||
<main class="layout">
|
||||
<section class="panel">
|
||||
<div class="panel-header">
|
||||
@@ -14,49 +14,14 @@
|
||||
<h1>SHiNE Wallet</h1>
|
||||
<p class="muted">Session-only wallet plugin</p>
|
||||
</div>
|
||||
<span id="connection-pill" class="pill pill-offline">offline</span>
|
||||
<span id="connection-pill" class="pill pill-offline">не подключено</span>
|
||||
</div>
|
||||
|
||||
<p id="server-login-info" class="muted small">Сервер SHiNE: —</p>
|
||||
<p id="server-address" class="muted small">Адрес: —</p>
|
||||
|
||||
<div id="session-card" class="card hidden">
|
||||
<div class="card-title">Подключённая wallet-session</div>
|
||||
<div class="summary-row"><span>Логин</span><strong id="session-login">—</strong></div>
|
||||
<div class="summary-row"><span>Session ID</span><code id="session-id">—</code></div>
|
||||
<div class="summary-row"><span>Тип</span><strong id="session-type">wallet</strong></div>
|
||||
<div class="summary-row"><span>deviceKey</span><code id="device-key-short">—</code></div>
|
||||
<div class="actions">
|
||||
<button id="resume-btn" class="btn secondary" type="button">Проверить session</button>
|
||||
<button id="refresh-devices-btn" class="btn secondary" type="button">Обновить устройства</button>
|
||||
<button id="disconnect-btn" class="btn danger" type="button">Отключить</button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div id="signing-card" class="card hidden">
|
||||
<div class="card-title">Подготовка подписи</div>
|
||||
<label class="field">
|
||||
<span>Ключ подписи</span>
|
||||
<select id="sign-key-select"></select>
|
||||
</label>
|
||||
<label class="field">
|
||||
<span>Устройство homeserver</span>
|
||||
<select id="device-select"></select>
|
||||
</label>
|
||||
<div id="homeserver-list" class="device-list"></div>
|
||||
<p class="muted small">
|
||||
Для выбора доступны homeserver-сессии, опубликованные в PDA аккаунта. Online-статус определяется без постоянного удержания соединения.
|
||||
</p>
|
||||
<div class="actions">
|
||||
<button id="prepare-sign-btn" class="btn primary" type="button">Запросить подпись</button>
|
||||
</div>
|
||||
<p class="muted small">
|
||||
Сам signaling подтверждения подписи ещё не доделан. Сейчас доступен только каркас выбора ключа и устройства.
|
||||
</p>
|
||||
</div>
|
||||
|
||||
<div class="card">
|
||||
<div class="card-title">Войти через другое устройство</div>
|
||||
<div id="connect-card" class="card">
|
||||
<div class="card-title">Подключение</div>
|
||||
<label class="field">
|
||||
<span>Логин</span>
|
||||
<input id="login-input" type="text" autocomplete="username" />
|
||||
@@ -69,29 +34,61 @@
|
||||
<span>Пароль подключения</span>
|
||||
<input id="password-input" type="password" autocomplete="current-password" />
|
||||
</label>
|
||||
<button id="start-btn" class="btn primary" type="button">Получить код</button>
|
||||
<p class="muted small">
|
||||
Wallet plugin создаёт временный requester keypair, ждёт подтверждение на доверенном устройстве
|
||||
и получает только wallet-session без передачи постоянных ключей.
|
||||
</p>
|
||||
<button id="start-btn" class="btn primary" type="button">Подключить</button>
|
||||
</div>
|
||||
|
||||
<div id="pairing-card" class="card hidden">
|
||||
<div class="card-title">Код подключения</div>
|
||||
<div id="short-code" class="code">00 00 00 00 00</div>
|
||||
<p id="pairing-hint" class="muted small">
|
||||
Покажите код на доверенном устройстве в разделе «Подключить по коду».
|
||||
</p>
|
||||
<p id="pairing-hint" class="muted small">Покажите код на доверенном устройстве.</p>
|
||||
<p id="pairing-expire" class="muted small"></p>
|
||||
<div class="actions">
|
||||
<button id="cancel-btn" class="btn secondary" type="button">Отменить</button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div id="session-card" class="card hidden">
|
||||
<div class="card-title">Подключено</div>
|
||||
<div class="summary-row"><span>Логин</span><strong id="session-login">—</strong></div>
|
||||
<div class="summary-row"><span>Session</span><code id="session-id">—</code></div>
|
||||
<div class="summary-row"><span>Тип</span><strong id="session-type">wallet</strong></div>
|
||||
<div class="summary-row"><span>deviceKey</span><code id="device-key-short">—</code></div>
|
||||
<div class="actions">
|
||||
<button id="resume-btn" class="btn secondary" type="button">Проверить session</button>
|
||||
<button id="disconnect-btn" class="btn danger" type="button">Отключить</button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div id="wallet-card" class="card hidden">
|
||||
<div class="card-title">Текущий кошелёк ESP32</div>
|
||||
<label class="field">
|
||||
<span>Homeserver</span>
|
||||
<select id="device-select"></select>
|
||||
</label>
|
||||
<div id="homeserver-list" class="device-list"></div>
|
||||
<div class="actions">
|
||||
<button id="refresh-devices-btn" class="btn secondary" type="button">Обновить устройства</button>
|
||||
<button id="request-wallet-btn" class="btn primary" type="button">Запросить кошелёк</button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div id="wallet-result-card" class="card hidden">
|
||||
<div class="card-title">Полученный кошелёк</div>
|
||||
<div class="summary-row"><span>Тип</span><strong id="wallet-type">—</strong></div>
|
||||
<div class="field">
|
||||
<span>Public key</span>
|
||||
<code id="wallet-pubkey" class="wallet-pubkey">—</code>
|
||||
</div>
|
||||
<p id="wallet-verify" class="muted small">—</p>
|
||||
<div class="actions">
|
||||
<button id="copy-wallet-btn" class="btn secondary" type="button">Копировать ключ</button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div id="status" class="status hidden"></div>
|
||||
</section>
|
||||
</main>
|
||||
|
||||
<script type="module" src="./popup.js"></script>
|
||||
</body>
|
||||
</html>
|
||||
</html>
|
||||
|
||||
@@ -8,6 +8,7 @@ const els = {
|
||||
passwordField: document.querySelector('#password-field'),
|
||||
passwordInput: document.querySelector('#password-input'),
|
||||
startBtn: document.querySelector('#start-btn'),
|
||||
connectCard: document.querySelector('#connect-card'),
|
||||
pairingCard: document.querySelector('#pairing-card'),
|
||||
shortCode: document.querySelector('#short-code'),
|
||||
pairingHint: document.querySelector('#pairing-hint'),
|
||||
@@ -22,11 +23,15 @@ const els = {
|
||||
resumeBtn: document.querySelector('#resume-btn'),
|
||||
refreshDevicesBtn: document.querySelector('#refresh-devices-btn'),
|
||||
disconnectBtn: document.querySelector('#disconnect-btn'),
|
||||
signingCard: document.querySelector('#signing-card'),
|
||||
signKeySelect: document.querySelector('#sign-key-select'),
|
||||
walletCard: document.querySelector('#wallet-card'),
|
||||
deviceSelect: document.querySelector('#device-select'),
|
||||
homeserverList: document.querySelector('#homeserver-list'),
|
||||
prepareSignBtn: document.querySelector('#prepare-sign-btn'),
|
||||
requestWalletBtn: document.querySelector('#request-wallet-btn'),
|
||||
walletResultCard: document.querySelector('#wallet-result-card'),
|
||||
walletType: document.querySelector('#wallet-type'),
|
||||
walletPubkey: document.querySelector('#wallet-pubkey'),
|
||||
walletVerify: document.querySelector('#wallet-verify'),
|
||||
copyWalletBtn: document.querySelector('#copy-wallet-btn'),
|
||||
connectionPill: document.querySelector('#connection-pill'),
|
||||
};
|
||||
|
||||
@@ -34,16 +39,19 @@ let state = {
|
||||
settings: {
|
||||
serverLogin: 'shineupme',
|
||||
serverHttp: 'https://shineup.me',
|
||||
serverUrl: 'wss://shineup.me/ws',
|
||||
login: '',
|
||||
},
|
||||
pairing: {
|
||||
active: false,
|
||||
pairingId: '',
|
||||
expiresAtMs: 0,
|
||||
shortCode: '',
|
||||
},
|
||||
session: null,
|
||||
connectionOnline: false,
|
||||
walletProfile: null,
|
||||
signing: {
|
||||
selectedDeviceName: '',
|
||||
},
|
||||
currentWallet: null,
|
||||
status: {
|
||||
text: '',
|
||||
kind: 'info',
|
||||
@@ -60,7 +68,7 @@ function setStatus(message, kind = 'info') {
|
||||
}
|
||||
|
||||
function setConnectedPill(connected) {
|
||||
els.connectionPill.textContent = connected ? 'online' : 'offline';
|
||||
els.connectionPill.textContent = connected ? 'подключено' : 'не подключено';
|
||||
els.connectionPill.className = connected ? 'pill pill-online' : 'pill pill-offline';
|
||||
}
|
||||
|
||||
@@ -104,76 +112,65 @@ function applyState(nextState) {
|
||||
const loginValue = String(state?.settings?.login || '');
|
||||
const resolvedServerLogin = String(state?.settings?.serverLogin || '').trim();
|
||||
const resolvedServerAddress = String(state?.settings?.serverHttp || '').trim();
|
||||
if (loginValue && resolvedServerLogin && resolvedServerAddress) {
|
||||
els.serverLoginInfo.textContent = `Сервер SHiNE: ${resolvedServerLogin}`;
|
||||
els.serverAddress.textContent = `Адрес: ${resolvedServerAddress}`;
|
||||
} else {
|
||||
els.serverLoginInfo.textContent = 'Сервер SHiNE: —';
|
||||
els.serverAddress.textContent = 'Адрес: —';
|
||||
}
|
||||
els.serverLoginInfo.textContent = resolvedServerLogin ? `Сервер SHiNE: ${resolvedServerLogin}` : 'Сервер SHiNE: —';
|
||||
els.serverAddress.textContent = resolvedServerAddress ? `Адрес: ${resolvedServerAddress}` : 'Адрес: —';
|
||||
if (document.activeElement !== els.loginInput) {
|
||||
els.loginInput.value = loginValue;
|
||||
}
|
||||
setConnectedPill(!!state?.connectionOnline);
|
||||
|
||||
setConnectedPill(!!state?.session);
|
||||
setStatus(state?.status?.text || '', state?.status?.kind || 'info');
|
||||
|
||||
const session = state?.session;
|
||||
const walletProfile = state?.walletProfile;
|
||||
const signing = state?.signing || {};
|
||||
const currentWallet = state?.currentWallet || null;
|
||||
|
||||
els.connectCard.classList.toggle('hidden', !!session);
|
||||
els.sessionCard.classList.toggle('hidden', !session);
|
||||
els.walletCard.classList.toggle('hidden', !session);
|
||||
|
||||
if (session) {
|
||||
els.sessionCard.classList.remove('hidden');
|
||||
els.sessionLogin.textContent = session.login || '—';
|
||||
els.sessionId.textContent = session.sessionId || '—';
|
||||
els.sessionType.textContent = String(session.sessionType || 50) === '50' ? 'wallet' : String(session.sessionType || '—');
|
||||
els.deviceKeyShort.textContent = shortKey(walletProfile?.publicKeys?.deviceKeyBase58 || '');
|
||||
els.signingCard.classList.remove('hidden');
|
||||
} else {
|
||||
els.sessionCard.classList.add('hidden');
|
||||
els.sessionLogin.textContent = '—';
|
||||
els.sessionId.textContent = '—';
|
||||
els.sessionType.textContent = 'wallet';
|
||||
els.deviceKeyShort.textContent = '—';
|
||||
els.signingCard.classList.add('hidden');
|
||||
}
|
||||
|
||||
const signKeyOptions = Array.isArray(walletProfile?.signingKeyOptions) ? walletProfile.signingKeyOptions : [];
|
||||
els.signKeySelect.innerHTML = '';
|
||||
signKeyOptions.forEach((item) => {
|
||||
const option = document.createElement('option');
|
||||
option.value = item.id;
|
||||
option.textContent = item.label;
|
||||
option.selected = item.id === signing.selectedKeyId;
|
||||
els.signKeySelect.append(option);
|
||||
});
|
||||
|
||||
const homeservers = Array.isArray(walletProfile?.homeserverSessions) ? walletProfile.homeserverSessions : [];
|
||||
els.deviceSelect.innerHTML = '';
|
||||
homeservers.forEach((item) => {
|
||||
const option = document.createElement('option');
|
||||
option.value = item.sessionName;
|
||||
option.textContent = `${item.sessionName} [${item.onlineState || 'unknown'}]`;
|
||||
option.textContent = `${item.sessionName} [${item.onlineState || 'offline'}]`;
|
||||
option.selected = item.sessionName === signing.selectedDeviceName;
|
||||
els.deviceSelect.append(option);
|
||||
});
|
||||
renderHomeserverList(homeservers);
|
||||
els.prepareSignBtn.disabled = !session || !signing.selectedKeyId || !signing.selectedDeviceName;
|
||||
els.requestWalletBtn.disabled = !session || !signing.selectedDeviceName;
|
||||
|
||||
if (currentWallet?.publicKeyBase58) {
|
||||
els.walletResultCard.classList.remove('hidden');
|
||||
els.walletType.textContent = currentWallet.type || '—';
|
||||
els.walletPubkey.textContent = currentWallet.publicKeyBase58 || '—';
|
||||
els.walletVerify.textContent = currentWallet.verificationText || '—';
|
||||
} else {
|
||||
els.walletResultCard.classList.add('hidden');
|
||||
els.walletType.textContent = '—';
|
||||
els.walletPubkey.textContent = '—';
|
||||
els.walletVerify.textContent = '—';
|
||||
}
|
||||
|
||||
const pairing = state?.pairing || {};
|
||||
if (pairing.active) {
|
||||
els.pairingCard.classList.remove('hidden');
|
||||
const shortCode = String(pairing.shortCode || els.shortCode.dataset.shortCode || els.shortCode.textContent || '');
|
||||
els.shortCode.dataset.shortCode = shortCode;
|
||||
els.shortCode.textContent = formatPairingShortCode(shortCode);
|
||||
els.pairingHint.textContent = pairing.trustedSessionOnline
|
||||
? 'Покажите код на доверенном устройстве и подтвердите выпуск wallet-session.'
|
||||
: 'Сейчас нет онлайн доверенной сессии. Откройте другое устройство и подтвердите заявку.';
|
||||
els.shortCode.textContent = formatPairingShortCode(String(pairing.shortCode || ''));
|
||||
const leftMs = Number(pairing.expiresAtMs || 0) - Date.now();
|
||||
els.pairingExpire.textContent = leftMs > 0 ? `Код действителен ещё ${formatRemaining(leftMs)}.` : 'Время ожидания истекло.';
|
||||
els.startBtn.disabled = true;
|
||||
} else {
|
||||
els.pairingCard.classList.add('hidden');
|
||||
els.shortCode.textContent = formatPairingShortCode('');
|
||||
delete els.shortCode.dataset.shortCode;
|
||||
els.pairingExpire.textContent = '';
|
||||
els.startBtn.disabled = false;
|
||||
}
|
||||
@@ -241,16 +238,13 @@ async function startPairing() {
|
||||
return;
|
||||
}
|
||||
setStatus('Создаём wallet-session заявку...', 'info');
|
||||
els.startBtn.disabled = true;
|
||||
try {
|
||||
const response = await sendMessage('wallet:startPairing', {
|
||||
await sendMessage('wallet:startPairing', {
|
||||
login,
|
||||
usePassword: !!els.usePassword.checked,
|
||||
password: String(els.passwordInput.value || ''),
|
||||
});
|
||||
applyState(response.state);
|
||||
} catch (error) {
|
||||
els.startBtn.disabled = false;
|
||||
setStatus(error.message || 'Не удалось начать pairing.', 'error');
|
||||
}
|
||||
}
|
||||
@@ -289,23 +283,33 @@ async function refreshDevices() {
|
||||
}
|
||||
}
|
||||
|
||||
async function updateSigningSelection() {
|
||||
async function updateDeviceSelection() {
|
||||
try {
|
||||
await sendMessage('wallet:updateSigningSelection', {
|
||||
selectedKeyId: String(els.signKeySelect.value || '').trim(),
|
||||
selectedDeviceName: String(els.deviceSelect.value || '').trim(),
|
||||
});
|
||||
} catch (error) {
|
||||
setStatus(error.message || 'Не удалось обновить выбор для подписи.', 'error');
|
||||
setStatus(error.message || 'Не удалось обновить выбор homeserver.', 'error');
|
||||
}
|
||||
}
|
||||
|
||||
async function prepareSignSignal() {
|
||||
setStatus('Готовим каркас запроса подписи...', 'info');
|
||||
async function requestCurrentWallet() {
|
||||
setStatus('Запрашиваем текущий кошелёк с ESP32...', 'info');
|
||||
try {
|
||||
await sendMessage('wallet:prepareSignSignal');
|
||||
await sendMessage('wallet:requestCurrentWallet');
|
||||
} catch (error) {
|
||||
setStatus(error.message || 'Не удалось подготовить запрос подписи.', 'error');
|
||||
setStatus(error.message || 'Не удалось получить кошелёк с ESP32.', 'error');
|
||||
}
|
||||
}
|
||||
|
||||
async function copyWalletKey() {
|
||||
const value = String(els.walletPubkey.textContent || '').trim();
|
||||
if (!value || value === '—') return;
|
||||
try {
|
||||
await navigator.clipboard.writeText(value);
|
||||
setStatus('Публичный ключ скопирован.', 'info');
|
||||
} catch (error) {
|
||||
setStatus(error.message || 'Не удалось скопировать ключ.', 'error');
|
||||
}
|
||||
}
|
||||
|
||||
@@ -340,9 +344,9 @@ function bindUi() {
|
||||
els.resumeBtn.addEventListener('click', () => { void resumeSession(); });
|
||||
els.refreshDevicesBtn.addEventListener('click', () => { void refreshDevices(); });
|
||||
els.disconnectBtn.addEventListener('click', () => { void disconnectSession(); });
|
||||
els.signKeySelect.addEventListener('change', () => { void updateSigningSelection(); });
|
||||
els.deviceSelect.addEventListener('change', () => { void updateSigningSelection(); });
|
||||
els.prepareSignBtn.addEventListener('click', () => { void prepareSignSignal(); });
|
||||
els.deviceSelect.addEventListener('change', () => { void updateDeviceSelection(); });
|
||||
els.requestWalletBtn.addEventListener('click', () => { void requestCurrentWallet(); });
|
||||
els.copyWalletBtn.addEventListener('click', () => { void copyWalletKey(); });
|
||||
}
|
||||
|
||||
async function init() {
|
||||
|
||||
@@ -0,0 +1,192 @@
|
||||
import { PublicKey, Transaction, VersionedTransaction } from './js/lib/vendor/solana-publickey-bundle.js';
|
||||
|
||||
const PAGE_REQUEST = 'shine-wallet-page-request';
|
||||
const PAGE_RESPONSE = 'shine-wallet-page-response';
|
||||
|
||||
function bytesToBase64(bytes) {
|
||||
let binary = '';
|
||||
const chunk = 0x8000;
|
||||
for (let i = 0; i < bytes.length; i += chunk) {
|
||||
const slice = bytes.subarray(i, i + chunk);
|
||||
binary += String.fromCharCode(...slice);
|
||||
}
|
||||
return btoa(binary);
|
||||
}
|
||||
|
||||
function base64ToBytes(value) {
|
||||
const binary = atob(String(value || '').trim());
|
||||
const out = new Uint8Array(binary.length);
|
||||
for (let i = 0; i < binary.length; i += 1) {
|
||||
out[i] = binary.charCodeAt(i);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
function createProviderError(message, code = '') {
|
||||
const error = new Error(String(message || 'Wallet provider error'));
|
||||
if (code === 'USER_REJECTED' || code === 'NOT_TRUSTED') {
|
||||
error.code = 4001;
|
||||
} else if (code) {
|
||||
error.code = code;
|
||||
}
|
||||
return error;
|
||||
}
|
||||
|
||||
function createRequest(method, params = {}) {
|
||||
const id = `shine-wallet-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
|
||||
return new Promise((resolve, reject) => {
|
||||
const onMessage = (event) => {
|
||||
if (event.source !== window) return;
|
||||
const data = event.data || {};
|
||||
if (data?.target !== PAGE_RESPONSE || String(data?.id || '') !== id) return;
|
||||
window.removeEventListener('message', onMessage);
|
||||
if (!data?.ok) {
|
||||
reject(createProviderError(data?.error || 'Wallet request failed', String(data?.code || '')));
|
||||
return;
|
||||
}
|
||||
resolve(data?.result || {});
|
||||
};
|
||||
window.addEventListener('message', onMessage);
|
||||
window.postMessage({
|
||||
target: PAGE_REQUEST,
|
||||
id,
|
||||
method,
|
||||
params,
|
||||
}, window.location.origin);
|
||||
});
|
||||
}
|
||||
|
||||
function serializeTransactionBase64(transaction) {
|
||||
if (!transaction || typeof transaction.serialize !== 'function') {
|
||||
throw createProviderError('Unsupported transaction object', 'UNSUPPORTED_TRANSACTION');
|
||||
}
|
||||
let raw;
|
||||
try {
|
||||
raw = transaction.serialize({ requireAllSignatures: false, verifySignatures: false });
|
||||
} catch {
|
||||
raw = transaction.serialize();
|
||||
}
|
||||
const bytes = raw instanceof Uint8Array ? raw : new Uint8Array(raw);
|
||||
return bytesToBase64(bytes);
|
||||
}
|
||||
|
||||
function deserializeSignedTransaction(base64, originalTransaction) {
|
||||
const bytes = base64ToBytes(base64);
|
||||
const ctor = originalTransaction?.constructor;
|
||||
if (ctor && typeof ctor.deserialize === 'function') {
|
||||
return ctor.deserialize(bytes);
|
||||
}
|
||||
if (ctor && typeof ctor.from === 'function') {
|
||||
return ctor.from(bytes);
|
||||
}
|
||||
if (typeof originalTransaction?.version === 'number') {
|
||||
return VersionedTransaction.deserialize(bytes);
|
||||
}
|
||||
return Transaction.from(bytes);
|
||||
}
|
||||
|
||||
class ShineSolanaProvider {
|
||||
constructor() {
|
||||
this.isSHiNE = true;
|
||||
this.isPhantom = true;
|
||||
this.publicKey = null;
|
||||
this.isConnected = false;
|
||||
this._listeners = new Map();
|
||||
}
|
||||
|
||||
on(event, handler) {
|
||||
const key = String(event || '');
|
||||
if (!this._listeners.has(key)) {
|
||||
this._listeners.set(key, new Set());
|
||||
}
|
||||
this._listeners.get(key).add(handler);
|
||||
return this;
|
||||
}
|
||||
|
||||
off(event, handler) {
|
||||
const bucket = this._listeners.get(String(event || ''));
|
||||
if (!bucket) return this;
|
||||
bucket.delete(handler);
|
||||
if (!bucket.size) {
|
||||
this._listeners.delete(String(event || ''));
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
removeListener(event, handler) {
|
||||
return this.off(event, handler);
|
||||
}
|
||||
|
||||
emit(event, payload) {
|
||||
const bucket = this._listeners.get(String(event || ''));
|
||||
if (!bucket?.size) return;
|
||||
for (const handler of [...bucket]) {
|
||||
try {
|
||||
handler(payload);
|
||||
} catch {}
|
||||
}
|
||||
}
|
||||
|
||||
async connect(options = {}) {
|
||||
const onlyIfTrusted = !!options?.onlyIfTrusted;
|
||||
if (!onlyIfTrusted) {
|
||||
const confirmed = window.confirm(`Connect SHiNE Wallet to ${window.location.origin}?`);
|
||||
if (!confirmed) {
|
||||
throw createProviderError('User rejected wallet connection', 'USER_REJECTED');
|
||||
}
|
||||
}
|
||||
const result = await createRequest('connect', { onlyIfTrusted });
|
||||
const nextKey = new PublicKey(String(result?.publicKeyBase58 || '').trim());
|
||||
this.publicKey = nextKey;
|
||||
this.isConnected = true;
|
||||
this.emit('connect', nextKey);
|
||||
this.emit('accountChanged', nextKey);
|
||||
return { publicKey: nextKey };
|
||||
}
|
||||
|
||||
async disconnect() {
|
||||
await createRequest('disconnect', {});
|
||||
this.isConnected = false;
|
||||
this.publicKey = null;
|
||||
this.emit('disconnect');
|
||||
this.emit('accountChanged', null);
|
||||
}
|
||||
|
||||
async signTransaction(transaction) {
|
||||
if (!this.publicKey) {
|
||||
await this.connect();
|
||||
}
|
||||
const transactionBase64 = serializeTransactionBase64(transaction);
|
||||
const comment = `Site ${window.location.origin} requested transaction signature`;
|
||||
const result = await createRequest('signTransaction', {
|
||||
publicKeyBase58: this.publicKey?.toBase58?.() || '',
|
||||
transactionBase64,
|
||||
comment,
|
||||
});
|
||||
return deserializeSignedTransaction(String(result?.signedTransactionBase64 || ''), transaction);
|
||||
}
|
||||
|
||||
async request(args = {}) {
|
||||
const method = String(args?.method || '');
|
||||
const params = args?.params;
|
||||
if (method === 'connect') {
|
||||
return this.connect(Array.isArray(params) ? params[0] : params || {});
|
||||
}
|
||||
if (method === 'disconnect') {
|
||||
return this.disconnect();
|
||||
}
|
||||
if (method === 'signTransaction') {
|
||||
const tx = Array.isArray(params) ? params[0] : params?.transaction || params;
|
||||
return this.signTransaction(tx);
|
||||
}
|
||||
throw createProviderError(`Unsupported request method: ${method}`, 'UNSUPPORTED_METHOD');
|
||||
}
|
||||
}
|
||||
|
||||
if (!window.solana) {
|
||||
const provider = new ShineSolanaProvider();
|
||||
window.solana = provider;
|
||||
window.phantom = window.phantom || {};
|
||||
window.phantom.solana = provider;
|
||||
window.dispatchEvent(new Event('solana#initialized'));
|
||||
}
|
||||
Reference in New Issue
Block a user