@yellow-org/sdk 1.0.1-alpha.0

package/dist/rpc/message.js

@@ -0,0 +1,102 @@
+import { newErrorPayload, ERROR_PARAM_KEY } from './error';
+export var MsgType;
+(function (MsgType) {
+    MsgType[MsgType["Req"] = 1] = "Req";
+    MsgType[MsgType["Resp"] = 2] = "Resp";
+    MsgType[MsgType["Event"] = 3] = "Event";
+    MsgType[MsgType["RespErr"] = 4] = "RespErr";
+})(MsgType || (MsgType = {}));
+function bigIntReplacer(key, value) {
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (key === 'blockchain_id' || key === 'epoch' || key === 'version' || key === 'nonce') {
+        if (typeof value === 'number' || typeof value === 'bigint') {
+            return value.toString();
+        }
+    }
+    return value;
+}
+export function newPayload(v) {
+    if (v === null || v === undefined) {
+        return {};
+    }
+    return JSON.parse(JSON.stringify(v, bigIntReplacer));
+}
+export function translatePayload(payload) {
+    return payload;
+}
+export function payloadError(payload) {
+    const errorMsg = payload[ERROR_PARAM_KEY];
+    if (typeof errorMsg === 'string') {
+        return new Error(errorMsg);
+    }
+    return null;
+}
+export function messageError(message) {
+    if (message.type !== MsgType.RespErr) {
+        return null;
+    }
+    return payloadError(message.payload);
+}
+export function newMessage(type, requestId, method, payload = {}) {
+    return {
+        type,
+        requestId,
+        method,
+        payload,
+        timestamp: Date.now(),
+    };
+}
+export function newRequest(requestId, method, payload = {}) {
+    return newMessage(MsgType.Req, requestId, method, payload);
+}
+export function newResponse(requestId, method, payload = {}) {
+    return newMessage(MsgType.Resp, requestId, method, payload);
+}
+export function newEvent(requestId, method, payload = {}) {
+    return newMessage(MsgType.Event, requestId, method, payload);
+}
+export function newErrorResponse(requestId, method, errMsg) {
+    const errPayload = newErrorPayload(errMsg);
+    return newMessage(MsgType.RespErr, requestId, method, errPayload);
+}
+export function marshalMessage(message) {
+    const arr = [
+        message.type,
+        message.requestId,
+        message.method,
+        message.payload,
+        message.timestamp,
+    ];
+    return JSON.stringify(arr, bigIntReplacer);
+}
+export function unmarshalMessage(data) {
+    const arr = JSON.parse(data);
+    if (!Array.isArray(arr) || arr.length !== 5) {
+        throw new Error('invalid RPCData: expected 5 elements in array');
+    }
+    const [type, requestId, method, payload, timestamp] = arr;
+    if (typeof type !== 'number') {
+        throw new Error('invalid type: expected number');
+    }
+    if (typeof requestId !== 'number') {
+        throw new Error('invalid requestId: expected number');
+    }
+    if (typeof method !== 'string') {
+        throw new Error('invalid method: expected string');
+    }
+    if (typeof payload !== 'object' || payload === null) {
+        throw new Error('invalid payload: expected object');
+    }
+    if (typeof timestamp !== 'number') {
+        throw new Error('invalid timestamp: expected number');
+    }
+    return {
+        type: type,
+        requestId,
+        method,
+        payload: payload,
+        timestamp,
+    };
+}

package/dist/rpc/methods.d.ts

