${data.resources
.map(
(resource) => `
Service: ${
resource.service
}
Name: ${resource?.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?.unlock.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 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 ${data.foreignAmount} ${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.001,
foreignBlockchain: data.foreignBlockchain,
foreignAmount: parseFloat(data.foreignAmount),
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 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;
const _url = await createEndpoint(
"/transactions/decode?ignoreValidityChecks=false"
);
const _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) {
const 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");
}
};
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")
}
};
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 getHostedData = async (data, isFromExtension) => {
const isGateway = await isRunningGateway();
if (isGateway) {
throw new Error("This action cannot be done through a public node");
}
const resPermission = await getUserPermission(
{
text1: "Do you give this application permission to",
text2: `Get a list of your hosted data?`,
},
isFromExtension
);
const { accepted } = resPermission;
if(accepted){
const limit = data?.limit ? data?.limit : 20;
const query = data?.query ? data?.query : ""
const offset = data?.offset ? data?.offset : 0
let urlPath = `/arbitrary/hosted/resources/?limit=${limit}&offset=${offset}`
if(query){
urlPath = urlPath + `&query=${query}`
}
const url = await createEndpoint(urlPath);
const response = await fetch(url);
const dataResponse = await response.json();
return dataResponse
} else {
throw new Error("User declined to get list of hosted resources");
}
};
export const deleteHostedData = async (data, isFromExtension) => {
const isGateway = await isRunningGateway();
if (isGateway) {
throw new Error("This action cannot be done through a public node");
}
const requiredFields = ["hostedData"];
const missingFields: string[] = [];
requiredFields.forEach((field) => {
if (!data[field]) {
missingFields.push(field);
}
});
const resPermission = await getUserPermission(
{
text1: "Do you give this application permission to",
text2: `Delete ${data?.hostedData?.length} hosted resources?`,
},
isFromExtension
);
const { accepted } = resPermission;
if(accepted){
const { hostedData } = data;
for (const hostedDataItem of hostedData){
try {
const url = await createEndpoint(`/arbitrary/resource/${hostedDataItem.service}/${hostedDataItem.name}/${hostedDataItem.identifier}`);
await fetch(url, {
method: "DELETE",
headers: {
"Content-Type": "application/json",
}
});
} catch (error) {
//error
}
}
return true
} else {
throw new Error("User declined delete hosted resources");
}
};
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 update this name?`,
text2: `previous name: ${oldName}`,
text3: `new name: ${newName}`,
text4: 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 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 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 getUserWalletTransactions = async (data, isFromExtension, appInfo) => {
const requiredFields = ["coin"];
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 value =
(await getPermission(
`getUserWalletTransactions-${appInfo?.name}-${data.coin}`
)) || false;
let skip = false;
if (value) {
skip = true;
}
let resPermission;
if (!skip) {
resPermission = await getUserPermission(
{
text1:
"Do you give this application permission to retrieve your wallet transactions",
highlightedText: `coin: ${data.coin}`,
checkbox1: {
value: true,
label: "Always allow wallet txs to be retrieved automatically",
},
},
isFromExtension
);
}
const { accepted = false, checkbox1 = false } = resPermission || {};
if (resPermission) {
setPermission(
`getUserWalletTransactions-${appInfo?.name}-${data.coin}`,
checkbox1
);
}
if (accepted || skip) {
const coin = data.coin;
const walletKeys = await getUserWalletFunc(coin);
let publicKey
if(data?.coin === 'ARRR'){
const resKeyPair = await getKeyPair();
const parsedData = resKeyPair;
publicKey = parsedData.arrrSeed58;
} else {
publicKey = walletKeys["publickey"]
}
const _url = await createEndpoint(
`/crosschain/` + data.coin.toLowerCase() + `/wallettransactions`
);
const _body = publicKey;
try {
const response = await fetch(_url, {
method: "POST",
headers: {
Accept: "*/*",
"Content-Type": "application/json",
},
body: _body,
});
if (!response?.ok) throw new Error("Unable to fetch wallet transactions");
let res;
try {
res = await response.clone().json();
} catch (e) {
res = await response.text();
}
if (res?.error && res?.message) {
throw new Error(res.message);
}
return res;
} catch (error) {
throw new Error(error?.message || "Fetch Wallet Transactions Failed");
}
} else {
throw new Error("User declined request");
}
};
export const getNodeInfo = async () => {
const url = `/admin/info`; // Simplified endpoint URL
try {
const endpoint = await createEndpoint(url); // Assuming createEndpoint is available for constructing the full URL
const response = await fetch(endpoint, {
method: "GET",
headers: {
Accept: "*/*",
},
});
if (!response.ok) throw new Error("Failed to retrieve node info");
let res;
try {
res = await response.clone().json();
} catch (e) {
res = await response.text();
}
if (res?.error && res?.message) {
throw new Error(res.message);
}
return res; // Return the full response
} catch (error) {
throw new Error(error?.message || "Error in retrieving node info");
}
};
export const getNodeStatus = async () => {
const url = `/admin/status`; // Simplified endpoint URL
try {
const endpoint = await createEndpoint(url); // Assuming createEndpoint is available for constructing the full URL
const response = await fetch(endpoint, {
method: "GET",
headers: {
Accept: "*/*",
},
});
if (!response.ok) throw new Error("Failed to retrieve node status");
let res;
try {
res = await response.clone().json();
} catch (e) {
res = await response.text();
}
if (res?.error && res?.message) {
throw new Error(res.message);
}
return res; // Return the full response
} catch (error) {
throw new Error(error?.message || "Error in retrieving node status");
}
};
export const getArrrSyncStatus = async () => {
const resKeyPair = await getKeyPair();
const parsedData = resKeyPair;
const arrrSeed = parsedData.arrrSeed58;
const url = `/crosschain/arrr/syncstatus`; // Simplified endpoint URL
try {
const endpoint = await createEndpoint(url); // Assuming createEndpoint is available for constructing the full URL
const response = await fetch(endpoint, {
method: "POST",
headers: {
Accept: "*/*",
},
body: arrrSeed
});
let res;
try {
res = await response.clone().json();
} catch (e) {
res = await response.text();
}
return res; // Return the full response
} catch (error) {
throw new Error(error?.message || "Error in retrieving arrr sync status");
}
};
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 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("")}