@haelp/teto
Version:
A typescript-based controllable TETR.IO client.
172 lines (171 loc) • 9.15 kB
JavaScript
import { version } from "../../../utils/index.mjs";
import { basic } from "../../../utils/api/basic.mjs";
import fsSync from "node:fs";
import fs from "node:fs/promises";
import { homedir } from "node:os";
import path from "node:path";
import chalk from "chalk";
let Amadeus = null;
const log = (msg, { level = "info" } = {
level: "info"
})=>{
const func = level === "info" ? chalk.blue : level === "warning" ? chalk.yellow : chalk.red;
console.log(`${func("[🎀\u2009Ribbon]")}: ${msg}`);
};
const extractPacker = (text)=>{
const trace = (text, start, openStr = "{", closeStr = "}")=>{
let i = start;
let brace = 1;
while(brace > 0 && i < text.length){
if (text[i] === openStr) brace++;
if (text[i] === closeStr) brace--;
i++;
}
return i;
};
let libraries = text.slice("(() => {\n".length, text.indexOf('(function(){"use strict";'));
const bufferStart = libraries.indexOf("e=function(){");
const bufferEnd = trace(libraries, bufferStart + "e=function(){".length) + "()".length;
libraries = libraries.slice(0, bufferStart) + "e=Buffer" + libraries.slice(bufferEnd);
const pixiStart = libraries.search(/[A-Za-z]{1}=function\([A-Za-z]{1}\)\{"use strict";var [A-Za-z]{1}=setTimeout;/);
let pixiEnd = trace(libraries, trace(libraries, pixiStart + "e=(function(t){".length) + '({}),s=function(t,e,r,n,i,o,s,a){"use strict";'.length);
pixiEnd = libraries.indexOf(";", pixiEnd);
libraries = libraries.slice(0, pixiStart - 1) + libraries.slice(pixiEnd) + "/*LIBRARY_CUTOFF*/";
libraries = libraries.replace("o.filters", "{}");
const assignIndex = libraries.search(/Object\.assign\(\{\},[A-Za-z]\);/);
libraries = libraries.slice(0, assignIndex) + libraries.slice(assignIndex + "Object.assign({},s);".length);
const mainStart = text.search(/class\s+[A-Za-z]{2}\s+extends\s+[A-Za-z]\{static\s+OptionsList/);
const parentName = text.slice(mainStart + "class ge extends ".length, mainStart + "class ge extends ".length + 1);
const parentStart = text.search(new RegExp(`class ${parentName}\\{constructor\\((.)\\)\\{this\\.self=\\1\\}`));
const parentEnd = trace(text, parentStart + "class k{".length);
const parentBody = text.slice(parentStart, parentEnd);
const zenithStaticStart = text.search(new RegExp(`class [A-Za-z]{2} extends ${parentName}\\{\\s*static FloorDistance`));
const zenithStaticEnd = text.indexOf("static GetSpeedCap(", zenithStaticStart);
const zenithStaticBody = text.slice(zenithStaticStart, zenithStaticEnd) + "}";
const bagStart = text.search(new RegExp(`class [A-Za-z]{1} extends ${parentName}\\{\\s*static BagList`));
const bagEnd = trace(text, bagStart + "class F extends k{".length);
let bagBody = text.slice(bagStart, bagEnd);
bagBody = bagBody.slice(0, bagBody.indexOf("];") + 2) + "}";
const counterStart = text.search(new RegExp(`class [A-Za-z]{1} extends ${parentName}\\{\\s*static DisplayCounters`));
const counterEnd = trace(text, counterStart + "class O extends k{".length);
let counterBody = text.slice(counterStart, counterEnd);
const counterEndStr = "Object.keys(this.DisplayCounters);";
counterBody = counterBody.slice(0, counterBody.indexOf(counterEndStr) + counterEndStr.length) + "}";
const engineStart = text.search(new RegExp(`class [A-Za-z]{1} extends ${parentName}\\{\\s*static init\\(\\)\\{this\\.ROTATION_LEFT=1`));
const engineName = text.slice(engineStart + "class ".length, engineStart + "class ".length + 1);
const engineEnd = trace(text, engineStart + "class H extends k{static init(){".length);
const engineBody = text.slice(engineStart, engineEnd) + "}" + engineName + ".init();";
const constantsStart = text.indexOf("={minotypes:") - 7;
const constantsEnd = trace(text, constantsStart + "const w={minotypes:".length);
const constantsBody = text.slice(constantsStart, constantsEnd) + ";";
const cacheBody = `function b(e){const t=Object.prototype.toString.call(e);return b.cached[t]?b.cached[t]:(b.cached[t] = t.substring(8, t.length - 1).toLowerCase());}b.cached={};`;
const versionString = "version:{default:";
const versionStart = text.indexOf(versionString, mainStart);
const versionVar = "const " + text.slice(versionStart + versionString.length, versionStart + versionString.length + 1) + "=11;";
const version2String = 'gameModes:{"40l":{version:';
const version2Start = text.indexOf(version2String);
const version2Var = "const " + text.slice(version2Start + version2String.length, version2Start + version2String.length + 1) + "=19;";
const spinRulesStart = text.indexOf(".SpinRules=[") - 2;
const spinRulesName = text.slice(spinRulesStart, spinRulesStart + 2);
const spinRulesBody = "class " + spinRulesName + "{}" + text.slice(spinRulesStart, text.indexOf("];", spinRulesStart) + 2);
// search for the start of obfuscation
text = text.slice(mainStart).trim();
// const internalName = text.slice(text.indexOf("return") + 7, text.indexOf("return") + 9);
// const functionStart = text.indexOf("function " + internalName);
// const functionEnd = trace(text, functionStart + "function Te(e, t){".length);
// const functionBody = text
// .slice(functionStart, functionEnd)
// .replaceAll("\n", "")
// .replaceAll(" ", "")
// .replaceAll(" = ", "=")
// .replace(" () ", "()");
// const dictName = functionBody.slice(
// functionBody.indexOf("const ") + 8,
// functionBody.indexOf("const ") + 10
// );
// const dictStart = text.indexOf("function " + dictName + "() {");
// const dictEnd = trace(text, dictStart + ("function " + dictName + "() {").length);
// const dictBody = text
// .slice(dictStart, dictEnd)
// .replaceAll("\n", "")
// .replaceAll(" ", "")
// .replaceAll(" = ", "=");
const obfuscationEnd = text.search(/class\s[a-z]{2}{/);
const classNameStart = text.search(/const\s+(\S{2})=new\s+class/);
const className = text.slice(classNameStart + 6, classNameStart + 8);
// let deobfuscator =
// dictBody +
// "\n" +
// functionBody +
// "\n" +
// text.slice(0, functionStart) +
// text.slice(functionEnd, dictStart) +
// text.slice(dictEnd, obfuscationEnd);
return `(() => { ` + libraries + parentBody + versionVar + version2Var + zenithStaticBody + bagBody + counterBody + cacheBody + constantsBody + spinRulesBody + engineBody + text.slice(0, obfuscationEnd) + `return ${className}})();`;
};
export const tetoPack = (userAgent, options = {
global: false
})=>{
if (Amadeus && options.global) return Promise.resolve(Amadeus);
return new Promise(async (resolve)=>{
const serverVersion = await basic({
userAgent,
token: "",
turnstile: null
}).get({
uri: "server/environment"
});
if (serverVersion.success === false) {
throw new Error(serverVersion.error.msg);
}
const triangleDir = path.join(homedir(), ".trianglejs");
const fileName = `tetrio-${version}-${serverVersion.signature.client.build.id}.js`;
let tetrioOverride;
try {
tetrioOverride = await fs.readFile(path.join(triangleDir, fileName), "utf-8");
} catch {
log("TETR.IO update found. Extracting new packer...", {
level: "warning"
});
if (!fsSync.existsSync(triangleDir)) {
await fs.mkdir(triangleDir, {
recursive: true
});
}
// empty triangle folder
const files = await fs.readdir(triangleDir);
for (const file of files){
await fs.rm(path.join(triangleDir, file), {
recursive: true,
force: true
});
}
const response = await fetch("https://tetr.io/js/tetrio.js");
const buffer = Buffer.from(await response.arrayBuffer());
tetrioOverride = buffer.toString();
tetrioOverride = extractPacker(tetrioOverride);
await fs.writeFile(path.join(triangleDir, fileName), tetrioOverride);
log(`tetrio.js @${serverVersion.signature.version}-${serverVersion.signature.client.build.id} patched`);
}
const tetrio = (0, eval)(tetrioOverride);
Amadeus = {
encode: (msg, data)=>{
const encoded = tetrio.Encode(msg, data).toJSON().data;
return Buffer.from([
...encoded
]);
},
decode: (data)=>{
const decoded = tetrio.Decode(data);
if (decoded.command === "packets") {
decoded.data.packets = decoded.data.packets.map((packet)=>Buffer.from([
...packet
]));
}
return decoded;
}
};
resolve(Amadeus);
});
};
//# sourceMappingURL=teto-pack.js.map