xpi-ts 0.2.21 → 0.2.23

package/dist/cjs/lib/lokad.js

@@ -0,0 +1,604 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScriptProcessor = exports.PlatformConfiguration = exports.ScriptChunksOptionalRANKMap = exports.ScriptChunksRANKMap = exports.RANK_SCRIPT_REQUIRED_LENGTH = exports.ScriptChunksRNKCMap = exports.SCRIPT_CHUNK_PLATFORM = exports.RANK_SENTIMENT_OP_CODES = exports.SCRIPT_CHUNK_SENTIMENT = exports.RANK_SENTIMENT_NEGATIVE = exports.RANK_SENTIMENT_POSITIVE = exports.RANK_SENTIMENT_NEUTRAL = exports.SCRIPT_CHUNK_LOKAD = exports.LOKAD_PREFIX_RNKE = exports.LOKAD_PREFIX_RNKC = exports.LOKAD_PREFIX_RANK = void 0;
+exports.isOpReturn = isOpReturn;
+exports.toProfileIdBuf = toProfileIdBuf;
+exports.toProfileIdUTF8 = toProfileIdUTF8;
+exports.toPostIdBuf = toPostIdBuf;
+exports.toPlatformBuf = toPlatformBuf;
+exports.toPlatformUTF8 = toPlatformUTF8;
+exports.toSentimentOpCode = toSentimentOpCode;
+exports.toSentimentUTF8 = toSentimentUTF8;
+exports.toCommentUTF8 = toCommentUTF8;
+exports.isValidLokad = isValidLokad;
+exports.fromScriptRANK = fromScriptRANK;
+exports.toScriptRANK = toScriptRANK;
+exports.fromScriptRNKC = fromScriptRNKC;
+exports.toScriptRNKC = toScriptRNKC;
+const bitcore_1 = require("./bitcore");
+const constants_js_1 = require("../utils/constants.js");
+const string_1 = require("../utils/string");
+exports.LOKAD_PREFIX_RANK = 0x52414e4b;
+exports.LOKAD_PREFIX_RNKC = 0x524e4b43;
+exports.LOKAD_PREFIX_RNKE = 0x524e4b45;
+exports.SCRIPT_CHUNK_LOKAD = new Map();
+exports.SCRIPT_CHUNK_LOKAD.set(exports.LOKAD_PREFIX_RANK, 'RANK');
+exports.SCRIPT_CHUNK_LOKAD.set(exports.LOKAD_PREFIX_RNKC, 'RNKC');
+exports.SCRIPT_CHUNK_LOKAD.set(exports.LOKAD_PREFIX_RNKE, 'RNKE');
+exports.RANK_SENTIMENT_NEUTRAL = bitcore_1.Opcode.OP_16;
+exports.RANK_SENTIMENT_POSITIVE = bitcore_1.Opcode.OP_1;
+exports.RANK_SENTIMENT_NEGATIVE = bitcore_1.Opcode.OP_0;
+exports.SCRIPT_CHUNK_SENTIMENT = new Map();
+exports.SCRIPT_CHUNK_SENTIMENT.set(exports.RANK_SENTIMENT_NEUTRAL, 'neutral');
+exports.SCRIPT_CHUNK_SENTIMENT.set(exports.RANK_SENTIMENT_POSITIVE, 'positive');
+exports.SCRIPT_CHUNK_SENTIMENT.set(exports.RANK_SENTIMENT_NEGATIVE, 'negative');
+exports.RANK_SENTIMENT_OP_CODES = new Map();
+exports.RANK_SENTIMENT_OP_CODES.set('neutral', 'OP_16');
+exports.RANK_SENTIMENT_OP_CODES.set('positive', 'OP_1');
+exports.RANK_SENTIMENT_OP_CODES.set('negative', 'OP_0');
+exports.SCRIPT_CHUNK_PLATFORM = new Map();
+exports.SCRIPT_CHUNK_PLATFORM.set(0x00, 'lotusia');
+exports.SCRIPT_CHUNK_PLATFORM.set(0x01, 'twitter');
+exports.ScriptChunksRNKCMap = new Map();
+exports.ScriptChunksRNKCMap.set('platform', {
+    offset: 7,
+    len: 1,
+    map: exports.SCRIPT_CHUNK_PLATFORM,
+});
+exports.ScriptChunksRNKCMap.set('profileId', {
+    offset: 9,
+    len: null,
+});
+exports.ScriptChunksRNKCMap.set('postId', {
+    offset: null,
+    len: null,
+});
+exports.ScriptChunksRNKCMap.set('comment', {
+    offset: null,
+    len: null,
+});
+exports.RANK_SCRIPT_REQUIRED_LENGTH = 10;
+exports.ScriptChunksRANKMap = new Map();
+exports.ScriptChunksRANKMap.set('sentiment', {
+    offset: 6,
+    len: 1,
+    map: exports.SCRIPT_CHUNK_SENTIMENT,
+});
+exports.ScriptChunksRANKMap.set('platform', {
+    offset: 8,
+    len: 1,
+    map: exports.SCRIPT_CHUNK_PLATFORM,
+});
+exports.ScriptChunksRANKMap.set('profileId', {
+    offset: 10,
+    len: null,
+});
+exports.ScriptChunksOptionalRANKMap = new Map();
+exports.ScriptChunksOptionalRANKMap.set('postId', {
+    offset: null,
+    len: null,
+});
+exports.ScriptChunksOptionalRANKMap.set('instanceId', {
+    offset: null,
+    len: null,
+});
+exports.PlatformConfiguration = new Map();
+exports.PlatformConfiguration.set('lotusia', {
+    profileId: {
+        len: 33,
+        regex: /^[0-9a-fA-F]{40,66}$/,
+    },
+    postId: {
+        len: 32,
+        regex: /^[0-9a-f]{64}$/,
+        type: 'String',
+    },
+});
+exports.PlatformConfiguration.set('twitter', {
+    profileId: {
+        len: 16,
+        regex: /^[a-z0-9_]{1,16}$/,
+    },
+    postId: {
+        len: 8,
+        regex: /^[0-9]+$/,
+        type: 'BigInt',
+    },
+});
+function isOpReturn(script) {
+    if (typeof script === 'string') {
+        script = bitcore_1.BufferUtil.from(script, 'hex');
+    }
+    return script.readUInt8(0) === bitcore_1.Opcode.OP_RETURN;
+}
+function toProfileIdBuf(platform, profileId) {
+    const platformSpec = exports.PlatformConfiguration.get(platform);
+    if (!platformSpec) {
+        return null;
+    }
+    const profileIdSpec = platformSpec.profileId;
+    if (!profileIdSpec) {
+        return null;
+    }
+    if (profileIdSpec.regex && !profileIdSpec.regex.test(profileId)) {
+        return null;
+    }
+    switch (platform) {
+        case 'lotusia': {
+            const profileIdHex = bitcore_1.BufferUtil.from(profileId, 'hex');
+            const actualLen = profileIdHex.length;
+            if (actualLen !== 20 && actualLen !== 33) {
+                return null;
+            }
+            const profileBuf = bitcore_1.BufferUtil.alloc(actualLen);
+            profileIdHex.copy(profileBuf, 0);
+            return profileBuf;
+        }
+        case 'twitter': {
+            const profileBuf = bitcore_1.BufferUtil.alloc(profileIdSpec.len);
+            bitcore_1.BufferUtil.from(profileId, 'utf8').copy(profileBuf, profileIdSpec.len - profileId.length);
+            return profileBuf;
+        }
+        default:
+            return null;
+    }
+}
+function toProfileIdUTF8(profileIdBuf) {
+    return new TextDecoder('utf-8').decode(profileIdBuf.filter(byte => byte != 0x00));
+}
+function toPostIdBuf(platform, postId) {
+    switch (platform) {
+        case 'lotusia':
+            return bitcore_1.BufferUtil.from(postId, 'hex');
+        case 'twitter':
+            return bitcore_1.BufferUtil.from(BigInt(postId).toString(16), 'hex');
+        default:
+            return undefined;
+    }
+}
+function toPlatformBuf(platform) {
+    for (const [byte, platformName] of exports.SCRIPT_CHUNK_PLATFORM) {
+        if (platformName == platform) {
+            return bitcore_1.BufferUtil.from([byte]);
+        }
+    }
+}
+function toPlatformUTF8(platformBuf) {
+    return exports.SCRIPT_CHUNK_PLATFORM.get(platformBuf.readUInt8(0));
+}
+function toSentimentOpCode(sentiment) {
+    return exports.RANK_SENTIMENT_OP_CODES.get(sentiment);
+}
+function toSentimentUTF8(sentimentBuf) {
+    return exports.SCRIPT_CHUNK_SENTIMENT.get(sentimentBuf.readUInt8(0));
+}
+function toCommentUTF8(commentBuf) {
+    return new TextDecoder('utf-8').decode(commentBuf);
+}
+function isValidLokad(scriptChunk, lokadType) {
+    let result = scriptChunk.buf !== undefined &&
+        scriptChunk.buf.length === 4 &&
+        exports.SCRIPT_CHUNK_LOKAD.has(scriptChunk.buf.readUInt32BE(0));
+    if (lokadType) {
+        result =
+            result &&
+                scriptChunk.buf !== undefined &&
+                exports.SCRIPT_CHUNK_LOKAD.get(scriptChunk.buf?.readUInt32BE(0)) === lokadType;
+    }
+    return result;
+}
+function fromScriptRANK(scriptBuf) {
+    const script = typeof scriptBuf === 'string'
+        ? bitcore_1.Script.fromString(scriptBuf)
+        : bitcore_1.Script.fromBuffer(scriptBuf);
+    if (!script.isDataOut()) {
+        throw new Error('Script is not OP_RETURN');
+    }
+    if (!isValidLokad(script.chunks[1], 'RANK')) {
+        throw new Error('LOKAD chunk is either invalid or unsupported');
+    }
+    const sentiment = exports.SCRIPT_CHUNK_SENTIMENT.get(script.chunks[2].opcodenum);
+    if (!sentiment) {
+        throw new Error('Invalid sentiment chunk');
+    }
+    const platform = exports.SCRIPT_CHUNK_PLATFORM.get(script.chunks[3].buf?.readUInt8(0));
+    if (!platform) {
+        throw new Error('Invalid platform chunk');
+    }
+    const platformSpec = exports.PlatformConfiguration.get(platform);
+    if (!platformSpec) {
+        throw new Error('Invalid platform spec');
+    }
+    const profileIdChunk = script.chunks[4];
+    if (profileIdChunk.buf === undefined ||
+        profileIdChunk.buf.length !== platformSpec.profileId.len) {
+        throw new Error(`Invalid profileId chunk (profileId chunk missing or length does not match platform ${platform})`);
+    }
+    const profileId = toProfileIdUTF8(profileIdChunk.buf);
+    if (!platformSpec.profileId.regex.test(profileId)) {
+        throw new Error(`Invalid profileId "${profileId}" (regex does not match for platform ${platform})`);
+    }
+    const data = {
+        sentiment,
+        platform,
+        profileId,
+    };
+    if (script.chunks.length > 5) {
+        const postIdChunk = script.chunks[5];
+        if (postIdChunk.buf === undefined) {
+            throw new Error('Invalid postId chunk (postId chunk missing)');
+        }
+        if (platformSpec.postId?.type === 'BigInt') {
+            data.postId = postIdChunk.buf.readBigUInt64BE(0).toString();
+        }
+        else {
+            data.postId = postIdChunk.buf.toString('hex');
+        }
+        if (platformSpec.postId?.regex &&
+            !platformSpec.postId.regex.test(data.postId)) {
+            throw new Error(`Invalid postId "${data.postId}" (regex does not match for platform ${platform})`);
+        }
+    }
+    return data;
+}
+function toScriptRANK(sentiment, platform, profileId, postId) {
+    if (!sentiment || !platform || !profileId) {
+        throw new Error('Must specify sentiment, platform, and profileId');
+    }
+    const platformSpec = exports.PlatformConfiguration.get(platform);
+    if (!platformSpec || !platformSpec.profileId) {
+        throw new Error(`RANK outputs for platform ${platform} are not supported`);
+    }
+    const script = bitcore_1.Script.empty()
+        .add(bitcore_1.Opcode.OP_RETURN)
+        .add(bitcore_1.BufferUtil.from((0, string_1.toHex)(exports.LOKAD_PREFIX_RANK), 'hex'));
+    switch (sentiment) {
+        case 'neutral':
+            script.add(exports.RANK_SENTIMENT_NEUTRAL);
+            break;
+        case 'positive':
+            script.add(exports.RANK_SENTIMENT_POSITIVE);
+            break;
+        case 'negative':
+            script.add(exports.RANK_SENTIMENT_NEGATIVE);
+            break;
+    }
+    script.add(toPlatformBuf(platform));
+    const profileIdBuf = toProfileIdBuf(platform, profileId);
+    script.add(profileIdBuf);
+    if (postId) {
+        if (!platformSpec.postId) {
+            throw new Error('Post ID provided, but no platform post specification defined');
+        }
+        script.add(toPostIdBuf(platform, postId));
+    }
+    return script.toBuffer();
+}
+function fromScriptRNKC(scriptBuf, supplementalScriptBufs, burnedSats, options) {
+    const script = typeof scriptBuf === 'string'
+        ? bitcore_1.Script.fromString(scriptBuf)
+        : bitcore_1.Script.fromBuffer(scriptBuf);
+    if (!script.isDataOut()) {
+        throw new Error('Script is not OP_RETURN');
+    }
+    if (!isValidLokad(script.chunks[1], 'RNKC')) {
+        throw new Error('LOKAD chunk is either invalid or unsupported');
+    }
+    const supplementalScripts = supplementalScriptBufs.map(s => typeof s === 'string' ? bitcore_1.Script.fromString(s) : bitcore_1.Script.fromBuffer(s));
+    const platform = exports.SCRIPT_CHUNK_PLATFORM.get(script.chunks[2].buf?.readUInt8(0));
+    if (!platform) {
+        throw new Error('Invalid platform chunk');
+    }
+    const platformSpec = exports.PlatformConfiguration.get(platform);
+    if (!platformSpec) {
+        throw new Error('Platform configuration not found');
+    }
+    const profileIdChunk = script.chunks[3];
+    if (!profileIdChunk?.buf) {
+        throw new Error('Invalid profileId chunk');
+    }
+    const profileId = toProfileIdUTF8(profileIdChunk.buf);
+    if (!platformSpec.profileId.regex.test(profileId)) {
+        throw new Error('Invalid profileId format for platform');
+    }
+    let postId;
+    if (script.chunks.length > 4 && script.chunks[4]?.buf) {
+        if (!platformSpec.postId) {
+            throw new Error('Post ID found but platform does not support post IDs');
+        }
+        postId = script.chunks[4].buf.toString('utf8');
+        if (!platformSpec.postId.regex.test(postId)) {
+            throw new Error('Invalid postId format for platform');
+        }
+    }
+    let commentBuf = bitcore_1.BufferUtil.alloc(0);
+    for (const supplementalScript of supplementalScripts) {
+        if (!supplementalScript.isDataOut()) {
+            break;
+        }
+        const chunks = supplementalScript.chunks;
+        if (chunks.length < 2 || !chunks[1]?.buf) {
+            break;
+        }
+        commentBuf = bitcore_1.BufferUtil.concat([commentBuf, chunks[1].buf]);
+    }
+    if (commentBuf.length === 0) {
+        throw new Error('No comment data found in supplemental scripts');
+    }
+    const minDataLength = options?.minDataLength ?? constants_js_1.RNKC_MIN_DATA_LENGTH;
+    const minFeeRate = options?.minFeeRate ?? constants_js_1.RNKC_MIN_FEE_RATE;
+    if (commentBuf.length < minDataLength) {
+        throw new Error(`Comment data length ${commentBuf.length} is below minimum ${minDataLength}`);
+    }
+    const burnedSatsNum = typeof burnedSats === 'bigint' ? Number(burnedSats) : burnedSats;
+    if (burnedSatsNum < minFeeRate * commentBuf.length) {
+        throw new Error(`Fee rate too low: ${Math.floor(burnedSatsNum / commentBuf.length)} < ${minFeeRate}`);
+    }
+    const result = {
+        data: new Uint8Array(commentBuf),
+        feeRate: Math.floor(burnedSatsNum / commentBuf.length),
+        inReplyToPlatform: platform,
+        inReplyToProfileId: profileId,
+        inReplyToPostId: postId,
+    };
+    if (!result) {
+        throw new Error('Failed to process RNKC script');
+    }
+    return result;
+}
+function toScriptRNKC({ platform, profileId, postId, comment, }) {
+    if (!platform || !profileId) {
+        throw new Error('Must specify platform and profileId');
+    }
+    const platformSpec = exports.PlatformConfiguration.get(platform);
+    if (!platformSpec || !platformSpec.profileId) {
+        throw new Error(`RNKC outputs for platform ${platform} are not supported`);
+    }
+    if (!platformSpec.profileId.regex.test(profileId)) {
+        throw new Error(`Invalid profileId: ${profileId}`);
+    }
+    if (postId && !platformSpec.postId.regex.test(postId)) {
+        throw new Error(`Invalid postId: ${postId}`);
+    }
+    const commentBuf = bitcore_1.BufferUtil.from(comment, 'utf8');
+    if (commentBuf.length < 1 || commentBuf.length > constants_js_1.MAX_OP_RETURN_DATA * 2) {
+        throw new Error(`Comment must be between 1 and ${constants_js_1.MAX_OP_RETURN_DATA * 2} bytes`);
+    }
+    const scriptBufs = [];
+    const script0 = bitcore_1.Script.empty()
+        .add(bitcore_1.Opcode.OP_RETURN)
+        .add(bitcore_1.BufferUtil.from((0, string_1.toHex)(exports.LOKAD_PREFIX_RNKC), 'hex'))
+        .add(toPlatformBuf(platform))
+        .add(toProfileIdBuf(platform, profileId));
+    if (postId) {
+        script0.add(toPostIdBuf(platform, postId));
+    }
+    scriptBufs.push(script0.toBuffer());
+    const commentBuf1 = commentBuf.slice(0, constants_js_1.MAX_OP_RETURN_DATA);
+    const script1 = bitcore_1.Script.empty().add(bitcore_1.Opcode.OP_RETURN).add(commentBuf1);
+    scriptBufs.push(script1.toBuffer());
+    if (commentBuf.length > constants_js_1.MAX_OP_RETURN_DATA) {
+        const commentBuf2 = commentBuf.slice(constants_js_1.MAX_OP_RETURN_DATA);
+        const script2 = bitcore_1.Script.empty().add(bitcore_1.Opcode.OP_RETURN).add(commentBuf2);
+        scriptBufs.push(script2.toBuffer());
+    }
+    return scriptBufs;
+}
+class ScriptProcessor {
+    chunks = null;
+    script;
+    supplementalScripts = [];
+    constructor(script) {
+        this.script = script;
+        switch (this.lokadType) {
+            case 'RANK':
+                this.chunks = exports.ScriptChunksRANKMap;
+                break;
+            case 'RNKC':
+                this.chunks = exports.ScriptChunksRNKCMap;
+                break;
+        }
+    }
+    addScript(script) {
+        if (!bitcore_1.BufferUtil.isBuffer(script)) {
+            script = bitcore_1.BufferUtil.from(script, 'hex');
+        }
+        if (!isOpReturn(script)) {
+            return false;
+        }
+        this.supplementalScripts.push(script);
+        return true;
+    }
+    get lokadType() {
+        return this.processLokad();
+    }
+    processLokad() {
+        const lokadBuf = this.script.slice(2, 6);
+        const lokad = exports.SCRIPT_CHUNK_LOKAD.get(lokadBuf.readUInt32BE(0));
+        if (!lokad) {
+            return undefined;
+        }
+        return lokad;
+    }
+    processSentiment() {
+        const chunk = this.chunks?.get('sentiment');
+        if (!chunk || chunk.offset === null) {
+            return undefined;
+        }
+        const sentimentBuf = this.script.slice(chunk.offset, chunk.offset + chunk.len);
+        return exports.SCRIPT_CHUNK_SENTIMENT.get(sentimentBuf.readUInt8(0));
+    }
+    processPlatform() {
+        const chunk = this.chunks?.get('platform');
+        if (!chunk || chunk.offset === null) {
+            return undefined;
+        }
+        const platformBuf = this.script.slice(chunk.offset, chunk.offset + chunk.len);
+        const platform = exports.SCRIPT_CHUNK_PLATFORM.get(platformBuf.readUInt8(0));
+        if (!platform) {
+            return undefined;
+        }
+        return platform;
+    }
+    processProfileId(platform) {
+        const chunk = this.chunks?.get('profileId');
+        if (!chunk || chunk.offset === null) {
+            return undefined;
+        }
+        const platformSpec = exports.PlatformConfiguration.get(platform);
+        if (!platformSpec || !platformSpec.profileId) {
+            return undefined;
+        }
+        const pushOpOffset = chunk.offset - 1;
+        if (pushOpOffset < 0 || pushOpOffset >= this.script.length) {
+            return undefined;
+        }
+        const actualLen = this.script.readUInt8(pushOpOffset);
+        if (platform === 'lotusia' && actualLen !== 20 && actualLen !== 33) {
+            return undefined;
+        }
+        const profileIdBuf = this.script.slice(chunk.offset, chunk.offset + actualLen);
+        if (profileIdBuf.length !== actualLen) {
+            return undefined;
+        }
+        switch (platform) {
+            case 'lotusia':
+                return (0, string_1.toHex)(profileIdBuf);
+            case 'twitter':
+                return toProfileIdUTF8(profileIdBuf);
+            default:
+                return undefined;
+        }
+    }
+    processPostId(platform) {
+        if (!platform) {
+            return undefined;
+        }
+        const platformSpec = exports.PlatformConfiguration.get(platform);
+        if (!platformSpec || !platformSpec.postId || !platformSpec.profileId) {
+            return undefined;
+        }
+        const profileIdChunk = this.chunks?.get('profileId');
+        if (!profileIdChunk?.offset) {
+            return undefined;
+        }
+        const profileIdPushOpOffset = profileIdChunk.offset - 1;
+        if (profileIdPushOpOffset < 0 ||
+            profileIdPushOpOffset >= this.script.length) {
+            return undefined;
+        }
+        const actualProfileIdLen = this.script.readUInt8(profileIdPushOpOffset);
+        const postIdSpec = platformSpec.postId;
+        const postIdOffset = profileIdChunk.offset + actualProfileIdLen + 1;
+        if (postIdOffset + postIdSpec.len > this.script.length) {
+            return undefined;
+        }
+        const postIdPushOpOffset = postIdOffset - 1;
+        if (postIdPushOpOffset >= this.script.length) {
+            return undefined;
+        }
+        const postIdPushOp = this.script.readUInt8(postIdPushOpOffset);
+        if (postIdPushOp !== postIdSpec.len) {
+            return undefined;
+        }
+        const postIdBuf = this.script.slice(postIdOffset, postIdOffset + postIdSpec.len);
+        try {
+            switch (platform) {
+                case 'lotusia':
+                    return postIdBuf.toString('hex');
+                case 'twitter':
+                    return postIdBuf.readBigUInt64BE(0).toString();
+                default:
+                    return undefined;
+            }
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    processComment(scripts) {
+        let commentBuf = bitcore_1.BufferUtil.alloc(0);
+        for (let i = 0; i < scripts.length; i++) {
+            const script = scripts[i];
+            if (script.readUInt8(1) !== bitcore_1.Opcode.OP_PUSHDATA1) {
+                break;
+            }
+            const dataSize = script.readUInt8(2);
+            if (isNaN(dataSize) || dataSize > constants_js_1.MAX_OP_RETURN_DATA) {
+                break;
+            }
+            commentBuf = bitcore_1.BufferUtil.concat([
+                commentBuf,
+                script.slice(3, 3 + dataSize),
+            ]);
+        }
+        if (!commentBuf) {
+            return null;
+        }
+        return new Uint8Array(commentBuf);
+    }
+    processScriptRANK() {
+        const sentiment = this.processSentiment();
+        if (!sentiment) {
+            return null;
+        }
+        const platform = this.processPlatform();
+        if (!platform) {
+            return null;
+        }
+        const profileId = this.processProfileId(platform);
+        if (!profileId) {
+            return null;
+        }
+        const output = {
+            sentiment,
+            platform,
+            profileId,
+        };
+        const postId = this.processPostId(platform);
+        if (postId) {
+            output.postId = postId;
+        }
+        return output;
+    }
+    processScriptRNKC(burnedSats, options) {
+        if (typeof burnedSats === 'bigint') {
+            burnedSats = Number(burnedSats);
+        }
+        if (this.supplementalScripts.length === 0 ||
+            this.supplementalScripts.length > 2) {
+            return null;
+        }
+        const inReplyToPlatform = this.processPlatform();
+        if (!inReplyToPlatform) {
+            return null;
+        }
+        const data = this.processComment(this.supplementalScripts);
+        if (!data) {
+            return null;
+        }
+        if (data.length < (options?.minDataLength ?? constants_js_1.RNKC_MIN_DATA_LENGTH)) {
+            return null;
+        }
+        if (burnedSats < (options?.minFeeRate ?? constants_js_1.RNKC_MIN_FEE_RATE) * data.length) {
+            return null;
+        }
+        const output = {
+            data,
+            feeRate: Math.floor(burnedSats / data.length),
+            inReplyToPlatform,
+            inReplyToProfileId: undefined,
+            inReplyToPostId: undefined,
+        };
+        const profileId = this.processProfileId(inReplyToPlatform);
+        if (profileId) {
+            output.inReplyToProfileId = profileId;
+            const postId = this.processPostId(inReplyToPlatform);
+            if (postId) {
+                output.inReplyToPostId = postId;
+            }
+        }
+        return output;
+    }
+}
+exports.ScriptProcessor = ScriptProcessor;

package/dist/esm/index.js

@@ -1,6 +1,6 @@
 export * from './lib/rpc.js';
 export * as Bitcore from './lib/bitcore/index.js';
-export * as RANK from './lib/rank/index.js';
+export * as LOKAD from './lib/lokad.js';
 export * from './utils/constants.js';
 export * from './utils/env.js';
 export * from './utils/string.js';

package/dist/esm/lib/bitcore/crypto/schnorr.js

@@ -73,17 +73,13 @@ export class Schnorr {
             Point.pointToCompressed(P),
             e.toBuffer({ size: 32 }),
         ])));
-        const s = e0.mul(d).add(k).mod(n);
+        const s = k.add(e0.mul(d)).mod(n);
         return { r, s, compressed: this.pubkey.compressed, isSchnorr: true };
     }
     getrBuffer(r) {
         const buf = r.toBuffer();
         return buf.length < 32 ? r.toBuffer({ size: 32 }) : buf;
     }
-    getsBuffer(s) {
-        const buf = s.toBuffer();
-        return buf.length < 32 ? s.toBuffer({ size: 32 }) : buf;
-    }
     sigError() {
         if (!BufferUtil.isBuffer(this.hashbuf) || this.hashbuf.length !== 32) {
             return true;