@ercworldio/blockchain-shared 1.0.2-dev-PROJ-1265.1 → 1.0.2-dev-PROJ-1265.1.fix

package/build/services/db/timelock/ScheduleTransactionService.js

@@ -0,0 +1,476 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+class ScheduleTransactionService {
+}
+_a = ScheduleTransactionService;
+ScheduleTransactionService.get_and_lock_available_jobs = (pool_1, ...args_1) => __awaiter(void 0, [pool_1, ...args_1], void 0, function* (pool, limit = 10, job_ttl_s = 120, lock_metadata = { lock_owner: "schedule-tx-worker", lock_reason: "process_queued" }) {
+    const ttlSeconds = job_ttl_s;
+    const res = yield pool.query(`
+      WITH status_ids AS (
+          SELECT
+            MAX(CASE WHEN status = 'queued'     THEN id END) AS queued_id,
+            MAX(CASE WHEN status = 'processing' THEN id END) AS processing_id
+          FROM multisig.schedule_job_statuses
+      ),
+      candidates AS (
+        SELECT cj.id
+        FROM multisig.schedule_transaction_jobs cj, status_ids
+        WHERE cj.status_id = status_ids.queued_id
+          AND (cj.lock_expires_at IS NULL OR cj.lock_expires_at < now())
+        ORDER BY cj.blockchain, cj.chain_id ASC
+        LIMIT $1
+        FOR UPDATE SKIP LOCKED
+      )
+      UPDATE multisig.schedule_transaction_jobs cj
+      SET
+        status_id       = si.processing_id,
+        locked_at       = now(),
+        lock_expires_at = now() + ($2 || ' seconds')::interval,
+        metadata = jsonb_set(
+                        jsonb_set(
+                            coalesce(cj.metadata, '{}'::jsonb),
+                            '{lock_owner}',
+                            to_jsonb($3::text)
+                        ),
+                        '{lock_reason}',
+                        to_jsonb($4::text)
+                    ),
+        updated_at = now()
+      FROM candidates c, status_ids si
+      WHERE cj.id = c.id
+      RETURNING cj.*;
+      `, [limit, ttlSeconds, lock_metadata.lock_owner, lock_metadata.lock_reason]);
+    return res.rows;
+});
+/** Locks and returns available jobs with full withdrawal details via inline SQL (bypasses DB function). */
+ScheduleTransactionService.get_and_lock_available_jobs_with_details = (pool_1, ...args_1) => __awaiter(void 0, [pool_1, ...args_1], void 0, function* (pool, limit = 10, job_ttl_s = 120, lock_metadata = { lock_owner: "schedule-tx-worker", lock_reason: "process_queued" }) {
+    var _b, _c;
+    const result = yield pool.query(`
+WITH status_ids AS (
+    SELECT
+        MAX(CASE WHEN status = 'queued'     THEN id END) AS queued_id,
+        MAX(CASE WHEN status = 'processing' THEN id END) AS processing_id
+    FROM multisig.schedule_job_statuses
+),
+candidates AS (
+    SELECT id
+    FROM multisig.schedule_transaction_jobs, status_ids
+    WHERE status_id = status_ids.queued_id
+      AND (lock_expires_at IS NULL OR lock_expires_at < NOW())
+    ORDER BY blockchain, chain_id ASC
+    LIMIT $1
+    FOR UPDATE SKIP LOCKED
+),
+updated AS (
+    UPDATE multisig.schedule_transaction_jobs j
+    SET status_id       = si.processing_id,
+        locked_at       = NOW(),
+        lock_expires_at = NOW() + ($2 || ' seconds')::INTERVAL,
+        batch_group_id  = gen_random_uuid(),
+        metadata        = jsonb_set(
+                            jsonb_set(
+                                COALESCE(j.metadata, '{}'::jsonb),
+                                '{lock_owner}', to_jsonb($3::text)
+                            ),
+                            '{lock_reason}', to_jsonb($4::text)
+                          ),
+        updated_at      = NOW()
+    FROM candidates c, status_ids si
+    WHERE j.id = c.id
+    RETURNING j.*
+)
+SELECT COALESCE(json_agg(json_build_object(
+    'id',             u.id,
+    'requestId',      u.request_id,
+    'operationType',  u.operation_type,
+    'status',         sjs.status,
+    'blockchain',     u.blockchain,
+    'chainId',        u.chain_id,
+    'batchGroupId',   u.batch_group_id,
+    'lockExpiresAt',  u.lock_expires_at,
+    'lockedAt',       u.locked_at,
+    'txHash',         u.tx_hash,
+    'sentAt',         u.sent_at,
+    'confirmedAt',    u.confirmed_at,
+    'retryCount',     u.retry_count,
+    'errorMessage',   u.error_message,
+    'lastErrorAt',    u.last_error_at,
+    'metadata',       u.metadata,
+    'createdAt',      u.created_at,
+    'updatedAt',      u.updated_at,
+    'withdrawalDetails', json_build_object(
+        'id',                    cw.id,
+        'userId',                cw.user_id,
+        'status',                LOWER(cws.status),
+        'blockchain',            LOWER(cwbt.blockchain),
+        'receiver',              cw.receiver_address,
+        'receiverAddress',       cw.receiver_address,
+        'paymentType',           LOWER(cwpt.type),
+        'chainId',               cw.chain_id,
+        'token',                 cw.token_address,
+        'amount',                cw.amount,
+        'amountInUsd',           cw.amount * cr.rate,
+        'destinationChainId',    cw.destination_chain_id,
+        'destinationToken',      cw.destination_token_address,
+        'destinationBlockchain', cw.destination_blockchain,
+        'sigsExecutiveRequired', cw.sigs_executive_required,
+        'sigsManagerRequired',   cw.sigs_manager_required,
+        'timeLockSeconds',       cw.timelock_seconds,
+        'multisigSignatures', (
+            SELECT COALESCE(json_agg(json_build_object(
+                'name',            COALESCE(role.role_alias, ''),
+                'signerAddress',   cs.signer_address,
+                'contractAddress', cs.contract_address,
+                'createdAt',       cs.created_at,
+                'updatedAt',       cs.updated_at,
+                'operationType',   cs.operation_type,
+                'v',               cs.v,
+                'r',               cs.r,
+                's',               cs.s,
+                'signature',       cs.signature
+            )), '[]'::json)
+            FROM multisig.crypto_signatures cs
+            LEFT JOIN multisig.crypto_escrow_roles cer
+                   ON LOWER(cer.wallet_address)   = LOWER(cs.signer_address)
+                  AND LOWER(cer.blockchain)        = LOWER(cs.blockchain)
+                  AND cer.chain_id                 = cs.chain_id
+                  AND LOWER(cer.contract_address)  = LOWER(cs.contract_address)
+            LEFT JOIN multisig.crypto_role role ON role.id = cer.role_id
+            WHERE cs.reference_id   = cw.id
+              AND cs.operation_type = 1
+              AND (
+                  (cs.v IS NOT NULL AND cs.r IS NOT NULL AND cs.s IS NOT NULL)
+                  OR cs.signature IS NOT NULL
+              )
+        )
+    )
+)), '[]'::json) AS result
+FROM updated u
+JOIN multisig.schedule_job_statuses                      sjs  ON sjs.id  = u.status_id
+JOIN accounting.crypto_withdrawals                       cw   ON cw.id   = u.request_id
+LEFT JOIN accounting.crypto_withdrawal_status            cws  ON cws.id  = cw.status_id
+LEFT JOIN accounting.crypto_withdrawal_blockchain_types  cwbt ON cwbt.id = cw.blockchain_id
+LEFT JOIN accounting.crypto_withdrawal_payment_types     cwpt ON cwpt.id = cw.payment_type_id
+LEFT JOIN usersmanagement.user_currency_mappings         ucm  ON ucm.currency_specific_user_id = cw.currency_specific_user_id
+LEFT JOIN public.currencies                              cur  ON cur.currencyid  = ucm.currency_id
+LEFT JOIN accounting.currencyrates                       cr   ON cr.symbol = UPPER(cur.currency_code || 'USD')
+            `, [limit, job_ttl_s, lock_metadata.lock_owner, lock_metadata.lock_reason]);
+    return (_c = (_b = result.rows[0]) === null || _b === void 0 ? void 0 : _b.result) !== null && _c !== void 0 ? _c : [];
+});
+/** Locks and returns available jobs with full withdrawal details via DB function. */
+ScheduleTransactionService.get_and_lock_available_jobs_with_details_depr = (pool_1, ...args_1) => __awaiter(void 0, [pool_1, ...args_1], void 0, function* (pool, limit = 10, job_ttl_s = 120, lock_metadata = { lock_owner: "schedule-tx-worker", lock_reason: "process_queued" }) {
+    var _b;
+    const result = yield pool.query(`SELECT multisig.fn_get_available_schedule_jobs_with_details($1::int, $2::int, $3::text, $4::text)`, [limit, job_ttl_s, lock_metadata.lock_owner, lock_metadata.lock_reason]);
+    return (_b = result.rows[0].fn_get_available_schedule_jobs_with_details) !== null && _b !== void 0 ? _b : [];
+});
+/**
+ * Requeues all jobs in the given status to "queued"
+ */
+ScheduleTransactionService.requeue_expired_jobs = (pool, data) => __awaiter(void 0, void 0, void 0, function* () {
+    const res = yield pool.query(`
+        WITH status_ids AS (
+            SELECT
+                MAX(CASE WHEN status = $4::text THEN id END) AS current_status_id,
+                MAX(CASE WHEN status = 'queued' THEN id END) AS queued_id
+            FROM multisig.schedule_job_statuses
+        ),
+        expired AS (
+          SELECT sj.id
+          FROM multisig.schedule_transaction_jobs sj, status_ids
+          WHERE sj.status_id = status_ids.current_status_id
+            AND (
+                sj.lock_expires_at IS NULL
+                OR sj.lock_expires_at < now()
+            )
+            AND sj.retry_count < $5
+          ORDER BY sj.lock_expires_at ASC
+          LIMIT $1
+          FOR UPDATE SKIP LOCKED
+        )
+        UPDATE multisig.schedule_transaction_jobs cj
+        SET
+          status_id       = si.queued_id,
+          locked_at       = NULL,
+          lock_expires_at = NULL,
+          metadata = jsonb_set(
+            jsonb_set(
+              coalesce(metadata, '{}'::jsonb),
+              '{requeued_by}',
+              to_jsonb($2::text),
+              true
+            ),
+            '{requeue_reason}',
+            to_jsonb($3::text),
+            true
+          ),
+          updated_at = now()
+        FROM expired e, status_ids si
+        WHERE cj.id = e.id
+        RETURNING cj.*;
+        `, [data.limit, data.lock_owner, data.lock_reason, data.watch_status, data.max_retries]);
+    return res.rows;
+});
+ScheduleTransactionService.batch_update_status = (pool, operation_type, request_ids, new_status) => __awaiter(void 0, void 0, void 0, function* () {
+    yield pool.query(`
+            UPDATE multisig.schedule_transaction_jobs
+            SET
+                status_id  = (SELECT id FROM multisig.schedule_job_statuses WHERE status = $1),
+                updated_at = CURRENT_TIMESTAMP
+            WHERE operation_type = $2::int
+              AND request_id = ANY($3)
+        `, [new_status, operation_type, request_ids]);
+});
+ScheduleTransactionService.batch_update_failed_jobs = (pool, operation_type, request_ids, new_status, error_message, retryable) => __awaiter(void 0, void 0, void 0, function* () {
+    yield pool.query(`
+            UPDATE multisig.schedule_transaction_jobs
+            SET
+                status_id     = (SELECT id FROM multisig.schedule_job_statuses WHERE status = $1),
+                updated_at    = CURRENT_TIMESTAMP,
+                error_message = COALESCE($2, error_message),
+                last_error_at = CASE
+                                    WHEN $2 IS NOT NULL THEN CURRENT_TIMESTAMP
+                                    ELSE last_error_at
+                                END,
+                retry_count   = CASE
+                                    WHEN $3 = true THEN retry_count + 1
+                                    ELSE retry_count
+                                END
+            WHERE operation_type = $5
+              AND request_id = ANY($4)
+        `, [
+        new_status,
+        error_message || null,
+        retryable === true,
+        request_ids,
+        operation_type,
+    ]);
+});
+ScheduleTransactionService.batch_update_failed_jobs_custom_error = (pool, operation_type, jobs) => __awaiter(void 0, void 0, void 0, function* () {
+    const operationTypes = jobs.map(() => operation_type);
+    const requestIds = jobs.map(j => j.request_id);
+    const newStatuses = jobs.map(j => j.new_status);
+    const errorMessages = jobs.map(j => j.error_message);
+    const retryables = jobs.map(j => j.retryable);
+    yield pool.query(`
+          UPDATE multisig.schedule_transaction_jobs AS t
+          SET
+            status_id     = sjs.id,
+            error_message = c.error_message,
+            last_error_at = CURRENT_TIMESTAMP,
+            retry_count   = CASE WHEN c.retryable THEN t.retry_count + 1 ELSE t.retry_count END,
+            updated_at    = CURRENT_TIMESTAMP
+          FROM (
+            SELECT
+                UNNEST($1::int[])     AS operation_type,
+                UNNEST($2::int[])     AS request_id,
+                UNNEST($3::text[])    AS status,
+                UNNEST($4::text[])    AS error_message,
+                UNNEST($5::boolean[]) AS retryable
+          ) AS c
+          JOIN multisig.schedule_job_statuses sjs ON sjs.status = c.status
+          WHERE t.operation_type = c.operation_type
+            AND t.request_id = c.request_id
+        `, [operationTypes, requestIds, newStatuses, errorMessages, retryables]);
+});
+ScheduleTransactionService.batch_update_executed_jobs = (pool, data) => __awaiter(void 0, void 0, void 0, function* () {
+    const requestIds = data.map(d => d.request_id);
+    const operationTypes = data.map(d => d.operation_type);
+    const txHashes = data.map(d => d.tx_hash);
+    const sentAts = data.map(d => d.sent_at);
+    yield pool.query(`
+        UPDATE multisig.schedule_transaction_jobs AS t
+        SET
+            tx_hash    = c.tx_hash,
+            sent_at    = c.sent_at,
+            status_id  = (SELECT id FROM multisig.schedule_job_statuses WHERE status = 'confirming'),
+            updated_at = CURRENT_TIMESTAMP
+        FROM (
+            SELECT
+                UNNEST($1::int[])       AS operation_type,
+                UNNEST($2::int[])       AS request_id,
+                UNNEST($3::text[])      AS tx_hash,
+                UNNEST($4::timestamptz[]) AS sent_at
+        ) AS c
+        WHERE t.request_id = c.request_id
+          AND t.operation_type = c.operation_type
+        `, [operationTypes, requestIds, txHashes, sentAts]);
+});
+ScheduleTransactionService.mark_complete = (pool, payloads) => __awaiter(void 0, void 0, void 0, function* () {
+    if (payloads.length === 0)
+        return;
+    const requestIds = payloads.map(d => d.requestId);
+    const operationTypes = payloads.map(d => d.operationType);
+    yield pool.query(`
+            UPDATE multisig.schedule_transaction_jobs AS t
+            SET
+                status_id  = (SELECT id FROM multisig.schedule_job_statuses WHERE status = 'completed'),
+                updated_at = CURRENT_TIMESTAMP
+            FROM (
+                SELECT
+                    UNNEST($1::int[]) AS request_id,
+                    UNNEST($2::int[]) AS operation_type
+            ) AS c
+            WHERE t.request_id = c.request_id
+              AND t.operation_type = c.operation_type
+        `, [requestIds, operationTypes]);
+});
+// ── BO read views ────────────────────────────────────────────────────────
+/**
+ * Paginated list of current schedule-transaction jobs, newest first, with the
+ * status resolved to text and (for withdrawal operation types) the receiver/token/
+ * amount joined in. All filters are optional and combine with AND.
+ */
+ScheduleTransactionService.list_jobs_paginated = (pool_1, page_1, ...args_1) => __awaiter(void 0, [pool_1, page_1, ...args_1], void 0, function* (pool, page, page_size = 20, filters = {}) {
+    var _b, _c;
+    if (page < 1)
+        page = 1;
+    const clauses = [];
+    const params = [];
+    let i = 1;
+    if (filters.status) {
+        clauses.push(`sjs.status = $${i++}`);
+        params.push(filters.status);
+    }
+    if (filters.blockchain) {
+        clauses.push(`j.blockchain = $${i++}`);
+        params.push(filters.blockchain);
+    }
+    if (filters.chainId) {
+        clauses.push(`j.chain_id = $${i++}`);
+        params.push(filters.chainId);
+    }
+    if (filters.operationType !== undefined) {
+        clauses.push(`j.operation_type = $${i++}`);
+        params.push(filters.operationType);
+    }
+    if (filters.requestId !== undefined) {
+        clauses.push(`j.request_id = $${i++}`);
+        params.push(filters.requestId);
+    }
+    if (filters.txHash) {
+        clauses.push(`j.tx_hash = $${i++}`);
+        params.push(filters.txHash);
+    }
+    const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+    const countRes = yield pool.query(`SELECT COUNT(*)::bigint AS count
+             FROM multisig.schedule_transaction_jobs j
+             JOIN multisig.schedule_job_statuses sjs ON sjs.id = j.status_id
+             ${where}`, params);
+    const total_count = Number((_c = (_b = countRes.rows[0]) === null || _b === void 0 ? void 0 : _b.count) !== null && _c !== void 0 ? _c : 0);
+    const limitParam = i++;
+    const offsetParam = i++;
+    const rowsRes = yield pool.query(`SELECT
+                j.id,
+                j.request_id      AS "requestId",
+                j.operation_type  AS "operationType",
+                sjs.status        AS status,
+                j.blockchain,
+                j.chain_id        AS "chainId",
+                j.tx_hash         AS "txHash",
+                j.locked_at       AS "lockedAt",
+                j.lock_expires_at AS "lockExpiresAt",
+                j.sent_at         AS "sentAt",
+                j.confirmed_at    AS "confirmedAt",
+                j.retry_count     AS "retryCount",
+                j.error_message   AS "errorMessage",
+                j.last_error_at   AS "lastErrorAt",
+                j.metadata,
+                j.created_at      AS "createdAt",
+                j.updated_at      AS "updatedAt",
+                cw.receiver_address AS "receiverAddress",
+                cw.token_address    AS "tokenAddress",
+                cw.amount           AS "amount"
+             FROM multisig.schedule_transaction_jobs j
+             JOIN multisig.schedule_job_statuses sjs ON sjs.id = j.status_id
+             LEFT JOIN accounting.crypto_withdrawals cw
+                    ON cw.id = j.request_id AND j.operation_type IN (1, 3)
+             ${where}
+             ORDER BY j.created_at DESC
+             LIMIT $${limitParam} OFFSET $${offsetParam}`, [...params, page_size, (page - 1) * page_size]);
+    return {
+        total_count,
+        pages_count: Math.ceil(total_count / page_size),
+        current_page: page,
+        has_next: total_count > page * page_size,
+        items: rowsRes.rows
+    };
+});
+/**
+ * Paginated schedule-transaction job history (append-only status transitions),
+ * newest first. All filters are optional and combine with AND.
+ */
+ScheduleTransactionService.list_history_paginated = (pool_1, page_1, ...args_1) => __awaiter(void 0, [pool_1, page_1, ...args_1], void 0, function* (pool, page, page_size = 20, filters = {}) {
+    var _b, _c;
+    if (page < 1)
+        page = 1;
+    const clauses = [];
+    const params = [];
+    let i = 1;
+    if (filters.jobId !== undefined) {
+        clauses.push(`h.job_id = $${i++}`);
+        params.push(filters.jobId);
+    }
+    if (filters.requestId !== undefined) {
+        clauses.push(`h.request_id = $${i++}`);
+        params.push(filters.requestId);
+    }
+    if (filters.operationType !== undefined) {
+        clauses.push(`h.operation_type = $${i++}`);
+        params.push(filters.operationType);
+    }
+    if (filters.status) {
+        clauses.push(`sjs.status = $${i++}`);
+        params.push(filters.status);
+    }
+    if (filters.blockchain) {
+        clauses.push(`h.blockchain = $${i++}`);
+        params.push(filters.blockchain);
+    }
+    if (filters.chainId) {
+        clauses.push(`h.chain_id = $${i++}`);
+        params.push(filters.chainId);
+    }
+    const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+    const countRes = yield pool.query(`SELECT COUNT(*)::bigint AS count
+             FROM multisig.schedule_transaction_jobs_history h
+             JOIN multisig.schedule_job_statuses sjs ON sjs.id = h.status_id
+             ${where}`, params);
+    const total_count = Number((_c = (_b = countRes.rows[0]) === null || _b === void 0 ? void 0 : _b.count) !== null && _c !== void 0 ? _c : 0);
+    const limitParam = i++;
+    const offsetParam = i++;
+    const rowsRes = yield pool.query(`SELECT
+                h.id,
+                h.job_id         AS "jobId",
+                h.request_id     AS "requestId",
+                h.operation_type AS "operationType",
+                sjs.status       AS status,
+                h.blockchain,
+                h.chain_id       AS "chainId",
+                h.tx_hash        AS "txHash",
+                h.retry_count    AS "retryCount",
+                h.error_message  AS "errorMessage",
+                h.created_at     AS "createdAt"
+             FROM multisig.schedule_transaction_jobs_history h
+             JOIN multisig.schedule_job_statuses sjs ON sjs.id = h.status_id
+             ${where}
+             ORDER BY h.created_at DESC
+             LIMIT $${limitParam} OFFSET $${offsetParam}`, [...params, page_size, (page - 1) * page_size]);
+    return {
+        total_count,
+        pages_count: Math.ceil(total_count / page_size),
+        current_page: page,
+        has_next: total_count > page * page_size,
+        items: rowsRes.rows
+    };
+});
+exports.default = ScheduleTransactionService;

