${data.resources
.map(
(resource) => `
Service: ${
resource.service
}
Name: ${name}
Identifier: ${
resource.identifier
}
${
resource.filename
? `
Filename: ${resource.filename}
`
: ''
}
`
)
.join('')}
Total Unlocking Fee:
${(+buyingFees?.unlock?.fee * atAddresses?.length)?.toFixed(8)} ${buyingFees.ticker}
This fee is an estimate based on ${atAddresses?.length} ${atAddresses?.length > 1 ? 'orders' : 'order'}, assuming a 300-byte size at a rate of ${buyingFees?.unlock?.feePerKb?.toFixed(8)} ${buyingFees.ticker} per KB.
Total Locking Fee:
${+buyingFees?.lock.fee.toFixed(8)} ${buyingFees.ticker} per kb
`,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const resBuyOrder = await createBuyOrderTx({
crosschainAtInfo,
isGateway,
foreignBlockchain,
});
return resBuyOrder;
} else {
throw new Error('User declined request');
}
} catch (error) {
throw new Error(error?.message || 'Failed to submit trade order.');
}
};
const cancelTradeOfferTradeBot = async (body, keyPair) => {
const txn = new DeleteTradeOffer().createTransaction(body);
const url = await createEndpoint(`/crosschain/tradeoffer`);
const bodyToString = JSON.stringify(txn);
const deleteTradeBotResponse = await fetch(url, {
method: 'DELETE',
headers: {
'Content-Type': 'application/json',
},
body: bodyToString,
});
if (!deleteTradeBotResponse.ok) throw new Error('Unable to update tradebot');
const unsignedTxn = await deleteTradeBotResponse.text();
const signedTxnBytes = await signTradeBotTransaction(unsignedTxn, keyPair);
const signedBytes = Base58.encode(signedTxnBytes);
let res;
try {
res = await processTransactionVersion2(signedBytes);
} catch (error) {
return {
error: 'Failed to Cancel Sell Order. Try again!',
failedTradeBot: {
atAddress: body.atAddress,
creatorAddress: body.creatorAddress,
},
};
}
if (res?.error) {
return {
error: 'Failed to Cancel Sell Order. Try again!',
failedTradeBot: {
atAddress: body.atAddress,
creatorAddress: body.creatorAddress,
},
};
}
if (res?.signature) {
return res;
} else {
throw new Error('Failed to Cancel Sell Order. Try again!');
}
};
const findFailedTradebot = async (createBotCreationTimestamp, body) => {
//wait 5 secs
const wallet = await getSaveWallet();
const address = wallet.address0;
await new Promise((res) => {
setTimeout(() => {
res(null);
}, 5000);
});
const url = await createEndpoint(
`/crosschain/tradebot?foreignBlockchain=LITECOIN`
);
const tradeBotsReponse = await fetch(url, {
method: 'GET',
headers: {
'Content-Type': 'application/json',
},
});
const data = await tradeBotsReponse.json();
const latestItem2 = data
.filter((item) => item.creatorAddress === address)
.sort((a, b) => b.timestamp - a.timestamp)[0];
const latestItem = data
.filter(
(item) =>
item.creatorAddress === address &&
+item.foreignAmount === +body.foreignAmount
)
.sort((a, b) => b.timestamp - a.timestamp)[0];
if (
latestItem &&
createBotCreationTimestamp - latestItem.timestamp <= 5000 &&
createBotCreationTimestamp > latestItem.timestamp // Ensure latestItem's timestamp is before createBotCreationTimestamp
) {
return latestItem;
} else {
return null;
}
};
const tradeBotCreateRequest = async (body, keyPair) => {
const txn = new TradeBotCreateRequest().createTransaction(body);
const url = await createEndpoint(`/crosschain/tradebot/create`);
const bodyToString = JSON.stringify(txn);
const unsignedTxnResponse = await fetch(url, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: bodyToString,
});
if (!unsignedTxnResponse.ok) throw new Error('Unable to create tradebot');
const createBotCreationTimestamp = Date.now();
const unsignedTxn = await unsignedTxnResponse.text();
const signedTxnBytes = await signTradeBotTransaction(unsignedTxn, keyPair);
const signedBytes = Base58.encode(signedTxnBytes);
let res;
try {
res = await processTransactionVersion2(signedBytes);
} catch (error) {
const findFailedTradeBot = await findFailedTradebot(
createBotCreationTimestamp,
body
);
return {
error: 'Failed to Create Sell Order. Try again!',
failedTradeBot: findFailedTradeBot,
};
}
if (res?.signature) {
return res;
} else {
throw new Error('Failed to Create Sell Order. Try again!');
}
};
export const createSellOrder = async (data, isFromExtension) => {
const requiredFields = ['qortAmount', 'foreignBlockchain', 'foreignAmount'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (!data[field]) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const parsedForeignAmount = Number(data.foreignAmount)?.toFixed(8);
const receivingAddress = await getUserWalletFunc(data.foreignBlockchain);
try {
const resPermission = await getUserPermission(
{
text1:
'Do you give this application permission to perform a sell order?',
text2: `${data.qortAmount}${' '}
${`QORT`}`,
text3: `FOR ${parsedForeignAmount} ${data.foreignBlockchain}`,
fee: '0.02',
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const resKeyPair = await getKeyPair();
const parsedData = resKeyPair;
const userPublicKey = parsedData.publicKey;
const uint8PrivateKey = Base58.decode(parsedData.privateKey);
const uint8PublicKey = Base58.decode(parsedData.publicKey);
const keyPair = {
privateKey: uint8PrivateKey,
publicKey: uint8PublicKey,
};
const response = await tradeBotCreateRequest(
{
creatorPublicKey: userPublicKey,
qortAmount: parseFloat(data.qortAmount),
fundingQortAmount: parseFloat(data.qortAmount) + 0.01,
foreignBlockchain: data.foreignBlockchain,
foreignAmount: parseFloat(parsedForeignAmount),
tradeTimeout: 120,
receivingAddress: receivingAddress.address,
},
keyPair
);
return response;
} else {
throw new Error('User declined request');
}
} catch (error) {
throw new Error(error?.message || 'Failed to submit sell order.');
}
};
export const cancelSellOrder = async (data, isFromExtension) => {
const requiredFields = ['atAddress'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (!data[field]) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const url = await createEndpoint(`/crosschain/trade/${data.atAddress}`);
const resAddress = await fetch(url);
const resData = await resAddress.json();
if (!resData?.qortalAtAddress) throw new Error('Cannot find AT info.');
try {
const fee = await getFee('MESSAGE');
const resPermission = await getUserPermission(
{
text1:
'Do you give this application permission to perform: cancel a sell order?',
text2: `${resData.qortAmount}${' '}
${`QORT`}`,
text3: `FOR ${resData.expectedForeignAmount} ${resData.foreignBlockchain}`,
fee: fee.fee,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const resKeyPair = await getKeyPair();
const parsedData = resKeyPair;
const userPublicKey = parsedData.publicKey;
const uint8PrivateKey = Base58.decode(parsedData.privateKey);
const uint8PublicKey = Base58.decode(parsedData.publicKey);
const keyPair = {
privateKey: uint8PrivateKey,
publicKey: uint8PublicKey,
};
const response = await cancelTradeOfferTradeBot(
{
creatorPublicKey: userPublicKey,
atAddress: data.atAddress,
},
keyPair
);
return response;
} else {
throw new Error('User declined request');
}
} catch (error) {
throw new Error(error?.message || 'Failed to submit sell order.');
}
};
export const openNewTab = async (data, isFromExtension) => {
const requiredFields = ['qortalLink'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (!data[field]) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const res = extractComponents(data.qortalLink);
if (res) {
const { service, name, identifier, path } = res;
if (!service && !name) throw new Error('Invalid qortal link');
executeEvent('addTab', { data: { service, name, identifier, path } });
executeEvent('open-apps-mode', {});
return true;
} else {
throw new Error('Invalid qortal link');
}
};
export const adminAction = async (data, isFromExtension) => {
const requiredFields = ['type'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (!data[field]) {
missingFields.push(field);
}
});
// For actions that require a value, check for 'value' field
const actionsRequiringValue = [
'addpeer',
'removepeer',
'forcesync',
'addmintingaccount',
'removemintingaccount',
];
if (actionsRequiringValue.includes(data.type.toLowerCase()) && !data.value) {
missingFields.push('value');
}
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const isGateway = await isRunningGateway();
if (isGateway) {
throw new Error('This action cannot be done through a public node');
}
let apiEndpoint = '';
let method = 'GET'; // Default method
let includeValueInBody = false;
switch (data.type.toLowerCase()) {
case 'stop':
apiEndpoint = await createEndpoint('/admin/stop');
break;
case 'restart':
apiEndpoint = await createEndpoint('/admin/restart');
break;
case 'bootstrap':
apiEndpoint = await createEndpoint('/admin/bootstrap');
break;
case 'addmintingaccount':
apiEndpoint = await createEndpoint('/admin/mintingaccounts');
method = 'POST';
includeValueInBody = true;
break;
case 'removemintingaccount':
apiEndpoint = await createEndpoint('/admin/mintingaccounts');
method = 'DELETE';
includeValueInBody = true;
break;
case 'forcesync':
apiEndpoint = await createEndpoint('/admin/forcesync');
method = 'POST';
includeValueInBody = true;
break;
case 'addpeer':
apiEndpoint = await createEndpoint('/peers');
method = 'POST';
includeValueInBody = true;
break;
case 'removepeer':
apiEndpoint = await createEndpoint('/peers');
method = 'DELETE';
includeValueInBody = true;
break;
default:
throw new Error(`Unknown admin action type: ${data.type}`);
}
// Prepare the permission prompt text
let permissionText = `Do you give this application permission to perform the admin action: ${data.type}`;
if (data.value) {
permissionText += ` with value: ${data.value}`;
}
const resPermission = await getUserPermission(
{
text1: permissionText,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
// Set up options for the API call
const options: RequestInit = {
method: method,
headers: {},
};
if (includeValueInBody) {
options.headers['Content-Type'] = 'text/plain';
options.body = data.value;
}
const response = await fetch(apiEndpoint, options);
if (!response.ok) throw new Error('Failed to perform request');
let res;
try {
res = await response.clone().json();
} catch (e) {
res = await response.text();
}
return res;
} else {
throw new Error('User declined request');
}
};
export const signTransaction = async (data, isFromExtension) => {
const requiredFields = ['unsignedBytes'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (!data[field]) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const shouldProcess = data?.process || false;
let _url = await createEndpoint(
'/transactions/decode?ignoreValidityChecks=false'
);
let _body = data.unsignedBytes;
const response = await fetch(_url, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: _body,
});
if (!response.ok) throw new Error('Failed to decode transaction');
const decodedData = await response.json();
const resPermission = await getUserPermission(
{
text1: `Do you give this application permission to ${shouldProcess ? 'SIGN and PROCESS' : 'SIGN'} a transaction?`,
highlightedText: 'Read the transaction carefully before accepting!',
text2: `Tx type: ${decodedData.type}`,
json: decodedData,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
let urlConverted = await createEndpoint('/transactions/convert');
const responseConverted = await fetch(urlConverted, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: data.unsignedBytes,
});
const resKeyPair = await getKeyPair();
const parsedData = resKeyPair;
const uint8PrivateKey = Base58.decode(parsedData.privateKey);
const uint8PublicKey = Base58.decode(parsedData.publicKey);
const keyPair = {
privateKey: uint8PrivateKey,
publicKey: uint8PublicKey,
};
const convertedBytes = await responseConverted.text();
const txBytes = Base58.decode(data.unsignedBytes);
const _arbitraryBytesBuffer = Object.keys(txBytes).map(function (key) {
return txBytes[key];
});
const arbitraryBytesBuffer = new Uint8Array(_arbitraryBytesBuffer);
const txByteSigned = Base58.decode(convertedBytes);
const _bytesForSigningBuffer = Object.keys(txByteSigned).map(
function (key) {
return txByteSigned[key];
}
);
const bytesForSigningBuffer = new Uint8Array(_bytesForSigningBuffer);
const signature = nacl.sign.detached(
bytesForSigningBuffer,
keyPair.privateKey
);
const signedBytes = utils.appendBuffer(arbitraryBytesBuffer, signature);
const signedBytesToBase58 = Base58.encode(signedBytes);
if (!shouldProcess) {
return signedBytesToBase58;
}
const res = await processTransactionVersion2(signedBytesToBase58);
if (!res?.signature)
throw new Error(
res?.message || 'Transaction was not able to be processed'
);
return res;
} else {
throw new Error('User declined request');
}
};
const missingFieldsFunc = (data, requiredFields) => {
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (!data[field]) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
};
const encode = (value) => encodeURIComponent(value.trim()); // Helper to encode values
const buildQueryParams = (data) => {
const allowedParams = [
'name',
'service',
'identifier',
'mimeType',
'fileName',
'encryptionType',
'key',
];
return Object.entries(data)
.map(([key, value]) => {
if (
value === undefined ||
value === null ||
value === false ||
!allowedParams.includes(key)
)
return null; // Skip null, undefined, or false
if (typeof value === 'boolean') return `${key}=${value}`; // Handle boolean values
return `${key}=${encode(value)}`; // Encode other values
})
.filter(Boolean) // Remove null values
.join('&'); // Join with `&`
};
export const createAndCopyEmbedLink = async (data, isFromExtension) => {
const requiredFields = ['type'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (!data[field]) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
switch (data.type) {
case 'POLL': {
missingFieldsFunc(data, ['type', 'name']);
const queryParams = [
`name=${encode(data.name)}`,
data.ref ? `ref=${encode(data.ref)}` : null, // Add only if ref exists
]
.filter(Boolean) // Remove null values
.join('&'); // Join with `&`
const link = `qortal://use-embed/POLL?${queryParams}`;
try {
await navigator.clipboard.writeText(link);
} catch (error) {
throw new Error('Failed to copy to clipboard.');
}
return link;
}
case 'IMAGE':
case 'ATTACHMENT': {
missingFieldsFunc(data, ['type', 'name', 'service', 'identifier']);
if (data?.encryptionType === 'private' && !data?.key) {
throw new Error(
'For an encrypted resource, you must provide the key to create the shared link'
);
}
const queryParams = buildQueryParams(data);
const link = `qortal://use-embed/${data.type}?${queryParams}`;
try {
await navigator.clipboard.writeText(link);
} catch (error) {
throw new Error('Failed to copy to clipboard.');
}
return link;
}
default:
throw new Error('Invalid type');
}
};
export const registerNameRequest = async (data, isFromExtension) => {
const requiredFields = ['name'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (!data[field]) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const fee = await getFee('REGISTER_NAME');
const resPermission = await getUserPermission(
{
text1: `Do you give this application permission to register this name?`,
highlightedText: data.name,
text2: data?.description,
fee: fee.fee,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const name = data.name;
const description = data?.description || '';
const response = await registerName({ name, description });
return response;
} else {
throw new Error('User declined request');
}
};
export const updateNameRequest = async (data, isFromExtension) => {
const requiredFields = ['newName', 'oldName'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (!data[field]) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const oldName = data.oldName;
const newName = data.newName;
const description = data?.description || '';
const fee = await getFee('UPDATE_NAME');
const resPermission = await getUserPermission(
{
text1: `Do you give this application permission to register this name?`,
highlightedText: data.newName,
text2: data?.description,
fee: fee.fee,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const response = await updateName({ oldName, newName, description });
return response;
} else {
throw new Error('User declined request');
}
};
export const leaveGroupRequest = async (data, isFromExtension) => {
const requiredFields = ['groupId'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (!data[field]) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const groupId = data.groupId;
let groupInfo = null;
try {
const url = await createEndpoint(`/groups/${groupId}`);
const response = await fetch(url);
if (!response.ok) throw new Error('Failed to fetch group');
groupInfo = await response.json();
} catch (error) {
const errorMsg = (error && error.message) || 'Group not found';
throw new Error(errorMsg);
}
const fee = await getFee('LEAVE_GROUP');
const resPermission = await getUserPermission(
{
text1: `Do you give this application permission to leave the following group?`,
highlightedText: `${groupInfo.groupName}`,
fee: fee.fee,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const response = await leaveGroup({ groupId });
return response;
} else {
throw new Error('User declined request');
}
};
export const inviteToGroupRequest = async (data, isFromExtension) => {
const requiredFields = ['groupId', 'inviteTime', 'inviteeAddress'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (!data[field]) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const groupId = data.groupId;
const qortalAddress = data?.inviteeAddress;
const inviteTime = data?.inviteTime;
let groupInfo = null;
try {
const url = await createEndpoint(`/groups/${groupId}`);
const response = await fetch(url);
if (!response.ok) throw new Error('Failed to fetch group');
groupInfo = await response.json();
} catch (error) {
const errorMsg = (error && error.message) || 'Group not found';
throw new Error(errorMsg);
}
const displayInvitee = await getNameInfoForOthers(qortalAddress);
const fee = await getFee('GROUP_INVITE');
const resPermission = await getUserPermission(
{
text1: `Do you give this application permission to invite ${displayInvitee || qortalAddress}?`,
highlightedText: `Group: ${groupInfo.groupName}`,
fee: fee.fee,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const response = await inviteToGroup({
groupId,
qortalAddress,
inviteTime,
});
return response;
} else {
throw new Error('User declined request');
}
};
export const kickFromGroupRequest = async (data, isFromExtension) => {
const requiredFields = ['groupId', 'qortalAddress'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (!data[field]) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const groupId = data.groupId;
const qortalAddress = data?.qortalAddress;
const reason = data?.reason;
let groupInfo = null;
try {
const url = await createEndpoint(`/groups/${groupId}`);
const response = await fetch(url);
if (!response.ok) throw new Error('Failed to fetch group');
groupInfo = await response.json();
} catch (error) {
const errorMsg = (error && error.message) || 'Group not found';
throw new Error(errorMsg);
}
const displayInvitee = await getNameInfoForOthers(qortalAddress);
const fee = await getFee('GROUP_KICK');
const resPermission = await getUserPermission(
{
text1: `Do you give this application permission to kick ${displayInvitee || qortalAddress} from the group?`,
highlightedText: `Group: ${groupInfo.groupName}`,
fee: fee.fee,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const response = await kickFromGroup({
groupId,
qortalAddress,
rBanReason: reason,
});
return response;
} else {
throw new Error('User declined request');
}
};
export const banFromGroupRequest = async (data, isFromExtension) => {
const requiredFields = ['groupId', 'qortalAddress'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (!data[field]) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const groupId = data.groupId;
const qortalAddress = data?.qortalAddress;
const rBanTime = data?.banTime;
const reason = data?.reason;
let groupInfo = null;
try {
const url = await createEndpoint(`/groups/${groupId}`);
const response = await fetch(url);
if (!response.ok) throw new Error('Failed to fetch group');
groupInfo = await response.json();
} catch (error) {
const errorMsg = (error && error.message) || 'Group not found';
throw new Error(errorMsg);
}
const displayInvitee = await getNameInfoForOthers(qortalAddress);
const fee = await getFee('GROUP_BAN');
const resPermission = await getUserPermission(
{
text1: `Do you give this application permission to ban ${displayInvitee || qortalAddress} from the group?`,
highlightedText: `Group: ${groupInfo.groupName}`,
fee: fee.fee,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const response = await banFromGroup({
groupId,
qortalAddress,
rBanTime,
rBanReason: reason,
});
return response;
} else {
throw new Error('User declined request');
}
};
export const cancelGroupBanRequest = async (data, isFromExtension) => {
const requiredFields = ['groupId', 'qortalAddress'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (!data[field]) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const groupId = data.groupId;
const qortalAddress = data?.qortalAddress;
let groupInfo = null;
try {
const url = await createEndpoint(`/groups/${groupId}`);
const response = await fetch(url);
if (!response.ok) throw new Error('Failed to fetch group');
groupInfo = await response.json();
} catch (error) {
const errorMsg = (error && error.message) || 'Group not found';
throw new Error(errorMsg);
}
const displayInvitee = await getNameInfoForOthers(qortalAddress);
const fee = await getFee('CANCEL_GROUP_BAN');
const resPermission = await getUserPermission(
{
text1: `Do you give this application permission to cancel the group ban for user ${displayInvitee || qortalAddress}?`,
highlightedText: `Group: ${groupInfo.groupName}`,
fee: fee.fee,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const response = await cancelBan({
groupId,
qortalAddress,
});
return response;
} else {
throw new Error('User declined request');
}
};
export const addGroupAdminRequest = async (data, isFromExtension) => {
const requiredFields = ['groupId', 'qortalAddress'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (!data[field]) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const groupId = data.groupId;
const qortalAddress = data?.qortalAddress;
let groupInfo = null;
try {
const url = await createEndpoint(`/groups/${groupId}`);
const response = await fetch(url);
if (!response.ok) throw new Error('Failed to fetch group');
groupInfo = await response.json();
} catch (error) {
const errorMsg = (error && error.message) || 'Group not found';
throw new Error(errorMsg);
}
const displayInvitee = await getNameInfoForOthers(qortalAddress);
const fee = await getFee('ADD_GROUP_ADMIN');
const resPermission = await getUserPermission(
{
text1: `Do you give this application permission to add user ${displayInvitee || qortalAddress} as an admin?`,
highlightedText: `Group: ${groupInfo.groupName}`,
fee: fee.fee,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const response = await makeAdmin({
groupId,
qortalAddress,
});
return response;
} else {
throw new Error('User declined request');
}
};
export const removeGroupAdminRequest = async (data, isFromExtension) => {
const requiredFields = ['groupId', 'qortalAddress'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (!data[field]) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const groupId = data.groupId;
const qortalAddress = data?.qortalAddress;
let groupInfo = null;
try {
const url = await createEndpoint(`/groups/${groupId}`);
const response = await fetch(url);
if (!response.ok) throw new Error('Failed to fetch group');
groupInfo = await response.json();
} catch (error) {
const errorMsg = (error && error.message) || 'Group not found';
throw new Error(errorMsg);
}
const displayInvitee = await getNameInfoForOthers(qortalAddress);
const fee = await getFee('REMOVE_GROUP_ADMIN');
const resPermission = await getUserPermission(
{
text1: `Do you give this application permission to remove user ${displayInvitee || qortalAddress} as admin?`,
highlightedText: `Group: ${groupInfo.groupName}`,
fee: fee.fee,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const response = await removeAdmin({
groupId,
qortalAddress,
});
return response;
} else {
throw new Error('User declined request');
}
};
export const cancelGroupInviteRequest = async (data, isFromExtension) => {
const requiredFields = ['groupId', 'qortalAddress'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (!data[field]) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const groupId = data.groupId;
const qortalAddress = data?.qortalAddress;
let groupInfo = null;
try {
const url = await createEndpoint(`/groups/${groupId}`);
const response = await fetch(url);
if (!response.ok) throw new Error('Failed to fetch group');
groupInfo = await response.json();
} catch (error) {
const errorMsg = (error && error.message) || 'Group not found';
throw new Error(errorMsg);
}
const displayInvitee = await getNameInfoForOthers(qortalAddress);
const fee = await getFee('CANCEL_GROUP_INVITE');
const resPermission = await getUserPermission(
{
text1: `Do you give this application permission to cancel the group invite for ${displayInvitee || qortalAddress}?`,
highlightedText: `Group: ${groupInfo.groupName}`,
fee: fee.fee,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const response = await cancelInvitationToGroup({
groupId,
qortalAddress,
});
return response;
} else {
throw new Error('User declined request');
}
};
export const createGroupRequest = async (data, isFromExtension) => {
const requiredFields = [
'groupId',
'qortalAddress',
'groupName',
'type',
'approvalThreshold',
'minBlock',
'maxBlock',
];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (data[field] !== undefined && data[field] !== null) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const groupName = data.groupName;
const description = data?.description || '';
const type = +data.type;
const approvalThreshold = +data?.approvalThreshold;
const minBlock = +data?.minBlock;
const maxBlock = +data.maxBlock;
const fee = await getFee('CREATE_GROUP');
const resPermission = await getUserPermission(
{
text1: `Do you give this application permission to create a group?`,
highlightedText: `Group name: ${groupName}`,
fee: fee.fee,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const response = await createGroup({
groupName,
groupDescription: description,
groupType: type,
groupApprovalThreshold: approvalThreshold,
minBlock,
maxBlock,
});
return response;
} else {
throw new Error('User declined request');
}
};
export const updateGroupRequest = async (data, isFromExtension) => {
const requiredFields = [
'groupId',
'newOwner',
'type',
'approvalThreshold',
'minBlock',
'maxBlock',
];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (data[field] !== undefined && data[field] !== null) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const groupId = +data.groupId;
const newOwner = data.newOwner;
const description = data?.description || '';
const type = +data.type;
const approvalThreshold = +data?.approvalThreshold;
const minBlock = +data?.minBlock;
const maxBlock = +data.maxBlock;
let groupInfo = null;
try {
const url = await createEndpoint(`/groups/${groupId}`);
const response = await fetch(url);
if (!response.ok) throw new Error('Failed to fetch group');
groupInfo = await response.json();
} catch (error) {
const errorMsg = (error && error.message) || 'Group not found';
throw new Error(errorMsg);
}
const displayInvitee = await getNameInfoForOthers(newOwner);
const fee = await getFee('CREATE_GROUP');
const resPermission = await getUserPermission(
{
text1: `Do you give this application permission to update this group?`,
text2: `New owner: ${displayInvitee || newOwner}`,
highlightedText: `Group: ${groupInfo.groupName}`,
fee: fee.fee,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const response = await updateGroup({
groupId,
newOwner,
newIsOpen: type,
newDescription: description,
newApprovalThreshold: approvalThreshold,
newMinimumBlockDelay: minBlock,
newMaximumBlockDelay: maxBlock,
});
return response;
} else {
throw new Error('User declined request');
}
};
export const decryptAESGCMRequest = async (data, isFromExtension) => {
const requiredFields = ['encryptedData', 'iv', 'senderPublicKey'];
requiredFields.forEach((field) => {
if (!data[field]) {
throw new Error(`Missing required field: ${field}`);
}
});
const encryptedData = data.encryptedData;
const iv = data.iv;
const senderPublicKeyBase58 = data.senderPublicKey;
// Decode keys and IV
const senderPublicKey = Base58.decode(senderPublicKeyBase58);
const resKeyPair = await getKeyPair(); // Assume this retrieves the current user's keypair
const uint8PrivateKey = Base58.decode(resKeyPair.privateKey);
// Convert ed25519 keys to Curve25519
const convertedPrivateKey = ed2curve.convertSecretKey(uint8PrivateKey);
const convertedPublicKey = ed2curve.convertPublicKey(senderPublicKey);
// Generate shared secret
const sharedSecret = new Uint8Array(32);
nacl.lowlevel.crypto_scalarmult(
sharedSecret,
convertedPrivateKey,
convertedPublicKey
);
// Derive encryption key
const encryptionKey: Uint8Array = new Sha256()
.process(sharedSecret)
.finish().result;
// Convert IV and ciphertext from Base64
const base64ToUint8Array = (base64) =>
Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
const ivUint8Array = base64ToUint8Array(iv);
const ciphertext = base64ToUint8Array(encryptedData);
// Validate IV and key lengths
if (ivUint8Array.length !== 12) {
throw new Error('Invalid IV: AES-GCM requires a 12-byte IV.');
}
if (encryptionKey.length !== 32) {
throw new Error('Invalid key: AES-GCM requires a 256-bit key.');
}
try {
// Decrypt data
const algorithm = { name: 'AES-GCM', iv: ivUint8Array };
const cryptoKey = await crypto.subtle.importKey(
'raw',
encryptionKey,
algorithm,
false,
['decrypt']
);
const decryptedArrayBuffer = await crypto.subtle.decrypt(
algorithm,
cryptoKey,
ciphertext
);
// Return decrypted data as Base64
return uint8ArrayToBase64(new Uint8Array(decryptedArrayBuffer));
} catch (error) {
console.error('Decryption failed:', error);
throw new Error(
'Failed to decrypt the message. Ensure the data and keys are correct.'
);
}
};
export const sellNameRequest = async (data, isFromExtension) => {
const requiredFields = ['salePrice', 'nameForSale'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (data[field] !== undefined && data[field] !== null) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const name = data.nameForSale;
const sellPrice = +data.salePrice;
const validApi = await getBaseApi();
const response = await fetch(validApi + '/names/' + name);
const nameData = await response.json();
if (!nameData) throw new Error('This name does not exist');
if (nameData?.isForSale) throw new Error('This name is already for sale');
const fee = await getFee('SELL_NAME');
const resPermission = await getUserPermission(
{
text1: `Do you give this application permission to create a sell name transaction?`,
highlightedText: `Sell ${name} for ${sellPrice} QORT`,
fee: fee.fee,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const response = await sellName({
name,
sellPrice,
});
return response;
} else {
throw new Error('User declined request');
}
};
export const cancelSellNameRequest = async (data, isFromExtension) => {
const requiredFields = ['nameForSale'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (data[field] !== undefined && data[field] !== null) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const name = data.nameForSale;
const validApi = await getBaseApi();
const response = await fetch(validApi + '/names/' + name);
const nameData = await response.json();
if (!nameData?.isForSale) throw new Error('This name is not for sale');
const fee = await getFee('CANCEL_SELL_NAME');
const resPermission = await getUserPermission(
{
text1: `Do you give this application permission to cancel the selling of a name?`,
highlightedText: `Name: ${name}`,
fee: fee.fee,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const response = await cancelSellName({
name,
});
return response;
} else {
throw new Error('User declined request');
}
};
export const buyNameRequest = async (data, isFromExtension) => {
const requiredFields = ['nameForSale'];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (data[field] !== undefined && data[field] !== null) {
missingFields.push(field);
}
});
if (missingFields.length > 0) {
const missingFieldsString = missingFields.join(', ');
const errorMsg = `Missing fields: ${missingFieldsString}`;
throw new Error(errorMsg);
}
const name = data.nameForSale;
const validApi = await getBaseApi();
const response = await fetch(validApi + '/names/' + name);
const nameData = await response.json();
if (!nameData?.isForSale) throw new Error('This name is not for sale');
const sellerAddress = nameData.owner;
const sellPrice = +nameData.salePrice;
const fee = await getFee('BUY_NAME');
const resPermission = await getUserPermission(
{
text1: `Do you give this application permission to buy a name?`,
highlightedText: `Buying ${name} for ${sellPrice} QORT`,
fee: fee.fee,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const response = await buyName({
name,
sellerAddress,
sellPrice,
});
return response;
} else {
throw new Error('User declined request');
}
};
export const signForeignFees = async (data, isFromExtension) => {
const resPermission = await getUserPermission(
{
text1: `Do you give this application permission to sign the required fees for all your trade offers?`,
},
isFromExtension
);
const { accepted } = resPermission;
if (accepted) {
const wallet = await getSaveWallet();
const address = wallet.address0;
const resKeyPair = await getKeyPair();
const parsedData = resKeyPair;
const uint8PrivateKey = Base58.decode(parsedData.privateKey);
const uint8PublicKey = Base58.decode(parsedData.publicKey);
const keyPair = {
privateKey: uint8PrivateKey,
publicKey: uint8PublicKey,
};
const unsignedFeesUrl = await createEndpoint(
`/crosschain/unsignedfees/${address}`
);
const unsignedFeesResponse = await fetch(unsignedFeesUrl);
const unsignedFees = await unsignedFeesResponse.json();
const signedFees = [];
unsignedFees.forEach((unsignedFee) => {
const unsignedDataDecoded = Base58.decode(unsignedFee.data);
const signature = nacl.sign.detached(
unsignedDataDecoded,
keyPair.privateKey
);
const signedFee = {
timestamp: unsignedFee.timestamp,
data: `${Base58.encode(signature)}`,
atAddress: unsignedFee.atAddress,
fee: unsignedFee.fee,
};
signedFees.push(signedFee);
});
const signedFeesUrl = await createEndpoint(`/crosschain/signedfees`);
await fetch(signedFeesUrl, {
method: 'POST',
headers: {
Accept: '*/*',
'Content-Type': 'application/json',
},
body: `${JSON.stringify(signedFees)}`,
});
return true;
} else {
throw new Error('User declined request');
}
};
export const multiPaymentWithPrivateData = async (data, isFromExtension) => {
const requiredFields = ['payments', 'assetId'];
requiredFields.forEach((field) => {
if (data[field] === undefined || data[field] === null) {
throw new Error(`Missing required field: ${field}`);
}
});
const resKeyPair = await getKeyPair();
const parsedData = resKeyPair;
const privateKey = parsedData.privateKey;
const userPublicKey = parsedData.publicKey;
const { fee: paymentFee } = await getFee('TRANSFER_ASSET');
const { fee: arbitraryFee } = await getFee('ARBITRARY');
let name = null;
const payments = data.payments;
const assetId = data.assetId;
const pendingTransactions = [];
const pendingAdditionalArbitraryTxs = [];
const additionalArbitraryTxsWithoutPayment =
data?.additionalArbitraryTxsWithoutPayment || [];
let totalAmount = 0;
let fee = 0;
for (const payment of payments) {
const paymentRefId = uid.rnd();
const requiredFieldsPayment = ['recipient', 'amount'];
for (const field of requiredFieldsPayment) {
if (!payment[field]) {
throw new Error(`Missing required field: ${field}`);
}
}
const confirmReceiver = await getNameOrAddress(payment.recipient);
if (confirmReceiver.error) {
throw new Error('Invalid receiver address or name');
}
const receiverPublicKey = await getPublicKey(confirmReceiver);
const amount = +payment.amount.toFixed(8);
pendingTransactions.push({
type: 'PAYMENT',
recipientAddress: confirmReceiver,
amount: amount,
paymentRefId,
});
fee = fee + +paymentFee;
totalAmount = totalAmount + amount;
if (payment.arbitraryTxs && payment.arbitraryTxs.length > 0) {
for (const arbitraryTx of payment.arbitraryTxs) {
const requiredFieldsArbitraryTx = ['service', 'identifier', 'base64'];
for (const field of requiredFieldsArbitraryTx) {
if (!arbitraryTx[field]) {
throw new Error(`Missing required field: ${field}`);
}
}
if (!name) {
const getName = await getNameInfo();
if (!getName) throw new Error('Name needed to publish');
name = getName;
}
const isValid = isValidBase64WithDecode(arbitraryTx.base64);
if (!isValid) throw new Error('Invalid base64 data');
if (!arbitraryTx?.service?.includes('_PRIVATE'))
throw new Error('Please use a PRIVATE service');
const additionalPublicKeys = arbitraryTx?.additionalPublicKeys || [];
pendingTransactions.push({
type: 'ARBITRARY',
identifier: arbitraryTx.identifier,
service: arbitraryTx.service,
base64: arbitraryTx.base64,
description: arbitraryTx?.description || '',
paymentRefId,
publicKeys: [receiverPublicKey, ...additionalPublicKeys],
});
fee = fee + +arbitraryFee;
}
}
}
if (
additionalArbitraryTxsWithoutPayment &&
additionalArbitraryTxsWithoutPayment.length > 0
) {
for (const arbitraryTx of additionalArbitraryTxsWithoutPayment) {
const requiredFieldsArbitraryTx = ['service', 'identifier', 'base64'];
for (const field of requiredFieldsArbitraryTx) {
if (!arbitraryTx[field]) {
throw new Error(`Missing required field: ${field}`);
}
}
if (!name) {
const getName = await getNameInfo();
if (!getName) throw new Error('Name needed to publish');
name = getName;
}
const isValid = isValidBase64WithDecode(arbitraryTx.base64);
if (!isValid) throw new Error('Invalid base64 data');
if (!arbitraryTx?.service?.includes('_PRIVATE'))
throw new Error('Please use a PRIVATE service');
const additionalPublicKeys = arbitraryTx?.additionalPublicKeys || [];
pendingAdditionalArbitraryTxs.push({
type: 'ARBITRARY',
identifier: arbitraryTx.identifier,
service: arbitraryTx.service,
base64: arbitraryTx.base64,
description: arbitraryTx?.description || '',
publicKeys: additionalPublicKeys,
});
fee = fee + +arbitraryFee;
}
}
if (!name) throw new Error('A name is needed to publish');
const balance = await getBalanceInfo();
if (+balance < fee) throw new Error('Your QORT balance is insufficient');
const assetBalance = await getAssetBalanceInfo(assetId);
const assetInfo = await getAssetInfo(assetId);
if (assetBalance < totalAmount)
throw new Error('Your asset balance is insufficient');
const resPermission = await getUserPermission(
{
text1:
'Do you give this application permission to make the following payments and publishes?',
text2: `Asset used in payments: ${assetInfo.name}`,
html: `
${pendingTransactions
.filter((item) => item.type === 'PAYMENT')
.map(
(payment) => `
Recipient: ${
payment.recipientAddress
}
Amount: ${payment.amount}
`
)
.join('')}
${[...pendingTransactions, ...pendingAdditionalArbitraryTxs]
.filter((item) => item.type === 'ARBITRARY')
.map(
(arbitraryTx) => `
Service: ${
arbitraryTx.service
}
Name: ${name}
Identifier: ${
arbitraryTx.identifier
}
`
)
.join('')}