@@ -0,0 +1,30 @@
+export type Group = string;
+export type Method = string;
+export declare const ChannelV1Group: Group;
+export declare const ChannelsV1GetHomeChannelMethod: Method;
+export declare const ChannelsV1GetEscrowChannelMethod: Method;
+export declare const ChannelsV1GetChannelsMethod: Method;
+export declare const ChannelsV1GetLatestStateMethod: Method;
+export declare const ChannelsV1GetStatesMethod: Method;
+export declare const ChannelsV1RequestCreationMethod: Method;
+export declare const ChannelsV1SubmitStateMethod: Method;
+export declare const ChannelsV1SubmitSessionKeyStateMethod: Method;
+export declare const ChannelsV1GetLastKeyStatesMethod: Method;
+export declare const AppSessionsV1Group: Group;
+export declare const AppSessionsV1SubmitDepositStateMethod: Method;
+export declare const AppSessionsV1SubmitAppStateMethod: Method;
+export declare const AppSessionsV1RebalanceAppSessionsMethod: Method;
+export declare const AppSessionsV1GetAppDefinitionMethod: Method;
+export declare const AppSessionsV1GetAppSessionsMethod: Method;
+export declare const AppSessionsV1CreateAppSessionMethod: Method;
+export declare const AppSessionsV1CloseAppSessionMethod: Method;
+export declare const AppSessionsV1SubmitSessionKeyStateMethod: Method;
+export declare const AppSessionsV1GetLastKeyStatesMethod: Method;
+export declare const UserV1Group: Group;
+export declare const UserV1GetBalancesMethod: Method;
+export declare const UserV1GetTransactionsMethod: Method;
+export declare const NodeV1Group: Group;
+export declare const NodeV1PingMethod: Method;
+export declare const NodeV1GetConfigMethod: Method;
+export declare const NodeV1GetAssetsMethod: Method;
+export type Event = string;

package/dist/rpc/methods.js

@@ -0,0 +1,27 @@
+export const ChannelV1Group = 'channels.v1';
+export const ChannelsV1GetHomeChannelMethod = 'channels.v1.get_home_channel';
+export const ChannelsV1GetEscrowChannelMethod = 'channels.v1.get_escrow_channel';
+export const ChannelsV1GetChannelsMethod = 'channels.v1.get_channels';
+export const ChannelsV1GetLatestStateMethod = 'channels.v1.get_latest_state';
+export const ChannelsV1GetStatesMethod = 'channels.v1.get_states';
+export const ChannelsV1RequestCreationMethod = 'channels.v1.request_creation';
+export const ChannelsV1SubmitStateMethod = 'channels.v1.submit_state';
+export const ChannelsV1SubmitSessionKeyStateMethod = 'channels.v1.submit_session_key_state';
+export const ChannelsV1GetLastKeyStatesMethod = 'channels.v1.get_last_key_states';
+export const AppSessionsV1Group = 'app_sessions.v1';
+export const AppSessionsV1SubmitDepositStateMethod = 'app_sessions.v1.submit_deposit_state';
+export const AppSessionsV1SubmitAppStateMethod = 'app_sessions.v1.submit_app_state';
+export const AppSessionsV1RebalanceAppSessionsMethod = 'app_sessions.v1.rebalance_app_sessions';
+export const AppSessionsV1GetAppDefinitionMethod = 'app_sessions.v1.get_app_definition';
+export const AppSessionsV1GetAppSessionsMethod = 'app_sessions.v1.get_app_sessions';
+export const AppSessionsV1CreateAppSessionMethod = 'app_sessions.v1.create_app_session';
+export const AppSessionsV1CloseAppSessionMethod = 'app_sessions.v1.close_app_session';
+export const AppSessionsV1SubmitSessionKeyStateMethod = 'app_sessions.v1.submit_session_key_state';
+export const AppSessionsV1GetLastKeyStatesMethod = 'app_sessions.v1.get_last_key_states';
+export const UserV1Group = 'user.v1';
+export const UserV1GetBalancesMethod = 'user.v1.get_balances';
+export const UserV1GetTransactionsMethod = 'user.v1.get_transactions';
+export const NodeV1Group = 'node.v1';
+export const NodeV1PingMethod = 'node.v1.ping';
+export const NodeV1GetConfigMethod = 'node.v1.get_config';
+export const NodeV1GetAssetsMethod = 'node.v1.get_assets';

package/dist/rpc/types.d.ts

