@bigmi/client
Version:
Reactive primitives for Bitcoin apps.
107 lines (106 loc) • 3.9 kB
JavaScript
import { ConnectorChainIdDetectionError, ProviderNotFoundError as ProviderNotFoundError$1 } from "../errors/connectors.js";
import { createConnector } from "../factories/createConnector.js";
import { AddressType, BaseError, MethodNotSupportedRpcError, UserRejectedRequestError, base64ToHex, getAddressChainId, hexToBase64 } from "@bigmi/core";
//#region src/connectors/dynamic.ts
function dynamic(parameters) {
const { chainId, shimDisconnect = true, wallet } = parameters;
let accountChanged;
return createConnector((config) => ({
id: wallet.connector.providerId,
name: wallet.connector.name,
type: dynamic.type,
icon: wallet.connector._metadata?.icon,
emitter: config.emitter,
async isAuthorized() {
return wallet.isAuthenticated;
},
async request({ method, params }) {
switch (method) {
case "signPsbt": try {
const { psbt, ...options } = params;
const allowedSighash = options.inputsToSign.map((input) => Number(input.sigHash));
const psbtBase64 = hexToBase64(psbt);
const response = await wallet.signPsbt({
allowedSighash,
unsignedPsbtBase64: psbtBase64,
signature: options.inputsToSign
});
if (!response) throw new Error("Error signing the transaction");
const { signedPsbt } = response;
return base64ToHex(signedPsbt);
} catch (error) {
throw new UserRejectedRequestError(error.message);
}
default: throw new MethodNotSupportedRpcError();
}
},
async setup() {},
async getProvider() {
const internalProvider = await this.getInternalProvider();
if (!internalProvider) throw new ProviderNotFoundError$1();
return { request: this.request.bind(internalProvider) };
},
async connect() {
if (!wallet.connector) throw new Error("DynamicWalletConnector not defined");
try {
const accounts = await this.getAccounts();
const chainId = getAddressChainId(accounts[0].address);
if (!accountChanged) {
accountChanged = this.onAccountsChanged.bind(this);
wallet.connector.addListener("accountChange", ({ accounts }) => accountChanged?.(accounts));
}
if (shimDisconnect) await Promise.all([config.storage?.setItem(`${this.id}.connected`, true), config.storage?.removeItem(`${this.id}.disconnected`)]);
return {
accounts,
chainId
};
} catch (error) {
throw new UserRejectedRequestError(error.message);
}
},
async disconnect() {
const provider = wallet.connector;
if (accountChanged) {
provider.removeListener("accountChange", ({ accounts }) => accountChanged?.(accounts));
accountChanged = void 0;
}
if (shimDisconnect) await Promise.all([config.storage?.setItem(`${this.id}.disconnected`, true), config.storage?.removeItem(`${this.id}.connected`)]);
},
async getAccounts() {
const account = wallet.additionalAddresses.find((wallet) => wallet.type === "payment");
if (!account) throw new BaseError("Please connect a wallet with a segwit address");
return [{
address: account.address,
publicKey: account.publicKey,
addressType: AddressType.p2pkh,
purpose: account.type
}];
},
async getChainId() {
if (chainId) return chainId;
const accounts = await this.getAccounts();
if (accounts.length === 0) throw new ConnectorChainIdDetectionError({ connector: this.name });
return getAddressChainId(accounts[0].address);
},
async getInternalProvider() {
return wallet.connector;
},
async onAccountsChanged(accounts) {
if (accounts.length === 0) this.onDisconnect();
else {
const newAccounts = await this.getAccounts();
config.emitter.emit("change", { accounts: newAccounts });
}
},
onChainChanged(chainId) {
config.emitter.emit("change", { chainId });
},
async onDisconnect(_error) {
config.emitter.emit("disconnect");
}
}));
}
dynamic.type = "UTXO";
//#endregion
export { dynamic };
//# sourceMappingURL=dynamic.js.map