package/build/services/rpc/RPC.d.ts

@@ -0,0 +1,20 @@
+import { BlockchainType } from "../../interfaces";
+import { RpcProviderType } from "../../chains/Provider";
+declare class RPC {
+    static instance: RPC;
+    private currentProvider;
+    initialized: boolean;
+    private constructor();
+    static getInstance(): RPC;
+    initialize(config: Partial<{
+        config: Partial<{
+            defaultEvmRpcProviderType: RpcProviderType;
+            defaultSolRpcProviderType: RpcProviderType;
+            defaultTronRpcProviderType: RpcProviderType;
+        }>;
+    }>): void;
+    updateDefault(blockchainType: BlockchainType, targetProvider: RpcProviderType): void;
+    getCurrentDefault(blockchainType: BlockchainType): RpcProviderType;
+}
+export default RPC;
+//# sourceMappingURL=RPC.d.ts.map

package/build/services/rpc/RPC.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RPC.d.ts","sourceRoot":"","sources":["../../../src/services/rpc/RPC.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAKxD,cAAM,GAAG;IACL,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC;IACrB,OAAO,CAAC,eAAe,CAAuC;IACvD,WAAW,EAAE,OAAO,CAAS;IAEpC,OAAO;IAaP,MAAM,CAAC,WAAW;IAQlB,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,OAAO,CAAC;YAAC,yBAAyB,EAAE,eAAe,CAAC;YAAC,yBAAyB,EAAE,eAAe,CAAC;YAAC,0BAA0B,EAAE,eAAe,CAAA;SAAC,CAAC,CAAA;KAAC,CAAC;IAcpL,aAAa,CAAC,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE,eAAe;IAI7E,iBAAiB,CAAC,cAAc,EAAE,cAAc;CAQnD;AAED,eAAe,GAAG,CAAC"}

