@relay-protocol/settlement-sdk 0.0.64

package/dist/order/index.js

@@ -0,0 +1,230 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeOrderExtraData = exports.encodeOrderExtraData = exports.decodeOrderCall = exports.encodeOrderCall = exports.getOrderId = exports.normalizeOrder = exports.ORDER_EIP712_TYPES = void 0;
+const tronweb = __importStar(require("tronweb"));
+const viem_1 = require("viem");
+const utils_1 = require("../utils");
+exports.ORDER_EIP712_TYPES = {
+    Order: [
+        { name: "version", type: "string" },
+        { name: "solverChainId", type: "string" },
+        { name: "solver", type: "address" },
+        { name: "salt", type: "uint256" },
+        { name: "inputs", type: "Input[]" },
+        { name: "output", type: "Output" },
+        { name: "fees", type: "Fee[]" },
+    ],
+    Input: [
+        { name: "payment", type: "InputPayment" },
+        { name: "refunds", type: "InputRefund[]" },
+    ],
+    InputPayment: [
+        { name: "chainId", type: "string" },
+        { name: "currency", type: "bytes" },
+        { name: "amount", type: "uint256" },
+        { name: "weight", type: "uint256" },
+    ],
+    InputRefund: [
+        { name: "chainId", type: "string" },
+        { name: "recipient", type: "bytes" },
+        { name: "currency", type: "bytes" },
+        { name: "minimumAmount", type: "uint256" },
+        { name: "deadline", type: "uint32" },
+        { name: "extraData", type: "bytes" },
+    ],
+    Output: [
+        { name: "chainId", type: "string" },
+        { name: "payments", type: "OutputPayment[]" },
+        { name: "deadline", type: "uint32" },
+        { name: "calls", type: "bytes[]" },
+        { name: "extraData", type: "bytes" },
+    ],
+    OutputPayment: [
+        { name: "recipient", type: "bytes" },
+        { name: "currency", type: "bytes" },
+        { name: "minimumAmount", type: "uint256" },
+        { name: "expectedAmount", type: "uint256" },
+    ],
+    Fee: [
+        { name: "recipientChainId", type: "string" },
+        { name: "recipient", type: "bytes" },
+        { name: "currencyChainId", type: "string" },
+        { name: "currency", type: "bytes" },
+        { name: "amount", type: "uint256" },
+    ],
+};
+const normalizeOrder = (order, chainsConfig) => {
+    const vmType = (chainId) => (0, utils_1.getChainVmType)(chainId, chainsConfig);
+    return {
+        version: order.version,
+        solverChainId: order.solverChainId,
+        solver: order.solver,
+        salt: order.salt,
+        inputs: order.inputs.map((input) => ({
+            payment: {
+                chainId: input.payment.chainId,
+                currency: (0, utils_1.encodeAddress)(input.payment.currency, vmType(input.payment.chainId)),
+                amount: input.payment.amount,
+                weight: input.payment.weight,
+            },
+            refunds: input.refunds.map((refund) => ({
+                chainId: refund.chainId,
+                recipient: (0, utils_1.encodeAddress)(refund.recipient, vmType(refund.chainId)),
+                currency: (0, utils_1.encodeAddress)(refund.currency, vmType(refund.chainId)),
+                minimumAmount: refund.minimumAmount,
+                deadline: refund.deadline,
+                extraData: (0, utils_1.encodeBytes)(refund.extraData),
+            })),
+        })),
+        output: {
+            chainId: order.output.chainId,
+            payments: order.output.payments.map((payment) => ({
+                recipient: (0, utils_1.encodeAddress)(payment.recipient, vmType(order.output.chainId)),
+                currency: (0, utils_1.encodeAddress)(payment.currency, vmType(order.output.chainId)),
+                minimumAmount: payment.minimumAmount,
+                expectedAmount: payment.expectedAmount,
+            })),
+            calls: order.output.calls.map(utils_1.encodeBytes),
+            deadline: order.output.deadline,
+            extraData: (0, utils_1.encodeBytes)(order.output.extraData),
+        },
+        fees: order.fees.map((fee) => ({
+            recipientChainId: fee.recipientChainId,
+            recipient: (0, utils_1.encodeAddress)(fee.recipient, vmType(fee.recipientChainId)),
+            currencyChainId: fee.currencyChainId,
+            currency: (0, utils_1.encodeAddress)(fee.currency, vmType(fee.currencyChainId)),
+            amount: fee.amount,
+        })),
+    };
+};
+exports.normalizeOrder = normalizeOrder;
+const getOrderId = (order, config) => {
+    return (0, viem_1.hashStruct)({
+        types: exports.ORDER_EIP712_TYPES,
+        primaryType: "Order",
+        data: (0, exports.normalizeOrder)(order, config),
+    });
+};
+exports.getOrderId = getOrderId;
+const encodeOrderCall = (call) => {
+    switch (call.vmType) {
+        case "ethereum-vm": {
+            return (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)(["(address to)", "(bytes data)", "(uint256 value)"]), [
+                { to: call.call.to },
+                { data: call.call.data },
+                { value: BigInt(call.call.value) },
+            ]);
+        }
+        default:
+            throw new Error("Unsupported vm type");
+    }
+};
+exports.encodeOrderCall = encodeOrderCall;
+const decodeOrderCall = (call, vmType) => {
+    switch (vmType) {
+        case "ethereum-vm": {
+            try {
+                const result = (0, viem_1.decodeAbiParameters)((0, viem_1.parseAbiParameters)([
+                    "(address to)",
+                    "(bytes data)",
+                    "(uint256 value)",
+                ]), call);
+                return {
+                    vmType: "ethereum-vm",
+                    call: {
+                        to: result[0].to.toLowerCase(),
+                        data: result[1].data.toLowerCase(),
+                        value: result[2].value.toString(),
+                    },
+                };
+            }
+            catch {
+                throw new Error("Failed to decode call");
+            }
+        }
+        default:
+            throw new Error("Unsupported vm type");
+    }
+};
+exports.decodeOrderCall = decodeOrderCall;
+const encodeOrderExtraData = (extraData) => {
+    switch (extraData.vmType) {
+        case "ethereum-vm": {
+            return (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)(["(address fillContract)"]), [{ fillContract: extraData.extraData.fillContract }]);
+        }
+        case "tron-vm": {
+            return tronweb.utils.abi.encodeParams(["address"], [extraData.extraData.fillContract]);
+        }
+        default:
+            throw new Error("Unsupported vm type");
+    }
+};
+exports.encodeOrderExtraData = encodeOrderExtraData;
+const decodeOrderExtraData = (extraData, vmType) => {
+    switch (vmType) {
+        case "ethereum-vm": {
+            try {
+                const result = (0, viem_1.decodeAbiParameters)((0, viem_1.parseAbiParameters)(["(address fillContract)"]), extraData);
+                return {
+                    vmType: "ethereum-vm",
+                    extraData: {
+                        fillContract: result[0].fillContract.toLowerCase(),
+                    },
+                };
+            }
+            catch {
+                throw new Error("Failed to decode extra data");
+            }
+        }
+        case "tron-vm": {
+            try {
+                const result = tronweb.utils.abi.decodeParams(["fillContract"], ["address"], extraData);
+                return {
+                    vmType: "tron-vm",
+                    extraData: {
+                        fillContract: tronweb.utils.address.fromHex(result.fillContract),
+                    },
+                };
+            }
+            catch {
+                throw new Error("Failed to decode extra data");
+            }
+        }
+        default:
+            throw new Error("Unsupported vm type");
+    }
+};
+exports.decodeOrderExtraData = decodeOrderExtraData;

