434 lines
14 KiB
JavaScript
434 lines
14 KiB
JavaScript
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';
|
|
const PAGE_MESSAGE_TARGET_ORIGIN = '*';
|
|
const STANDARD_REGISTER_EVENT = 'wallet-standard:register-wallet';
|
|
const STANDARD_APP_READY_EVENT = 'wallet-standard:app-ready';
|
|
const SOLANA_CHAINS = ['solana:mainnet', 'solana:devnet', 'solana:testnet'];
|
|
const SOLANA_STANDARD_FEATURES = ['solana:signTransaction'];
|
|
const WALLET_ICON = `data:image/svg+xml;base64,${btoa(
|
|
'<svg xmlns="http://www.w3.org/2000/svg" width="96" height="96" viewBox="0 0 96 96" fill="none"><rect width="96" height="96" rx="20" fill="#101722"/><path d="M23 28h50l-8 10H31l-8-10Z" fill="#3FB0FF"/><path d="M31 44h34l8 10H23l8-10Z" fill="#77D67A"/><path d="M23 68h50l-8-10H31l-8 10Z" fill="#A881FF"/></svg>'
|
|
)}`;
|
|
|
|
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 summarizeTransaction(transaction) {
|
|
const summary = {
|
|
kind: 'legacy',
|
|
instructionCount: 0,
|
|
accountCount: 0,
|
|
feePayer: '',
|
|
recentBlockhash: '',
|
|
programs: [],
|
|
};
|
|
if (!transaction) return summary;
|
|
|
|
const isVersioned = typeof transaction?.version === 'number' || transaction instanceof VersionedTransaction;
|
|
summary.kind = isVersioned ? `versioned:${String(transaction.version)}` : 'legacy';
|
|
summary.feePayer = String(transaction?.feePayer?.toBase58?.() || '').trim();
|
|
summary.recentBlockhash = String(transaction?.recentBlockhash || transaction?.message?.recentBlockhash || '').trim();
|
|
|
|
if (isVersioned) {
|
|
const message = transaction?.message || {};
|
|
const staticKeys = Array.isArray(message?.staticAccountKeys) ? message.staticAccountKeys : [];
|
|
const instructions = Array.isArray(message?.compiledInstructions) ? message.compiledInstructions : [];
|
|
summary.instructionCount = instructions.length;
|
|
summary.accountCount = staticKeys.length;
|
|
summary.programs = instructions
|
|
.map((instruction) => staticKeys[instruction?.programIdIndex]?.toBase58?.() || '')
|
|
.filter(Boolean)
|
|
.slice(0, 5);
|
|
return summary;
|
|
}
|
|
|
|
const instructions = Array.isArray(transaction?.instructions) ? transaction.instructions : [];
|
|
summary.instructionCount = instructions.length;
|
|
summary.accountCount = Array.isArray(transaction?.signatures) ? transaction.signatures.length : 0;
|
|
summary.programs = instructions
|
|
.map((instruction) => instruction?.programId?.toBase58?.() || '')
|
|
.filter(Boolean)
|
|
.slice(0, 5);
|
|
return summary;
|
|
}
|
|
|
|
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,
|
|
}, PAGE_MESSAGE_TARGET_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 ShineWalletAccount {
|
|
constructor(publicKeyBase58) {
|
|
this.address = publicKeyBase58;
|
|
this.publicKey = new Uint8Array(new PublicKey(publicKeyBase58).toBytes());
|
|
this.chains = SOLANA_CHAINS.slice();
|
|
this.features = SOLANA_STANDARD_FEATURES.slice();
|
|
this.label = 'SHiNE Wallet';
|
|
this.icon = WALLET_ICON;
|
|
}
|
|
}
|
|
|
|
class ShineProviderCore {
|
|
constructor() {
|
|
this.publicKey = null;
|
|
this.isConnected = false;
|
|
this._legacyListeners = new Map();
|
|
this._standardListeners = new Set();
|
|
this._accounts = [];
|
|
}
|
|
|
|
get publicKeyBase58() {
|
|
return this.publicKey?.toBase58?.() || '';
|
|
}
|
|
|
|
get standardAccounts() {
|
|
return this._accounts.slice();
|
|
}
|
|
|
|
async connect(options = {}) {
|
|
const onlyIfTrusted = !!options?.onlyIfTrusted || !!options?.silent;
|
|
const result = await createRequest('connect', { onlyIfTrusted });
|
|
const nextKey = new PublicKey(String(result?.publicKeyBase58 || '').trim());
|
|
this.publicKey = nextKey;
|
|
this.isConnected = true;
|
|
this._accounts = [new ShineWalletAccount(nextKey.toBase58())];
|
|
this.emitLegacy('connect', nextKey);
|
|
this.emitLegacy('accountChanged', nextKey);
|
|
this.emitStandardChange();
|
|
return {
|
|
publicKey: nextKey,
|
|
accounts: this.standardAccounts,
|
|
};
|
|
}
|
|
|
|
async disconnect() {
|
|
await createRequest('disconnect', {});
|
|
this.isConnected = false;
|
|
this.publicKey = null;
|
|
this._accounts = [];
|
|
this.emitLegacy('disconnect');
|
|
this.emitLegacy('accountChanged', null);
|
|
this.emitStandardChange();
|
|
}
|
|
|
|
async signTransaction(transaction, comment = '') {
|
|
if (!this.publicKey) {
|
|
await this.connect();
|
|
}
|
|
const transactionBase64 = serializeTransactionBase64(transaction);
|
|
const transactionSummary = summarizeTransaction(transaction);
|
|
const result = await createRequest('signTransaction', {
|
|
publicKeyBase58: this.publicKeyBase58,
|
|
transactionBase64,
|
|
comment: String(comment || '').trim() || `Site ${window.location.origin} requested transaction signature`,
|
|
transactionSummary,
|
|
});
|
|
return deserializeSignedTransaction(String(result?.signedTransactionBase64 || ''), transaction);
|
|
}
|
|
|
|
async signTransactionBytes(transactionBytes, comment = '') {
|
|
if (!this.publicKey) {
|
|
await this.connect();
|
|
}
|
|
const transactionSummary = {
|
|
kind: 'raw-bytes',
|
|
instructionCount: 0,
|
|
accountCount: 0,
|
|
feePayer: this.publicKeyBase58,
|
|
recentBlockhash: '',
|
|
programs: [],
|
|
byteLength: Number(transactionBytes?.length || 0),
|
|
};
|
|
const result = await createRequest('signTransaction', {
|
|
publicKeyBase58: this.publicKeyBase58,
|
|
transactionBase64: bytesToBase64(transactionBytes),
|
|
comment: String(comment || '').trim() || `Site ${window.location.origin} requested transaction signature`,
|
|
transactionSummary,
|
|
});
|
|
return base64ToBytes(String(result?.signedTransactionBase64 || '').trim());
|
|
}
|
|
|
|
onLegacy(event, handler) {
|
|
const key = String(event || '');
|
|
if (!this._legacyListeners.has(key)) {
|
|
this._legacyListeners.set(key, new Set());
|
|
}
|
|
this._legacyListeners.get(key).add(handler);
|
|
return this;
|
|
}
|
|
|
|
offLegacy(event, handler) {
|
|
const key = String(event || '');
|
|
const bucket = this._legacyListeners.get(key);
|
|
if (!bucket) return this;
|
|
bucket.delete(handler);
|
|
if (!bucket.size) this._legacyListeners.delete(key);
|
|
return this;
|
|
}
|
|
|
|
emitLegacy(event, payload) {
|
|
const bucket = this._legacyListeners.get(String(event || ''));
|
|
if (!bucket?.size) return;
|
|
for (const handler of [...bucket]) {
|
|
try {
|
|
handler(payload);
|
|
} catch {}
|
|
}
|
|
}
|
|
|
|
onStandardChange(listener) {
|
|
this._standardListeners.add(listener);
|
|
return () => {
|
|
this._standardListeners.delete(listener);
|
|
};
|
|
}
|
|
|
|
emitStandardChange() {
|
|
const properties = { accounts: this.standardAccounts };
|
|
for (const listener of [...this._standardListeners]) {
|
|
try {
|
|
listener(properties);
|
|
} catch {}
|
|
}
|
|
}
|
|
}
|
|
|
|
class ShineSolanaProvider {
|
|
constructor(core) {
|
|
this.core = core;
|
|
this.isSHiNE = true;
|
|
this.isPhantom = true;
|
|
}
|
|
|
|
get publicKey() {
|
|
return this.core.publicKey;
|
|
}
|
|
|
|
get isConnected() {
|
|
return this.core.isConnected;
|
|
}
|
|
|
|
on(event, handler) {
|
|
return this.core.onLegacy(event, handler);
|
|
}
|
|
|
|
off(event, handler) {
|
|
return this.core.offLegacy(event, handler);
|
|
}
|
|
|
|
removeListener(event, handler) {
|
|
return this.off(event, handler);
|
|
}
|
|
|
|
async connect(options = {}) {
|
|
const result = await this.core.connect(options);
|
|
return { publicKey: result.publicKey };
|
|
}
|
|
|
|
async disconnect() {
|
|
await this.core.disconnect();
|
|
}
|
|
|
|
async signTransaction(transaction) {
|
|
return this.core.signTransaction(transaction);
|
|
}
|
|
|
|
async signAllTransactions(transactions = []) {
|
|
const list = Array.isArray(transactions) ? transactions : [];
|
|
const outputs = [];
|
|
for (const transaction of list) {
|
|
outputs.push(await this.core.signTransaction(transaction));
|
|
}
|
|
return outputs;
|
|
}
|
|
|
|
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);
|
|
}
|
|
if (method === 'signAllTransactions') {
|
|
const transactions = Array.isArray(params)
|
|
? params
|
|
: Array.isArray(params?.transactions) ? params.transactions : [];
|
|
return this.signAllTransactions(transactions);
|
|
}
|
|
throw createProviderError(`Unsupported request method: ${method}`, 'UNSUPPORTED_METHOD');
|
|
}
|
|
}
|
|
|
|
class ShineStandardWallet {
|
|
constructor(core) {
|
|
this.core = core;
|
|
this.version = '1.0.0';
|
|
this.name = 'SHiNE Wallet';
|
|
this.icon = WALLET_ICON;
|
|
this.chains = SOLANA_CHAINS.slice();
|
|
this.features = {
|
|
'standard:connect': {
|
|
version: '1.0.0',
|
|
connect: async (input = {}) => {
|
|
const result = await this.core.connect({ silent: !!input?.silent });
|
|
return { accounts: result.accounts };
|
|
},
|
|
},
|
|
'standard:disconnect': {
|
|
version: '1.0.0',
|
|
disconnect: async () => {
|
|
await this.core.disconnect();
|
|
},
|
|
},
|
|
'standard:events': {
|
|
version: '1.0.0',
|
|
on: (event, listener) => {
|
|
if (event !== 'change' || typeof listener !== 'function') {
|
|
return () => {};
|
|
}
|
|
return this.core.onStandardChange(listener);
|
|
},
|
|
},
|
|
'solana:signTransaction': {
|
|
version: '1.0.0',
|
|
supportedTransactionVersions: ['legacy', 0],
|
|
signTransaction: async (...inputs) => {
|
|
const outputs = [];
|
|
for (const input of inputs) {
|
|
const accountAddress = String(input?.account?.address || '').trim();
|
|
if (accountAddress && this.core.publicKeyBase58 && accountAddress !== this.core.publicKeyBase58) {
|
|
throw createProviderError('Requested account does not match current wallet account', 'ACCOUNT_MISMATCH');
|
|
}
|
|
const comment = `Site ${window.location.origin} requested transaction signature`;
|
|
const signedTransaction = await this.core.signTransactionBytes(new Uint8Array(input.transaction), comment);
|
|
outputs.push({ signedTransaction });
|
|
}
|
|
return outputs;
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
get accounts() {
|
|
return this.core.standardAccounts;
|
|
}
|
|
}
|
|
|
|
function registerStandardWallet(wallet) {
|
|
const callback = ({ register }) => register(wallet);
|
|
try {
|
|
window.dispatchEvent(new CustomEvent(STANDARD_REGISTER_EVENT, { detail: callback }));
|
|
} catch (error) {
|
|
console.error('wallet-standard register dispatch failed', error);
|
|
}
|
|
try {
|
|
window.addEventListener(STANDARD_APP_READY_EVENT, ({ detail }) => {
|
|
try {
|
|
callback(detail);
|
|
} catch (error) {
|
|
console.error('wallet-standard app-ready callback failed', error);
|
|
}
|
|
});
|
|
} catch (error) {
|
|
console.error('wallet-standard app-ready listener failed', error);
|
|
}
|
|
try {
|
|
window.navigator.wallets = window.navigator.wallets || [];
|
|
window.navigator.wallets.push(callback);
|
|
} catch {}
|
|
}
|
|
|
|
const core = new ShineProviderCore();
|
|
const legacyProvider = new ShineSolanaProvider(core);
|
|
const standardWallet = new ShineStandardWallet(core);
|
|
|
|
registerStandardWallet(standardWallet);
|
|
|
|
if (!window.solana) {
|
|
window.solana = legacyProvider;
|
|
window.phantom = window.phantom || {};
|
|
window.phantom.solana = legacyProvider;
|
|
window.dispatchEvent(new Event('solana#initialized'));
|
|
}
|