@@ -0,0 +1,101 @@
+import { Address } from 'viem';
+import { TransitionType, TransactionType } from '../core/types';
+export interface ChannelV1 {
+    channel_id: string;
+    user_wallet: Address;
+    asset: string;
+    type: string;
+    blockchain_id: string;
+    token_address: Address;
+    challenge_duration: number;
+    challenge_expires_at?: string;
+    nonce: string;
+    approved_sig_validators: string;
+    status: string;
+    state_version: string;
+}
+export interface ChannelDefinitionV1 {
+    nonce: string;
+    challenge: number;
+    approved_sig_validators: string;
+}
+export interface TransitionV1 {
+    type: TransitionType;
+    tx_id: string;
+    account_id: string;
+    amount: string;
+}
+export interface LedgerV1 {
+    token_address: Address;
+    blockchain_id: string;
+    user_balance: string;
+    user_net_flow: string;
+    node_balance: string;
+    node_net_flow: string;
+}
+export interface StateV1 {
+    id: string;
+    transition: TransitionV1;
+    asset: string;
+    user_wallet: Address;
+    epoch: string;
+    version: string;
+    home_channel_id?: string;
+    escrow_channel_id?: string;
+    home_ledger: LedgerV1;
+    escrow_ledger?: LedgerV1;
+    user_sig?: string;
+    node_sig?: string;
+}
+export interface ChannelSessionKeyStateV1 {
+    user_address: string;
+    session_key: string;
+    version: string;
+    assets: string[];
+    expires_at: string;
+    user_sig: string;
+}
+export interface AssetV1 {
+    name: string;
+    symbol: string;
+    decimals: number;
+    suggested_blockchain_id: string;
+    tokens: TokenV1[];
+}
+export interface TokenV1 {
+    name: string;
+    symbol: string;
+    address: Address;
+    blockchain_id: string;
+    decimals: number;
+}
+export interface BlockchainInfoV1 {
+    name: string;
+    blockchain_id: string;
+    channel_hub_address: Address;
+}
+export interface BalanceEntryV1 {
+    asset: string;
+    amount: string;
+}
+export interface TransactionV1 {
+    id: string;
+    asset: string;
+    tx_type: TransactionType;
+    from_account: Address;
+    to_account: Address;
+    sender_new_state_id?: string;
+    receiver_new_state_id?: string;
+    amount: string;
+    created_at: string;
+}
+export interface PaginationParamsV1 {
+    offset?: number;
+    limit?: number;
+}
+export interface PaginationMetadataV1 {
+    page: number;
+    per_page: number;
+    total_count: number;
+    page_count: number;
+}

package/dist/rpc/types.js

@@ -0,0 +1 @@
+export {};

package/dist/signers.d.ts

@@ -0,0 +1,48 @@
+import { Address, Hex } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+export interface StateSigner {
+    getAddress(): Address;
+    signMessage(hash: Hex): Promise<Hex>;
+}
+export interface TransactionSigner {
+    getAddress(): Address;
+    sendTransaction(tx: any): Promise<Hex>;
+    signMessage(message: {
+        raw: Hex;
+    }): Promise<Hex>;
+}
+export declare class EthereumMsgSigner implements StateSigner {
+    private account;
+    constructor(privateKeyOrAccount: Hex | ReturnType<typeof privateKeyToAccount>);
+    getAddress(): Address;
+    signMessage(hash: Hex): Promise<Hex>;
+}
+export declare class EthereumRawSigner implements TransactionSigner {
+    private account;
+    constructor(privateKeyOrAccount: Hex | ReturnType<typeof privateKeyToAccount>);
+    getAddress(): Address;
+    sendTransaction(tx: any): Promise<Hex>;
+    signMessage(message: {
+        raw: Hex;
+    }): Promise<Hex>;
+}
+export declare class ChannelDefaultSigner implements StateSigner {
+    private inner;
+    constructor(inner: StateSigner);
+    getAddress(): Address;
+    signMessage(hash: Hex): Promise<Hex>;
+}
+export declare class ChannelSessionKeyStateSigner implements StateSigner {
+    private account;
+    private walletAddress;
+    private metadataHash;
+    private authSignature;
+    constructor(sessionKeyPrivateKey: Hex, walletAddress: Address, metadataHash: Hex, authSignature: Hex);
+    getAddress(): Address;
+    getSessionKeyAddress(): Address;
+    signMessage(hash: Hex): Promise<Hex>;
+}
+export declare function createSigners(privateKey: Hex): {
+    stateSigner: StateSigner;
+    txSigner: TransactionSigner;
+};

package/dist/signers.js