package/dist/utils.d.ts

@@ -0,0 +1,9 @@
+export type VmType = "bitcoin-vm" | "ethereum-vm" | "hyperliquid-vm" | "solana-vm" | "sui-vm" | "ton-vm" | "tron-vm" | "lighter-vm";
+export type ChainIdToVmType = Record<string, VmType>;
+export declare const getChainVmType: (chainId: string, chainsConfig: ChainIdToVmType) => VmType;
+export declare const getVmTypeNativeCurrency: (vmType: VmType) => "bc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqmql8k8" | "0x0000000000000000000000000000000000000000" | "0x00000000000000000000000000000000" | "11111111111111111111111111111111" | "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb" | "0";
+export declare const encodeBytes: (bytes: string) => import("viem").ByteArray;
+export declare const encodeAddress: (address: string, vmType: VmType) => Uint8Array;
+export declare const decodeAddress: (address: Uint8Array, vmType: VmType) => string;
+export declare const encodeTransactionId: (transactionId: string, vmType: VmType) => Uint8Array;
+export declare const decodeTransactionId: (transactionId: Uint8Array, vmType: VmType) => string;

package/dist/utils.js

@@ -0,0 +1,255 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeTransactionId = exports.encodeTransactionId = exports.decodeAddress = exports.encodeAddress = exports.encodeBytes = exports.getVmTypeNativeCurrency = exports.getChainVmType = void 0;
+const viem_1 = require("viem");
+const bech32_1 = require("bech32");
+const bitcoin = __importStar(require("bitcoinjs-lib"));
+const bs58_1 = __importDefault(require("bs58"));
+const tronweb = __importStar(require("tronweb"));
+const getChainVmType = (chainId, chainsConfig) => {
+    if (!chainsConfig[chainId]) {
+        throw new Error(`Unknown vm type for chain ${chainId}`);
+    }
+    return chainsConfig[chainId];
+};
+exports.getChainVmType = getChainVmType;
+// Native currencies
+const getVmTypeNativeCurrency = (vmType) => {
+    switch (vmType) {
+        case "bitcoin-vm":
+            return "bc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqmql8k8";
+        case "ethereum-vm":
+            return "0x0000000000000000000000000000000000000000";
+        case "hyperliquid-vm":
+            return "0x00000000000000000000000000000000";
+        case "solana-vm":
+            return "11111111111111111111111111111111";
+        case "tron-vm":
+            return "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb";
+        case "lighter-vm":
+            return "0";
+        default:
+            throw new Error(`Native currency not available for vm type ${vmType}`);
+    }
+};
+exports.getVmTypeNativeCurrency = getVmTypeNativeCurrency;
+// Bytes encoding
+const encodeBytes = (bytes) => (0, viem_1.hexToBytes)(bytes);
+exports.encodeBytes = encodeBytes;
+// Address encoding
+const encodeAddress = (address, vmType) => {
+    switch (vmType) {
+        case "bitcoin-vm": {
+            const getBitcoinAddressType = (address) => {
+                if (address.startsWith("1")) {
+                    return "p2pkh";
+                }
+                if (address.startsWith("3")) {
+                    return "p2sh";
+                }
+                if (address.startsWith("bc1")) {
+                    const lower = address.toLowerCase();
+                    // Try Bech32 first (v0)
+                    try {
+                        const decoded = bech32_1.bech32.decode(lower, 90);
+                        if (decoded.prefix === "bc" && decoded.words[0] === 0) {
+                            return "bech32";
+                        }
+                    }
+                    catch (_) { }
+                    // Try Bech32m (v1+)
+                    try {
+                        const decoded = bech32_1.bech32m.decode(lower, 90);
+                        if (decoded.prefix === "bc" && decoded.words[0] >= 1) {
+                            return "bech32m";
+                        }
+                    }
+                    catch (_) { }
+                }
+                throw new Error("Unsupported address format");
+            };
+            const type = getBitcoinAddressType(address);
+            if (type === "p2pkh" || type === "p2sh") {
+                const decoded = bs58_1.default.decode(address);
+                // Strip the checksum
+                return decoded.slice(0, -4);
+            }
+            else {
+                const decoder = type === "bech32" ? bech32_1.bech32 : bech32_1.bech32m;
+                const { words } = decoder.decode(address);
+                const version = words[0];
+                const program = bech32_1.bech32.fromWords(words.slice(1));
+                return Uint8Array.from([version, ...program]);
+            }
+        }
+        case "ethereum-vm": {
+            return (0, viem_1.hexToBytes)(address);
+        }
+        case "hyperliquid-vm": {
+            return (0, viem_1.hexToBytes)(address);
+        }
+        case "solana-vm": {
+            return bs58_1.default.decode(address);
+        }
+        case "sui-vm": {
+            return (0, viem_1.hexToBytes)(address);
+        }
+        case "ton-vm": {
+            throw new Error("Vm type not implemented (encodeAddress)");
+        }
+        case "tron-vm": {
+            return (0, viem_1.hexToBytes)(`0x${tronweb.utils.address.toHex(address)}`);
+        }
+        case "lighter-vm": {
+            return (0, viem_1.hexToBytes)(`0x${Number(address).toString(16).padStart(32, "0")}`);
+        }
+        default: {
+            throw new Error(`Vm type not implemented (encodeAddress)`);
+        }
+    }
+};
+exports.encodeAddress = encodeAddress;
+const decodeAddress = (address, vmType) => {
+    switch (vmType) {
+        case "bitcoin-vm": {
+            if (address.length === 21 &&
+                (address[0] === 0x00 || address[0] === 0x05)) {
+                // Base58Check (P2PKH/P2SH)
+                const checksum = bitcoin.crypto
+                    .hash256(Buffer.from(address))
+                    .slice(0, 4);
+                const full = Buffer.concat([Buffer.from(address), checksum]);
+                return bs58_1.default.encode(full);
+            }
+            else {
+                // Bech32/Bech32m
+                const version = address[0];
+                const program = Array.from(address.slice(1));
+                const words = [version, ...bech32_1.bech32.toWords(Uint8Array.from(program))];
+                if (version === 0) {
+                    return bech32_1.bech32.encode("bc", words);
+                }
+                else {
+                    return bech32_1.bech32m.encode("bc", words);
+                }
+            }
+        }
+        case "ethereum-vm": {
+            return (0, viem_1.bytesToHex)(address);
+        }
+        case "hyperliquid-vm": {
+            return (0, viem_1.bytesToHex)(address);
+        }
+        case "solana-vm": {
+            return bs58_1.default.encode(address);
+        }
+        case "sui-vm": {
+            return (0, viem_1.bytesToHex)(address);
+        }
+        case "ton-vm": {
+            throw new Error("Vm type not implemented (decodeAddress)");
+        }
+        case "tron-vm": {
+            return tronweb.utils.address.fromHex((0, viem_1.bytesToHex)(address).slice(2));
+        }
+        case "lighter-vm": {
+            return Number("0x" + Buffer.from(address).toString("hex")).toString();
+        }
+    }
+};
+exports.decodeAddress = decodeAddress;
+// Transaction encoding
+const encodeTransactionId = (transactionId, vmType) => {
+    switch (vmType) {
+        case "bitcoin-vm": {
+            return Uint8Array.from(Buffer.from(transactionId, "hex"));
+        }
+        case "ethereum-vm": {
+            return (0, viem_1.hexToBytes)(transactionId);
+        }
+        case "hyperliquid-vm": {
+            return (0, viem_1.hexToBytes)(transactionId);
+        }
+        case "solana-vm": {
+            return bs58_1.default.decode(transactionId);
+        }
+        case "sui-vm": {
+            throw new Error("Vm type not implemented (encodeTransactionId)");
+        }
+        case "ton-vm": {
+            throw new Error("Vm type not implemented (encodeTransactionId)");
+        }
+        case "tron-vm": {
+            return (0, viem_1.hexToBytes)(`0x${transactionId}`);
+        }
+        case "lighter-vm": {
+            return (0, viem_1.hexToBytes)(`0x${transactionId}`);
+        }
+    }
+};
+exports.encodeTransactionId = encodeTransactionId;
+const decodeTransactionId = (transactionId, vmType) => {
+    switch (vmType) {
+        case "bitcoin-vm": {
+            return Buffer.from(transactionId).toString("hex");
+        }
+        case "ethereum-vm": {
+            return (0, viem_1.bytesToHex)(transactionId);
+        }
+        case "hyperliquid-vm": {
+            return (0, viem_1.bytesToHex)(transactionId);
+        }
+        case "solana-vm": {
+            return bs58_1.default.encode(transactionId);
+        }
+        case "sui-vm": {
+            throw new Error("Vm type not implemented (decodeTransactionId)");
+        }
+        case "ton-vm": {
+            throw new Error("Vm type not implemented (decodeTransactionId)");
+        }
+        case "tron-vm": {
+            return (0, viem_1.bytesToHex)(transactionId).slice(2);
+        }
+        case "lighter-vm": {
+            return (0, viem_1.bytesToHex)(transactionId).slice(2);
+        }
+    }
+};
+exports.decodeTransactionId = decodeTransactionId;

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@relay-protocol/settlement-sdk",
+  "version": "0.0.64",
+  "description": "Relay protocol SDK",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": "https://github.com/relayprotocol/settlement-protocol/packages/sdk",
+  "author": "Uneven Labs",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "prepublishOnly": "yarn clean && yarn build",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.3",
+    "typescript": "^5.5.4",
+    "vitest": "^2.1.8"
+  },
+  "dependencies": {
+    "@coral-xyz/anchor": "^0.31.1",
+    "@mysten/sui": "^1.24.0",
+    "bech32": "^2.0.0",
+    "bitcoinjs-lib": "^6.1.7",
+    "bs58": "^6.0.0",
+    "js-sha256": "^0.11.0",
+    "tronweb": "^6.0.4",
+    "viem": "^2.26.3"
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
+}