package/build/services/rpc/RPC.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
+const Provider_1 = require("../../chains/Provider");
+// export var default_archival_connection_provider: RpcProviderType = RpcProviderType.ALCHEMY;
+// export var default_evm_rpc_provider: RpcProviderType = RpcProviderType.ALCHEMY;
+class RPC {
+    constructor() {
+        this.initialized = false;
+        this.currentProvider = new Map();
+        // const config = Config.getInstance();
+        // const evmProvider = config.config.defaultEvmRpcProviderType ? config.config.defaultEvmRpcProviderType : RpcProviderType.ALCHEMY;
+        // const solanaProvider = config.config.defaultSolRpcProviderType ? config.config.defaultSolRpcProviderType : RpcProviderType.ALCHEMY;
+        // const tronProvider = config.config.defaultTronRpcProviderType ? config.config.defaultTronRpcProviderType : RpcProviderType.ALCHEMY;
+        // this.updateDefault(BLOCKCHAINS.EVM, evmProvider);
+        // this.updateDefault(BLOCKCHAINS.SOLANA, solanaProvider);
+        // this.updateDefault(BLOCKCHAINS.TRON, tronProvider);
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new RPC();
+        }
+        return this.instance;
+    }
+    initialize(config) {
+        var _a, _b, _c;
+        if (this.initialized)
+            throw new Error(`RPC provider manager is already initialized. Use 'updateDefault' instead.`);
+        const evmProvider = ((_a = config === null || config === void 0 ? void 0 : config.config) === null || _a === void 0 ? void 0 : _a.defaultEvmRpcProviderType) ? config.config.defaultEvmRpcProviderType : Provider_1.RpcProviderType.ALCHEMY;
+        const solanaProvider = ((_b = config === null || config === void 0 ? void 0 : config.config) === null || _b === void 0 ? void 0 : _b.defaultSolRpcProviderType) ? config.config.defaultSolRpcProviderType : Provider_1.RpcProviderType.ALCHEMY;
+        const tronProvider = ((_c = config === null || config === void 0 ? void 0 : config.config) === null || _c === void 0 ? void 0 : _c.defaultTronRpcProviderType) ? config.config.defaultTronRpcProviderType : Provider_1.RpcProviderType.ALCHEMY;
+        this.updateDefault(constants_1.BLOCKCHAINS.EVM, evmProvider);
+        this.updateDefault(constants_1.BLOCKCHAINS.SOLANA, solanaProvider);
+        this.updateDefault(constants_1.BLOCKCHAINS.TRON, tronProvider);
+        this.initialized = true;
+    }
+    updateDefault(blockchainType, targetProvider) {
+        this.currentProvider.set(blockchainType, targetProvider);
+    }
+    getCurrentDefault(blockchainType) {
+        if (!this.initialized)
+            throw new Error(`RPC provider manager is not initialized`);
+        const current = this.currentProvider.get(blockchainType);
+        if (!current)
+            throw new Error(`RPC provider manager is not initialized`);
+        return current;
+    }
+}
+exports.default = RPC;