@@ -0,0 +1,96 @@
+import { encodeAbiParameters } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+export class EthereumMsgSigner {
+    constructor(privateKeyOrAccount) {
+        if (typeof privateKeyOrAccount === 'string') {
+            this.account = privateKeyToAccount(privateKeyOrAccount);
+        }
+        else {
+            this.account = privateKeyOrAccount;
+        }
+    }
+    getAddress() {
+        return this.account.address;
+    }
+    async signMessage(hash) {
+        return await this.account.signMessage({
+            message: { raw: hash },
+        });
+    }
+}
+export class EthereumRawSigner {
+    constructor(privateKeyOrAccount) {
+        if (typeof privateKeyOrAccount === 'string') {
+            this.account = privateKeyToAccount(privateKeyOrAccount);
+        }
+        else {
+            this.account = privateKeyOrAccount;
+        }
+    }
+    getAddress() {
+        return this.account.address;
+    }
+    async sendTransaction(tx) {
+        throw new Error('sendTransaction requires a wallet client - use the blockchain client instead');
+    }
+    async signMessage(message) {
+        return await this.account.sign({ hash: message.raw });
+    }
+}
+export class ChannelDefaultSigner {
+    constructor(inner) {
+        this.inner = inner;
+    }
+    getAddress() {
+        return this.inner.getAddress();
+    }
+    async signMessage(hash) {
+        const sig = await this.inner.signMessage(hash);
+        return `0x00${sig.slice(2)}`;
+    }
+}
+export class ChannelSessionKeyStateSigner {
+    constructor(sessionKeyPrivateKey, walletAddress, metadataHash, authSignature) {
+        this.account = privateKeyToAccount(sessionKeyPrivateKey);
+        this.walletAddress = walletAddress;
+        this.metadataHash = metadataHash;
+        this.authSignature = authSignature;
+    }
+    getAddress() {
+        return this.walletAddress;
+    }
+    getSessionKeyAddress() {
+        return this.account.address;
+    }
+    async signMessage(hash) {
+        const sessionKeySig = await this.account.signMessage({
+            message: { raw: hash },
+        });
+        const encoded = encodeAbiParameters([
+            {
+                type: 'tuple',
+                components: [
+                    { name: 'sessionKey', type: 'address' },
+                    { name: 'metadataHash', type: 'bytes32' },
+                    { name: 'authSignature', type: 'bytes' },
+                ],
+            },
+            { type: 'bytes' },
+        ], [
+            {
+                sessionKey: this.account.address,
+                metadataHash: this.metadataHash,
+                authSignature: this.authSignature,
+            },
+            sessionKeySig,
+        ]);
+        return `0x01${encoded.slice(2)}`;
+    }
+}
+export function createSigners(privateKey) {
+    const account = privateKeyToAccount(privateKey);
+    return {
+        stateSigner: new ChannelDefaultSigner(new EthereumMsgSigner(account)),
+        txSigner: new EthereumRawSigner(account),
+    };
+}

package/dist/utils/sign.d.ts

@@ -0,0 +1,2 @@
+import { Hex } from 'viem';
+export declare function signRawECDSAMessage(message: Hex, privateKey: Hex): Promise<Hex>;

package/dist/utils/sign.js

@@ -0,0 +1,8 @@
+import { privateKeyToAccount } from 'viem/accounts';
+export async function signRawECDSAMessage(message, privateKey) {
+    const account = privateKeyToAccount(privateKey);
+    const signature = await account.signMessage({
+        message: { raw: message },
+    });
+    return signature;
+}

package/dist/utils.d.ts

@@ -0,0 +1,42 @@
+import * as core from './core/types';
+import * as API from './rpc/api';
+import { AssetV1, BalanceEntryV1, ChannelV1, LedgerV1, TransitionV1, StateV1, TransactionV1, PaginationMetadataV1 } from './rpc/types';
+export declare function generateNonce(): bigint;
+export declare function transformNodeConfig(resp: API.NodeV1GetConfigResponse): core.NodeConfig;
+export declare function transformAssets(assets: AssetV1[]): core.Asset[];
+export declare function transformBalances(balances: BalanceEntryV1[]): core.BalanceEntry[];
+export declare function transformChannel(channel: ChannelV1): core.Channel;
+export declare function transformLedger(ledger: LedgerV1): core.Ledger;
+export declare function transformTransition(transition: TransitionV1): core.Transition;
+export declare function transformState(state: StateV1): core.State;
+export declare function transformTransaction(tx: TransactionV1): core.Transaction;
+export declare function transformPaginationMetadata(metadata: PaginationMetadataV1): core.PaginationMetadata;
+import { AppDefinitionV1, AppStateUpdateV1, SignedAppStateUpdateV1, AppSessionInfoV1 } from './app/types';
+export declare function transformAppDefinitionToRPC(def: AppDefinitionV1): any;
+export declare function transformAppStateUpdateToRPC(update: AppStateUpdateV1): {
+    app_session_id: string;
+    intent: import("./app").AppStateUpdateIntent;
+    version: string;
+    allocations: {
+        participant: `0x${string}`;
+        asset: string;
+        amount: string;
+    }[];
+    session_data: string;
+};
+export declare function transformSignedAppStateUpdateToRPC(signed: SignedAppStateUpdateV1): {
+    app_state_update: {
+        app_session_id: string;
+        intent: import("./app").AppStateUpdateIntent;
+        version: string;
+        allocations: {
+            participant: `0x${string}`;
+            asset: string;
+            amount: string;
+        }[];
+        session_data: string;
+    };
+    quorum_sigs: string[];
+};
+export declare function transformAppSessionInfo(raw: any): AppSessionInfoV1;
+export declare function transformAppDefinitionFromRPC(raw: any): AppDefinitionV1;

