mirror of
https://github.com/sonr-io/sonr.git
synced 2026-08-04 10:21:40 +00:00
Prad Nukala
@@ -0,0 +1,14 @@
|
||||
/**
|
||||
* The unique identifier of the wallet.
|
||||
*/
|
||||
export const WalletName = {
|
||||
STATION: 'station',
|
||||
KEPLR: 'keplr',
|
||||
LEAP: 'leap',
|
||||
COMPASS: 'compass',
|
||||
COSMOSTATION: 'cosmostation',
|
||||
METAMASK_INJECTIVE: 'metamask-injective',
|
||||
NINJI: 'ninji',
|
||||
OWALLET: 'owallet',
|
||||
} as const;
|
||||
export type WalletName = (typeof WalletName)[keyof typeof WalletName];
|
||||
@@ -0,0 +1,8 @@
|
||||
/**
|
||||
* The type of connection to the wallet.
|
||||
*/
|
||||
export const WalletType = {
|
||||
EXTENSION: 'extension',
|
||||
WALLETCONNECT: 'walletconnect',
|
||||
} as const;
|
||||
export type WalletType = (typeof WalletType)[keyof typeof WalletType];
|
||||
@@ -0,0 +1,17 @@
|
||||
export { WalletName } from './constants/WalletName';
|
||||
export { WalletType } from './constants/WalletType';
|
||||
export { isAndroid, isIOS, isMobile } from './utils/os';
|
||||
export { verifyArbitrary } from './utils/verify';
|
||||
export {
|
||||
ConnectedWallet,
|
||||
type PollTxOptions,
|
||||
type SignArbitraryResponse,
|
||||
type UnsignedTx,
|
||||
} from './wallets/ConnectedWallet';
|
||||
export { MnemonicWallet } from './wallets/mnemonic/MnemonicWallet';
|
||||
export {
|
||||
type ChainInfo,
|
||||
type EventCallback,
|
||||
WalletController,
|
||||
} from './wallets/WalletController';
|
||||
export { WalletError } from './wallets/WalletError';
|
||||
@@ -0,0 +1,18 @@
|
||||
export function isAndroid() {
|
||||
return navigator && /Android/i.test(navigator.userAgent);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see https://stackoverflow.com/a/58065241
|
||||
*/
|
||||
export function isIOS() {
|
||||
return (
|
||||
navigator &&
|
||||
(/iPhone|iPad|iPod/i.test(navigator.userAgent) ||
|
||||
(navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1))
|
||||
);
|
||||
}
|
||||
|
||||
export function isMobile() {
|
||||
return isAndroid() || isIOS();
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
import { describe, expect, it } from 'vitest';
|
||||
|
||||
import { extractExpectedAccountSequence } from './sequence';
|
||||
|
||||
describe('extractExpectedAccountSequence', () => {
|
||||
it('should extract expected account sequence numbers from valid errors', () => {
|
||||
// Older cosmos sdk chains
|
||||
const err1 = new Error(
|
||||
'account sequence mismatch, expected 10, got 11: incorrect account sequence: invalid request'
|
||||
);
|
||||
expect(extractExpectedAccountSequence(err1)).toBe(10n);
|
||||
|
||||
// Newer cosmos sdk chains (0.45+)
|
||||
const err2 = new Error(
|
||||
'rpc error: code = Unknown desc = account sequence mismatch, expected 10, got 11: ......'
|
||||
);
|
||||
expect(extractExpectedAccountSequence(err2)).toBe(10n);
|
||||
|
||||
// Injective
|
||||
const err3 = new Error(
|
||||
`[reason]:"incorrect account sequence" metadata:{key:"ABCICode" value:"32"} ...... rpc error: code = Unknown desc = account sequence mismatch, expected 10, got 11: ......`
|
||||
);
|
||||
expect(extractExpectedAccountSequence(err3)).toBe(10n);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,14 @@
|
||||
/**
|
||||
* Extracts and returns the expected account sequence number from an error. If
|
||||
* the error is not related to an account sequence mismatch, `null` is returned.
|
||||
*/
|
||||
export function extractExpectedAccountSequence(err: Error): bigint | null {
|
||||
const matches = err.message.match(
|
||||
// This regex is intentionally kept as strict as possible
|
||||
/account sequence mismatch, expected (\d+), got (\d+):/
|
||||
);
|
||||
if (!matches || matches.length < 3) {
|
||||
return null;
|
||||
}
|
||||
return BigInt(matches[1]);
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
import { base64, utf8, verifyADR36, verifyECDSA, verifyEIP191 } from '@sonr.io/es/codec';
|
||||
|
||||
import { WalletName } from '../constants/WalletName';
|
||||
|
||||
type VerifyArbitraryParams = {
|
||||
/** The identifier of the wallet which created the signature */
|
||||
wallet: WalletName;
|
||||
/** The base64 encoded public key which created the signature */
|
||||
pubKey: string;
|
||||
/** The bech32 account address prefix of the signer */
|
||||
bech32Prefix: string;
|
||||
/** The utf-8 encoded arbitrary string that was signed */
|
||||
data: string;
|
||||
/** The base64 encoded string of the signature */
|
||||
signature: string;
|
||||
/** The type of the signature */
|
||||
type?: 'secp256k1' | 'ethsecp256k1';
|
||||
};
|
||||
|
||||
/**
|
||||
* Verifies the signature output of a valid call to `ConnectedWallet.signArbitrary`.
|
||||
* Returns `true` if and only if the signature is valid.
|
||||
*
|
||||
* @param wallet The identifier of the wallet which created the signature
|
||||
* @param pubKey The base64 encoded public key which created the signature
|
||||
* @param bech32Prefix The bech32 account address prefix of the signer
|
||||
* @param data The utf-8 encoded arbitrary string that was signed
|
||||
* @param signature The base64 encoded string of the signature
|
||||
* @param type The type of the signature (default: `secp256k1`)
|
||||
*/
|
||||
export function verifyArbitrary({
|
||||
wallet,
|
||||
pubKey,
|
||||
bech32Prefix,
|
||||
data,
|
||||
signature,
|
||||
type = 'secp256k1',
|
||||
}: VerifyArbitraryParams): boolean {
|
||||
const params = {
|
||||
pubKey: base64.decode(pubKey),
|
||||
bech32Prefix,
|
||||
data: utf8.decode(data),
|
||||
signature: base64.decode(signature),
|
||||
type,
|
||||
};
|
||||
try {
|
||||
switch (wallet) {
|
||||
case WalletName.METAMASK_INJECTIVE:
|
||||
return verifyEIP191(params);
|
||||
default:
|
||||
// Station mobile uses `verifyECDSA`, all other wallets uses `verifyADR36`.
|
||||
// We can remove `verifyECDSA` once Station mobile uses `verifyECDSA`.
|
||||
return verifyADR36(params) || verifyECDSA(params);
|
||||
}
|
||||
} catch (_err) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
/**
|
||||
* Similar to `window.addEventListener`, but safe for nodejs/SSR environments,
|
||||
* and which returns an `unsubscribe` function that when called, removes the
|
||||
* event listener via `window.removeEventListener`.
|
||||
*/
|
||||
export function onWindowEvent(
|
||||
event: string,
|
||||
cb: EventListenerOrEventListenerObject,
|
||||
opts?: AddEventListenerOptions | undefined
|
||||
): () => void {
|
||||
if (typeof window === 'undefined') {
|
||||
// eslint-disable-next-line @typescript-eslint/no-empty-function
|
||||
return () => {};
|
||||
}
|
||||
window.addEventListener(event, cb, opts);
|
||||
return () => window.removeEventListener(event, cb);
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
import type { IQRCodeModal } from '@walletconnect/legacy-types';
|
||||
|
||||
import { isAndroid, isMobile } from '../utils/os';
|
||||
import { qrcodegen } from './qrcodegen';
|
||||
|
||||
export type MobileAppDetails = {
|
||||
name: string;
|
||||
android: string;
|
||||
ios: string;
|
||||
isStation?: boolean | undefined;
|
||||
};
|
||||
|
||||
export class QRCodeModal implements IQRCodeModal {
|
||||
private readonly id = `wc-modal-${Date.now()}`;
|
||||
private readonly details: MobileAppDetails;
|
||||
|
||||
constructor(details: MobileAppDetails) {
|
||||
this.details = details;
|
||||
}
|
||||
|
||||
public open(uri: string): void {
|
||||
const overlay = document.createElement('div');
|
||||
overlay.style.cssText = [
|
||||
'background-color: rgba(0, 0, 0, 0.5)',
|
||||
'backdrop-filter: blur(4px)',
|
||||
'z-index: 10000',
|
||||
'height: 100vh',
|
||||
'width: 100vw',
|
||||
'position: fixed',
|
||||
'top: 0',
|
||||
'left: 0',
|
||||
'display: flex',
|
||||
'align-items: center',
|
||||
'justify-content: center',
|
||||
'pointer-events: auto',
|
||||
].join(';');
|
||||
overlay.onclick = (e): void => {
|
||||
e.stopPropagation();
|
||||
if (e.target === overlay) {
|
||||
this.close();
|
||||
}
|
||||
};
|
||||
|
||||
const modal = document.createElement('div');
|
||||
modal.style.cssText = [
|
||||
'background-color: #f4f4f5',
|
||||
'padding: 1rem',
|
||||
'border-radius: 0.5rem',
|
||||
].join(';');
|
||||
|
||||
const schemeUri = this.details.isStation
|
||||
? `https://terrastation.page.link/?link=https://terra.money?${encodeURIComponent(
|
||||
`action=wallet_connect&payload=${encodeURIComponent(uri)}`
|
||||
)}&apn=money.terra.station&ibi=money.terra.station&isi=1548434735`
|
||||
: uri;
|
||||
const qr = qrcodegen.QrCode.encodeText(schemeUri, qrcodegen.QrCode.Ecc.MEDIUM);
|
||||
const canvas = document.createElement('canvas');
|
||||
const scale = this.details.isStation ? 3.7 : 5;
|
||||
canvas.width = qr.size * scale;
|
||||
canvas.height = canvas.width;
|
||||
const ctx = canvas.getContext('2d');
|
||||
if (!ctx) {
|
||||
console.error('Failed to get canvas context');
|
||||
return;
|
||||
}
|
||||
for (let y = 0; y < qr.size; y++) {
|
||||
for (let x = 0; x < qr.size; x++) {
|
||||
ctx.fillStyle = qr.getModule(x, y) ? '#18181b' : '#f4f4f5';
|
||||
ctx.fillRect(x * scale, y * scale, scale, scale);
|
||||
}
|
||||
}
|
||||
|
||||
if (isMobile()) {
|
||||
// On mobile, render button to open mobile app and QR code as fallback
|
||||
const openAppButton = document.createElement('button');
|
||||
openAppButton.textContent = `Open ${this.details.name}`;
|
||||
openAppButton.style.cssText = [
|
||||
'background-color: #3b82f6',
|
||||
'color: white',
|
||||
'padding: 0.75rem 1.5rem',
|
||||
'border: none',
|
||||
'border-radius: 0.375rem',
|
||||
'font-size: 1rem',
|
||||
'font-weight: 600',
|
||||
'cursor: pointer',
|
||||
'margin-bottom: 1rem',
|
||||
'width: 100%',
|
||||
].join(';');
|
||||
openAppButton.onclick = () => {
|
||||
window.location.href = this.details.isStation
|
||||
? schemeUri
|
||||
: isAndroid()
|
||||
? this.generateAndroidIntent(uri)
|
||||
: this.generateIosIntent(uri);
|
||||
};
|
||||
modal.appendChild(openAppButton);
|
||||
|
||||
const orText = document.createElement('div');
|
||||
orText.textContent = 'or scan QR code';
|
||||
orText.style.cssText = [
|
||||
'text-align: center',
|
||||
'margin-bottom: 0.5rem',
|
||||
'color: #6b7280',
|
||||
'font-size: 0.875rem',
|
||||
].join(';');
|
||||
modal.appendChild(orText);
|
||||
} else {
|
||||
// On desktop, show help message to scan the QR code
|
||||
const msg = document.createElement('div');
|
||||
msg.textContent = `Scan via ${this.details.name} mobile app`;
|
||||
msg.style.cssText = [
|
||||
'margin-bottom: 0.5rem',
|
||||
'font-size: 1rem',
|
||||
'text-align: center',
|
||||
'color: #18181b',
|
||||
].join(';');
|
||||
modal.appendChild(msg);
|
||||
}
|
||||
|
||||
const rootDiv = document.createElement('div');
|
||||
rootDiv.id = this.id;
|
||||
const shadowRoot = rootDiv.attachShadow({ mode: 'open' });
|
||||
|
||||
modal.appendChild(canvas);
|
||||
overlay.appendChild(modal);
|
||||
shadowRoot.appendChild(overlay);
|
||||
document.body.appendChild(rootDiv);
|
||||
}
|
||||
|
||||
public close(): void {
|
||||
const rootDiv = document.getElementById(this.id);
|
||||
if (rootDiv) {
|
||||
document.body.removeChild(rootDiv);
|
||||
}
|
||||
}
|
||||
|
||||
private generateAndroidIntent(uri: string): string {
|
||||
const hashIndex = this.details.android.indexOf('#');
|
||||
return `${this.details.android.slice(0, hashIndex)}?${encodeURIComponent(uri)}${this.details.android.slice(hashIndex)}`;
|
||||
}
|
||||
|
||||
private generateIosIntent(uri: string): string {
|
||||
return `${this.details.ios}?${encodeURIComponent(uri)}`;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,85 @@
|
||||
import WalletConnect from '@walletconnect/legacy-client';
|
||||
import type { IWalletConnectSession } from '@walletconnect/legacy-types';
|
||||
|
||||
import { type MobileAppDetails, QRCodeModal } from './QRCodeModal';
|
||||
|
||||
type ConnectOptions = Required<
|
||||
Pick<ConstructorParameters<typeof WalletConnect>[0], 'bridge' | 'signingMethods'>
|
||||
>;
|
||||
|
||||
export class WalletConnectV1 {
|
||||
private readonly sessionStorageKey: string;
|
||||
private readonly mobileAppDetails: MobileAppDetails;
|
||||
private readonly connectOpts: ConnectOptions;
|
||||
private readonly onDisconnectCbs: Set<() => unknown>;
|
||||
|
||||
constructor(
|
||||
sessionStorageKey: string,
|
||||
mobileAppDetails: MobileAppDetails,
|
||||
connectOpts: ConnectOptions
|
||||
) {
|
||||
this.sessionStorageKey = sessionStorageKey;
|
||||
this.mobileAppDetails = mobileAppDetails;
|
||||
this.connectOpts = connectOpts;
|
||||
this.onDisconnectCbs = new Set();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the current session if it exists, else, creates a new session.
|
||||
*/
|
||||
public async connect(): Promise<WalletConnect> {
|
||||
// Get cached session in local storage
|
||||
const cachedSession = localStorage.getItem(this.sessionStorageKey);
|
||||
const session = cachedSession
|
||||
? (JSON.parse(cachedSession) as IWalletConnectSession)
|
||||
: undefined;
|
||||
|
||||
// Create a new WalletConnect instance
|
||||
const wc = new WalletConnect({
|
||||
...this.connectOpts,
|
||||
qrcodeModal: new QRCodeModal(this.mobileAppDetails),
|
||||
session,
|
||||
});
|
||||
wc.on('disconnect', () => {
|
||||
localStorage.removeItem(this.sessionStorageKey);
|
||||
for (const cb of this.onDisconnectCbs) {
|
||||
cb();
|
||||
}
|
||||
});
|
||||
|
||||
// If a previous session exists, return the WalletConnect instance
|
||||
if (session && wc.connected) {
|
||||
return wc;
|
||||
}
|
||||
|
||||
// Else, if no previous session exists, create a new session
|
||||
if (wc.connected) {
|
||||
await wc.killSession();
|
||||
}
|
||||
await wc.createSession();
|
||||
|
||||
// Return the WalletConnect instance once connected
|
||||
return new Promise((resolve, reject) => {
|
||||
wc.on('connect', (error, _payload) => {
|
||||
// Do NOT cache the session here as the user may not have approved the connection
|
||||
error ? reject(error) : resolve(wc);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
public onDisconnect(cb: () => unknown): () => void {
|
||||
this.onDisconnectCbs.add(cb);
|
||||
return () => this.onDisconnectCbs.delete(cb);
|
||||
}
|
||||
|
||||
/**
|
||||
* Saves the session to local storage. Should only be called once the user actually
|
||||
* approves the connection to the chain.
|
||||
*/
|
||||
public cacheSession(wc: WalletConnect) {
|
||||
if (!wc.connected) {
|
||||
return;
|
||||
}
|
||||
localStorage.setItem(this.sessionStorageKey, JSON.stringify(wc.session));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,289 @@
|
||||
import type { SignDoc, StdSignDoc } from '@sonr.io/es/registry';
|
||||
import SignClient from '@walletconnect/sign-client';
|
||||
import { debounce } from 'lodash-es';
|
||||
|
||||
import { isAndroid, isMobile } from '../utils/os';
|
||||
import { type MobileAppDetails, QRCodeModal } from './QRCodeModal';
|
||||
|
||||
/** The JSON data stored in `localStorage` to recover previous sessions. */
|
||||
type StorageSession = {
|
||||
/** The WalletConnect V2 topic. */
|
||||
topic: string;
|
||||
/** Non-namespaced chain IDs (eg. `osmosis-1`). */
|
||||
chainIds: string[];
|
||||
};
|
||||
|
||||
type GetAccountResponse = {
|
||||
name?: string | undefined;
|
||||
address: string;
|
||||
algo: string;
|
||||
pubkey: string;
|
||||
};
|
||||
|
||||
/**
|
||||
* The data returned by the `cosmos_signAmino` method. `signed` is optional
|
||||
* because some wallets (like Cosmostation) may not return it.
|
||||
*/
|
||||
type WcSignAminoResponse = {
|
||||
signature: {
|
||||
signature: string;
|
||||
};
|
||||
signed?: StdSignDoc | undefined;
|
||||
};
|
||||
type SignAminoResponse = Required<WcSignAminoResponse>;
|
||||
|
||||
/**
|
||||
* The data returned by the `cosmos_signDirect` method. `signed` is optional
|
||||
* because some wallets (like Cosmostation) may not return it.
|
||||
*/
|
||||
type WcSignDirectResponse = {
|
||||
signature: {
|
||||
signature: string;
|
||||
};
|
||||
signed?: SignDoc | undefined;
|
||||
};
|
||||
type SignDirectResponse = Required<WcSignDirectResponse>;
|
||||
|
||||
const Method = {
|
||||
GET_ACCOUNTS: 'cosmos_getAccounts',
|
||||
SIGN_AMINO: 'cosmos_signAmino',
|
||||
SIGN_DIRECT: 'cosmos_signDirect',
|
||||
} as const;
|
||||
type Method = (typeof Method)[keyof typeof Method];
|
||||
|
||||
const Event = {
|
||||
CHAIN_CHANGED: 'chainChanged',
|
||||
ACCOUNTS_CHANGED: 'accountsChanged',
|
||||
} as const;
|
||||
type Event = (typeof Event)[keyof typeof Event];
|
||||
|
||||
const DEFAULT_SIGN_OPTIONS = {
|
||||
preferNoSetFee: true,
|
||||
preferNoSetMemo: true,
|
||||
};
|
||||
|
||||
export class WalletConnectV2 {
|
||||
private readonly projectId: string;
|
||||
private readonly mobileAppDetails: MobileAppDetails;
|
||||
private readonly sessionStorageKey: string;
|
||||
private readonly onDisconnectCbs: Set<() => unknown>;
|
||||
private readonly onAccountChangeCbs: Set<() => unknown>;
|
||||
private signClient: SignClient | null;
|
||||
|
||||
constructor(projectId: string, mobileAppDetails: MobileAppDetails) {
|
||||
this.projectId = projectId;
|
||||
this.mobileAppDetails = mobileAppDetails;
|
||||
this.sessionStorageKey = `@sonr.io/es.wallet.${mobileAppDetails.name.toLowerCase()}.wcSession`;
|
||||
this.onDisconnectCbs = new Set();
|
||||
this.onAccountChangeCbs = new Set();
|
||||
this.signClient = null;
|
||||
}
|
||||
|
||||
public async connect(chainIds: string[]): Promise<void> {
|
||||
// Initialise the sign client and event listeners if they don't already exist
|
||||
if (!this.signClient) {
|
||||
this.signClient = await SignClient.init({
|
||||
projectId: this.projectId,
|
||||
});
|
||||
// Disconnect if the session is disconnected or expired
|
||||
this.signClient.on('session_delete', ({ topic }) => this.disconnect(topic));
|
||||
this.signClient.on('session_expire', ({ topic }) => this.disconnect(topic));
|
||||
// Handle the `accountsChanged` event
|
||||
const handleAccountChange = debounce(
|
||||
// Handler is debounced as the `accountsChanged` event is fired once for
|
||||
// each connected chain, but we only want to trigger the callback once.
|
||||
() => this.onAccountChangeCbs.forEach((cb) => cb()),
|
||||
300,
|
||||
{ leading: true, trailing: false }
|
||||
);
|
||||
this.signClient.on('session_event', ({ params }) => {
|
||||
if (params.event.name === Event.ACCOUNTS_CHANGED) {
|
||||
handleAccountChange();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// Check if a valid session already exists
|
||||
const oldSession = localStorage.getItem(this.sessionStorageKey);
|
||||
const chainIdsSet = new Set(chainIds);
|
||||
if (oldSession) {
|
||||
const { topic, chainIds: storedIds } = JSON.parse(oldSession) as StorageSession;
|
||||
const storedIdsSet = new Set(storedIds);
|
||||
if (chainIds.every((id) => storedIdsSet.has(id))) {
|
||||
// If the requested chain IDs are a subset of the stored chain IDs, we can
|
||||
// proceed to check if the session is still working and connected
|
||||
if (await this.isConnected(this.signClient, topic, 4)) {
|
||||
// If the current session is properly connected, we can return early
|
||||
return;
|
||||
}
|
||||
// Otherwise, assume the session is stale and disconnect
|
||||
this.disconnect(topic);
|
||||
} else {
|
||||
// Otherwise, we need to merge the stored IDs with the requested IDs
|
||||
for (const id of storedIds) {
|
||||
chainIdsSet.add(id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Initialise a new session
|
||||
const { uri, approval } = await this.signClient.connect({
|
||||
requiredNamespaces: {
|
||||
cosmos: {
|
||||
chains: [...chainIdsSet].map((id) => this.toCosmosNamespace(id)),
|
||||
methods: Object.values(Method),
|
||||
events: Object.values(Event),
|
||||
},
|
||||
},
|
||||
});
|
||||
if (uri) {
|
||||
// Open the QR code modal and wait for the user to approve the connection
|
||||
const modal = new QRCodeModal(this.mobileAppDetails);
|
||||
modal.open(uri);
|
||||
const { topic } = await approval();
|
||||
modal.close();
|
||||
// Save this new session to local storage
|
||||
const newSession: StorageSession = {
|
||||
topic,
|
||||
chainIds: [...chainIdsSet],
|
||||
};
|
||||
localStorage.setItem(this.sessionStorageKey, JSON.stringify(newSession));
|
||||
// Disconnect the older session if it exists
|
||||
if (oldSession) {
|
||||
const { topic } = JSON.parse(oldSession) as StorageSession;
|
||||
this.signClient.disconnect({
|
||||
topic,
|
||||
reason: { code: 6000, message: 'User rejected connection' },
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public onDisconnect(cb: () => unknown): () => void {
|
||||
this.onDisconnectCbs.add(cb);
|
||||
return () => this.onDisconnectCbs.delete(cb);
|
||||
}
|
||||
|
||||
public onAccountChange(cb: () => unknown): () => void {
|
||||
this.onAccountChangeCbs.add(cb);
|
||||
return () => this.onAccountChangeCbs.delete(cb);
|
||||
}
|
||||
|
||||
public async getAccount(chainId: string): Promise<GetAccountResponse> {
|
||||
const [res] = await this.request<GetAccountResponse[]>(chainId, Method.GET_ACCOUNTS, {});
|
||||
return res || { address: '', algo: '', pubkey: '' };
|
||||
}
|
||||
|
||||
public async signAmino(
|
||||
chainId: string,
|
||||
signerAddress: string,
|
||||
stdSignDoc: StdSignDoc
|
||||
): Promise<SignAminoResponse> {
|
||||
const { signature, signed } = await this.request<WcSignAminoResponse>(
|
||||
chainId,
|
||||
Method.SIGN_AMINO,
|
||||
{
|
||||
signerAddress,
|
||||
signDoc: stdSignDoc,
|
||||
signOptions: DEFAULT_SIGN_OPTIONS,
|
||||
}
|
||||
);
|
||||
return {
|
||||
signature: signature,
|
||||
signed: signed ?? stdSignDoc, // simply return the original sign doc if `signed` is not returned
|
||||
};
|
||||
}
|
||||
|
||||
public async signDirect(
|
||||
chainId: string,
|
||||
signerAddress: string,
|
||||
signDoc: SignDoc
|
||||
): Promise<SignDirectResponse> {
|
||||
const { signature, signed } = await this.request<WcSignDirectResponse>(
|
||||
chainId,
|
||||
Method.SIGN_DIRECT,
|
||||
{
|
||||
signerAddress,
|
||||
signDoc,
|
||||
signOptions: DEFAULT_SIGN_OPTIONS,
|
||||
}
|
||||
);
|
||||
return {
|
||||
signature: signature,
|
||||
signed: signed ?? signDoc, // simply return the original sign doc if `signed` is not returned
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the current session is **really connected**. The `ping` method may
|
||||
* never return a response if the session is already disconnected. Thus, we
|
||||
* listen to the `session_delete` and `session_expire` events to detect if the
|
||||
* session is disconnected. If all else fails, we timeout after `timeoutSeconds`
|
||||
* and assume the session is not connected.
|
||||
*/
|
||||
private isConnected(
|
||||
signClient: SignClient,
|
||||
topic: string,
|
||||
timeoutSeconds: number
|
||||
): Promise<boolean> {
|
||||
const tryPing = async (): Promise<boolean> =>
|
||||
signClient
|
||||
.ping({ topic })
|
||||
.then(() => true) // we only return `true` if the ping succeeds
|
||||
.catch(() => false);
|
||||
const waitDisconnect = async (): Promise<boolean> =>
|
||||
new Promise((resolve) => {
|
||||
signClient.on('session_delete', (res) => {
|
||||
if (topic === res.topic) {
|
||||
resolve(false);
|
||||
}
|
||||
});
|
||||
signClient.on('session_expire', (res) => {
|
||||
if (topic === res.topic) {
|
||||
resolve(false);
|
||||
}
|
||||
});
|
||||
});
|
||||
const timeout = async (): Promise<boolean> =>
|
||||
new Promise((resolve) => setTimeout(() => resolve(false), timeoutSeconds * 1_000));
|
||||
return Promise.race([tryPing(), waitDisconnect(), timeout()]);
|
||||
}
|
||||
|
||||
private disconnect(topic: string) {
|
||||
const session = localStorage.getItem(this.sessionStorageKey);
|
||||
if (!session || session.includes(topic)) {
|
||||
// Ignore stale disconnects; clean up only if the topic matches
|
||||
localStorage.removeItem(this.sessionStorageKey);
|
||||
this.onDisconnectCbs.forEach((cb) => cb());
|
||||
}
|
||||
}
|
||||
|
||||
private async request<T>(chainId: string, method: Method, params: unknown) {
|
||||
const session = localStorage.getItem(this.sessionStorageKey);
|
||||
if (!session || !this.signClient) {
|
||||
throw new Error(`Session not found for ${chainId}`);
|
||||
}
|
||||
const { topic } = JSON.parse(session) as StorageSession;
|
||||
if (
|
||||
isMobile() &&
|
||||
// GET_ACCOUNTS does not require the user to authorise
|
||||
method !== Method.GET_ACCOUNTS
|
||||
) {
|
||||
window.location.href = isAndroid()
|
||||
? this.mobileAppDetails.android
|
||||
: this.mobileAppDetails.ios;
|
||||
}
|
||||
return this.signClient.request<T>({
|
||||
topic,
|
||||
chainId: this.toCosmosNamespace(chainId),
|
||||
request: {
|
||||
method,
|
||||
params,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
private toCosmosNamespace(chainId: string): string {
|
||||
return `cosmos:${chainId}`;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,956 @@
|
||||
export namespace qrcodegen {
|
||||
type bit = number;
|
||||
type byte = number;
|
||||
type int = number;
|
||||
|
||||
/*---- QR Code symbol class ----*/
|
||||
|
||||
/*
|
||||
* A QR Code symbol, which is a type of two-dimension barcode.
|
||||
* Invented by Denso Wave and described in the ISO/IEC 18004 standard.
|
||||
* Instances of this class represent an immutable square grid of dark and light cells.
|
||||
* The class provides static factory functions to create a QR Code from text or binary data.
|
||||
* The class covers the QR Code Model 2 specification, supporting all versions (sizes)
|
||||
* from 1 to 40, all 4 error correction levels, and 4 character encoding modes.
|
||||
*
|
||||
* Ways to create a QR Code object:
|
||||
* - High level: Take the payload data and call QrCode.encodeText() or QrCode.encodeBinary().
|
||||
* - Mid level: Custom-make the list of segments and call QrCode.encodeSegments().
|
||||
* - Low level: Custom-make the array of data codeword bytes (including
|
||||
* segment headers and final padding, excluding error correction codewords),
|
||||
* supply the appropriate version number, and call the QrCode() constructor.
|
||||
* (Note that all ways require supplying the desired error correction level.)
|
||||
*/
|
||||
export class QrCode {
|
||||
/*-- Static factory functions (high level) --*/
|
||||
|
||||
// Returns a QR Code representing the given Unicode text string at the given error correction level.
|
||||
// As a conservative upper bound, this function is guaranteed to succeed for strings that have 738 or fewer
|
||||
// Unicode code points (not UTF-16 code units) if the low error correction level is used. The smallest possible
|
||||
// QR Code version is automatically chosen for the output. The ECC level of the result may be higher than the
|
||||
// ecl argument if it can be done without increasing the version.
|
||||
public static encodeText(text: string, ecl: QrCode.Ecc): QrCode {
|
||||
const segs: Array<QrSegment> = qrcodegen.QrSegment.makeSegments(text);
|
||||
return QrCode.encodeSegments(segs, ecl);
|
||||
}
|
||||
|
||||
// Returns a QR Code representing the given binary data at the given error correction level.
|
||||
// This function always encodes using the binary segment mode, not any text mode. The maximum number of
|
||||
// bytes allowed is 2953. The smallest possible QR Code version is automatically chosen for the output.
|
||||
// The ECC level of the result may be higher than the ecl argument if it can be done without increasing the version.
|
||||
public static encodeBinary(data: Readonly<Array<byte>>, ecl: QrCode.Ecc): QrCode {
|
||||
const seg: QrSegment = qrcodegen.QrSegment.makeBytes(data);
|
||||
return QrCode.encodeSegments([seg], ecl);
|
||||
}
|
||||
|
||||
/*-- Static factory functions (mid level) --*/
|
||||
|
||||
// Returns a QR Code representing the given segments with the given encoding parameters.
|
||||
// The smallest possible QR Code version within the given range is automatically
|
||||
// chosen for the output. Iff boostEcl is true, then the ECC level of the result
|
||||
// may be higher than the ecl argument if it can be done without increasing the
|
||||
// version. The mask number is either between 0 to 7 (inclusive) to force that
|
||||
// mask, or -1 to automatically choose an appropriate mask (which may be slow).
|
||||
// This function allows the user to create a custom sequence of segments that switches
|
||||
// between modes (such as alphanumeric and byte) to encode text in less space.
|
||||
// This is a mid-level API; the high-level API is encodeText() and encodeBinary().
|
||||
public static encodeSegments(
|
||||
segs: Readonly<Array<QrSegment>>,
|
||||
ecl: QrCode.Ecc,
|
||||
minVersion: int = 1,
|
||||
maxVersion: int = 40,
|
||||
mask: int = -1,
|
||||
boostEcl = true
|
||||
): QrCode {
|
||||
if (
|
||||
!(
|
||||
QrCode.MIN_VERSION <= minVersion &&
|
||||
minVersion <= maxVersion &&
|
||||
maxVersion <= QrCode.MAX_VERSION
|
||||
) ||
|
||||
mask < -1 ||
|
||||
mask > 7
|
||||
)
|
||||
throw new RangeError('Invalid value');
|
||||
|
||||
// Find the minimal version number to use
|
||||
let version: int;
|
||||
let dataUsedBits: int;
|
||||
for (version = minVersion; ; version++) {
|
||||
const dataCapacityBits: int = QrCode.getNumDataCodewords(version, ecl) * 8; // Number of data bits available
|
||||
const usedBits: number = QrSegment.getTotalBits(segs, version);
|
||||
if (usedBits <= dataCapacityBits) {
|
||||
dataUsedBits = usedBits;
|
||||
break; // This version number is found to be suitable
|
||||
}
|
||||
if (version >= maxVersion)
|
||||
// All versions in the range could not fit the given data
|
||||
throw new RangeError('Data too long');
|
||||
}
|
||||
|
||||
// Increase the error correction level while the data still fits in the current version number
|
||||
for (const newEcl of [QrCode.Ecc.MEDIUM, QrCode.Ecc.QUARTILE, QrCode.Ecc.HIGH]) {
|
||||
// From low to high
|
||||
if (boostEcl && dataUsedBits <= QrCode.getNumDataCodewords(version, newEcl) * 8)
|
||||
ecl = newEcl;
|
||||
}
|
||||
|
||||
// Concatenate all segments to create the data bit string
|
||||
const bb: Array<bit> = [];
|
||||
for (const seg of segs) {
|
||||
appendBits(seg.mode.modeBits, 4, bb);
|
||||
appendBits(seg.numChars, seg.mode.numCharCountBits(version), bb);
|
||||
for (const b of seg.getData()) bb.push(b);
|
||||
}
|
||||
assert(bb.length === dataUsedBits);
|
||||
|
||||
// Add terminator and pad up to a byte if applicable
|
||||
const dataCapacityBits: int = QrCode.getNumDataCodewords(version, ecl) * 8;
|
||||
assert(bb.length <= dataCapacityBits);
|
||||
appendBits(0, Math.min(4, dataCapacityBits - bb.length), bb);
|
||||
appendBits(0, (8 - (bb.length % 8)) % 8, bb);
|
||||
assert(bb.length % 8 === 0);
|
||||
|
||||
// Pad with alternating bytes until data capacity is reached
|
||||
for (let padByte = 0xec; bb.length < dataCapacityBits; padByte ^= 0xec ^ 0x11)
|
||||
appendBits(padByte, 8, bb);
|
||||
|
||||
// Pack bits into bytes in big endian
|
||||
const dataCodewords: Array<byte> = [];
|
||||
while (dataCodewords.length * 8 < bb.length) dataCodewords.push(0);
|
||||
bb.forEach((b: bit, i: int) => (dataCodewords[i >>> 3] |= b << (7 - (i & 7))));
|
||||
|
||||
// Create the QR Code object
|
||||
return new QrCode(version, ecl, dataCodewords, mask);
|
||||
}
|
||||
|
||||
/*-- Fields --*/
|
||||
|
||||
// The width and height of this QR Code, measured in modules, between
|
||||
// 21 and 177 (inclusive). This is equal to version * 4 + 17.
|
||||
public readonly size: int;
|
||||
|
||||
// The index of the mask pattern used in this QR Code, which is between 0 and 7 (inclusive).
|
||||
// Even if a QR Code is created with automatic masking requested (mask = -1),
|
||||
// the resulting object still has a mask value between 0 and 7.
|
||||
public readonly mask: int;
|
||||
|
||||
// The modules of this QR Code (false = light, true = dark).
|
||||
// Immutable after constructor finishes. Accessed through getModule().
|
||||
private readonly modules: Array<Array<boolean>> = [];
|
||||
|
||||
// Indicates function modules that are not subjected to masking. Discarded when constructor finishes.
|
||||
private readonly isFunction: Array<Array<boolean>> = [];
|
||||
|
||||
/*-- Constructor (low level) and fields --*/
|
||||
|
||||
// Creates a new QR Code with the given version number,
|
||||
// error correction level, data codeword bytes, and mask number.
|
||||
// This is a low-level API that most users should not use directly.
|
||||
// A mid-level API is the encodeSegments() function.
|
||||
public constructor(
|
||||
// The version number of this QR Code, which is between 1 and 40 (inclusive).
|
||||
// This determines the size of this barcode.
|
||||
public readonly version: int,
|
||||
|
||||
// The error correction level used in this QR Code.
|
||||
public readonly errorCorrectionLevel: QrCode.Ecc,
|
||||
|
||||
dataCodewords: Readonly<Array<byte>>,
|
||||
|
||||
msk: int
|
||||
) {
|
||||
// Check scalar arguments
|
||||
if (version < QrCode.MIN_VERSION || version > QrCode.MAX_VERSION)
|
||||
throw new RangeError('Version value out of range');
|
||||
if (msk < -1 || msk > 7) throw new RangeError('Mask value out of range');
|
||||
this.size = version * 4 + 17;
|
||||
|
||||
// Initialize both grids to be size*size arrays of Boolean false
|
||||
const row: Array<boolean> = [];
|
||||
for (let i = 0; i < this.size; i++) row.push(false);
|
||||
for (let i = 0; i < this.size; i++) {
|
||||
this.modules.push(row.slice()); // Initially all light
|
||||
this.isFunction.push(row.slice());
|
||||
}
|
||||
|
||||
// Compute ECC, draw modules
|
||||
this.drawFunctionPatterns();
|
||||
const allCodewords: Array<byte> = this.addEccAndInterleave(dataCodewords);
|
||||
this.drawCodewords(allCodewords);
|
||||
|
||||
// Do masking
|
||||
if (msk === -1) {
|
||||
// Automatically choose best mask
|
||||
let minPenalty: int = 1000000000;
|
||||
for (let i = 0; i < 8; i++) {
|
||||
this.applyMask(i);
|
||||
this.drawFormatBits(i);
|
||||
const penalty: int = this.getPenaltyScore();
|
||||
if (penalty < minPenalty) {
|
||||
msk = i;
|
||||
minPenalty = penalty;
|
||||
}
|
||||
this.applyMask(i); // Undoes the mask due to XOR
|
||||
}
|
||||
}
|
||||
assert(0 <= msk && msk <= 7);
|
||||
this.mask = msk;
|
||||
this.applyMask(msk); // Apply the final choice of mask
|
||||
this.drawFormatBits(msk); // Overwrite old format bits
|
||||
|
||||
this.isFunction = [];
|
||||
}
|
||||
|
||||
/*-- Accessor methods --*/
|
||||
|
||||
// Returns the color of the module (pixel) at the given coordinates, which is false
|
||||
// for light or true for dark. The top left corner has the coordinates (x=0, y=0).
|
||||
// If the given coordinates are out of bounds, then false (light) is returned.
|
||||
public getModule(x: int, y: int): boolean {
|
||||
return 0 <= x && x < this.size && 0 <= y && y < this.size && this.modules[y][x];
|
||||
}
|
||||
|
||||
/*-- Private helper methods for constructor: Drawing function modules --*/
|
||||
|
||||
// Reads this object's version field, and draws and marks all function modules.
|
||||
private drawFunctionPatterns(): void {
|
||||
// Draw horizontal and vertical timing patterns
|
||||
for (let i = 0; i < this.size; i++) {
|
||||
this.setFunctionModule(6, i, i % 2 === 0);
|
||||
this.setFunctionModule(i, 6, i % 2 === 0);
|
||||
}
|
||||
|
||||
// Draw 3 finder patterns (all corners except bottom right; overwrites some timing modules)
|
||||
this.drawFinderPattern(3, 3);
|
||||
this.drawFinderPattern(this.size - 4, 3);
|
||||
this.drawFinderPattern(3, this.size - 4);
|
||||
|
||||
// Draw numerous alignment patterns
|
||||
const alignPatPos: Array<int> = this.getAlignmentPatternPositions();
|
||||
const numAlign: int = alignPatPos.length;
|
||||
for (let i = 0; i < numAlign; i++) {
|
||||
for (let j = 0; j < numAlign; j++) {
|
||||
// Don't draw on the three finder corners
|
||||
if (
|
||||
!(
|
||||
(i === 0 && j === 0) ||
|
||||
(i === 0 && j === numAlign - 1) ||
|
||||
(i === numAlign - 1 && j === 0)
|
||||
)
|
||||
)
|
||||
this.drawAlignmentPattern(alignPatPos[i], alignPatPos[j]);
|
||||
}
|
||||
}
|
||||
|
||||
// Draw configuration data
|
||||
this.drawFormatBits(0); // Dummy mask value; overwritten later in the constructor
|
||||
this.drawVersion();
|
||||
}
|
||||
|
||||
// Draws two copies of the format bits (with its own error correction code)
|
||||
// based on the given mask and this object's error correction level field.
|
||||
private drawFormatBits(mask: int): void {
|
||||
// Calculate error correction code and pack bits
|
||||
const data: int = (this.errorCorrectionLevel.formatBits << 3) | mask; // errCorrLvl is uint2, mask is uint3
|
||||
let rem: int = data;
|
||||
for (let i = 0; i < 10; i++) rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
|
||||
const bits = ((data << 10) | rem) ^ 0x5412; // uint15
|
||||
assert(bits >>> 15 === 0);
|
||||
|
||||
// Draw first copy
|
||||
for (let i = 0; i <= 5; i++) this.setFunctionModule(8, i, getBit(bits, i));
|
||||
this.setFunctionModule(8, 7, getBit(bits, 6));
|
||||
this.setFunctionModule(8, 8, getBit(bits, 7));
|
||||
this.setFunctionModule(7, 8, getBit(bits, 8));
|
||||
for (let i = 9; i < 15; i++) this.setFunctionModule(14 - i, 8, getBit(bits, i));
|
||||
|
||||
// Draw second copy
|
||||
for (let i = 0; i < 8; i++) this.setFunctionModule(this.size - 1 - i, 8, getBit(bits, i));
|
||||
for (let i = 8; i < 15; i++) this.setFunctionModule(8, this.size - 15 + i, getBit(bits, i));
|
||||
this.setFunctionModule(8, this.size - 8, true); // Always dark
|
||||
}
|
||||
|
||||
// Draws two copies of the version bits (with its own error correction code),
|
||||
// based on this object's version field, iff 7 <= version <= 40.
|
||||
private drawVersion(): void {
|
||||
if (this.version < 7) return;
|
||||
|
||||
// Calculate error correction code and pack bits
|
||||
let rem: int = this.version; // version is uint6, in the range [7, 40]
|
||||
for (let i = 0; i < 12; i++) rem = (rem << 1) ^ ((rem >>> 11) * 0x1f25);
|
||||
const bits: int = (this.version << 12) | rem; // uint18
|
||||
assert(bits >>> 18 === 0);
|
||||
|
||||
// Draw two copies
|
||||
for (let i = 0; i < 18; i++) {
|
||||
const color: boolean = getBit(bits, i);
|
||||
const a: int = this.size - 11 + (i % 3);
|
||||
const b: int = Math.floor(i / 3);
|
||||
this.setFunctionModule(a, b, color);
|
||||
this.setFunctionModule(b, a, color);
|
||||
}
|
||||
}
|
||||
|
||||
// Draws a 9*9 finder pattern including the border separator,
|
||||
// with the center module at (x, y). Modules can be out of bounds.
|
||||
private drawFinderPattern(x: int, y: int): void {
|
||||
for (let dy = -4; dy <= 4; dy++) {
|
||||
for (let dx = -4; dx <= 4; dx++) {
|
||||
const dist: int = Math.max(Math.abs(dx), Math.abs(dy)); // Chebyshev/infinity norm
|
||||
const xx: int = x + dx;
|
||||
const yy: int = y + dy;
|
||||
if (0 <= xx && xx < this.size && 0 <= yy && yy < this.size)
|
||||
this.setFunctionModule(xx, yy, dist !== 2 && dist !== 4);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Draws a 5*5 alignment pattern, with the center module
|
||||
// at (x, y). All modules must be in bounds.
|
||||
private drawAlignmentPattern(x: int, y: int): void {
|
||||
for (let dy = -2; dy <= 2; dy++) {
|
||||
for (let dx = -2; dx <= 2; dx++)
|
||||
this.setFunctionModule(x + dx, y + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
|
||||
}
|
||||
}
|
||||
|
||||
// Sets the color of a module and marks it as a function module.
|
||||
// Only used by the constructor. Coordinates must be in bounds.
|
||||
private setFunctionModule(x: int, y: int, isDark: boolean): void {
|
||||
this.modules[y][x] = isDark;
|
||||
this.isFunction[y][x] = true;
|
||||
}
|
||||
|
||||
/*-- Private helper methods for constructor: Codewords and masking --*/
|
||||
|
||||
// Returns a new byte string representing the given data with the appropriate error correction
|
||||
// codewords appended to it, based on this object's version and error correction level.
|
||||
private addEccAndInterleave(data: Readonly<Array<byte>>): Array<byte> {
|
||||
const ver: int = this.version;
|
||||
const ecl: QrCode.Ecc = this.errorCorrectionLevel;
|
||||
if (data.length !== QrCode.getNumDataCodewords(ver, ecl))
|
||||
throw new RangeError('Invalid argument');
|
||||
|
||||
// Calculate parameter numbers
|
||||
const numBlocks: int = QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver];
|
||||
const blockEccLen: int = QrCode.ECC_CODEWORDS_PER_BLOCK[ecl.ordinal][ver];
|
||||
const rawCodewords: int = Math.floor(QrCode.getNumRawDataModules(ver) / 8);
|
||||
const numShortBlocks: int = numBlocks - (rawCodewords % numBlocks);
|
||||
const shortBlockLen: int = Math.floor(rawCodewords / numBlocks);
|
||||
|
||||
// Split data into blocks and append ECC to each block
|
||||
const blocks: Array<Array<byte>> = [];
|
||||
const rsDiv: Array<byte> = QrCode.reedSolomonComputeDivisor(blockEccLen);
|
||||
for (let i = 0, k = 0; i < numBlocks; i++) {
|
||||
const dat: Array<byte> = data.slice(
|
||||
k,
|
||||
k + shortBlockLen - blockEccLen + (i < numShortBlocks ? 0 : 1)
|
||||
);
|
||||
k += dat.length;
|
||||
const ecc: Array<byte> = QrCode.reedSolomonComputeRemainder(dat, rsDiv);
|
||||
if (i < numShortBlocks) dat.push(0);
|
||||
blocks.push(dat.concat(ecc));
|
||||
}
|
||||
|
||||
// Interleave (not concatenate) the bytes from every block into a single sequence
|
||||
const result: Array<byte> = [];
|
||||
for (let i = 0; i < blocks[0].length; i++) {
|
||||
blocks.forEach((block, j) => {
|
||||
// Skip the padding byte in short blocks
|
||||
if (i !== shortBlockLen - blockEccLen || j >= numShortBlocks) result.push(block[i]);
|
||||
});
|
||||
}
|
||||
assert(result.length === rawCodewords);
|
||||
return result;
|
||||
}
|
||||
|
||||
// Draws the given sequence of 8-bit codewords (data and error correction) onto the entire
|
||||
// data area of this QR Code. Function modules need to be marked off before this is called.
|
||||
private drawCodewords(data: Readonly<Array<byte>>): void {
|
||||
if (data.length !== Math.floor(QrCode.getNumRawDataModules(this.version) / 8))
|
||||
throw new RangeError('Invalid argument');
|
||||
let i: int = 0; // Bit index into the data
|
||||
// Do the funny zigzag scan
|
||||
for (let right = this.size - 1; right >= 1; right -= 2) {
|
||||
// Index of right column in each column pair
|
||||
if (right === 6) right = 5;
|
||||
for (let vert = 0; vert < this.size; vert++) {
|
||||
// Vertical counter
|
||||
for (let j = 0; j < 2; j++) {
|
||||
const x: int = right - j; // Actual x coordinate
|
||||
const upward: boolean = ((right + 1) & 2) === 0;
|
||||
const y: int = upward ? this.size - 1 - vert : vert; // Actual y coordinate
|
||||
if (!this.isFunction[y][x] && i < data.length * 8) {
|
||||
this.modules[y][x] = getBit(data[i >>> 3], 7 - (i & 7));
|
||||
i++;
|
||||
}
|
||||
// If this QR Code has any remainder bits (0 to 7), they were assigned as
|
||||
// 0/false/light by the constructor and are left unchanged by this method
|
||||
}
|
||||
}
|
||||
}
|
||||
assert(i === data.length * 8);
|
||||
}
|
||||
|
||||
// XORs the codeword modules in this QR Code with the given mask pattern.
|
||||
// The function modules must be marked and the codeword bits must be drawn
|
||||
// before masking. Due to the arithmetic of XOR, calling applyMask() with
|
||||
// the same mask value a second time will undo the mask. A final well-formed
|
||||
// QR Code needs exactly one (not zero, two, etc.) mask applied.
|
||||
private applyMask(mask: int): void {
|
||||
if (mask < 0 || mask > 7) throw new RangeError('Mask value out of range');
|
||||
for (let y = 0; y < this.size; y++) {
|
||||
for (let x = 0; x < this.size; x++) {
|
||||
let invert: boolean;
|
||||
switch (mask) {
|
||||
case 0:
|
||||
invert = (x + y) % 2 === 0;
|
||||
break;
|
||||
case 1:
|
||||
invert = y % 2 === 0;
|
||||
break;
|
||||
case 2:
|
||||
invert = x % 3 === 0;
|
||||
break;
|
||||
case 3:
|
||||
invert = (x + y) % 3 === 0;
|
||||
break;
|
||||
case 4:
|
||||
invert = (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0;
|
||||
break;
|
||||
case 5:
|
||||
invert = ((x * y) % 2) + ((x * y) % 3) === 0;
|
||||
break;
|
||||
case 6:
|
||||
invert = (((x * y) % 2) + ((x * y) % 3)) % 2 === 0;
|
||||
break;
|
||||
case 7:
|
||||
invert = (((x + y) % 2) + ((x * y) % 3)) % 2 === 0;
|
||||
break;
|
||||
default:
|
||||
throw new Error('Unreachable');
|
||||
}
|
||||
if (!this.isFunction[y][x] && invert) this.modules[y][x] = !this.modules[y][x];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Calculates and returns the penalty score based on state of this QR Code's current modules.
|
||||
// This is used by the automatic mask choice algorithm to find the mask pattern that yields the lowest score.
|
||||
private getPenaltyScore(): int {
|
||||
let result: int = 0;
|
||||
|
||||
// Adjacent modules in row having same color, and finder-like patterns
|
||||
for (let y = 0; y < this.size; y++) {
|
||||
let runColor = false;
|
||||
let runX = 0;
|
||||
const runHistory = [0, 0, 0, 0, 0, 0, 0];
|
||||
for (let x = 0; x < this.size; x++) {
|
||||
if (this.modules[y][x] === runColor) {
|
||||
runX++;
|
||||
if (runX === 5) result += QrCode.PENALTY_N1;
|
||||
else if (runX > 5) result++;
|
||||
} else {
|
||||
this.finderPenaltyAddHistory(runX, runHistory);
|
||||
if (!runColor)
|
||||
result += this.finderPenaltyCountPatterns(runHistory) * QrCode.PENALTY_N3;
|
||||
runColor = this.modules[y][x];
|
||||
runX = 1;
|
||||
}
|
||||
}
|
||||
result +=
|
||||
this.finderPenaltyTerminateAndCount(runColor, runX, runHistory) * QrCode.PENALTY_N3;
|
||||
}
|
||||
// Adjacent modules in column having same color, and finder-like patterns
|
||||
for (let x = 0; x < this.size; x++) {
|
||||
let runColor = false;
|
||||
let runY = 0;
|
||||
const runHistory = [0, 0, 0, 0, 0, 0, 0];
|
||||
for (let y = 0; y < this.size; y++) {
|
||||
if (this.modules[y][x] === runColor) {
|
||||
runY++;
|
||||
if (runY === 5) result += QrCode.PENALTY_N1;
|
||||
else if (runY > 5) result++;
|
||||
} else {
|
||||
this.finderPenaltyAddHistory(runY, runHistory);
|
||||
if (!runColor)
|
||||
result += this.finderPenaltyCountPatterns(runHistory) * QrCode.PENALTY_N3;
|
||||
runColor = this.modules[y][x];
|
||||
runY = 1;
|
||||
}
|
||||
}
|
||||
result +=
|
||||
this.finderPenaltyTerminateAndCount(runColor, runY, runHistory) * QrCode.PENALTY_N3;
|
||||
}
|
||||
|
||||
// 2*2 blocks of modules having same color
|
||||
for (let y = 0; y < this.size - 1; y++) {
|
||||
for (let x = 0; x < this.size - 1; x++) {
|
||||
const color: boolean = this.modules[y][x];
|
||||
if (
|
||||
color === this.modules[y][x + 1] &&
|
||||
color === this.modules[y + 1][x] &&
|
||||
color === this.modules[y + 1][x + 1]
|
||||
)
|
||||
result += QrCode.PENALTY_N2;
|
||||
}
|
||||
}
|
||||
|
||||
// Balance of dark and light modules
|
||||
let dark: int = 0;
|
||||
for (const row of this.modules)
|
||||
dark = row.reduce((sum, color) => sum + (color ? 1 : 0), dark);
|
||||
const total: int = this.size * this.size; // Note that size is odd, so dark/total != 1/2
|
||||
// Compute the smallest integer k >= 0 such that (45-5k)% <= dark/total <= (55+5k)%
|
||||
const k: int = Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1;
|
||||
assert(0 <= k && k <= 9);
|
||||
result += k * QrCode.PENALTY_N4;
|
||||
assert(0 <= result && result <= 2568888); // Non-tight upper bound based on default values of PENALTY_N1, ..., N4
|
||||
return result;
|
||||
}
|
||||
|
||||
/*-- Private helper functions --*/
|
||||
|
||||
// Returns an ascending list of positions of alignment patterns for this version number.
|
||||
// Each position is in the range [0,177), and are used on both the x and y axes.
|
||||
// This could be implemented as lookup table of 40 variable-length lists of integers.
|
||||
private getAlignmentPatternPositions(): Array<int> {
|
||||
if (this.version === 1) return [];
|
||||
|
||||
const numAlign: int = Math.floor(this.version / 7) + 2;
|
||||
const step: int =
|
||||
this.version === 32 ? 26 : Math.ceil((this.version * 4 + 4) / (numAlign * 2 - 2)) * 2;
|
||||
const result: Array<int> = [6];
|
||||
for (let pos = this.size - 7; result.length < numAlign; pos -= step) result.splice(1, 0, pos);
|
||||
return result;
|
||||
}
|
||||
|
||||
// Returns the number of data bits that can be stored in a QR Code of the given version number, after
|
||||
// all function modules are excluded. This includes remainder bits, so it might not be a multiple of 8.
|
||||
// The result is in the range [208, 29648]. This could be implemented as a 40-entry lookup table.
|
||||
private static getNumRawDataModules(ver: int): int {
|
||||
if (ver < QrCode.MIN_VERSION || ver > QrCode.MAX_VERSION)
|
||||
throw new RangeError('Version number out of range');
|
||||
let result: int = (16 * ver + 128) * ver + 64;
|
||||
if (ver >= 2) {
|
||||
const numAlign: int = Math.floor(ver / 7) + 2;
|
||||
result -= (25 * numAlign - 10) * numAlign - 55;
|
||||
if (ver >= 7) result -= 36;
|
||||
}
|
||||
assert(208 <= result && result <= 29648);
|
||||
return result;
|
||||
}
|
||||
|
||||
// Returns the number of 8-bit data (i.e. not error correction) codewords contained in any
|
||||
// QR Code of the given version number and error correction level, with remainder bits discarded.
|
||||
// This stateless pure function could be implemented as a (40*4)-cell lookup table.
|
||||
private static getNumDataCodewords(ver: int, ecl: QrCode.Ecc): int {
|
||||
return (
|
||||
Math.floor(QrCode.getNumRawDataModules(ver) / 8) -
|
||||
QrCode.ECC_CODEWORDS_PER_BLOCK[ecl.ordinal][ver] *
|
||||
QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver]
|
||||
);
|
||||
}
|
||||
|
||||
// Returns a Reed-Solomon ECC generator polynomial for the given degree. This could be
|
||||
// implemented as a lookup table over all possible parameter values, instead of as an algorithm.
|
||||
private static reedSolomonComputeDivisor(degree: int): Array<byte> {
|
||||
if (degree < 1 || degree > 255) throw new RangeError('Degree out of range');
|
||||
// Polynomial coefficients are stored from highest to lowest power, excluding the leading term which is always 1.
|
||||
// For example the polynomial x^3 + 255x^2 + 8x + 93 is stored as the uint8 array [255, 8, 93].
|
||||
const result: Array<byte> = [];
|
||||
for (let i = 0; i < degree - 1; i++) result.push(0);
|
||||
result.push(1); // Start off with the monomial x^0
|
||||
|
||||
// Compute the product polynomial (x - r^0) * (x - r^1) * (x - r^2) * ... * (x - r^{degree-1}),
|
||||
// and drop the highest monomial term which is always 1x^degree.
|
||||
// Note that r = 0x02, which is a generator element of this field GF(2^8/0x11D).
|
||||
let root = 1;
|
||||
for (let i = 0; i < degree; i++) {
|
||||
// Multiply the current product by (x - r^i)
|
||||
for (let j = 0; j < result.length; j++) {
|
||||
result[j] = QrCode.reedSolomonMultiply(result[j], root);
|
||||
if (j + 1 < result.length) result[j] ^= result[j + 1];
|
||||
}
|
||||
root = QrCode.reedSolomonMultiply(root, 0x02);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// Returns the Reed-Solomon error correction codeword for the given data and divisor polynomials.
|
||||
private static reedSolomonComputeRemainder(
|
||||
data: Readonly<Array<byte>>,
|
||||
divisor: Readonly<Array<byte>>
|
||||
): Array<byte> {
|
||||
const result: Array<byte> = divisor.map((_) => 0);
|
||||
for (const b of data) {
|
||||
// Polynomial division
|
||||
const factor: byte = b ^ (result.shift() as byte);
|
||||
result.push(0);
|
||||
divisor.forEach((coef, i) => (result[i] ^= QrCode.reedSolomonMultiply(coef, factor)));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// Returns the product of the two given field elements modulo GF(2^8/0x11D). The arguments and result
|
||||
// are unsigned 8-bit integers. This could be implemented as a lookup table of 256*256 entries of uint8.
|
||||
private static reedSolomonMultiply(x: byte, y: byte): byte {
|
||||
if (x >>> 8 !== 0 || y >>> 8 !== 0) throw new RangeError('Byte out of range');
|
||||
// Russian peasant multiplication
|
||||
let z: int = 0;
|
||||
for (let i = 7; i >= 0; i--) {
|
||||
z = (z << 1) ^ ((z >>> 7) * 0x11d);
|
||||
z ^= ((y >>> i) & 1) * x;
|
||||
}
|
||||
assert(z >>> 8 === 0);
|
||||
return z as byte;
|
||||
}
|
||||
|
||||
// Can only be called immediately after a light run is added, and
|
||||
// returns either 0, 1, or 2. A helper function for getPenaltyScore().
|
||||
private finderPenaltyCountPatterns(runHistory: Readonly<Array<int>>): int {
|
||||
const n: int = runHistory[1];
|
||||
assert(n <= this.size * 3);
|
||||
const core: boolean =
|
||||
n > 0 &&
|
||||
runHistory[2] === n &&
|
||||
runHistory[3] === n * 3 &&
|
||||
runHistory[4] === n &&
|
||||
runHistory[5] === n;
|
||||
return (
|
||||
(core && runHistory[0] >= n * 4 && runHistory[6] >= n ? 1 : 0) +
|
||||
(core && runHistory[6] >= n * 4 && runHistory[0] >= n ? 1 : 0)
|
||||
);
|
||||
}
|
||||
|
||||
// Must be called at the end of a line (row or column) of modules. A helper function for getPenaltyScore().
|
||||
private finderPenaltyTerminateAndCount(
|
||||
currentRunColor: boolean,
|
||||
currentRunLength: int,
|
||||
runHistory: Array<int>
|
||||
): int {
|
||||
if (currentRunColor) {
|
||||
// Terminate dark run
|
||||
this.finderPenaltyAddHistory(currentRunLength, runHistory);
|
||||
currentRunLength = 0;
|
||||
}
|
||||
currentRunLength += this.size; // Add light border to final run
|
||||
this.finderPenaltyAddHistory(currentRunLength, runHistory);
|
||||
return this.finderPenaltyCountPatterns(runHistory);
|
||||
}
|
||||
|
||||
// Pushes the given value to the front and drops the last value. A helper function for getPenaltyScore().
|
||||
private finderPenaltyAddHistory(currentRunLength: int, runHistory: Array<int>): void {
|
||||
if (runHistory[0] === 0) currentRunLength += this.size; // Add light border to initial run
|
||||
runHistory.pop();
|
||||
runHistory.unshift(currentRunLength);
|
||||
}
|
||||
|
||||
/*-- Constants and tables --*/
|
||||
|
||||
// The minimum version number supported in the QR Code Model 2 standard.
|
||||
public static readonly MIN_VERSION: int = 1;
|
||||
// The maximum version number supported in the QR Code Model 2 standard.
|
||||
public static readonly MAX_VERSION: int = 40;
|
||||
|
||||
// For use in getPenaltyScore(), when evaluating which mask is best.
|
||||
private static readonly PENALTY_N1: int = 3;
|
||||
private static readonly PENALTY_N2: int = 3;
|
||||
private static readonly PENALTY_N3: int = 40;
|
||||
private static readonly PENALTY_N4: int = 10;
|
||||
|
||||
private static readonly ECC_CODEWORDS_PER_BLOCK: Array<Array<int>> = [
|
||||
// Version: (note that index 0 is for padding, and is set to an illegal value)
|
||||
//0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40 Error correction level
|
||||
[
|
||||
-1, 7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28,
|
||||
30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
|
||||
], // Low
|
||||
[
|
||||
-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
|
||||
], // Medium
|
||||
[
|
||||
-1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30,
|
||||
30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
|
||||
], // Quartile
|
||||
[
|
||||
-1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24,
|
||||
30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
|
||||
], // High
|
||||
];
|
||||
|
||||
private static readonly NUM_ERROR_CORRECTION_BLOCKS: Array<Array<int>> = [
|
||||
// Version: (note that index 0 is for padding, and is set to an illegal value)
|
||||
//0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40 Error correction level
|
||||
[
|
||||
-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13,
|
||||
14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25,
|
||||
], // Low
|
||||
[
|
||||
-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21,
|
||||
23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49,
|
||||
], // Medium
|
||||
[
|
||||
-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29,
|
||||
34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68,
|
||||
], // Quartile
|
||||
[
|
||||
-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32,
|
||||
35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81,
|
||||
], // High
|
||||
];
|
||||
}
|
||||
|
||||
// Appends the given number of low-order bits of the given value
|
||||
// to the given buffer. Requires 0 <= len <= 31 and 0 <= val < 2^len.
|
||||
function appendBits(val: int, len: int, bb: Array<bit>): void {
|
||||
if (len < 0 || len > 31 || val >>> len !== 0) throw new RangeError('Value out of range');
|
||||
for (
|
||||
let i = len - 1;
|
||||
i >= 0;
|
||||
i-- // Append bit by bit
|
||||
)
|
||||
bb.push((val >>> i) & 1);
|
||||
}
|
||||
|
||||
// Returns true iff the i'th bit of x is set to 1.
|
||||
function getBit(x: int, i: int): boolean {
|
||||
return ((x >>> i) & 1) !== 0;
|
||||
}
|
||||
|
||||
// Throws an exception if the given condition is false.
|
||||
function assert(cond: boolean): void {
|
||||
if (!cond) throw new Error('Assertion error');
|
||||
}
|
||||
|
||||
/*---- Data segment class ----*/
|
||||
|
||||
/*
|
||||
* A segment of character/binary/control data in a QR Code symbol.
|
||||
* Instances of this class are immutable.
|
||||
* The mid-level way to create a segment is to take the payload data
|
||||
* and call a static factory function such as QrSegment.makeNumeric().
|
||||
* The low-level way to create a segment is to custom-make the bit buffer
|
||||
* and call the QrSegment() constructor with appropriate values.
|
||||
* This segment class imposes no length restrictions, but QR Codes have restrictions.
|
||||
* Even in the most favorable conditions, a QR Code can only hold 7089 characters of data.
|
||||
* Any segment longer than this is meaningless for the purpose of generating QR Codes.
|
||||
*/
|
||||
export class QrSegment {
|
||||
/*-- Static factory functions (mid level) --*/
|
||||
|
||||
// Returns a segment representing the given binary data encoded in
|
||||
// byte mode. All input byte arrays are acceptable. Any text string
|
||||
// can be converted to UTF-8 bytes and encoded as a byte mode segment.
|
||||
public static makeBytes(data: Readonly<Array<byte>>): QrSegment {
|
||||
const bb: Array<bit> = [];
|
||||
for (const b of data) appendBits(b, 8, bb);
|
||||
return new QrSegment(QrSegment.Mode.BYTE, data.length, bb);
|
||||
}
|
||||
|
||||
// Returns a segment representing the given string of decimal digits encoded in numeric mode.
|
||||
public static makeNumeric(digits: string): QrSegment {
|
||||
if (!QrSegment.isNumeric(digits))
|
||||
throw new RangeError('String contains non-numeric characters');
|
||||
const bb: Array<bit> = [];
|
||||
for (let i = 0; i < digits.length; ) {
|
||||
// Consume up to 3 digits per iteration
|
||||
const n: int = Math.min(digits.length - i, 3);
|
||||
appendBits(Number.parseInt(digits.substring(i, i + n), 10), n * 3 + 1, bb);
|
||||
i += n;
|
||||
}
|
||||
return new QrSegment(QrSegment.Mode.NUMERIC, digits.length, bb);
|
||||
}
|
||||
|
||||
// Returns a segment representing the given text string encoded in alphanumeric mode.
|
||||
// The characters allowed are: 0 to 9, A to Z (uppercase only), space,
|
||||
// dollar, percent, asterisk, plus, hyphen, period, slash, colon.
|
||||
public static makeAlphanumeric(text: string): QrSegment {
|
||||
if (!QrSegment.isAlphanumeric(text))
|
||||
throw new RangeError('String contains unencodable characters in alphanumeric mode');
|
||||
const bb: Array<bit> = [];
|
||||
let i: int;
|
||||
for (i = 0; i + 2 <= text.length; i += 2) {
|
||||
// Process groups of 2
|
||||
let temp: int = QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)) * 45;
|
||||
temp += QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i + 1));
|
||||
appendBits(temp, 11, bb);
|
||||
}
|
||||
if (i < text.length)
|
||||
// 1 character remaining
|
||||
appendBits(QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)), 6, bb);
|
||||
return new QrSegment(QrSegment.Mode.ALPHANUMERIC, text.length, bb);
|
||||
}
|
||||
|
||||
// Returns a new mutable list of zero or more segments to represent the given Unicode text string.
|
||||
// The result may use various segment modes and switch modes to optimize the length of the bit stream.
|
||||
public static makeSegments(text: string): Array<QrSegment> {
|
||||
// Select the most efficient segment encoding automatically
|
||||
if (text === '') return [];
|
||||
if (QrSegment.isNumeric(text)) return [QrSegment.makeNumeric(text)];
|
||||
if (QrSegment.isAlphanumeric(text)) return [QrSegment.makeAlphanumeric(text)];
|
||||
return [QrSegment.makeBytes(QrSegment.toUtf8ByteArray(text))];
|
||||
}
|
||||
|
||||
// Returns a segment representing an Extended Channel Interpretation
|
||||
// (ECI) designator with the given assignment value.
|
||||
public static makeEci(assignVal: int): QrSegment {
|
||||
const bb: Array<bit> = [];
|
||||
if (assignVal < 0) throw new RangeError('ECI assignment value out of range');
|
||||
if (assignVal < 1 << 7) appendBits(assignVal, 8, bb);
|
||||
else if (assignVal < 1 << 14) {
|
||||
appendBits(0b10, 2, bb);
|
||||
appendBits(assignVal, 14, bb);
|
||||
} else if (assignVal < 1000000) {
|
||||
appendBits(0b110, 3, bb);
|
||||
appendBits(assignVal, 21, bb);
|
||||
} else throw new RangeError('ECI assignment value out of range');
|
||||
return new QrSegment(QrSegment.Mode.ECI, 0, bb);
|
||||
}
|
||||
|
||||
// Tests whether the given string can be encoded as a segment in numeric mode.
|
||||
// A string is encodable iff each character is in the range 0 to 9.
|
||||
public static isNumeric(text: string): boolean {
|
||||
return QrSegment.NUMERIC_REGEX.test(text);
|
||||
}
|
||||
|
||||
// Tests whether the given string can be encoded as a segment in alphanumeric mode.
|
||||
// A string is encodable iff each character is in the following set: 0 to 9, A to Z
|
||||
// (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.
|
||||
public static isAlphanumeric(text: string): boolean {
|
||||
return QrSegment.ALPHANUMERIC_REGEX.test(text);
|
||||
}
|
||||
|
||||
/*-- Constructor (low level) and fields --*/
|
||||
|
||||
// Creates a new QR Code segment with the given attributes and data.
|
||||
// The character count (numChars) must agree with the mode and the bit buffer length,
|
||||
// but the constraint isn't checked. The given bit buffer is cloned and stored.
|
||||
public constructor(
|
||||
// The mode indicator of this segment.
|
||||
public readonly mode: QrSegment.Mode,
|
||||
|
||||
// The length of this segment's unencoded data. Measured in characters for
|
||||
// numeric/alphanumeric/kanji mode, bytes for byte mode, and 0 for ECI mode.
|
||||
// Always zero or positive. Not the same as the data's bit length.
|
||||
public readonly numChars: int,
|
||||
|
||||
// The data bits of this segment. Accessed through getData().
|
||||
private readonly bitData: Array<bit>
|
||||
) {
|
||||
if (numChars < 0) throw new RangeError('Invalid argument');
|
||||
this.bitData = bitData.slice(); // Make defensive copy
|
||||
}
|
||||
|
||||
/*-- Methods --*/
|
||||
|
||||
// Returns a new copy of the data bits of this segment.
|
||||
public getData(): Array<bit> {
|
||||
return this.bitData.slice(); // Make defensive copy
|
||||
}
|
||||
|
||||
// (Package-private) Calculates and returns the number of bits needed to encode the given segments at
|
||||
// the given version. The result is infinity if a segment has too many characters to fit its length field.
|
||||
public static getTotalBits(segs: Readonly<Array<QrSegment>>, version: int): number {
|
||||
let result = 0;
|
||||
for (const seg of segs) {
|
||||
const ccbits: int = seg.mode.numCharCountBits(version);
|
||||
if (seg.numChars >= 1 << ccbits) return Number.POSITIVE_INFINITY; // The segment's length doesn't fit the field's bit width
|
||||
result += 4 + ccbits + seg.bitData.length;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// Returns a new array of bytes representing the given string encoded in UTF-8.
|
||||
private static toUtf8ByteArray(str: string): Array<byte> {
|
||||
str = encodeURI(str);
|
||||
const result: Array<byte> = [];
|
||||
for (let i = 0; i < str.length; i++) {
|
||||
if (str.charAt(i) !== '%') result.push(str.charCodeAt(i));
|
||||
else {
|
||||
result.push(Number.parseInt(str.substring(i + 1, i + 3), 16));
|
||||
i += 2;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/*-- Constants --*/
|
||||
|
||||
// Describes precisely all strings that are encodable in numeric mode.
|
||||
private static readonly NUMERIC_REGEX: RegExp = /^[0-9]*$/;
|
||||
|
||||
// Describes precisely all strings that are encodable in alphanumeric mode.
|
||||
private static readonly ALPHANUMERIC_REGEX: RegExp = /^[A-Z0-9 $%*+./:-]*$/;
|
||||
|
||||
// The set of all legal characters in alphanumeric mode,
|
||||
// where each character value maps to the index in the string.
|
||||
private static readonly ALPHANUMERIC_CHARSET: string =
|
||||
'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:';
|
||||
}
|
||||
}
|
||||
|
||||
/*---- Public helper enumeration ----*/
|
||||
|
||||
export namespace qrcodegen.QrCode {
|
||||
type int = number;
|
||||
|
||||
/*
|
||||
* The error correction level in a QR Code symbol. Immutable.
|
||||
*/
|
||||
export class Ecc {
|
||||
/*-- Constants --*/
|
||||
|
||||
public static readonly LOW = new Ecc(0, 1); // The QR Code can tolerate about 7% erroneous codewords
|
||||
public static readonly MEDIUM = new Ecc(1, 0); // The QR Code can tolerate about 15% erroneous codewords
|
||||
public static readonly QUARTILE = new Ecc(2, 3); // The QR Code can tolerate about 25% erroneous codewords
|
||||
public static readonly HIGH = new Ecc(3, 2); // The QR Code can tolerate about 30% erroneous codewords
|
||||
|
||||
/*-- Constructor and fields --*/
|
||||
|
||||
private constructor(
|
||||
// In the range 0 to 3 (unsigned 2-bit integer).
|
||||
public readonly ordinal: int,
|
||||
// (Package-private) In the range 0 to 3 (unsigned 2-bit integer).
|
||||
public readonly formatBits: int
|
||||
) {}
|
||||
}
|
||||
}
|
||||
|
||||
/*---- Public helper enumeration ----*/
|
||||
|
||||
export namespace qrcodegen.QrSegment {
|
||||
type int = number;
|
||||
|
||||
/*
|
||||
* Describes how a segment's data bits are interpreted. Immutable.
|
||||
*/
|
||||
export class Mode {
|
||||
/*-- Constants --*/
|
||||
|
||||
public static readonly NUMERIC = new Mode(0x1, [10, 12, 14]);
|
||||
public static readonly ALPHANUMERIC = new Mode(0x2, [9, 11, 13]);
|
||||
public static readonly BYTE = new Mode(0x4, [8, 16, 16]);
|
||||
public static readonly KANJI = new Mode(0x8, [8, 10, 12]);
|
||||
public static readonly ECI = new Mode(0x7, [0, 0, 0]);
|
||||
|
||||
/*-- Constructor and fields --*/
|
||||
|
||||
private constructor(
|
||||
// The mode indicator bits, which is a uint4 value (range 0 to 15).
|
||||
public readonly modeBits: int,
|
||||
// Number of character count bits for three different version ranges.
|
||||
private readonly numBitsCharCount: [int, int, int]
|
||||
) {}
|
||||
|
||||
/*-- Method --*/
|
||||
|
||||
// (Package-private) Returns the bit width of the character count field for a segment in
|
||||
// this mode in a QR Code at the given version number. The result is in the range [0, 16].
|
||||
public numCharCountBits(ver: int): int {
|
||||
return this.numBitsCharCount[Math.floor((ver + 7) / 17)];
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,219 @@
|
||||
import type { PlainMessage } from '@bufbuild/protobuf';
|
||||
import {
|
||||
type Adapter,
|
||||
type PollTxParams,
|
||||
type Secp256k1PubKey,
|
||||
Tx,
|
||||
calculateFee,
|
||||
getAccount,
|
||||
pollTx,
|
||||
simulateTx,
|
||||
toBaseAccount,
|
||||
} from '@sonr.io/es/client';
|
||||
import {
|
||||
CosmosBaseV1beta1Coin as Coin,
|
||||
type CosmosTxV1beta1Fee as Fee,
|
||||
type CosmosTxV1beta1GetTxResponse as GetTxResponse,
|
||||
} from '@sonr.io/es/protobufs';
|
||||
|
||||
import type { WalletName } from '../constants/WalletName';
|
||||
import type { WalletType } from '../constants/WalletType';
|
||||
import { extractExpectedAccountSequence } from '../utils/sequence';
|
||||
|
||||
export type UnsignedTx = {
|
||||
msgs: Adapter[];
|
||||
memo?: string | undefined;
|
||||
timeoutHeight?: bigint | undefined;
|
||||
};
|
||||
|
||||
export type PollTxOptions = Pick<PollTxParams, 'intervalSeconds' | 'maxAttempts'>;
|
||||
|
||||
export type SignArbitraryResponse = {
|
||||
data: string;
|
||||
pubKey: string;
|
||||
signature: string;
|
||||
};
|
||||
|
||||
/**
|
||||
* Represents a connected wallet that is ready to sign transactions.
|
||||
* Use `WalletController` to create an instance of this class.
|
||||
*/
|
||||
export abstract class ConnectedWallet {
|
||||
/** The identifier of this wallet. */
|
||||
public readonly id: WalletName;
|
||||
/** The type of connection to the wallet. */
|
||||
public readonly type: WalletType;
|
||||
/** The user-defined label for this wallet, if any. */
|
||||
public readonly label: string | undefined;
|
||||
/** The chain ID this wallet is connected to. */
|
||||
public readonly chainId: string;
|
||||
/** The public key. */
|
||||
public readonly pubKey: Secp256k1PubKey;
|
||||
/** The bech32 address. */
|
||||
public readonly address: string;
|
||||
/** The RPC endpoint to use for interacting with the chain. */
|
||||
public readonly rpc: string;
|
||||
/** The gas price to use for transactions. */
|
||||
public readonly gasPrice: Coin;
|
||||
private accountNumber: bigint | undefined;
|
||||
private sequence: bigint | undefined;
|
||||
|
||||
constructor(
|
||||
id: WalletName,
|
||||
type: WalletType,
|
||||
label: string | undefined,
|
||||
chainId: string,
|
||||
pubKey: Secp256k1PubKey,
|
||||
address: string,
|
||||
rpc: string,
|
||||
gasPrice: PlainMessage<Coin>
|
||||
) {
|
||||
this.id = id;
|
||||
this.type = type;
|
||||
this.label = label;
|
||||
this.chainId = chainId;
|
||||
this.pubKey = pubKey;
|
||||
this.address = address;
|
||||
this.rpc = rpc;
|
||||
this.gasPrice = new Coin(gasPrice);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the account number and sequence for the connected address. If `fromCache`
|
||||
* is true, the cached values (if they are available) will be returned instead of
|
||||
* querying the auth module.
|
||||
*
|
||||
* @throws if the account does not exist in the auth module.
|
||||
*/
|
||||
public async getAuthInfo(fromCache = false): Promise<{
|
||||
accountNumber: bigint;
|
||||
sequence: bigint;
|
||||
}> {
|
||||
if (!this.accountNumber || !this.sequence || !fromCache) {
|
||||
const account = await getAccount(this.rpc, { address: this.address });
|
||||
const { accountNumber, sequence } = toBaseAccount(account);
|
||||
this.accountNumber = accountNumber;
|
||||
this.sequence = sequence;
|
||||
}
|
||||
return {
|
||||
accountNumber: this.accountNumber,
|
||||
sequence: this.sequence,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Simulates the tx and returns an estimate of the gas fees required.
|
||||
*
|
||||
* @throws if the tx fails to simulate.
|
||||
*/
|
||||
public async estimateFee({ msgs, memo }: UnsignedTx, feeMultiplier = 1.4): Promise<Fee> {
|
||||
const estimate = async () => {
|
||||
const { sequence } = await this.getAuthInfo(true);
|
||||
const { gasInfo } = await simulateTx(this.rpc, {
|
||||
sequence,
|
||||
memo,
|
||||
tx: new Tx({ chainId: this.chainId, pubKey: this.pubKey, msgs: msgs }),
|
||||
});
|
||||
if (!gasInfo) {
|
||||
throw new Error('Unable to estimate fee');
|
||||
}
|
||||
return calculateFee(gasInfo, this.gasPrice, feeMultiplier);
|
||||
};
|
||||
// If we encounter an account sequence mismatch error, we retry exactly once
|
||||
// by parsing the error for the correct sequence to use
|
||||
try {
|
||||
return await estimate();
|
||||
} catch (err) {
|
||||
if (!(err instanceof Error)) {
|
||||
// Rethrow non-errors
|
||||
throw err;
|
||||
}
|
||||
const expectedSequence = extractExpectedAccountSequence(err);
|
||||
if (!expectedSequence) {
|
||||
// Rethrow errors not related to account sequence mismatch
|
||||
throw err;
|
||||
}
|
||||
// Set the cached sequence to the one from the error message
|
||||
this.sequence = expectedSequence;
|
||||
return estimate();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Signs and broadcasts the given `unsignedTx`, returning the tx hash if successful.
|
||||
* The `fee` parameter can (and should) be obtained by running `estimateFee` on
|
||||
* the `unsignedTx` prior to calling this method.
|
||||
*
|
||||
* **Important**: successful execution of this method does not guarantee that the
|
||||
* tx was successfully included in a block. Use `pollTx` to poll for the result of
|
||||
* the tx.
|
||||
*
|
||||
* @throws if the user denies the signing of the tx.
|
||||
* @throws if the tx fails to broadcast.
|
||||
*/
|
||||
public async broadcastTx(unsignedTx: UnsignedTx, fee: Fee): Promise<string> {
|
||||
const { accountNumber, sequence } = await this.getAuthInfo(true);
|
||||
const hash = await this.signAndBroadcastTx(unsignedTx, fee, accountNumber, sequence);
|
||||
// Greedily increment the sequence for the next tx. This may result in the wrong
|
||||
// sequence, but if `estimateFee` was called prior to this, it will be corrected
|
||||
this.sequence = sequence + 1n;
|
||||
return hash;
|
||||
}
|
||||
|
||||
/**
|
||||
* Polls for the tx matching the given `txHash` every `intervalSeconds` until it is
|
||||
* included in a block or when `maxAttempts` is reached (default: 2s, 64 attempts).
|
||||
*
|
||||
* @throws if the tx is not included in a block after the given `maxAttempts`.
|
||||
*/
|
||||
public async pollTx(
|
||||
txHash: string,
|
||||
{ maxAttempts, intervalSeconds }: PollTxOptions = {}
|
||||
): Promise<Required<PlainMessage<GetTxResponse>>> {
|
||||
return pollTx(this.rpc, {
|
||||
hash: txHash,
|
||||
maxAttempts,
|
||||
intervalSeconds,
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes `broadcastTx` and `pollTx` sequentially, returning the result of the
|
||||
* tx. If `feeOrFeeMultiplier` is `undefined` or a number, an additional call to
|
||||
* `estimateFee` will be made. Use this if there is no need to independently
|
||||
* execute the three methods.
|
||||
*/
|
||||
public async broadcastTxSync(
|
||||
unsignedTx: UnsignedTx,
|
||||
feeOrFeeMultiplier: Fee | number = 1.4,
|
||||
pollOpts: PollTxOptions = {}
|
||||
): Promise<Required<PlainMessage<GetTxResponse>>> {
|
||||
const fee =
|
||||
typeof feeOrFeeMultiplier === 'number'
|
||||
? await this.estimateFee(unsignedTx, feeOrFeeMultiplier)
|
||||
: feeOrFeeMultiplier;
|
||||
const txHash = await this.broadcastTx(unsignedTx, fee);
|
||||
return this.pollTx(txHash, pollOpts);
|
||||
}
|
||||
|
||||
/**
|
||||
* Signs the UTF-8 encoded `data` string. Note that some mobile wallets do not
|
||||
* support this method.
|
||||
*
|
||||
* @throws if the user denies the signing of the data.
|
||||
* @throws if the wallet does not support signing arbitrary data.
|
||||
*/
|
||||
public abstract signArbitrary(data: string): Promise<SignArbitraryResponse>;
|
||||
|
||||
/**
|
||||
* Signs the given `unsignedTx` and broadcasts the resulting signed tx, returning
|
||||
* the hex encoded tx hash if successful. This abstract method should be implemented
|
||||
* by the concrete child classes.
|
||||
*/
|
||||
protected abstract signAndBroadcastTx(
|
||||
unsignedTx: UnsignedTx,
|
||||
fee: Fee,
|
||||
accountNumber: bigint,
|
||||
sequence: bigint
|
||||
): Promise<string>;
|
||||
}
|
||||
@@ -0,0 +1,186 @@
|
||||
import type { PlainMessage } from '@bufbuild/protobuf';
|
||||
import type { CosmosBaseV1beta1Coin as Coin } from '@sonr.io/es/protobufs';
|
||||
|
||||
import type { WalletName } from '../constants/WalletName';
|
||||
import { WalletType } from '../constants/WalletType';
|
||||
import type { WalletConnectV1 } from '../walletconnect/WalletConnectV1';
|
||||
import type { WalletConnectV2 } from '../walletconnect/WalletConnectV2';
|
||||
import type { ConnectedWallet } from './ConnectedWallet';
|
||||
|
||||
/**
|
||||
* Represents a chain that the wallet can connect to.
|
||||
*/
|
||||
export type ChainInfo<T extends string> = {
|
||||
/**
|
||||
* The unique identifier for the chain (eg. `phoenix-1`).
|
||||
*/
|
||||
chainId: T;
|
||||
/**
|
||||
* A valid RPC endpoint that can be used to simulate and broadcast transactions.
|
||||
*/
|
||||
rpc: string;
|
||||
/**
|
||||
* The current gas price of the chain.
|
||||
*/
|
||||
gasPrice: PlainMessage<Coin>;
|
||||
};
|
||||
|
||||
export type EventCallback = (wallets: ConnectedWallet[]) => unknown;
|
||||
|
||||
/**
|
||||
* Controls initial connection to the wallet, and instantiates the
|
||||
* various `ConnectedWallet` instances.
|
||||
*/
|
||||
export abstract class WalletController {
|
||||
/** The identifier of this wallet. */
|
||||
public readonly id: WalletName;
|
||||
/** Map of chain ID to connected wallets. */
|
||||
public readonly connectedWallets: Map<string, ConnectedWallet>;
|
||||
private readonly onDisconnectCbs: Set<EventCallback>;
|
||||
protected readonly onAccountChangeCbs: Set<EventCallback>;
|
||||
private isWcOnDisconnectRegistered: boolean;
|
||||
|
||||
constructor(id: WalletName) {
|
||||
this.id = id;
|
||||
this.connectedWallets = new Map();
|
||||
this.onDisconnectCbs = new Set();
|
||||
this.onAccountChangeCbs = new Set();
|
||||
this.isWcOnDisconnectRegistered = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns `true` iff the wallet is installed.
|
||||
*/
|
||||
public abstract isInstalled(type: WalletType): Promise<boolean>;
|
||||
|
||||
/**
|
||||
* Connects to the wallet and returns a map of `ConnectedWallet` instances.
|
||||
* The keys of the map are the chain IDs.
|
||||
*/
|
||||
public async connect<T extends string>(
|
||||
type: WalletType,
|
||||
chains: ChainInfo<T>[]
|
||||
): Promise<Map<T, ConnectedWallet>> {
|
||||
if (chains.length === 0) {
|
||||
return new Map();
|
||||
}
|
||||
let connectedWallets: Map<T, ConnectedWallet>;
|
||||
if (type === WalletType.EXTENSION) {
|
||||
connectedWallets = await this.connectExtension(chains);
|
||||
} else {
|
||||
const { wallets, wc } = await this.connectWalletConnect(chains);
|
||||
if (!this.isWcOnDisconnectRegistered) {
|
||||
// On WalletConnect session disconnect, remove all WalletConnect wallets
|
||||
this.isWcOnDisconnectRegistered = true;
|
||||
wc.onDisconnect(() => {
|
||||
this.disconnect(
|
||||
Array.from(this.connectedWallets.keys()).filter(
|
||||
(id) => this.connectedWallets.get(id)?.type === WalletType.WALLETCONNECT
|
||||
)
|
||||
);
|
||||
});
|
||||
}
|
||||
connectedWallets = wallets;
|
||||
}
|
||||
for (const [key, value] of connectedWallets) {
|
||||
this.connectedWallets.set(key, value);
|
||||
}
|
||||
return connectedWallets;
|
||||
}
|
||||
|
||||
/**
|
||||
* Disconnects the wallet connected to the given `chainIds`.
|
||||
*/
|
||||
public disconnect(chainIds: string[]) {
|
||||
const callbackIds = chainIds.filter((id) => this.connectedWallets.has(id));
|
||||
if (callbackIds.length === 0) {
|
||||
return;
|
||||
}
|
||||
const disconnectedWallets: ConnectedWallet[] = [];
|
||||
for (const id of callbackIds) {
|
||||
const wallet = this.connectedWallets.get(id);
|
||||
if (wallet) {
|
||||
disconnectedWallets.push(wallet);
|
||||
this.connectedWallets.delete(id);
|
||||
}
|
||||
}
|
||||
for (const cb of this.onDisconnectCbs) {
|
||||
cb(disconnectedWallets);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Should be called when any account changes are detected. This will disconnect
|
||||
* from all chains that were connected via the given `walletType`, and emit the
|
||||
* `onAccountChange` event.
|
||||
*/
|
||||
protected changeAccount(walletType: WalletType) {
|
||||
// Ignore if controller does not have any connected wallets
|
||||
if (this.connectedWallets.size === 0) {
|
||||
return;
|
||||
}
|
||||
// Find all wallets that were connected via the given `walletType`
|
||||
const wallets = [...this.connectedWallets.values()].filter(
|
||||
(wallet) => wallet.type === walletType
|
||||
);
|
||||
// Disconnect from those chains
|
||||
const chainIds = wallets.map((wallet) => wallet.chainId);
|
||||
this.disconnect(chainIds);
|
||||
// Fire the account change callbacks
|
||||
for (const cb of this.onAccountChangeCbs) {
|
||||
cb(wallets);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers a callback that is called when the wallet is disconnected.
|
||||
* Returns an `unsubscribe` function that should be called after the
|
||||
* callback is no longer needed.
|
||||
*
|
||||
* ```ts
|
||||
* const unsubscribe = walletController.onDisconnect((wallets) => {
|
||||
* // do something with the wallets that were disconnected
|
||||
* console.log(wallets);
|
||||
* // unsubscribe from this callback (if necessary)
|
||||
* unsubsribe();
|
||||
* });
|
||||
* ```
|
||||
*/
|
||||
public onDisconnect(cb: EventCallback): () => void {
|
||||
this.onDisconnectCbs.add(cb);
|
||||
return () => this.onDisconnectCbs.delete(cb);
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers a callback that is called when the wallet's account is changed after
|
||||
* the initial connection. When the account changes, the `onDisconnect` event
|
||||
* will also be fired before this `onAccountChange` event. Returns an `unsubscribe`
|
||||
* function that should be called after the callback is no longer needed.
|
||||
*
|
||||
* ```ts
|
||||
* const unsubscribe = walletController.onAccountChange((wallets) => {
|
||||
* // do something with the wallets that were affected
|
||||
* console.log(wallets);
|
||||
* // unsubscribe from this callback (if necessary)
|
||||
* unsubsribe();
|
||||
* });
|
||||
* ```
|
||||
*/
|
||||
public onAccountChange(cb: EventCallback): () => void {
|
||||
this.onAccountChangeCbs.add(cb);
|
||||
return () => this.onAccountChangeCbs.delete(cb);
|
||||
}
|
||||
|
||||
protected abstract connectExtension<T extends string>(
|
||||
chains: ChainInfo<T>[]
|
||||
): Promise<Map<T, ConnectedWallet>>;
|
||||
|
||||
protected abstract connectWalletConnect<T extends string>(
|
||||
chains: ChainInfo<T>[]
|
||||
): Promise<{
|
||||
wallets: Map<T, ConnectedWallet>;
|
||||
wc: WalletConnectV1 | WalletConnectV2;
|
||||
}>;
|
||||
|
||||
protected abstract registerAccountChangeHandlers(): void;
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
/**
|
||||
* Custom error class which wraps around an error thrown by a wallet.
|
||||
*/
|
||||
export class WalletError extends Error {
|
||||
/**
|
||||
* Holds the original error and type thrown by the wallet.
|
||||
*/
|
||||
public raw: unknown;
|
||||
|
||||
constructor(message: string, raw: unknown) {
|
||||
super(message);
|
||||
this.name = 'WalletError';
|
||||
this.raw = raw;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the result of the `promise` if it resolves successfully, normalising
|
||||
* any errors thrown into a `WalletError` instance.
|
||||
*
|
||||
* It is best to wrap all wallet API calls with this function as some wallets
|
||||
* throw other data types other than actual `Error` instances.
|
||||
*/
|
||||
public static async wrap<T>(promise: Promise<T>): Promise<T> {
|
||||
try {
|
||||
return await promise;
|
||||
} catch (err) {
|
||||
if (typeof err === 'string') {
|
||||
throw new WalletError(err, err);
|
||||
}
|
||||
if (WalletError.isRecord(err)) {
|
||||
// Takes into account normal error instances and objects with the 'error' key
|
||||
throw new WalletError(err.message ?? err.error ?? 'unknown error', err);
|
||||
}
|
||||
throw new WalletError('unknown error', err);
|
||||
}
|
||||
}
|
||||
|
||||
private static isRecord(value: unknown): value is Record<string, string> {
|
||||
return typeof value === 'object' && value != null;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,169 @@
|
||||
import { RpcClient, Secp256k1PubKey, Tx } from '@sonr.io/es/client';
|
||||
import {
|
||||
base64,
|
||||
resolveBech32Address,
|
||||
resolveKeyPair,
|
||||
signAmino,
|
||||
signDirect,
|
||||
utf8,
|
||||
} from '@sonr.io/es/codec';
|
||||
import type { CosmosTxV1beta1Fee as Fee } from '@sonr.io/es/protobufs';
|
||||
import type { StdSignDoc } from '@sonr.io/es/registry';
|
||||
|
||||
import type { Prettify } from '../../../typeutils/prettify';
|
||||
import type { WalletName } from '../../constants/WalletName';
|
||||
import type { WalletType } from '../../constants/WalletType';
|
||||
import { ConnectedWallet, type SignArbitraryResponse, type UnsignedTx } from '../ConnectedWallet';
|
||||
import type { ChainInfo } from '../WalletController';
|
||||
|
||||
export type ConnectMnemonicWalletOptions = Prettify<
|
||||
{
|
||||
/**
|
||||
* Also known as the 12-24 words seed phrase. **Warning: keep this safe!**
|
||||
*/
|
||||
mnemonic: string;
|
||||
/**
|
||||
* The address prefix for the chain (eg. "osmo").
|
||||
*/
|
||||
bech32Prefix: string;
|
||||
/**
|
||||
* Coin type number for HD derivation (default: `118`). For Terra chains, change
|
||||
* this to `330`.
|
||||
*/
|
||||
coinType?: number | undefined;
|
||||
/**
|
||||
* Address index number for HD derivation (default: `0`).
|
||||
*/
|
||||
index?: number | undefined;
|
||||
} & ChainInfo<string>
|
||||
>;
|
||||
|
||||
/**
|
||||
* This wallet accepts a mnemonic (aka seed phrase) and is able to directly sign
|
||||
* and broadcast transactions to the chain without relying on an external wallet
|
||||
* like Keplr or Station. Use this if you want to programmatically broadcast
|
||||
* transactions. Unlike the other wallets, there is no Controller class and this
|
||||
* object must be instantiated directly.
|
||||
*
|
||||
* ```ts
|
||||
* // Example usage for Osmosis chain
|
||||
* const wallet = new MnemonicWallet({
|
||||
* mnemonic: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about", // Example 12-word mnemonic for testing
|
||||
* bech32Prefix: "osmo",
|
||||
* chainId: "osmosis-1",
|
||||
* rpc: "https://rpc.osmosis.zone",
|
||||
* gasPrice: {
|
||||
* amount: "0.0025",
|
||||
* denom: "uosmo",
|
||||
* },
|
||||
* coinType: 118, // optional (default: 118)
|
||||
* index: 0, // optional (default: 0)
|
||||
* });
|
||||
* console.log("Address:", wallet.address); // prints the bech32 address
|
||||
*
|
||||
* // Sign an arbitrary message
|
||||
* const { signature } = await wallet.signArbitrary("Hello from @sonr.io/es!");
|
||||
* console.log("Signature:", signature);
|
||||
*
|
||||
* // Sign and broadcast a tx
|
||||
* const unsignedTx = { msgs: [...], memo: "Hello Cosmos!", timeoutHeight: 0n };
|
||||
* const res = await wallet.broadcastTxSync(unsignedTx, 1.4); // Uses 1.4x fee multiplier
|
||||
* console.log("Tx result:", res);
|
||||
* ```
|
||||
*/
|
||||
export class MnemonicWallet extends ConnectedWallet {
|
||||
public readonly publicKey: string;
|
||||
public readonly privateKey: Uint8Array;
|
||||
public readonly keyType: 'secp256k1' | 'ethsecp256k1';
|
||||
|
||||
constructor({
|
||||
mnemonic,
|
||||
bech32Prefix,
|
||||
coinType,
|
||||
index,
|
||||
chainId,
|
||||
gasPrice,
|
||||
rpc,
|
||||
}: ConnectMnemonicWalletOptions) {
|
||||
const { publicKey, privateKey } = resolveKeyPair(mnemonic, {
|
||||
coinType,
|
||||
index,
|
||||
});
|
||||
const keyType =
|
||||
chainId.startsWith('injective') || chainId.startsWith('dymension')
|
||||
? 'ethsecp256k1'
|
||||
: 'secp256k1';
|
||||
const address = resolveBech32Address(publicKey, bech32Prefix, keyType);
|
||||
super(
|
||||
// We typecast here instead of adding "mnemonic" to `WalletName` and
|
||||
// `WalletType` as this wallet is considered a special wallet that is
|
||||
// unlikely to be used by most consumers of @sonr.io/es.
|
||||
'mnemonic' as WalletName,
|
||||
'mnemonic' as WalletType,
|
||||
undefined,
|
||||
chainId,
|
||||
new Secp256k1PubKey({
|
||||
chainId,
|
||||
key: publicKey as any,
|
||||
}),
|
||||
address,
|
||||
rpc,
|
||||
gasPrice
|
||||
);
|
||||
this.publicKey = base64.encode(publicKey);
|
||||
this.privateKey = privateKey;
|
||||
this.keyType = keyType;
|
||||
}
|
||||
|
||||
public async signArbitrary(data: string): Promise<SignArbitraryResponse> {
|
||||
// This sign doc follows ADR 036 specs.
|
||||
// See: https://github.com/cosmos/cosmos-sdk/blob/main/docs/architecture/adr-036-arbitrary-signature.md
|
||||
const doc: StdSignDoc = {
|
||||
chain_id: '',
|
||||
account_number: '0',
|
||||
sequence: '0',
|
||||
fee: {
|
||||
gas: '0',
|
||||
amount: [],
|
||||
},
|
||||
msgs: [
|
||||
{
|
||||
type: 'sign/MsgSignData',
|
||||
value: {
|
||||
signer: this.address,
|
||||
data: base64.encode(utf8.decode(data)),
|
||||
},
|
||||
},
|
||||
],
|
||||
memo: '',
|
||||
};
|
||||
const signature = signAmino(doc, this.privateKey, this.keyType);
|
||||
return {
|
||||
data,
|
||||
pubKey: this.publicKey,
|
||||
signature: base64.encode(signature),
|
||||
};
|
||||
}
|
||||
|
||||
public async signAndBroadcastTx(
|
||||
{ msgs, memo, timeoutHeight }: UnsignedTx,
|
||||
fee: Fee,
|
||||
accountNumber: bigint,
|
||||
sequence: bigint
|
||||
): Promise<string> {
|
||||
const tx = new Tx({
|
||||
chainId: this.chainId,
|
||||
pubKey: this.pubKey,
|
||||
msgs: msgs,
|
||||
});
|
||||
const doc = tx.toSignDoc({
|
||||
accountNumber,
|
||||
sequence,
|
||||
fee,
|
||||
memo,
|
||||
timeoutHeight,
|
||||
});
|
||||
const signature = signDirect(doc, this.privateKey, this.keyType);
|
||||
return RpcClient.broadcastTx(this.rpc, tx.toSignedDirect(doc, signature));
|
||||
}
|
||||
}
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
import { Window as KeplrWindow } from "@sonr.io/es/registry";
|
||||
|
||||
import { Window as CompassWindow } from "./compass/types";
|
||||
import { Window as CosmostationWindow } from "./cosmostation/types";
|
||||
import { Window as LeapWindow } from "./leap/types";
|
||||
import { Window as EthereumWindow } from "./metamask-injective/types";
|
||||
import { Window as NinjiWindow } from "./ninji/types";
|
||||
import { Window as OWalletWindow } from "./owallet/types";
|
||||
import { Window as StationWindow } from "./station/types";
|
||||
|
||||
declare global {
|
||||
interface Window
|
||||
extends KeplrWindow,
|
||||
CosmostationWindow,
|
||||
StationWindow,
|
||||
LeapWindow,
|
||||
CompassWindow,
|
||||
EthereumWindow,
|
||||
NinjiWindow,
|
||||
OWalletWindow {}
|
||||
}
|
||||
Reference in New Issue
Block a user