package/build/services/solana/escrow/services/TreasuryWithdrawalSignature.d.ts

@@ -0,0 +1,58 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+/**
+ * Treasury withdrawal approval message + Ed25519 assembly.
+ *
+ * Mirrors the escrow program's `build_withdrawal_message` and its Ed25519SigVerify layout so the
+ * batch-withdraw transaction the funding worker sends carries signatures the program accepts.
+ */
+/** One treasury manager/executive approval over a request's message. */
+export interface TreasurySignatureInput {
+    /** Base58 signer pubkey — a current treasury manager/executive on-chain. */
+    signer: string;
+    /** 64-byte Ed25519 signature (base64/hex/base58). */
+    signature: string;
+}
+/**
+ * Builds the UTF-8 approval message a treasury signer approves. MUST match the program's
+ * `build_withdrawal_message` byte for byte, or verification fails.
+ *
+ *   Withdrawal Approval
+ *   Version: 1
+ *   Chain: <chainId>
+ *   Request: <requestId>
+ *   Recipient: <recipient base58>
+ *   Token: <mint base58>
+ *   Amount: <committed amount, raw base units>
+ *
+ * `Amount` is the committed (approved) amount — the net paid out is chosen later by the backend
+ * and bounded on-chain by TreasuryConfig.max_fee_delta. The title + Version line domain-separate
+ * the signature; bump Version in lockstep with the program on any format change.
+ */
+export declare function buildWithdrawalApprovalMessage(params: {
+    recipient: PublicKey;
+    tokenMint: PublicKey;
+    committedAmount: bigint;
+    chainId: bigint;
+    requestId: bigint;
+}): Buffer;
+/** Decode a 64-byte Ed25519 signature from base64, hex (0x-optional), or base58. */
+export declare function decodeEd25519Signature(s: string): Uint8Array;
+/** One fully-decoded signature entry: pubkey + signature over `message`. */
+export interface Ed25519Entry {
+    publicKey: Uint8Array;
+    signature: Uint8Array;
+    message: Uint8Array;
+}
+/**
+ * Builds a single Ed25519SigVerify instruction carrying `entries` self-contained signatures
+ * (each entry's pubkey, signature and message live in this instruction's own data). This is the
+ * compact layout the program scans in `verify_treasury_threshold`; one instruction for the whole
+ * batch keeps the transaction far smaller than one instruction per signature.
+ *
+ * Identical messages are stored ONCE and shared by every signature over them, since the offsets
+ * table lets multiple entries point at the same message region. This matters: the N signers who
+ * approve one withdrawal all sign the same ~194-byte payload, so without sharing, a 2-of-N
+ * approval would spend an extra ~194 bytes and overflow Solana's 1232-byte transaction limit.
+ */
+export declare function buildTreasuryEd25519Instruction(entries: Ed25519Entry[]): TransactionInstruction;
+//# sourceMappingURL=TreasuryWithdrawalSignature.d.ts.map

package/build/services/solana/escrow/services/TreasuryWithdrawalSignature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreasuryWithdrawalSignature.d.ts","sourceRoot":"","sources":["../../../../../src/services/solana/escrow/services/TreasuryWithdrawalSignature.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,SAAS,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAGpF;;;;;GAKG;AAEH,wEAAwE;AACxE,MAAM,WAAW,sBAAsB;IACnC,4EAA4E;IAC5E,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE;IACnD,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,SAAS,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACrB,GAAG,MAAM,CAUT;AAED,oFAAoF;AACpF,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,CAU5D;AAED,4EAA4E;AAC5E,MAAM,WAAW,YAAY;IACzB,SAAS,EAAE,UAAU,CAAC;IACtB,SAAS,EAAE,UAAU,CAAC;IACtB,OAAO,EAAE,UAAU,CAAC;CACvB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,sBAAsB,CAoD/F"}