package/dist/utils.js

@@ -0,0 +1,226 @@
+import * as core from './core/types';
+import Decimal from 'decimal.js';
+export function generateNonce() {
+    return BigInt(Date.now()) * 1000000n + BigInt(Math.floor(Math.random() * 1000000));
+}
+function decodeSigValidators(raw) {
+    if (Array.isArray(raw))
+        return raw;
+    if (typeof raw === 'string' && raw.length > 0) {
+        const binary = atob(raw);
+        return Array.from(binary, (c) => c.charCodeAt(0));
+    }
+    return [];
+}
+export function transformNodeConfig(resp) {
+    const blockchains = resp.blockchains.map((info) => ({
+        name: info.name,
+        id: BigInt(info.blockchain_id),
+        channelHubAddress: info.channel_hub_address,
+        blockStep: 0n,
+    }));
+    return {
+        nodeAddress: resp.node_address,
+        nodeVersion: resp.node_version,
+        supportedSigValidators: decodeSigValidators(resp.supported_sig_validators),
+        blockchains,
+    };
+}
+export function transformAssets(assets) {
+    return assets.map((asset) => ({
+        name: asset.name,
+        symbol: asset.symbol,
+        decimals: asset.decimals,
+        suggestedBlockchainId: BigInt(asset.suggested_blockchain_id),
+        tokens: asset.tokens.map((token) => ({
+            name: token.name,
+            symbol: token.symbol,
+            address: token.address,
+            blockchainId: BigInt(token.blockchain_id),
+            decimals: token.decimals,
+        })),
+    }));
+}
+export function transformBalances(balances) {
+    return balances.map((balance) => ({
+        asset: balance.asset,
+        balance: new Decimal(balance.amount),
+    }));
+}
+function parseChannelType(type) {
+    switch (type.toLowerCase()) {
+        case 'home':
+            return core.ChannelType.Home;
+        case 'escrow':
+            return core.ChannelType.Escrow;
+        default:
+            return core.ChannelType.Home;
+    }
+}
+function parseChannelStatus(status) {
+    switch (status.toLowerCase()) {
+        case 'void':
+            return core.ChannelStatus.Void;
+        case 'open':
+            return core.ChannelStatus.Open;
+        case 'challenged':
+            return core.ChannelStatus.Challenged;
+        case 'closed':
+            return core.ChannelStatus.Closed;
+        default:
+            return core.ChannelStatus.Void;
+    }
+}
+export function transformChannel(channel) {
+    const result = {
+        channelId: channel.channel_id,
+        userWallet: channel.user_wallet,
+        asset: channel.asset,
+        type: parseChannelType(channel.type),
+        blockchainId: BigInt(channel.blockchain_id),
+        tokenAddress: channel.token_address,
+        challengeDuration: channel.challenge_duration,
+        nonce: BigInt(channel.nonce),
+        approvedSigValidators: channel.approved_sig_validators,
+        status: parseChannelStatus(channel.status),
+        stateVersion: BigInt(channel.state_version),
+    };
+    if (channel.challenge_expires_at) {
+        result.challengeExpiresAt = new Date(channel.challenge_expires_at);
+    }
+    return result;
+}
+export function transformLedger(ledger) {
+    return {
+        tokenAddress: ledger.token_address,
+        blockchainId: BigInt(ledger.blockchain_id),
+        userBalance: new Decimal(ledger.user_balance),
+        userNetFlow: new Decimal(ledger.user_net_flow),
+        nodeBalance: new Decimal(ledger.node_balance),
+        nodeNetFlow: new Decimal(ledger.node_net_flow),
+    };
+}
+export function transformTransition(transition) {
+    const result = {
+        type: transition.type,
+        txId: transition.tx_id,
+        amount: new Decimal(transition.amount),
+    };
+    if (transition.account_id) {
+        result.accountId = transition.account_id;
+    }
+    return result;
+}
+export function transformState(state) {
+    const result = {
+        id: state.id,
+        transition: transformTransition(state.transition),
+        asset: state.asset,
+        userWallet: state.user_wallet,
+        epoch: BigInt(state.epoch),
+        version: BigInt(state.version),
+        homeLedger: transformLedger(state.home_ledger),
+    };
+    if (state.home_channel_id) {
+        result.homeChannelId = state.home_channel_id;
+    }
+    if (state.escrow_channel_id) {
+        result.escrowChannelId = state.escrow_channel_id;
+    }
+    if (state.escrow_ledger) {
+        result.escrowLedger = transformLedger(state.escrow_ledger);
+    }
+    if (state.user_sig) {
+        result.userSig = state.user_sig;
+    }
+    if (state.node_sig) {
+        result.nodeSig = state.node_sig;
+    }
+    return result;
+}
+export function transformTransaction(tx) {
+    const result = {
+        id: tx.id,
+        asset: tx.asset,
+        txType: tx.tx_type,
+        fromAccount: tx.from_account,
+        toAccount: tx.to_account,
+        amount: new Decimal(tx.amount),
+        createdAt: new Date(tx.created_at),
+    };
+    if (tx.sender_new_state_id) {
+        result.senderNewStateId = tx.sender_new_state_id;
+    }
+    if (tx.receiver_new_state_id) {
+        result.receiverNewStateId = tx.receiver_new_state_id;
+    }
+    return result;
+}
+export function transformPaginationMetadata(metadata) {
+    return {
+        page: metadata.page,
+        perPage: metadata.per_page,
+        totalCount: metadata.total_count,
+        pageCount: metadata.page_count,
+    };
+}
+export function transformAppDefinitionToRPC(def) {
+    return {
+        application: def.application,
+        participants: def.participants.map(p => ({
+            wallet_address: p.walletAddress,
+            signature_weight: p.signatureWeight,
+        })),
+        quorum: def.quorum,
+        nonce: def.nonce.toString(),
+    };
+}
+export function transformAppStateUpdateToRPC(update) {
+    return {
+        app_session_id: update.appSessionId,
+        intent: update.intent,
+        version: update.version.toString(),
+        allocations: update.allocations.map(a => ({
+            participant: a.participant,
+            asset: a.asset,
+            amount: a.amount.toString(),
+        })),
+        session_data: update.sessionData,
+    };
+}
+export function transformSignedAppStateUpdateToRPC(signed) {
+    return {
+        app_state_update: transformAppStateUpdateToRPC(signed.appStateUpdate),
+        quorum_sigs: signed.quorumSigs,
+    };
+}
+export function transformAppSessionInfo(raw) {
+    return {
+        appSessionId: raw.app_session_id,
+        isClosed: raw.status === 'closed',
+        participants: (raw.participants || []).map((p) => ({
+            walletAddress: p.wallet_address,
+            signatureWeight: p.signature_weight,
+        })),
+        sessionData: raw.session_data || '',
+        quorum: raw.quorum,
+        version: BigInt(raw.version),
+        nonce: BigInt(raw.nonce),
+        allocations: (raw.allocations || []).map((a) => ({
+            participant: a.participant,
+            asset: a.asset,
+            amount: new Decimal(a.amount),
+        })),
+    };
+}
+export function transformAppDefinitionFromRPC(raw) {
+    return {
+        application: raw.application,
+        participants: (raw.participants || []).map((p) => ({
+            walletAddress: p.wallet_address,
+            signatureWeight: p.signature_weight,
+        })),
+        quorum: raw.quorum,
+        nonce: BigInt(raw.nonce),
+    };
+}