@usearete/sdk 0.1.5 → 0.2.0

package/dist/index.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var pako = require('pako');
+var ed25519 = require('@noble/ed25519');
 
 const DEFAULT_MAX_ENTRIES_PER_VIEW = 10000;
 const DEFAULT_CONFIG = {
@@ -187,6 +188,11 @@ function isHostedAreteWebsocketUrl(websocketUrl) {
         return false;
     }
 }
+/**
+ * Historical sentinel accepted for back-compat: connecting with this URL is
+ * treated the same as passing no WebSocket URL at all (HTTP-only mode).
+ */
+const DISABLED_WEBSOCKET_URL = 'ws://127.0.0.1/__arete_disabled__';
 class ConnectionManager {
     constructor(config) {
         this.ws = null;
@@ -202,11 +208,11 @@ class ConnectionManager {
         this.stateHandlers = new Set();
         this.socketIssueHandlers = new Set();
         this.reconnectForTokenRefresh = false;
-        if (!config.websocketUrl) {
-            throw new AreteError('websocketUrl is required', 'INVALID_CONFIG');
-        }
-        this.websocketUrl = config.websocketUrl;
-        this.hostedAreteUrl = isHostedAreteWebsocketUrl(config.websocketUrl);
+        const websocketUrl = config.websocketUrl && config.websocketUrl !== DISABLED_WEBSOCKET_URL
+            ? config.websocketUrl
+            : null;
+        this.websocketUrl = websocketUrl;
+        this.hostedAreteUrl = websocketUrl !== null && isHostedAreteWebsocketUrl(websocketUrl);
         this.reconnectIntervals = config.reconnectIntervals ?? DEFAULT_CONFIG.reconnectIntervals;
         this.maxReconnectAttempts =
             config.maxReconnectAttempts ?? DEFAULT_CONFIG.maxReconnectAttempts;
@@ -298,7 +304,7 @@ class ConnectionManager {
     }
     createTokenEndpointRequestBody() {
         return {
-            websocket_url: this.websocketUrl,
+            websocket_url: this.websocketUrl ?? '',
         };
     }
     async fetchTokenFromEndpoint(tokenEndpoint) {
@@ -452,14 +458,21 @@ class ConnectionManager {
         this.ws.close(1000, 'token refresh');
     }
     buildAuthUrl(token) {
+        const websocketUrl = this.requireWebsocketUrl();
         if (this.authConfig?.tokenTransport === 'bearer') {
-            return this.websocketUrl;
+            return websocketUrl;
         }
         if (!token) {
-            return this.websocketUrl;
+            return websocketUrl;
+        }
+        const separator = websocketUrl.includes('?') ? '&' : '?';
+        return `${websocketUrl}${separator}${DEFAULT_QUERY_PARAMETER}=${encodeURIComponent(token)}`;
+    }
+    requireWebsocketUrl() {
+        if (this.websocketUrl === null) {
+            throw new AreteError('WebSocket transport is disabled (client was connected with transport: "http"); views and subscriptions are unavailable', 'WEBSOCKET_DISABLED');
         }
-        const separator = this.websocketUrl.includes('?') ? '&' : '?';
-        return `${this.websocketUrl}${separator}${DEFAULT_QUERY_PARAMETER}=${encodeURIComponent(token)}`;
+        return this.websocketUrl;
     }
     createWebSocket(url, token) {
         if (this.authConfig?.tokenTransport === 'bearer') {
@@ -479,6 +492,12 @@ class ConnectionManager {
     getState() {
         return this.currentState;
     }
+    async getHttpAuthToken(forceRefresh = false) {
+        return this.getOrRefreshToken(forceRefresh);
+    }
+    clearHttpAuthToken() {
+        this.clearTokenState();
+    }
     onFrame(handler) {
         this.frameHandlers.add(handler);
         return () => {
@@ -514,6 +533,7 @@ class ConnectionManager {
         return issue;
     }
     async connect() {
+        this.requireWebsocketUrl();
         if (this.ws?.readyState === WebSocket.OPEN ||
             this.ws?.readyState === WebSocket.CONNECTING ||
             this.currentState === 'connecting') {
@@ -658,6 +678,7 @@ class ConnectionManager {
         }
     }
     subscribe(subscription) {
+        this.requireWebsocketUrl();
         const subKey = this.makeSubKey(subscription);
         if (this.currentState === 'connected' && this.ws?.readyState === WebSocket.OPEN) {
             if (this.activeSubscriptions.has(subKey)) {
@@ -761,16 +782,20 @@ class ConnectionManager {
     }
 }
 
-function isObject$1(item) {
+const INTERNAL_SEQ_FIELD = '__seq';
+function isObject(item) {
     return item !== null && typeof item === 'object' && !Array.isArray(item);
 }
-function deepMergeWithAppend$1(target, source, appendPaths, currentPath = '') {
-    if (!isObject$1(target) || !isObject$1(source)) {
+function deepMergeWithAppend(target, source, appendPaths, currentPath = '') {
+    if (!isObject(target) || !isObject(source)) {
         return source;
     }
     const result = { ...target };
     for (const key in source) {
         const sourceValue = source[key];
+        if (sourceValue === undefined) {
+            continue;
+        }
         const targetValue = result[key];
         const fieldPath = currentPath ? `${currentPath}.${key}` : key;
         if (Array.isArray(sourceValue) && Array.isArray(targetValue)) {
@@ -781,8 +806,8 @@ function deepMergeWithAppend$1(target, source, appendPaths, currentPath = '') {
                 result[key] = sourceValue;
             }
         }
-        else if (isObject$1(sourceValue) && isObject$1(targetValue)) {
-            result[key] = deepMergeWithAppend$1(targetValue, sourceValue, appendPaths, fieldPath);
+        else if (isObject(sourceValue) && isObject(targetValue)) {
+            result[key] = deepMergeWithAppend(targetValue, sourceValue, appendPaths, fieldPath);
         }
         else {
             result[key] = sourceValue;
@@ -790,6 +815,36 @@ function deepMergeWithAppend$1(target, source, appendPaths, currentPath = '') {
     }
     return result;
 }
+function stripUndefinedProperties(value) {
+    if (Array.isArray(value)) {
+        return value.map(item => stripUndefinedProperties(item));
+    }
+    if (!isObject(value)) {
+        return value;
+    }
+    const result = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+        if (nestedValue === undefined) {
+            continue;
+        }
+        result[key] = stripUndefinedProperties(nestedValue);
+    }
+    return result;
+}
+function toCamelCaseSegment(value) {
+    if (value === '_seq') {
+        return INTERNAL_SEQ_FIELD;
+    }
+    const pascal = value
+        .split(/[_.-]/)
+        .filter(segment => segment.length > 0)
+        .map(segment => segment[0].toUpperCase() + segment.slice(1))
+        .join('');
+    if (pascal.length === 0) {
+        return value;
+    }
+    return pascal[0].toLowerCase() + pascal.slice(1);
+}
 class FrameProcessor {
     constructor(storage, config = {}) {
         this.pendingUpdates = [];
@@ -801,9 +856,10 @@ class FrameProcessor {
             : config.maxEntriesPerView;
         this.flushIntervalMs = config.flushIntervalMs ?? 0;
         this.schemas = config.schemas;
+        this.patchSchemas = config.patchSchemas;
     }
-    getSchema(viewPath) {
-        const schemas = this.schemas;
+    getSchema(viewPath, patch = false) {
+        const schemas = patch ? this.patchSchemas : this.schemas;
         if (!schemas)
             return null;
         const entityName = viewPath.split('/')[0];
@@ -812,19 +868,86 @@ class FrameProcessor {
         const entityKey = entityName;
         return schemas[entityKey] ?? null;
     }
-    validateEntity(viewPath, data) {
-        const schema = this.getSchema(viewPath);
+    normalizeEntity(viewPath, data, patch = false) {
+        const schema = this.getSchema(viewPath, patch)
+            ?? (!patch ? null : this.getSchema(viewPath));
         if (!schema)
-            return true;
+            return data;
         const result = schema.safeParse(data);
         if (!result.success) {
             console.warn('[Arete] Frame validation failed:', {
                 view: viewPath,
                 error: result.error,
             });
-            return false;
+            return null;
         }
-        return true;
+        return stripUndefinedProperties(result.data);
+    }
+    hasSchema(viewPath) {
+        return this.getSchema(viewPath) !== null;
+    }
+    normalizePathSegment(viewPath, segment) {
+        if (!this.hasSchema(viewPath)) {
+            return segment;
+        }
+        return toCamelCaseSegment(segment);
+    }
+    normalizePath(viewPath, path) {
+        if (!this.hasSchema(viewPath)) {
+            return path;
+        }
+        return path
+            .split('.')
+            .filter(segment => segment.length > 0)
+            .map(segment => this.normalizePathSegment(viewPath, segment))
+            .join('.');
+    }
+    normalizeSortConfig(viewPath, sort) {
+        if (!this.hasSchema(viewPath)) {
+            return sort;
+        }
+        return {
+            ...sort,
+            field: sort.field.map(segment => this.normalizePathSegment(viewPath, segment)),
+        };
+    }
+    normalizeAppendPaths(viewPath, append) {
+        if (!append || append.length === 0 || !this.hasSchema(viewPath)) {
+            return append ?? [];
+        }
+        return append.map(path => this.normalizePath(viewPath, path));
+    }
+    extractSeq(data) {
+        if (!isObject(data)) {
+            return undefined;
+        }
+        const seq = data._seq;
+        if (typeof seq === 'string') {
+            return seq;
+        }
+        if (typeof seq === 'number' && Number.isFinite(seq)) {
+            return String(seq);
+        }
+        return undefined;
+    }
+    getInternalSeq(data) {
+        if (!isObject(data)) {
+            return undefined;
+        }
+        const seq = data[INTERNAL_SEQ_FIELD];
+        return typeof seq === 'string' ? seq : undefined;
+    }
+    attachInternalSeq(viewPath, data, seq) {
+        if (!seq || !this.hasSchema(viewPath) || !isObject(data)) {
+            return data;
+        }
+        Object.defineProperty(data, INTERNAL_SEQ_FIELD, {
+            value: seq,
+            enumerable: false,
+            configurable: true,
+            writable: true,
+        });
+        return data;
     }
     handleFrame(frame) {
         if (this.flushIntervalMs === 0) {
@@ -910,7 +1033,9 @@ class FrameProcessor {
     }
     handleSubscribedFrame(frame) {
         if (this.storage.setViewConfig && frame.sort) {
-            this.storage.setViewConfig(frame.view, { sort: frame.sort });
+            this.storage.setViewConfig(frame.view, {
+                sort: this.normalizeSortConfig(frame.view, frame.sort),
+            });
         }
     }
     handleSnapshotFrame(frame) {
@@ -920,17 +1045,19 @@ class FrameProcessor {
     handleSnapshotFrameWithoutEnforce(frame) {
         const viewPath = frame.entity;
         for (const entity of frame.data) {
-            if (!this.validateEntity(viewPath, entity.data)) {
+            const normalized = this.normalizeEntity(viewPath, entity.data);
+            if (normalized === null) {
                 continue;
             }
+            const nextValue = this.attachInternalSeq(viewPath, normalized, this.extractSeq(entity.data));
             const previousValue = this.storage.get(viewPath, entity.key);
-            this.storage.set(viewPath, entity.key, entity.data);
+            this.storage.set(viewPath, entity.key, nextValue);
             this.storage.notifyUpdate(viewPath, entity.key, {
                 type: 'upsert',
                 key: entity.key,
-                data: entity.data,
+                data: nextValue,
             });
-            this.emitRichUpdate(viewPath, entity.key, previousValue, entity.data, 'upsert');
+            this.emitRichUpdate(viewPath, entity.key, previousValue, nextValue, 'upsert');
         }
     }
     handleEntityFrame(frame) {
@@ -943,33 +1070,39 @@ class FrameProcessor {
         switch (frame.op) {
             case 'create':
             case 'upsert':
-                if (!this.validateEntity(viewPath, frame.data)) {
+                {
+                    const normalized = this.normalizeEntity(viewPath, frame.data);
+                    if (normalized === null) {
+                        break;
+                    }
+                    const nextValue = this.attachInternalSeq(viewPath, normalized, frame.seq ?? this.extractSeq(frame.data));
+                    this.storage.set(viewPath, frame.key, nextValue);
+                    this.storage.notifyUpdate(viewPath, frame.key, {
+                        type: 'upsert',
+                        key: frame.key,
+                        data: nextValue,
+                    });
+                    this.emitRichUpdate(viewPath, frame.key, previousValue, nextValue, frame.op);
                     break;
                 }
-                this.storage.set(viewPath, frame.key, frame.data);
-                this.storage.notifyUpdate(viewPath, frame.key, {
-                    type: 'upsert',
-                    key: frame.key,
-                    data: frame.data,
-                });
-                this.emitRichUpdate(viewPath, frame.key, previousValue, frame.data, frame.op);
-                break;
             case 'patch': {
                 const existing = this.storage.get(viewPath, frame.key);
-                const appendPaths = frame.append ?? [];
-                const merged = existing
-                    ? deepMergeWithAppend$1(existing, frame.data, appendPaths)
-                    : frame.data;
-                if (!this.validateEntity(viewPath, merged)) {
+                const normalizedPatch = this.normalizeEntity(viewPath, frame.data, true);
+                if (normalizedPatch === null) {
                     break;
                 }
-                this.storage.set(viewPath, frame.key, merged);
+                const appendPaths = this.normalizeAppendPaths(viewPath, frame.append);
+                const merged = existing
+                    ? deepMergeWithAppend(existing, normalizedPatch, appendPaths)
+                    : normalizedPatch;
+                const nextValue = this.attachInternalSeq(viewPath, merged, frame.seq ?? this.extractSeq(frame.data) ?? this.getInternalSeq(existing));
+                this.storage.set(viewPath, frame.key, nextValue);
                 this.storage.notifyUpdate(viewPath, frame.key, {
                     type: 'patch',
                     key: frame.key,
-                    data: frame.data,
+                    data: normalizedPatch,
                 });
-                this.emitRichUpdate(viewPath, frame.key, previousValue, merged, 'patch', frame.data);
+                this.emitRichUpdate(viewPath, frame.key, previousValue, nextValue, 'patch', normalizedPatch);
                 break;
             }
             case 'delete':
@@ -1002,7 +1135,7 @@ class FrameProcessor {
     }
 }
 
-let ViewData$1 = class ViewData {
+class ViewData {
     constructor() {
         this.entities = new Map();
         this.accessOrder = [];
@@ -1056,7 +1189,7 @@ let ViewData$1 = class ViewData {
         this.entities.clear();
         this.accessOrder = [];
     }
-};
+}
 class MemoryAdapter {
     constructor(_config = {}) {
         this.views = new Map();
@@ -1104,7 +1237,7 @@ class MemoryAdapter {
     set(viewPath, key, data) {
         let view = this.views.get(viewPath);
         if (!view) {
-            view = new ViewData$1();
+            view = new ViewData();
             this.views.set(viewPath, view);
         }
         view.set(key, data);
@@ -1144,7 +1277,7 @@ class MemoryAdapter {
     }
 }
 
-function getNestedValue$1(obj, path) {
+function getNestedValue(obj, path) {
     let current = obj;
     for (const segment of path) {
         if (current === null || current === undefined)
@@ -1155,16 +1288,25 @@ function getNestedValue$1(obj, path) {
     }
     return current;
 }
-function compareSortValues$1(a, b) {
+function compareSortValues(a, b) {
     if (a === b)
         return 0;
     if (a === undefined || a === null)
         return -1;
     if (b === undefined || b === null)
         return 1;
+    if (typeof a === 'bigint' && typeof b === 'bigint') {
+        return a < b ? -1 : 1;
+    }
     if (typeof a === 'number' && typeof b === 'number') {
         return a - b;
     }
+    if (typeof a === 'bigint' && typeof b === 'number' && Number.isInteger(b)) {
+        return a < BigInt(b) ? -1 : 1;
+    }
+    if (typeof a === 'number' && typeof b === 'bigint' && Number.isInteger(a)) {
+        return BigInt(a) < b ? -1 : 1;
+    }
     if (typeof a === 'string' && typeof b === 'string') {
         return a.localeCompare(b);
     }
@@ -1291,7 +1433,7 @@ class SortedStorageDecorator {
         sortedKeys.splice(insertIdx, 0, key);
     }
     binarySearchInsertPosition(viewPath, sortedKeys, sortConfig, newKey, newValue) {
-        const newSortValue = getNestedValue$1(newValue, sortConfig.field);
+        const newSortValue = getNestedValue(newValue, sortConfig.field);
         const isDesc = sortConfig.order === 'desc';
         let low = 0;
         let high = sortedKeys.length;
@@ -1299,8 +1441,8 @@ class SortedStorageDecorator {
             const mid = Math.floor((low + high) / 2);
             const midKey = sortedKeys[mid];
             const midEntity = this.inner.get(viewPath, midKey);
-            const midValue = getNestedValue$1(midEntity, sortConfig.field);
-            let cmp = compareSortValues$1(newSortValue, midValue);
+            const midValue = getNestedValue(midEntity, sortConfig.field);
+            let cmp = compareSortValues(newSortValue, midValue);
             if (isDesc)
                 cmp = -cmp;
             if (cmp === 0) {
@@ -1322,9 +1464,9 @@ class SortedStorageDecorator {
         const isDesc = sortConfig.order === 'desc';
         const entries = allKeys.map(k => [k, this.inner.get(viewPath, k)]);
         entries.sort((a, b) => {
-            const aValue = getNestedValue$1(a[1], sortConfig.field);
-            const bValue = getNestedValue$1(b[1], sortConfig.field);
-            let cmp = compareSortValues$1(aValue, bValue);
+            const aValue = getNestedValue(a[1], sortConfig.field);
+            const bValue = getNestedValue(b[1], sortConfig.field);
+            let cmp = compareSortValues(aValue, bValue);
             if (isDesc)
                 cmp = -cmp;
             if (cmp === 0) {
@@ -1654,6 +1796,160 @@ function createTypedViews(stack, storage, subscriptionRegistry) {
     return views;
 }
 
+class ReadRequestError extends Error {
+    constructor(input) {
+        super(`Read request to '${input.path}' failed (${input.status}): ${input.body}`);
+        this.name = 'ReadRequestError';
+        this.status = input.status;
+        this.path = input.path;
+        this.body = input.body;
+        this.serverErrorCode = input.serverErrorCode;
+    }
+}
+function getServerErrorCode(response, body) {
+    const headerCode = response.headers.get('X-Error-Code');
+    if (headerCode) {
+        return headerCode;
+    }
+    try {
+        const parsed = JSON.parse(body);
+        return typeof parsed.code === 'string' ? parsed.code : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function parseReadResponse(response, path) {
+    if (!response.ok) {
+        const body = await response.text();
+        throw new ReadRequestError({
+            status: response.status,
+            path,
+            body,
+            serverErrorCode: getServerErrorCode(response, body),
+        });
+    }
+    return response.json();
+}
+function programAccountRead(input) {
+    return {
+        account: input.account,
+        path: input.path,
+        schema: input.schema,
+    };
+}
+function programQuery(input) {
+    return {
+        name: input.name,
+        path: input.path,
+        method: input.method,
+        schema: input.schema,
+    };
+}
+function stackQuery(input) {
+    return {
+        name: input.name,
+        path: input.path,
+        method: input.method,
+        schema: input.schema,
+    };
+}
+
+function joinUrl(baseUrl, path) {
+    return `${baseUrl.replace(/\/$/, '')}${path.startsWith('/') ? path : `/${path}`}`;
+}
+function decodeBase64(encoded) {
+    if (typeof atob === 'function') {
+        const binary = atob(encoded);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes;
+    }
+    const bufferCtor = globalThis.Buffer;
+    if (bufferCtor) {
+        return new Uint8Array(bufferCtor.from(encoded, 'base64'));
+    }
+    throw new Error('No base64 decoder available in this environment');
+}
+function deriveHttpEndpoint(wsUrl) {
+    try {
+        const parsed = new URL(wsUrl);
+        if (parsed.protocol === 'ws:') {
+            parsed.protocol = 'http:';
+        }
+        else if (parsed.protocol === 'wss:') {
+            parsed.protocol = 'https:';
+        }
+        return parsed.toString().replace(/\/$/, '');
+    }
+    catch {
+        return wsUrl.replace(/^wss?:/i, (protocol) => protocol.toLowerCase() === 'wss:' ? 'https:' : 'http:');
+    }
+}
+function createChainClient(httpBaseUrl, fetchImpl) {
+    return {
+        async exists(address) {
+            const path = `/chain/exists/${encodeURIComponent(address)}`;
+            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
+            const body = await parseReadResponse(response, path);
+            return body.exists;
+        },
+        async lamports(address) {
+            const path = `/chain/lamports/${encodeURIComponent(address)}`;
+            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
+            const body = await parseReadResponse(response, path);
+            return body.lamports;
+        },
+        async minimumBalanceForRentExemption(space) {
+            const path = `/chain/rent-exemption/${encodeURIComponent(String(space))}`;
+            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
+            const body = await parseReadResponse(response, path);
+            return body.lamports;
+        },
+        async clock() {
+            const path = '/chain/clock';
+            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
+            return parseReadResponse(response, path);
+        },
+        async account(address) {
+            const path = `/chain/accounts/${encodeURIComponent(address)}`;
+            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
+            const body = await parseReadResponse(response, path);
+            if (!body) {
+                return null;
+            }
+            return {
+                address: body.address,
+                ownerProgram: body.ownerProgram,
+                lamports: body.lamports,
+                executable: body.executable,
+                data: decodeBase64(body.data),
+            };
+        },
+        async mint(address) {
+            const path = `/chain/mints/${encodeURIComponent(address)}`;
+            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
+            return parseReadResponse(response, path);
+        },
+        async tokenAccount(address) {
+            const path = `/chain/token-accounts/${encodeURIComponent(address)}`;
+            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
+            return parseReadResponse(response, path);
+        },
+        async balance(input) {
+            const path = '/chain/balances';
+            const response = await fetchImpl(joinUrl(httpBaseUrl, path), {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify(input),
+            });
+            return parseReadResponse(response, path);
+        },
+    };
+}
+
 /**
  * PDA (Program Derived Address) derivation utilities.
  *
@@ -1668,7 +1964,10 @@ function decodeBase58(str) {
     if (str.length === 0) {
         return new Uint8Array(0);
     }
-    const bytes = [0];
+    // Big-endian byte accumulator (stored little-endian here, reversed at the
+    // end). Must start empty: a leading `[0]` produces a spurious extra byte for
+    // all-zero values such as the System Program ("111...1").
+    const bytes = [];
     for (const char of str) {
         const value = BASE58_ALPHABET.indexOf(char);
         if (value === -1) {
@@ -1700,7 +1999,9 @@ function encodeBase58(bytes) {
     if (bytes.length === 0) {
         return '';
     }
-    const digits = [0];
+    // Must start empty for the same reason as `decodeBase58`: a leading `[0]`
+    // yields an extra '1' character when encoding all-zero inputs.
+    const digits = [];
     for (const byte of bytes) {
         let carry = byte;
         for (let i = 0; i < digits.length; i++) {
@@ -1721,25 +2022,125 @@ function encodeBase58(bytes) {
     }
     return digits.reverse().map(d => BASE58_ALPHABET[d]).join('');
 }
+// SHA-256 round constants (first 32 bits of the fractional parts of the cube
+// roots of the first 64 primes).
+const SHA256_K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+/**
+ * Dependency-free, synchronous SHA-256.
+ *
+ * Used so PDA derivation works identically in browsers, Node (both CJS and
+ * ESM), and bundlers without relying on `require('crypto')` or async WebCrypto.
+ */
+function sha256Pure(data) {
+    const h = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const bitLen = data.length * 8;
+    // Pad: append 0x80, then zeros, until length ≡ 56 (mod 64), then 8-byte length.
+    const paddedLen = ((data.length + 8) >> 6) * 64 + 64;
+    const msg = new Uint8Array(paddedLen);
+    msg.set(data);
+    msg[data.length] = 0x80;
+    // 64-bit big-endian bit length (high 32 bits assumed 0 for our seed sizes).
+    const dv = new DataView(msg.buffer);
+    dv.setUint32(paddedLen - 4, bitLen >>> 0, false);
+    dv.setUint32(paddedLen - 8, Math.floor(bitLen / 0x100000000), false);
+    const w = new Uint32Array(64);
+    for (let offset = 0; offset < paddedLen; offset += 64) {
+        for (let i = 0; i < 16; i++) {
+            w[i] = dv.getUint32(offset + i * 4, false);
+        }
+        for (let i = 16; i < 64; i++) {
+            const w15 = w[i - 15];
+            const w2 = w[i - 2];
+            const s0 = ((w15 >>> 7) | (w15 << 25)) ^ ((w15 >>> 18) | (w15 << 14)) ^ (w15 >>> 3);
+            const s1 = ((w2 >>> 17) | (w2 << 15)) ^ ((w2 >>> 19) | (w2 << 13)) ^ (w2 >>> 10);
+            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
+        }
+        let a = h[0], b = h[1], c = h[2], d = h[3];
+        let e = h[4], f = h[5], g = h[6], hh = h[7];
+        for (let i = 0; i < 64; i++) {
+            const S1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
+            const ch = (e & f) ^ (~e & g);
+            const t1 = (hh + S1 + ch + SHA256_K[i] + w[i]) >>> 0;
+            const S0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const t2 = (S0 + maj) >>> 0;
+            hh = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        h[0] = (h[0] + a) >>> 0;
+        h[1] = (h[1] + b) >>> 0;
+        h[2] = (h[2] + c) >>> 0;
+        h[3] = (h[3] + d) >>> 0;
+        h[4] = (h[4] + e) >>> 0;
+        h[5] = (h[5] + f) >>> 0;
+        h[6] = (h[6] + g) >>> 0;
+        h[7] = (h[7] + hh) >>> 0;
+    }
+    const out = new Uint8Array(32);
+    const outView = new DataView(out.buffer);
+    for (let i = 0; i < 8; i++) {
+        outView.setUint32(i * 4, h[i], false);
+    }
+    return out;
+}
 /**
- * SHA-256 hash function (synchronous, Node.js).
+ * SHA-256 hash function (synchronous).
  */
 function sha256Sync(data) {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const { createHash } = require('crypto');
-    return new Uint8Array(createHash('sha256').update(Buffer.from(data)).digest());
+    return sha256Pure(data);
 }
 /**
- * SHA-256 hash function (async, works in browser and Node.js).
+ * SHA-256 hash function (async). Uses WebCrypto when available for speed,
+ * otherwise falls back to the pure implementation.
  */
 async function sha256Async(data) {
     if (typeof globalThis !== 'undefined' && globalThis.crypto && globalThis.crypto.subtle) {
-        // Create a copy of the data to ensure we have an ArrayBuffer
         const copy = new Uint8Array(data);
         const hashBuffer = await globalThis.crypto.subtle.digest('SHA-256', copy);
         return new Uint8Array(hashBuffer);
     }
-    return sha256Sync(data);
+    return sha256Pure(data);
+}
+/**
+ * Check if a 32-byte value is a valid point on the ed25519 curve.
+ *
+ * A valid PDA must be OFF the curve (it must NOT correspond to a real
+ * ed25519 public key, so that no private key can ever sign for it).
+ *
+ * We determine on-curve status by attempting to decompress the candidate
+ * as a compressed Edwards point. If decompression succeeds the value lies
+ * on the curve; if it throws, the value is off-curve and is a valid PDA.
+ * This matches the behaviour of `PublicKey.isOnCurve` in @solana/web3.js.
+ */
+function isOnCurve(publicKey) {
+    if (publicKey.length !== 32) {
+        return false;
+    }
+    try {
+        ed25519.Point.fromHex(publicKey);
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 /**
  * PDA marker bytes appended to seeds before hashing.
@@ -1807,7 +2208,7 @@ async function findProgramAddress(seeds, programId) {
     for (let bump = 255; bump >= 0; bump--) {
         const buffer = buildPdaBuffer(seeds, programIdBytes, bump);
         const hash = await sha256Async(buffer);
-        {
+        if (!isOnCurve(hash)) {
             return [encodeBase58(hash), bump];
         }
     }
@@ -1827,7 +2228,7 @@ function findProgramAddressSync(seeds, programId) {
     for (let bump = 255; bump >= 0; bump--) {
         const buffer = buildPdaBuffer(seeds, programIdBytes, bump);
         const hash = sha256Sync(buffer);
-        {
+        if (!isOnCurve(hash)) {
             return [encodeBase58(hash), bump];
         }
     }
@@ -1876,6 +2277,134 @@ function createPublicKeySeed(address) {
     return decoded;
 }
 
+/**
+ * Typed serialization of PDA seed values.
+ *
+ * Shared by the standalone PDA DSL (`pda-dsl.ts`) and instruction account
+ * resolution (`account-resolver.ts`). When a seed carries a declared type
+ * (from the IDL or the `pdas!` registry), encoding is exact: pubkeys are
+ * base58-decoded to 32 bytes, integers are little-endian at the declared
+ * width. Without a type, legacy heuristics apply for backward compatibility.
+ */
+/**
+ * Normalizes the type-name variants that IDLs and codegen produce
+ * ("Pubkey", "publicKey", "solana_pubkey::Pubkey", "String", ...) to a
+ * canonical seed type. Returns undefined for types that cannot be a seed.
+ */
+function normalizeSeedType(argType) {
+    if (!argType)
+        return undefined;
+    // Strip any path qualifier (e.g. solana_pubkey::Pubkey).
+    const parts = argType.split('::');
+    const t = (parts[parts.length - 1] ?? argType).trim();
+    if (/^[ui](8|16|32|64|128)$/.test(t)) {
+        return t;
+    }
+    switch (t) {
+        case 'pubkey':
+        case 'Pubkey':
+        case 'publicKey':
+        case 'PublicKey':
+            return 'pubkey';
+        case 'string':
+        case 'String':
+        case 'str':
+            return 'string';
+        default:
+            return undefined;
+    }
+}
+/**
+ * Serializes a PDA seed value.
+ *
+ * With a recognized `argType`, encoding is strict and width-exact; an
+ * incompatible value throws rather than deriving a wrong address. Without
+ * one, the legacy heuristics apply: raw bytes pass through, 43/44-character
+ * strings are tried as base58, other strings are utf-8, numbers are 8-byte
+ * little-endian u64.
+ */
+function serializeSeedValue(value, argType) {
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    const t = normalizeSeedType(argType);
+    if (t === 'pubkey') {
+        if (typeof value !== 'string') {
+            throw new Error(`Pubkey seed requires a base58 string, got ${typeof value}`);
+        }
+        const decoded = decodeBase58(value);
+        if (decoded.length !== 32) {
+            throw new Error(`Pubkey seed '${value}' decoded to ${decoded.length} bytes, expected 32`);
+        }
+        return decoded;
+    }
+    if (t === 'string') {
+        if (typeof value !== 'string') {
+            throw new Error(`String seed requires a string value, got ${typeof value}`);
+        }
+        return new TextEncoder().encode(value);
+    }
+    if (t !== undefined) {
+        // Numeric type at a declared width.
+        if (typeof value !== 'bigint' && typeof value !== 'number') {
+            throw new Error(`Numeric seed of type ${t} requires a number/bigint, got ${typeof value}`);
+        }
+        const bits = parseInt(t.slice(1), 10);
+        return serializeNumber(value, bits / 8, t.startsWith('i'));
+    }
+    // --- Untyped: legacy heuristics. ---
+    if (typeof value === 'string') {
+        if (value.length === 43 || value.length === 44) {
+            try {
+                return decodeBase58(value);
+            }
+            catch {
+                return new TextEncoder().encode(value);
+            }
+        }
+        return new TextEncoder().encode(value);
+    }
+    if (typeof value === 'bigint' || typeof value === 'number') {
+        return serializeNumber(value, 8, true);
+    }
+    throw new Error(`Cannot serialize value for PDA seed: ${typeof value}`);
+}
+/**
+ * Little-endian two's-complement encoding at a fixed byte width, with an
+ * overflow check so out-of-range values fail instead of silently truncating.
+ */
+function serializeNumber(value, size, signed) {
+    const buffer = new Uint8Array(size);
+    let n = typeof value === 'bigint' ? value : BigInt(value);
+    const original = n;
+    for (let i = 0; i < size; i++) {
+        buffer[i] = Number(n & BigInt(0xff));
+        n >>= BigInt(8);
+    }
+    const fits = signed ? n === BigInt(0) || n === BigInt(-1) : n === BigInt(0);
+    if (!fits) {
+        throw new Error(`Seed value ${original} does not fit in ${size * 8} bits`);
+    }
+    return buffer;
+}
+
+function getValueByPath(source, path) {
+    if (!source) {
+        return undefined;
+    }
+    if (Object.prototype.hasOwnProperty.call(source, path)) {
+        return source[path];
+    }
+    let current = source;
+    for (const segment of path.split('.')) {
+        if (current === null || typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+
 /**
  * Topologically sort accounts so that dependencies (accountRef) are resolved first.
  * Non-PDA accounts come first, then PDAs in dependency order.
@@ -1962,13 +2491,32 @@ function resolveAccounts(accountMetas, args, options) {
             missing.push(meta.name);
         }
     }
-    // Return accounts in original order (as defined in accountMetas)
+    // Return accounts in original order (as defined in accountMetas).
+    //
+    // Omitted optional accounts that precede a resolved account cannot simply
+    // be dropped — that would shift every later account into the wrong slot.
+    // Anchor's convention is to pass the program ID as a placeholder; trailing
+    // omitted optionals are dropped as usual.
+    const lastResolvedIndex = accountMetas.reduce((last, meta, index) => (resolvedMap[meta.name] ? index : last), -1);
     const orderedAccounts = [];
-    for (const meta of accountMetas) {
+    for (let i = 0; i < accountMetas.length; i++) {
+        const meta = accountMetas[i];
         const resolved = resolvedMap[meta.name];
         if (resolved) {
             orderedAccounts.push(resolved);
         }
+        else if (meta.isOptional && i < lastResolvedIndex) {
+            if (!options.programId) {
+                throw new Error('Omitted optional account "' + meta.name + '" precedes other accounts and needs ' +
+                    'the program ID as a placeholder, but no programId was provided in options.');
+            }
+            orderedAccounts.push({
+                name: meta.name,
+                address: options.programId,
+                isSigner: false,
+                isWritable: false,
+            });
+        }
     }
     return {
         accounts: orderedAccounts,
@@ -1978,24 +2526,25 @@ function resolveAccounts(accountMetas, args, options) {
 function resolveSingleAccount(meta, args, options, resolvedMap) {
     switch (meta.category) {
         case 'signer':
-            return resolveSignerAccount(meta, options.wallet);
+            return resolveSignerAccount(meta, options.accounts, options.wallet);
         case 'known':
             return resolveKnownAccount(meta);
         case 'pda':
-            return resolvePdaAccount(meta, args, resolvedMap, options.programId);
+            return resolvePdaAccount(meta, args, resolvedMap, options.programId, options.resolve);
         case 'userProvided':
             return resolveUserProvidedAccount(meta, options.accounts);
         default:
             return null;
     }
 }
-function resolveSignerAccount(meta, wallet) {
-    if (!wallet) {
+function resolveSignerAccount(meta, accounts, wallet) {
+    const address = accounts?.[meta.name] ?? wallet?.publicKey;
+    if (!address) {
         return null;
     }
     return {
         name: meta.name,
-        address: wallet.publicKey,
+        address,
         isSigner: true,
         isWritable: meta.isWritable,
     };
@@ -2011,7 +2560,7 @@ function resolveKnownAccount(meta) {
         isWritable: meta.isWritable,
     };
 }
-function resolvePdaAccount(meta, args, resolvedMap, programId) {
+function resolvePdaAccount(meta, args, resolvedMap, programId, resolve) {
     if (!meta.pdaConfig) {
         return null;
     }
@@ -2028,13 +2577,16 @@ function resolvePdaAccount(meta, args, resolvedMap, programId) {
             case 'literal':
                 seeds.push(createSeed(seed.value));
                 break;
+            case 'bytes':
+                seeds.push(Uint8Array.from(seed.value));
+                break;
             case 'argRef': {
-                const argValue = args[seed.argName];
+                const argValue = getValueByPath(args, seed.argName) ?? getValueByPath(resolve, seed.argName);
                 if (argValue === undefined) {
                     throw new Error('PDA seed references missing argument: ' + seed.argName +
                         ' (for account "' + meta.name + '")');
                 }
-                seeds.push(createSeed(argValue));
+                seeds.push(serializeSeedValue(argValue, seed.argType));
                 break;
             }
             case 'accountRef': {
@@ -2102,6 +2654,11 @@ function serializeInstructionData(discriminator, args, schema) {
     const buffers = [Buffer.from(discriminator)];
     for (const field of schema) {
         const value = args[field.name];
+        // Option fields treat undefined as None; everything else must be present
+        // (silently encoding zeros for a missing arg corrupts instruction data).
+        if (value === undefined && !(typeof field.type === 'object' && 'option' in field.type)) {
+            throw new Error(`Missing required argument "${field.name}" (type ${JSON.stringify(field.type)})`);
+        }
         const serialized = serializeValue(value, field.type);
         buffers.push(serialized);
     }
@@ -2120,8 +2677,108 @@ function serializeValue(value, type) {
     if ('array' in type) {
         return serializeArray(value, type.array[0], type.array[1]);
     }
+    if ('hashMap' in type) {
+        return serializeHashMap(value, type.hashMap[0], type.hashMap[1]);
+    }
+    if ('struct' in type) {
+        return serializeStruct(value, type.struct);
+    }
+    if ('enum' in type) {
+        return serializeEnum(value, type.enum);
+    }
     throw new Error(`Unknown type: ${JSON.stringify(type)}`);
 }
+function serializeStruct(value, fields) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error(`Struct value must be a plain object, got ${typeof value}`);
+    }
+    const obj = value;
+    const buffers = [];
+    for (const field of fields) {
+        const fieldValue = obj[field.name];
+        if (fieldValue === undefined &&
+            !(typeof field.type === 'object' && 'option' in field.type)) {
+            throw new Error(`Missing required struct field "${field.name}"`);
+        }
+        buffers.push(serializeValue(fieldValue, field.type));
+    }
+    return Buffer.concat(buffers);
+}
+function serializeHashMap(value, keyType, valueType) {
+    if (keyType !== 'string') {
+        throw new Error(`Instruction hashMap keys must use the 'string' schema, got ${JSON.stringify(keyType)}`);
+    }
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error(`HashMap value must be a plain object, got ${typeof value}`);
+    }
+    const entries = Object.entries(value).sort(([left], [right]) => 
+    // Rust/Borsh sorts String keys by their UTF-8 bytes before serializing.
+    Buffer.compare(Buffer.from(left, 'utf8'), Buffer.from(right, 'utf8')));
+    const len = Buffer.alloc(4);
+    len.writeUInt32LE(entries.length, 0);
+    const entryBuffers = [];
+    for (const [key, entryValue] of entries) {
+        entryBuffers.push(serializePrimitive(key, 'string'));
+        entryBuffers.push(serializeValue(entryValue, valueType));
+    }
+    return Buffer.concat([len, ...entryBuffers]);
+}
+function variantName(variant) {
+    return typeof variant === 'string' ? variant : variant.name;
+}
+function serializeEnum(value, variants) {
+    // Numeric value: a bare variant index (fieldless variants only).
+    if (typeof value === 'number') {
+        if (!Number.isInteger(value) || value < 0 || value >= variants.length) {
+            throw new Error(`Enum variant index ${value} out of range (0..${variants.length - 1})`);
+        }
+        const variant = variants[value];
+        if (typeof variant !== 'string') {
+            throw new Error(`Enum variant "${variantName(variant)}" carries data; pass { ${variantName(variant)}: ... } instead of an index`);
+        }
+        return Buffer.from([value]);
+    }
+    // String value: a fieldless variant by name.
+    if (typeof value === 'string') {
+        const index = variants.findIndex((v) => variantName(v) === value);
+        if (index === -1) {
+            throw new Error(`Unknown enum variant "${value}". Expected one of: ${variants.map(variantName).join(', ')}`);
+        }
+        const variant = variants[index];
+        if (typeof variant !== 'string') {
+            throw new Error(`Enum variant "${value}" carries data; pass { ${value}: ... } instead of a bare name`);
+        }
+        return Buffer.from([index]);
+    }
+    // Object value: { variantName: payload } for data-carrying variants.
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        const keys = Object.keys(value);
+        if (keys.length !== 1) {
+            throw new Error(`Enum value must be a single-key object ({ variantName: payload }), got keys [${keys.join(', ')}]`);
+        }
+        const key = keys[0];
+        const payload = value[key];
+        const index = variants.findIndex((v) => variantName(v) === key);
+        if (index === -1) {
+            throw new Error(`Unknown enum variant "${key}". Expected one of: ${variants.map(variantName).join(', ')}`);
+        }
+        const variant = variants[index];
+        if (typeof variant === 'string') {
+            throw new Error(`Enum variant "${key}" is fieldless; pass '${key}' instead of an object`);
+        }
+        const prefix = Buffer.from([index]);
+        if ('fields' in variant) {
+            return Buffer.concat([prefix, serializeStruct(payload, variant.fields)]);
+        }
+        const tuple = payload;
+        if (!Array.isArray(tuple) || tuple.length !== variant.tuple.length) {
+            throw new Error(`Enum variant "${key}" expects a tuple of length ${variant.tuple.length}`);
+        }
+        const elements = variant.tuple.map((elementType, i) => serializeValue(tuple[i], elementType));
+        return Buffer.concat([prefix, ...elements]);
+    }
+    throw new Error(`Cannot serialize enum from value of type ${typeof value}`);
+}
 function serializePrimitive(value, type) {
     switch (type) {
         case 'u8':
@@ -2162,21 +2819,60 @@ function serializePrimitive(value, type) {
         case 'i128':
             const i128 = Buffer.alloc(16);
             const bigI128 = BigInt(value);
-            i128.writeBigInt64LE(bigI128 & BigInt('0xFFFFFFFFFFFFFFFF'), 0);
+            // The masked low limb is always non-negative, so it must be written
+            // unsigned; the arithmetic-shifted high limb carries the sign.
+            i128.writeBigUInt64LE(bigI128 & BigInt('0xFFFFFFFFFFFFFFFF'), 0);
             i128.writeBigInt64LE(bigI128 >> BigInt(64), 8);
             return i128;
+        case 'f32': {
+            const f32 = Buffer.alloc(4);
+            f32.writeFloatLE(value, 0);
+            return f32;
+        }
+        case 'f64': {
+            const f64 = Buffer.alloc(8);
+            f64.writeDoubleLE(value, 0);
+            return f64;
+        }
         case 'bool':
             return Buffer.from([value ? 1 : 0]);
+        case 'bytes': {
+            // Borsh bytes: u32 LE length prefix + raw bytes.
+            const raw = value instanceof Uint8Array
+                ? value
+                : Array.isArray(value)
+                    ? Uint8Array.from(value)
+                    : null;
+            if (raw === null) {
+                throw new Error(`Cannot serialize bytes from value of type ${typeof value}`);
+            }
+            const lenPrefix = Buffer.alloc(4);
+            lenPrefix.writeUInt32LE(raw.length, 0);
+            return Buffer.concat([lenPrefix, Buffer.from(raw)]);
+        }
         case 'string':
             const str = value;
             const strBytes = Buffer.from(str, 'utf-8');
             const strLen = Buffer.alloc(4);
             strLen.writeUInt32LE(strBytes.length, 0);
             return Buffer.concat([strLen, strBytes]);
-        case 'pubkey':
-            // Public key is 32 bytes
-            // In production, decode base58 to 32 bytes
-            return Buffer.alloc(32, 0);
+        case 'pubkey': {
+            // Public key is 32 bytes. Accept base58 strings or raw 32-byte buffers.
+            if (value instanceof Uint8Array) {
+                if (value.length !== 32) {
+                    throw new Error(`Invalid pubkey byte length: expected 32, got ${value.length}`);
+                }
+                return Buffer.from(value);
+            }
+            if (typeof value === 'string') {
+                const decoded = decodeBase58(value);
+                if (decoded.length !== 32) {
+                    throw new Error(`Invalid pubkey: '${value}' decoded to ${decoded.length} bytes, expected 32`);
+                }
+                return Buffer.from(decoded);
+            }
+            throw new Error(`Cannot serialize pubkey from value of type ${typeof value}`);
+        }
         default:
             throw new Error(`Unknown primitive type: ${type}`);
     }
@@ -2203,59 +2899,7 @@ function serializeArray(values, elementType, length) {
 }
 
 /**
- * Waits for transaction confirmation.
- *
- * @param signature - Transaction signature
- * @param level - Desired confirmation level
- * @param timeout - Maximum wait time in milliseconds
- * @returns Confirmation result
- */
-async function waitForConfirmation(signature, level = 'confirmed', timeout = 60000) {
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeout) {
-        const status = await checkTransactionStatus();
-        if (status.err) {
-            throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
-        }
-        if (isConfirmationLevelSufficient(status.confirmations, level)) {
-            return {
-                level,
-                slot: status.slot,
-            };
-        }
-        await sleep(1000);
-    }
-    throw new Error(`Transaction confirmation timeout after ${timeout}ms`);
-}
-async function checkTransactionStatus(_signature) {
-    // In production, query the Solana RPC
-    return {
-        err: null,
-        confirmations: 32,
-        slot: 123456789,
-    };
-}
-function isConfirmationLevelSufficient(confirmations, level) {
-    if (confirmations === null) {
-        return false;
-    }
-    switch (level) {
-        case 'processed':
-            return confirmations >= 0;
-        case 'confirmed':
-            return confirmations >= 1;
-        case 'finalized':
-            return confirmations >= 32;
-        default:
-            return false;
-    }
-}
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-/**
- * Parses and handles instruction errors.
+ * Parses and handles instruction errors.
  */
 /**
  * Parses an error returned from a Solana transaction.
@@ -2313,91 +2957,159 @@ function extractErrorCode(error) {
 function formatProgramError(error) {
     return `${error.name} (${error.code}): ${error.message}`;
 }
-
 /**
- * Converts resolved account array to a map for the builder.
+ * Error thrown when an instruction fails to send and the underlying failure
+ * could be parsed against the handler's IDL error definitions.
  */
-function toResolvedAccountsMap(accounts) {
-    const map = {};
-    for (const account of accounts) {
-        map[account.name] = account.address;
+class InstructionError extends Error {
+    constructor(message, programError, cause) {
+        super(message);
+        this.name = 'InstructionError';
+        this.programError = programError;
+        this.cause = cause;
     }
-    return map;
+}
+
+/**
+ * Creates a data-driven instruction handler.
+ *
+ * The returned handler implements `build()` generically: it serializes args
+ * via the schema-driven serializer and constructs the account key list from
+ * the resolved, ordered accounts. No imperative per-instruction code is
+ * required, which keeps generated SDKs tiny and puts all serialization logic
+ * in one tested place.
+ */
+function createInstructionHandler(config) {
+    const discriminator = config.discriminator instanceof Uint8Array
+        ? config.discriminator
+        : Uint8Array.from(config.discriminator);
+    const argNames = config.args.map((a) => a.name);
+    const errors = config.errors ?? [];
+    return {
+        programId: config.programId,
+        accounts: config.accounts,
+        errors,
+        argNames,
+        build(args, resolved) {
+            const data = serializeInstructionData(discriminator, args, config.args);
+            return {
+                programId: config.programId,
+                keys: resolved.map((r) => ({
+                    pubkey: r.address,
+                    isSigner: r.isSigner,
+                    isWritable: r.isWritable,
+                })),
+                data,
+            };
+        },
+    };
 }
 /**
- * Executes an instruction handler with the given arguments and options.
+ * Splits a merged params object into serialized args and account overrides.
  *
- * This is the main function for executing Solana instructions. It handles:
- * 1. Account resolution (signer, PDA, user-provided)
- * 2. Calling the generated build() function
- * 3. Transaction signing and sending
- * 4. Confirmation waiting
+ * Keys matching a declared argument name are args; keys matching a declared
+ * account name (with a string value) are account address overrides. This
+ * applies to signer slots too, allowing explicit signer addresses to override
+ * the wallet fallback. Anything else throws — a typo'd key silently dropped
+ * here would otherwise change the built instruction. `options.accounts` on
+ * {@link BuildOptions} remains an unvalidated escape hatch for advanced callers.
+ */
+function splitParams(handler, params) {
+    const argNameSet = new Set(handler.argNames);
+    const accountNameSet = new Set(handler.accounts.map((a) => a.name));
+    const args = {};
+    const accountOverrides = {};
+    let resolve;
+    for (const [key, value] of Object.entries(params)) {
+        if (argNameSet.has(key)) {
+            args[key] = value;
+        }
+        else if (key === 'resolve' && !accountNameSet.has(key)) {
+            if (value === undefined) {
+                continue;
+            }
+            if (value === null || Array.isArray(value) || typeof value !== 'object') {
+                throw new Error('Parameter "resolve" must be an object when provided');
+            }
+            resolve = value;
+        }
+        else if (accountNameSet.has(key)) {
+            if (typeof value !== 'string') {
+                // Non-string values are not valid account addresses.
+                throw new Error(`Parameter "${key}" is not a known argument and is not a base58 account address`);
+            }
+            accountOverrides[key] = value;
+        }
+        else {
+            throw new Error(`Unknown parameter "${key}". Expected one of args [${[...argNameSet].join(', ')}] ` +
+                `or accounts [${[...accountNameSet].join(', ')}]`);
+        }
+    }
+    return { args, accountOverrides, resolve };
+}
+/**
+ * Builds a {@link BuiltInstruction} from a handler and a merged params object.
  *
- * @param handler - Instruction handler from generated SDK
- * @param args - Instruction arguments
- * @param options - Execution options
- * @returns Execution result with signature
+ * This is a pure function: it performs no network access. It is the unit of
+ * composition for batching (`wallet.signAndSend([a, b, c])`).
  */
-async function executeInstruction(handler, args, options = {}) {
-    // Step 1: Resolve accounts using handler's account metadata
+function buildInstruction(handler, params, options = {}) {
+    const { args, accountOverrides, resolve } = splitParams(handler, params);
     const resolutionOptions = {
-        accounts: options.accounts,
+        accounts: { ...accountOverrides, ...options.accounts },
+        resolve,
         wallet: options.wallet,
-        programId: handler.programId, // Pass programId for PDA derivation
+        programId: handler.programId,
     };
     const resolution = resolveAccounts(handler.accounts, args, resolutionOptions);
     validateAccountResolution(resolution);
-    // Step 2: Call generated build() function
-    const resolvedAccountsMap = toResolvedAccountsMap(resolution.accounts);
-    const instruction = handler.build(args, resolvedAccountsMap);
-    // Step 3: Build transaction from the built instruction
-    const transaction = buildTransaction(instruction);
-    // Step 4: Sign and send
-    if (!options.wallet) {
-        throw new Error('Wallet required to sign transaction');
+    const instruction = handler.build(args, resolution.accounts);
+    if (options.remainingAccounts?.length) {
+        instruction.keys.push(...options.remainingAccounts);
     }
-    const signature = await options.wallet.signAndSend(transaction);
-    // Step 5: Wait for confirmation
-    const confirmationLevel = options.confirmationLevel ?? 'confirmed';
-    const timeout = options.timeout ?? 60000;
-    const confirmation = await waitForConfirmation(signature, confirmationLevel, timeout);
-    return {
-        signature,
-        confirmationLevel: confirmation.level,
-        slot: confirmation.slot,
-    };
+    return instruction;
 }
 /**
- * Creates a transaction object from a built instruction.
+ * Builds, signs, and sends an instruction via the wallet adapter.
  *
- * @param instruction - Built instruction from handler
- * @returns Transaction object ready for signing
+ * The core SDK does not touch RPC: the adapter owns blockhash, compilation,
+ * signing, sending, and confirmation. On failure, program errors are parsed
+ * against the handler's IDL error definitions and surfaced as an
+ * {@link InstructionError}.
  */
-function buildTransaction(instruction) {
-    // This returns a framework-agnostic transaction representation.
-    // The wallet adapter is responsible for converting this to the
-    // appropriate format (@solana/web3.js Transaction, etc.)
-    return {
-        instructions: [{
-                programId: instruction.programId,
-                keys: instruction.keys,
-                data: Array.from(instruction.data),
-            }],
+async function executeInstruction(handler, params, options = {}) {
+    const instruction = buildInstruction(handler, params, options);
+    if (!options.wallet) {
+        throw new Error('Wallet required to sign and send transaction');
+    }
+    const sendOptions = {
+        ...options.send,
     };
+    if (options.confirmationLevel !== undefined) {
+        sendOptions.confirmationLevel = options.confirmationLevel;
+    }
+    try {
+        const result = await options.wallet.signAndSend([instruction], sendOptions);
+        return { signature: result.signature, slot: result.slot };
+    }
+    catch (err) {
+        const programError = parseInstructionError(err, handler.errors);
+        if (programError) {
+            throw new InstructionError(`${programError.name} (${programError.code}): ${programError.message}`, programError, err);
+        }
+        throw err;
+    }
 }
 /**
  * Creates an instruction executor bound to a specific wallet.
- *
- * @param wallet - Wallet adapter
- * @returns Bound executor function
  */
 function createInstructionExecutor(wallet) {
     return {
-        execute: async (handler, args, options) => {
-            return executeInstruction(handler, args, {
-                ...options,
-                wallet,
-            });
+        execute: async (handler, params, options) => {
+            return executeInstruction(handler, params, { ...options, wallet });
+        },
+        build: (handler, params, options) => {
+            return buildInstruction(handler, params, { ...options, wallet });
         },
     };
 }
@@ -2422,11 +3134,11 @@ function resolveSeeds(seeds, context) {
             case 'bytes':
                 return seed.value;
             case 'argRef': {
-                const value = context.args?.[seed.argName];
+                const value = getValueByPath(context.args, seed.argName) ?? getValueByPath(context.resolve, seed.argName);
                 if (value === undefined) {
                     throw new Error(`Missing arg for PDA seed: ${seed.argName}`);
                 }
-                return serializeArgForSeed(value, seed.argType);
+                return serializeSeedValue(value, seed.argType);
             }
             case 'accountRef': {
                 const address = context.accounts?.[seed.accountName];
@@ -2438,47 +3150,6 @@ function resolveSeeds(seeds, context) {
         }
     });
 }
-function serializeArgForSeed(value, argType) {
-    if (value instanceof Uint8Array) {
-        return value;
-    }
-    if (typeof value === 'string') {
-        if (value.length === 43 || value.length === 44) {
-            try {
-                return decodeBase58(value);
-            }
-            catch {
-                return new TextEncoder().encode(value);
-            }
-        }
-        return new TextEncoder().encode(value);
-    }
-    if (typeof value === 'bigint' || typeof value === 'number') {
-        const size = getArgSize(argType);
-        return serializeNumber(value, size);
-    }
-    throw new Error(`Cannot serialize value for PDA seed: ${typeof value}`);
-}
-function getArgSize(argType) {
-    if (!argType)
-        return 8;
-    const match = argType.match(/^[ui](\d+)$/);
-    if (match && match[1]) {
-        return parseInt(match[1], 10) / 8;
-    }
-    if (argType === 'pubkey')
-        return 32;
-    return 8;
-}
-function serializeNumber(value, size) {
-    const buffer = new Uint8Array(size);
-    let n = typeof value === 'bigint' ? value : BigInt(value);
-    for (let i = 0; i < size; i++) {
-        buffer[i] = Number(n & BigInt(0xff));
-        n >>= BigInt(8);
-    }
-    return buffer;
-}
 function pda(programId, ...seeds) {
     return {
         seeds,
@@ -2504,560 +3175,1250 @@ function createProgramPdas(pdas) {
     return pdas;
 }
 
-class Arete {
-    constructor(url, options) {
-        this.stack = options.stack;
-        this.storage = new SortedStorageDecorator(options.storage ?? new MemoryAdapter());
-        this.processor = new FrameProcessor(this.storage, {
-            maxEntriesPerView: options.maxEntriesPerView,
-            flushIntervalMs: options.flushIntervalMs,
-            schemas: options.validateFrames ? this.stack.schemas : undefined,
-        });
-        this.connection = new ConnectionManager({
-            websocketUrl: url,
-            reconnectIntervals: options.reconnectIntervals,
-            maxReconnectAttempts: options.maxReconnectAttempts,
-            auth: options.auth,
-        });
-        this.subscriptionRegistry = new SubscriptionRegistry(this.connection);
-        this.connection.onFrame((frame) => {
-            this.processor.handleFrame(frame);
-        });
-        this._views = createTypedViews(this.stack, this.storage, this.subscriptionRegistry);
-        this._instructions = this.buildInstructions();
-    }
-    buildInstructions() {
-        const instructions = {};
-        if (this.stack.instructions) {
-            for (const [name, handler] of Object.entries(this.stack.instructions)) {
-                instructions[name] = (args, options) => {
-                    return executeInstruction(handler, args, options);
-                };
-            }
-        }
-        return instructions;
-    }
-    static async connect(stack, options) {
-        const url = options?.url ?? stack.url;
-        if (!url) {
-            throw new AreteError('URL is required (provide url option or define url in stack)', 'INVALID_CONFIG');
-        }
-        const internalOptions = {
-            stack,
-            storage: options?.storage,
-            maxEntriesPerView: options?.maxEntriesPerView,
-            flushIntervalMs: options?.flushIntervalMs,
-            autoReconnect: options?.autoReconnect,
-            reconnectIntervals: options?.reconnectIntervals,
-            maxReconnectAttempts: options?.maxReconnectAttempts,
-            validateFrames: options?.validateFrames,
-            auth: options?.auth,
-        };
-        const client = new Arete(url, internalOptions);
-        if (options?.autoReconnect !== false) {
-            await client.connection.connect();
+const STACK_RUNTIME_EXTENSIONS = '__areteStackRuntimeExtensions';
+const PROGRAM_OPERATION_EXTENSIONS = '__areteProgramOperationExtensions';
+function defineProgramExtensions() {
+    return (extensions) => extensions;
+}
+function mergeNamespace(base, extension) {
+    if (base && typeof base === 'object' && !Array.isArray(base)
+        && extension && typeof extension === 'object' && !Array.isArray(extension)) {
+        const merged = { ...base };
+        for (const [key, value] of Object.entries(extension)) {
+            merged[key] = key in merged ? mergeNamespace(merged[key], value) : value;
         }
-        return client;
+        return merged;
     }
-    get views() {
-        return this._views;
+    return extension;
+}
+function mergeOperations(base, extension) {
+    return {
+        instructions: mergeNamespace(base?.instructions, extension?.instructions),
+        transactions: mergeNamespace(base?.transactions, extension?.transactions),
+        flows: mergeNamespace(base?.flows, extension?.flows),
+    };
+}
+function extendProgram(program, extensions) {
+    const base = program;
+    const extended = { ...program };
+    for (const key of ['pdas', 'accounts', 'queries', 'addresses', 'constants', 'defaults', 'math']) {
+        const extensionValue = extensions[key];
+        if (extensionValue !== undefined) {
+            extended[key] = mergeNamespace(base[key], extensionValue);
+        }
+    }
+    if (extensions.raw !== undefined) {
+        extended.rawInstructions = mergeNamespace(base.rawInstructions, extensions.raw);
+    }
+    const baseFactory = base[PROGRAM_OPERATION_EXTENSIONS]?.createOperations;
+    const extensionFactory = extensions.createOperations;
+    if (baseFactory || extensionFactory) {
+        Object.defineProperty(extended, PROGRAM_OPERATION_EXTENSIONS, {
+            value: {
+                createOperations(context) {
+                    const baseOperations = baseFactory?.(context);
+                    if (baseOperations) {
+                        const connectedProgram = context.program;
+                        connectedProgram.instructions = mergeNamespace(connectedProgram.instructions, baseOperations.instructions);
+                        connectedProgram.transactions = mergeNamespace(connectedProgram.transactions, baseOperations.transactions);
+                        connectedProgram.flows = mergeNamespace(connectedProgram.flows, baseOperations.flows);
+                    }
+                    return mergeOperations(baseOperations, extensionFactory?.(context));
+                },
+            },
+            enumerable: false,
+            configurable: false,
+            writable: false,
+        });
     }
-    get instructions() {
-        return this._instructions;
+    return extended;
+}
+function extendPrograms(programs, extensions) {
+    const merged = { ...programs };
+    for (const [name, program] of Object.entries(programs)) {
+        const extension = extensions[name];
+        merged[name] = extension
+            ? extendProgram(program, extension)
+            : program;
+    }
+    return merged;
+}
+function getProgramRuntimeExtensions(program) {
+    return program[PROGRAM_OPERATION_EXTENSIONS];
+}
+function defineStackExtensions() {
+    return (extensions) => extensions;
+}
+function extendStack(stack, extensions) {
+    const base = stack;
+    const extended = { ...stack };
+    for (const key of ['addresses', 'constants', 'defaults', 'math']) {
+        if (extensions[key] !== undefined) {
+            extended[key] = mergeNamespace(base[key], extensions[key]);
+        }
+    }
+    const baseRuntime = base[STACK_RUNTIME_EXTENSIONS];
+    if (baseRuntime || extensions.createRead || extensions.createFlows) {
+        Object.defineProperty(extended, STACK_RUNTIME_EXTENSIONS, {
+            value: {
+                createRead: baseRuntime?.createRead && extensions.createRead
+                    ? (client) => mergeNamespace(baseRuntime.createRead(client), extensions.createRead(client))
+                    : extensions.createRead ?? baseRuntime?.createRead,
+                createFlows: baseRuntime?.createFlows && extensions.createFlows
+                    ? (client) => mergeNamespace(baseRuntime.createFlows(client), extensions.createFlows(client))
+                    : extensions.createFlows ?? baseRuntime?.createFlows,
+            },
+            enumerable: false,
+            configurable: false,
+            writable: false,
+        });
     }
-    get connectionState() {
-        return this.connection.getState();
+    return extended;
+}
+function getStackRuntimeExtensions(stack) {
+    return stack[STACK_RUNTIME_EXTENSIONS];
+}
+function defineClientField(target, key, value) {
+    if (value === undefined || key in target) {
+        return;
+    }
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: false,
+    });
+}
+function applyConnectedStackExtensions(client, stack) {
+    const extendedStack = stack;
+    defineClientField(client, 'addresses', extendedStack.addresses);
+    defineClientField(client, 'constants', extendedStack.constants);
+    defineClientField(client, 'defaults', extendedStack.defaults);
+    defineClientField(client, 'math', extendedStack.math);
+    const runtime = getStackRuntimeExtensions(stack);
+    defineClientField(client, 'flows', runtime?.createFlows?.(client));
+    defineClientField(client, 'read', runtime?.createRead?.(client));
+    return client;
+}
+
+function isPreparedInstruction(instruction) {
+    return 'kind' in instruction
+        && instruction.kind === 'instruction'
+        && 'instruction' in instruction;
+}
+function nonEmpty(values, label) {
+    if (values.length === 0) {
+        throw new Error(`${label} must contain at least one item`);
     }
-    get stackName() {
-        return this.stack.name;
+    return [...values];
+}
+function dedupe(values) {
+    return [...new Set(values)];
+}
+function inferSignerAddresses(instructions) {
+    return dedupe(instructions.flatMap((instruction) => instruction.keys.filter((key) => key.isSigner).map((key) => key.pubkey)));
+}
+function createPreparedTransactionBody(input) {
+    const instructions = nonEmpty(input.instructions, `Transaction '${input.name}'`);
+    return {
+        name: input.name,
+        instructions,
+        requiredSignerAddresses: dedupe(input.requiredSignerAddresses ?? inferSignerAddresses(instructions)),
+        errors: [...(input.errors ?? [])],
+    };
+}
+function createPlan(name, artifacts, transactions) {
+    return {
+        name,
+        artifacts,
+        transactions: nonEmpty(transactions, `Flow '${name}'`),
+    };
+}
+function createPreparedInstruction(input) {
+    const transaction = createPreparedTransactionBody({
+        name: input.name,
+        instructions: [input.instruction],
+        requiredSignerAddresses: input.requiredSignerAddresses,
+        errors: input.errors,
+    });
+    return {
+        kind: 'instruction',
+        name: input.name,
+        instruction: input.instruction,
+        transaction,
+        plan: createPlan(input.name, input.artifacts, [transaction]),
+        artifacts: input.artifacts,
+    };
+}
+function createPreparedTransaction(input) {
+    const hasInstructions = input.instructions !== undefined;
+    const hasOperations = input.operations !== undefined;
+    if (hasInstructions === hasOperations) {
+        throw new Error(`Transaction '${input.name}' must provide exactly one of instructions or operations`);
+    }
+    const transactionParts = hasOperations
+        ? input.operations.map((operation) => operation.transaction)
+        : input.instructions.map((instruction) => isPreparedInstruction(instruction)
+            ? instruction.transaction
+            : createPreparedTransactionBody({
+                name: input.name,
+                instructions: [instruction],
+            }));
+    const transaction = createPreparedTransactionBody({
+        name: input.name,
+        instructions: transactionParts.flatMap((part) => part.instructions),
+        requiredSignerAddresses: input.requiredSignerAddresses
+            ?? transactionParts.flatMap((part) => part.requiredSignerAddresses),
+        errors: input.errors ?? transactionParts.flatMap((part) => part.errors),
+    });
+    return {
+        kind: 'transaction',
+        name: input.name,
+        transaction,
+        plan: createPlan(input.name, input.artifacts, [transaction]),
+        artifacts: input.artifacts,
+    };
+}
+function createPreparedFlow(input) {
+    const transactions = input.transactions.map((transaction) => createPreparedTransactionBody(transaction));
+    return {
+        kind: 'flow',
+        name: input.name,
+        plan: createPlan(input.name, input.artifacts, transactions),
+        artifacts: input.artifacts,
+    };
+}
+function prependTransactionInstructions(transaction, instructions) {
+    return createPreparedTransactionBody({
+        ...transaction,
+        instructions: [...instructions, ...transaction.instructions],
+        requiredSignerAddresses: [
+            ...inferSignerAddresses(instructions),
+            ...transaction.requiredSignerAddresses,
+        ],
+    });
+}
+function appendTransactionInstructions(transaction, instructions) {
+    return createPreparedTransactionBody({
+        ...transaction,
+        instructions: [...transaction.instructions, ...instructions],
+        requiredSignerAddresses: [
+            ...transaction.requiredSignerAddresses,
+            ...inferSignerAddresses(instructions),
+        ],
+    });
+}
+function appendFlowTransactions(flow, transactions) {
+    return createPreparedFlow({
+        name: flow.name,
+        artifacts: flow.artifacts,
+        transactions: [...flow.plan.transactions, ...transactions],
+    });
+}
+function prependFlowTransactionInstructions(flow, transactionIndex, instructions) {
+    const transaction = flow.plan.transactions[transactionIndex];
+    if (!transaction) {
+        throw new Error(`Flow '${flow.name}' has no transaction at index ${transactionIndex}`);
+    }
+    const transactions = [...flow.plan.transactions];
+    transactions[transactionIndex] = prependTransactionInstructions(transaction, instructions);
+    return createPreparedFlow({
+        name: flow.name,
+        artifacts: flow.artifacts,
+        transactions,
+    });
+}
+function inferSignerAddress(value) {
+    if (typeof value === 'string' && value.length > 0) {
+        return value;
     }
-    get store() {
-        return this.storage;
+    if (!value || typeof value !== 'object') {
+        return null;
     }
-    onConnectionStateChange(callback) {
-        return this.connection.onStateChange(callback);
+    const candidate = value;
+    if (typeof candidate.address === 'string' && candidate.address.length > 0) {
+        return candidate.address;
     }
-    onFrame(callback) {
-        return this.connection.onFrame(callback);
+    if (typeof candidate.publicKey === 'string' && candidate.publicKey.length > 0) {
+        return candidate.publicKey;
     }
-    onSocketIssue(callback) {
-        return this.connection.onSocketIssue(callback);
+    const publicKey = candidate.publicKey;
+    return typeof publicKey?.toBase58 === 'function' ? publicKey.toBase58() : null;
+}
+function validateTransactionSigners(transaction, host, options) {
+    const signerAddresses = (options.signers ?? []).map(inferSignerAddress);
+    const available = new Set(options.availableSignerAddresses ?? []);
+    for (const address of options.signerRegistry?.addresses() ?? []) {
+        available.add(address);
     }
-    async connect() {
-        await this.connection.connect();
+    const wallet = options.wallet ?? host.wallet;
+    for (const address of wallet?.signerAddresses ?? []) {
+        available.add(address);
     }
-    disconnect() {
-        this.subscriptionRegistry.clear();
-        this.connection.disconnect();
+    const walletAddress = wallet?.publicKey ?? host.publicKey;
+    if (walletAddress) {
+        available.add(walletAddress);
     }
-    isConnected() {
-        return this.connection.isConnected();
+    for (const address of signerAddresses) {
+        if (address) {
+            available.add(address);
+        }
     }
-    clearStore() {
-        this.storage.clear();
+    const missing = transaction.requiredSignerAddresses.filter((address) => !available.has(address));
+    if (missing.length > 0) {
+        throw new Error(`Missing signer(s) for ${transaction.name}: ${missing.join(', ')}`);
     }
-    getStore() {
-        return this.storage;
+}
+class OperationExecutionError extends Error {
+    constructor(input) {
+        super(`Operation '${input.operation.name}' failed at transaction ${input.failedTransactionIndex + 1} (${input.failedTransaction.name})`);
+        this.name = 'OperationExecutionError';
+        this.operation = input.operation;
+        this.failedTransaction = input.failedTransaction;
+        this.failedTransactionIndex = input.failedTransactionIndex;
+        this.completedReceipts = [...input.completedReceipts];
+        this.cause = input.cause;
     }
-    getConnection() {
-        return this.connection;
+}
+async function executePreparedOperation(host, operation, options = {}) {
+    const receipts = [];
+    const signers = [
+        ...new Set([
+            ...(options.signerRegistry?.values() ?? []),
+            ...(options.signers ?? []),
+        ]),
+    ];
+    for (const [transactionIndex, transaction] of operation.plan.transactions.entries()) {
+        try {
+            validateTransactionSigners(transaction, host, options);
+            await options.onTransactionStart?.({ operation, transaction, transactionIndex });
+            const result = await host.transaction(transaction.instructions, {
+                wallet: options.wallet,
+                send: options.send,
+                errors: [...transaction.errors],
+                signers: signers.length > 0 ? signers : undefined,
+            });
+            const receipt = {
+                transactionIndex,
+                transactionName: transaction.name,
+                signature: result.signature,
+                slot: result.slot,
+            };
+            receipts.push(receipt);
+            await options.onTransactionSuccess?.({
+                operation,
+                transaction,
+                transactionIndex,
+                receipt,
+            });
+        }
+        catch (cause) {
+            throw new OperationExecutionError({
+                operation,
+                failedTransaction: transaction,
+                failedTransactionIndex: transactionIndex,
+                completedReceipts: receipts,
+                cause,
+            });
+        }
     }
-    getSubscriptionRegistry() {
-        return this.subscriptionRegistry;
+    if (operation.kind === 'flow') {
+        return {
+            kind: 'flow',
+            operationName: operation.name,
+            artifacts: operation.artifacts,
+            signatures: nonEmpty(receipts.map((receipt) => receipt.signature), `Operation '${operation.name}' signatures`),
+            transactions: nonEmpty(receipts, `Operation '${operation.name}' receipts`),
+        };
     }
+    return {
+        kind: operation.kind,
+        operationName: operation.name,
+        artifacts: operation.artifacts,
+        signatures: [receipts[0].signature],
+        transaction: receipts[0],
+    };
 }
-
-function getNestedValue(obj, path) {
-    let current = obj;
-    for (const segment of path) {
-        if (current === null || current === undefined)
-            return undefined;
-        if (typeof current !== 'object')
-            return undefined;
-        current = current[segment];
+function convertToJsonValue(value, ancestors) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+        return value;
     }
-    return current;
-}
-function compareSortValues(a, b) {
-    if (a === b)
-        return 0;
-    if (a === undefined || a === null)
-        return -1;
-    if (b === undefined || b === null)
-        return 1;
-    if (typeof a === 'number' && typeof b === 'number') {
-        return a - b;
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : null;
     }
-    if (typeof a === 'string' && typeof b === 'string') {
-        return a.localeCompare(b);
+    if (typeof value === 'bigint') {
+        return value.toString();
     }
-    if (typeof a === 'boolean' && typeof b === 'boolean') {
-        return (a ? 1 : 0) - (b ? 1 : 0);
+    if (value === undefined
+        || typeof value === 'function'
+        || typeof value === 'symbol') {
+        return undefined;
     }
-    return String(a).localeCompare(String(b));
-}
-class ViewData {
-    constructor(sortConfig) {
-        this.entities = new Map();
-        this.accessOrder = [];
-        this.sortedKeys = [];
-        this.sortConfig = sortConfig;
+    if (typeof value !== 'object') {
+        return String(value);
     }
-    get(key) {
-        return this.entities.get(key);
+    if (ancestors.has(value)) {
+        throw new Error('Cannot convert a circular value to JSON');
     }
-    set(key, value) {
-        const isNew = !this.entities.has(key);
-        this.entities.set(key, value);
-        if (this.sortConfig) {
-            this.updateSortedPosition(key, value, isNew);
+    ancestors.add(value);
+    try {
+        if (ArrayBuffer.isView(value)) {
+            return Array.from(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
         }
-        else {
-            if (isNew) {
-                this.accessOrder.push(key);
-            }
-            else {
-                this.touch(key);
-            }
+        if (value instanceof ArrayBuffer) {
+            return Array.from(new Uint8Array(value));
         }
-    }
-    updateSortedPosition(key, value, isNew) {
-        if (!isNew) {
-            const existingIdx = this.sortedKeys.indexOf(key);
-            if (existingIdx !== -1) {
-                this.sortedKeys.splice(existingIdx, 1);
-            }
+        if (Array.isArray(value)) {
+            return value.map((entry) => convertToJsonValue(entry, ancestors) ?? null);
         }
-        const sortValue = getNestedValue(value, this.sortConfig.field);
-        const isDesc = this.sortConfig.order === 'desc';
-        let insertIdx = this.binarySearchInsertPosition(sortValue, key, isDesc);
-        this.sortedKeys.splice(insertIdx, 0, key);
-    }
-    binarySearchInsertPosition(sortValue, key, isDesc) {
-        let low = 0;
-        let high = this.sortedKeys.length;
-        while (low < high) {
-            const mid = Math.floor((low + high) / 2);
-            const midKey = this.sortedKeys[mid];
-            if (midKey === undefined)
-                break;
-            const midEntity = this.entities.get(midKey);
-            const midValue = getNestedValue(midEntity, this.sortConfig.field);
-            let cmp = compareSortValues(sortValue, midValue);
-            if (isDesc)
-                cmp = -cmp;
-            if (cmp === 0) {
-                cmp = key.localeCompare(midKey);
-            }
-            if (cmp < 0) {
-                high = mid;
-            }
-            else {
-                low = mid + 1;
-            }
+        if (value instanceof Set) {
+            return [...value].map((entry) => convertToJsonValue(entry, ancestors) ?? null);
         }
-        return low;
-    }
-    delete(key) {
-        if (this.sortConfig) {
-            const idx = this.sortedKeys.indexOf(key);
-            if (idx !== -1) {
-                this.sortedKeys.splice(idx, 1);
+        if (value instanceof Map) {
+            const result = {};
+            for (const [key, entry] of value) {
+                const converted = convertToJsonValue(entry, ancestors);
+                if (converted !== undefined) {
+                    result[String(key)] = converted;
+                }
             }
+            return result;
         }
-        else {
-            const idx = this.accessOrder.indexOf(key);
-            if (idx !== -1) {
-                this.accessOrder.splice(idx, 1);
+        const toJSON = value.toJSON;
+        if (typeof toJSON === 'function') {
+            return convertToJsonValue(toJSON.call(value), ancestors) ?? null;
+        }
+        const result = {};
+        for (const [key, entry] of Object.entries(value)) {
+            const converted = convertToJsonValue(entry, ancestors);
+            if (converted !== undefined) {
+                result[key] = converted;
             }
         }
-        return this.entities.delete(key);
+        return result;
     }
-    has(key) {
-        return this.entities.has(key);
+    finally {
+        ancestors.delete(value);
     }
-    values() {
-        if (this.sortConfig) {
-            return this.sortedKeys.map(k => this.entities.get(k));
+}
+function toJsonValue(value) {
+    return convertToJsonValue(value, new Set()) ?? null;
+}
+function describePreparedOperation(operation) {
+    return {
+        kind: operation.kind,
+        name: operation.name,
+        artifacts: toJsonValue(operation.artifacts),
+        transactions: operation.plan.transactions.map((transaction) => ({
+            name: transaction.name,
+            requiredSignerAddresses: transaction.requiredSignerAddresses,
+            errors: transaction.errors,
+            instructions: transaction.instructions.map((instruction) => ({
+                programId: instruction.programId,
+                keys: instruction.keys,
+                data: Array.from(instruction.data),
+            })),
+        })),
+    };
+}
+function formatPreparedOperation(operation) {
+    const lines = [
+        `${operation.kind}: ${operation.name}`,
+        `Transactions: ${operation.plan.transactions.length}`,
+    ];
+    for (const [index, transaction] of operation.plan.transactions.entries()) {
+        lines.push(`  ${index + 1}. ${transaction.name} (${transaction.instructions.length} instruction${transaction.instructions.length === 1 ? '' : 's'})`);
+        if (transaction.requiredSignerAddresses.length > 0) {
+            lines.push(`    Signers: ${transaction.requiredSignerAddresses.join(', ')}`);
+        }
+    }
+    return lines.join('\n');
+}
+
+function mergeAttachedPrograms(stack, attachedPrograms) {
+    const merged = { ...(attachedPrograms ?? {}) };
+    for (const [name, definition] of Object.entries(stack.programs ?? {})) {
+        if (name in merged) {
+            console.warn(`Ignoring attached program '${name}' for stack '${stack.name}' because the stack already defines that key`);
         }
-        return Array.from(this.entities.values());
+        merged[name] = definition;
     }
-    keys() {
-        if (this.sortConfig) {
-            return [...this.sortedKeys];
-        }
-        return Array.from(this.entities.keys());
+    return merged;
+}
+function normalizeProgramAccountWireKeys(value) {
+    if (Array.isArray(value)) {
+        return value.map(normalizeProgramAccountWireKeys);
     }
-    get size() {
-        return this.entities.size;
+    if (!value || typeof value !== 'object') {
+        return value;
     }
-    touch(key) {
-        if (this.sortConfig)
-            return;
-        const idx = this.accessOrder.indexOf(key);
-        if (idx !== -1) {
-            this.accessOrder.splice(idx, 1);
-            this.accessOrder.push(key);
-        }
+    return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => [
+        key.replace(/[A-Z]/g, (letter, index) => `${index === 0 ? '' : '_'}${letter.toLowerCase()}`),
+        normalizeProgramAccountWireKeys(nestedValue),
+    ]));
+}
+function parseProgramAccountValue(definition, value) {
+    const schema = definition.schema;
+    if (!schema) {
+        return value;
     }
-    evictOldest() {
-        if (this.sortConfig) {
-            const oldest = this.sortedKeys.pop();
-            if (oldest !== undefined) {
-                this.entities.delete(oldest);
-            }
-            return oldest;
-        }
-        const oldest = this.accessOrder.shift();
-        if (oldest !== undefined) {
-            this.entities.delete(oldest);
-        }
-        return oldest;
+    const parsed = schema.safeParse(value);
+    if (parsed.success) {
+        return parsed.data;
     }
-    setSortConfig(config) {
-        if (this.sortConfig)
-            return;
-        this.sortConfig = config;
-        this.rebuildSortedKeys();
+    const normalized = schema.safeParse(normalizeProgramAccountWireKeys(value));
+    if (normalized.success) {
+        return normalized.data;
     }
-    rebuildSortedKeys() {
-        if (!this.sortConfig)
-            return;
-        const entries = Array.from(this.entities.entries());
-        const isDesc = this.sortConfig.order === 'desc';
-        entries.sort((a, b) => {
-            const aValue = getNestedValue(a[1], this.sortConfig.field);
-            const bValue = getNestedValue(b[1], this.sortConfig.field);
-            let cmp = compareSortValues(aValue, bValue);
-            if (isDesc)
-                cmp = -cmp;
-            if (cmp === 0) {
-                cmp = a[0].localeCompare(b[0]);
-            }
-            return cmp;
+    throw new Error(`Program account read '${definition.account}' failed schema validation`);
+}
+function cloneStackWithPrograms(stack, programs) {
+    const cloned = Object.create(Object.getPrototypeOf(stack), Object.getOwnPropertyDescriptors(stack));
+    cloned.programs = programs;
+    return cloned;
+}
+function withPrograms(stack, attachedPrograms) {
+    return cloneStackWithPrograms(stack, mergeAttachedPrograms(stack, attachedPrograms));
+}
+let Arete$1 = class Arete {
+    constructor(url, httpBaseUrl, options) {
+        this.stack = options.stack;
+        this._wallet = options.wallet;
+        this.executionDefaults = options.execution;
+        this.httpBaseUrl = httpBaseUrl;
+        this.fetchImpl = options.fetch ?? this.resolveFetchImpl();
+        this.storage = new SortedStorageDecorator(options.storage ?? new MemoryAdapter());
+        this.processor = new FrameProcessor(this.storage, {
+            maxEntriesPerView: options.maxEntriesPerView,
+            flushIntervalMs: options.flushIntervalMs,
+            schemas: this.stack.schemas,
+            patchSchemas: this.stack.patchSchemas,
         });
-        this.sortedKeys = entries.map(([k]) => k);
-        this.accessOrder = [];
+        this.connection = new ConnectionManager({
+            websocketUrl: url,
+            reconnectIntervals: options.reconnectIntervals,
+            maxReconnectAttempts: options.maxReconnectAttempts,
+            auth: options.auth,
+        });
+        this.subscriptionRegistry = new SubscriptionRegistry(this.connection);
+        this.connection.onFrame((frame) => {
+            this.processor.handleFrame(frame);
+        });
+        this._views = createTypedViews(this.stack, this.storage, this.subscriptionRegistry);
+        this._queries = this.buildQueries();
+        this._chain = createChainClient(this.httpBaseUrl, this.authenticatedFetch.bind(this));
+        this._programs = this.buildPrograms();
     }
-    getSortConfig() {
-        return this.sortConfig;
+    resolveFetchImpl() {
+        if (typeof globalThis.fetch !== 'function') {
+            throw new AreteError('A fetch implementation is required for HTTP point reads (provide ConnectOptions.fetch or use an environment with global fetch)', 'INVALID_CONFIG');
+        }
+        return globalThis.fetch.bind(globalThis);
     }
-}
-function isObject(item) {
-    return item !== null && typeof item === 'object' && !Array.isArray(item);
-}
-function deepMergeWithAppend(target, source, appendPaths, currentPath = '') {
-    if (!isObject(target) || !isObject(source)) {
-        return source;
+    buildQueries() {
+        const queries = {};
+        for (const [name, definition] of Object.entries(this.stack.queries ?? {})) {
+            queries[name] = this.createQueryExecutor(definition);
+        }
+        return queries;
     }
-    const result = { ...target };
-    for (const key in source) {
-        const sourceValue = source[key];
-        const targetValue = result[key];
-        const fieldPath = currentPath ? `${currentPath}.${key}` : key;
-        if (Array.isArray(sourceValue) && Array.isArray(targetValue)) {
-            if (appendPaths.includes(fieldPath)) {
-                result[key] = [...targetValue, ...sourceValue];
+    buildPrograms() {
+        const bases = {};
+        for (const [name, definition] of Object.entries(this.stack.programs ?? {})) {
+            const instructions = {};
+            for (const [instructionName, handler] of Object.entries(definition.rawInstructions ?? {})) {
+                instructions[instructionName] = this.createTypedInstruction(handler);
             }
-            else {
-                result[key] = sourceValue;
+            const accounts = {};
+            for (const [accountName, accountDefinition] of Object.entries(definition.accounts ?? {})) {
+                accounts[accountName] = this.createAccountReader(accountDefinition);
             }
+            const queries = {};
+            for (const [queryName, queryDefinition] of Object.entries(definition.queries ?? {})) {
+                queries[queryName] = this.createQueryExecutor(queryDefinition);
+            }
+            bases[name] = {
+                name: definition.name,
+                programId: definition.programId,
+                schemas: definition.schemas,
+                pdas: definition.pdas ?? {},
+                accounts,
+                queries,
+                raw: instructions,
+                addresses: definition.addresses ?? {},
+                constants: definition.constants ?? {},
+                defaults: definition.defaults ?? {},
+                math: definition.math ?? {},
+            };
         }
-        else if (isObject(sourceValue) && isObject(targetValue)) {
-            result[key] = deepMergeWithAppend(targetValue, sourceValue, appendPaths, fieldPath);
-        }
-        else {
-            result[key] = sourceValue;
+        const programs = {};
+        const client = this;
+        for (const [name, definition] of Object.entries(this.stack.programs ?? {})) {
+            const base = bases[name];
+            const connectedProgram = {
+                ...base,
+                instructions: {},
+                transactions: {},
+                flows: {},
+            };
+            const runtime = getProgramRuntimeExtensions(definition);
+            const operations = runtime?.createOperations({
+                chain: this._chain,
+                get wallet() {
+                    return client._wallet;
+                },
+                program: connectedProgram,
+            });
+            connectedProgram.instructions = operations?.instructions ?? {};
+            connectedProgram.transactions = operations?.transactions ?? {};
+            connectedProgram.flows = operations?.flows ?? {};
+            programs[name] = connectedProgram;
         }
+        return programs;
     }
-    return result;
-}
-class EntityStore {
-    constructor(config = {}) {
-        this.views = new Map();
-        this.viewConfigs = new Map();
-        this.updateCallbacks = new Set();
-        this.richUpdateCallbacks = new Set();
-        this.maxEntriesPerView = config.maxEntriesPerView === undefined
-            ? DEFAULT_MAX_ENTRIES_PER_VIEW
-            : config.maxEntriesPerView;
+    createTypedInstruction(handler) {
+        return {
+            build: (params, options) => buildInstruction(handler, params, this.withWallet(options)),
+        };
     }
-    enforceMaxEntries(viewData) {
-        if (this.maxEntriesPerView === null)
-            return;
-        while (viewData.size > this.maxEntriesPerView) {
-            viewData.evictOldest();
-        }
+    createAccountReader(definition) {
+        return {
+            fetch: async (address) => {
+                const result = await this.readJson(`${definition.path}/${encodeURIComponent(address)}`);
+                return result === null ? null : parseProgramAccountValue(definition, result);
+            },
+            fetchMany: async (addresses) => {
+                const result = await this.readJson(definition.path, {
+                    method: 'POST',
+                    body: { addresses },
+                });
+                return result.map((value) => value === null ? null : parseProgramAccountValue(definition, value));
+            },
+            exists: async (address) => {
+                const result = await this.readJson(`${definition.path}/${encodeURIComponent(address)}/exists`);
+                return result.exists;
+            },
+        };
     }
-    handleFrame(frame) {
-        if (isSubscribedFrame(frame)) {
-            this.handleSubscribedFrame(frame);
-            return;
-        }
-        if (isSnapshotFrame(frame)) {
-            this.handleSnapshotFrame(frame);
-            return;
-        }
-        this.handleEntityFrame(frame);
+    createQueryExecutor(definition) {
+        return async (params) => {
+            const result = await this.readJson(definition.path, {
+                method: definition.method ?? 'POST',
+                body: params,
+            });
+            if (!definition.schema) {
+                return result;
+            }
+            const parsed = definition.schema.safeParse(result);
+            if (!parsed.success) {
+                throw new Error(`Query '${definition.name}' failed schema validation`);
+            }
+            return parsed.data;
+        };
     }
-    handleSubscribedFrame(frame) {
-        const viewPath = frame.view;
-        const config = {};
-        if (frame.sort) {
-            config.sort = frame.sort;
-        }
-        this.viewConfigs.set(viewPath, config);
-        const existingView = this.views.get(viewPath);
-        if (existingView && frame.sort) {
-            existingView.setSortConfig(frame.sort);
+    async readJson(path, options) {
+        const response = await this.authenticatedFetch(this.resolveReadUrl(path), {
+            method: options?.method ?? 'GET',
+            headers: options?.body === undefined ? undefined : { 'content-type': 'application/json' },
+            body: options?.body === undefined ? undefined : JSON.stringify(options.body),
+        });
+        return parseReadResponse(response, path);
+    }
+    async authenticatedFetch(input, init) {
+        const attempt = async (forceRefresh = false) => {
+            const token = await this.connection.getHttpAuthToken(forceRefresh);
+            const headers = new Headers(init?.headers ?? undefined);
+            if (token) {
+                headers.set('authorization', `Bearer ${token}`);
+            }
+            return this.fetchImpl(input, {
+                ...init,
+                headers,
+            });
+        };
+        let response = await attempt(false);
+        if (!response.ok) {
+            const wireErrorCode = response.headers.get('X-Error-Code');
+            const errorCode = wireErrorCode ? parseErrorCode(wireErrorCode) : undefined;
+            if (errorCode && shouldRefreshToken(errorCode)) {
+                this.connection.clearHttpAuthToken();
+                response = await attempt(true);
+            }
         }
+        return response;
     }
-    handleSnapshotFrame(frame) {
-        const viewPath = frame.entity;
-        let viewData = this.views.get(viewPath);
-        const viewConfig = this.viewConfigs.get(viewPath);
-        if (!viewData) {
-            viewData = new ViewData(viewConfig?.sort);
-            this.views.set(viewPath, viewData);
+    resolveReadUrl(path) {
+        return `${this.httpBaseUrl.replace(/\/$/, '')}${path.startsWith('/') ? path : `/${path}`}`;
+    }
+    /** Merge the client's default wallet into call options (call options win). */
+    withWallet(options) {
+        const merged = { ...(options ?? {}) };
+        if (!merged.wallet && this._wallet) {
+            merged.wallet = this._wallet;
         }
-        for (const entity of frame.data) {
-            const previousValue = viewData.get(entity.key);
-            viewData.set(entity.key, entity.data);
-            this.notifyUpdate(viewPath, entity.key, {
-                type: 'upsert',
-                key: entity.key,
-                data: entity.data,
-            });
-            this.notifyRichUpdate(viewPath, entity.key, previousValue, entity.data, 'upsert');
+        return merged;
+    }
+    static async connect(stack, options) {
+        const requestedUrl = options?.url ?? stack.endpoints.ws;
+        const autoReconnect = options?.autoReconnect !== false;
+        const httpOnly = options?.transport === 'http' || (!requestedUrl && !autoReconnect);
+        const url = httpOnly ? null : requestedUrl;
+        const httpUrl = options?.httpUrl
+            ?? stack.endpoints.http
+            ?? (requestedUrl ? deriveHttpEndpoint(requestedUrl) : undefined);
+        if (!httpOnly && !url) {
+            throw new AreteError('WebSocket URL is required (provide url option or define endpoints.ws in stack)', 'INVALID_CONFIG');
+        }
+        if (!httpUrl) {
+            throw new AreteError('HTTP endpoint is required for transport: "http" (provide httpUrl option or define endpoints.http in stack)', 'INVALID_CONFIG');
+        }
+        const attachedPrograms = options?.programs;
+        const effectiveStack = withPrograms(stack, attachedPrograms);
+        const internalOptions = {
+            stack: effectiveStack,
+            httpUrl,
+            storage: options?.storage,
+            maxEntriesPerView: options?.maxEntriesPerView,
+            flushIntervalMs: options?.flushIntervalMs,
+            autoReconnect: options?.autoReconnect,
+            reconnectIntervals: options?.reconnectIntervals,
+            maxReconnectAttempts: options?.maxReconnectAttempts,
+            validateFrames: options?.validateFrames,
+            auth: options?.auth,
+            wallet: options?.wallet,
+            fetch: options?.fetch,
+            execution: options?.execution,
+        };
+        const client = new Arete(url, httpUrl, internalOptions);
+        if (!httpOnly && autoReconnect) {
+            await client.connection.connect();
         }
-        this.enforceMaxEntries(viewData);
+        return applyConnectedStackExtensions(client, effectiveStack);
     }
-    handleEntityFrame(frame) {
-        const viewPath = frame.entity;
-        let viewData = this.views.get(viewPath);
-        const viewConfig = this.viewConfigs.get(viewPath);
-        if (!viewData) {
-            viewData = new ViewData(viewConfig?.sort);
-            this.views.set(viewPath, viewData);
+    get views() {
+        return this._views;
+    }
+    get queries() {
+        return this._queries;
+    }
+    get programs() {
+        return this._programs;
+    }
+    get chain() {
+        return this._chain;
+    }
+    /** The default wallet adapter, if one was configured. */
+    get wallet() {
+        return this._wallet;
+    }
+    /** The connected wallet address, if a default wallet was configured. */
+    get publicKey() {
+        return this._wallet?.publicKey;
+    }
+    /**
+     * Set (or clear) the default wallet adapter used for instruction execution.
+     * Useful for connecting/disconnecting a wallet after the client is created.
+     */
+    setWallet(wallet) {
+        this._wallet = wallet;
+    }
+    /**
+     * Sign and send a batch of pre-built instructions as a single transaction.
+     *
+     * Build instructions with `client.programs.<program>.raw.<name>.build(params)`
+     * and compose them here. RPC/compilation/confirmation are owned by the adapter.
+     *
+     * On failure, the error is parsed against `options.errors` when given,
+     * otherwise against error metadata aggregated from all the stack's handlers
+     * (deduped by code, first-wins — if the stack bundles programs with
+     * overlapping error codes, pass `options.errors` or use the per-instruction
+     * call path for precise attribution).
+     */
+    async transaction(instructions, options) {
+        const wallet = options?.wallet ?? this._wallet;
+        if (!wallet) {
+            throw new Error('Wallet required to sign and send transaction');
         }
-        const previousValue = viewData.get(frame.key);
-        switch (frame.op) {
-            case 'create':
-            case 'upsert':
-                viewData.set(frame.key, frame.data);
-                this.enforceMaxEntries(viewData);
-                this.notifyUpdate(viewPath, frame.key, {
-                    type: 'upsert',
-                    key: frame.key,
-                    data: frame.data,
-                });
-                this.notifyRichUpdate(viewPath, frame.key, previousValue, frame.data, frame.op);
-                break;
-            case 'patch': {
-                const existing = viewData.get(frame.key);
-                const appendPaths = frame.append ?? [];
-                const merged = existing
-                    ? deepMergeWithAppend(existing, frame.data, appendPaths)
-                    : frame.data;
-                viewData.set(frame.key, merged);
-                this.enforceMaxEntries(viewData);
-                this.notifyUpdate(viewPath, frame.key, {
-                    type: 'patch',
-                    key: frame.key,
-                    data: frame.data,
-                });
-                this.notifyRichUpdate(viewPath, frame.key, previousValue, merged, 'patch', frame.data);
-                break;
+        try {
+            const sendOptions = {
+                ...(options?.send ?? {}),
+            };
+            if (options?.signers !== undefined) {
+                sendOptions.signers = options.signers;
             }
-            case 'delete':
-                viewData.delete(frame.key);
-                this.notifyUpdate(viewPath, frame.key, {
-                    type: 'delete',
-                    key: frame.key,
-                });
-                if (previousValue !== undefined) {
-                    this.notifyRichDelete(viewPath, frame.key, previousValue);
+            const result = await wallet.signAndSend(instructions, sendOptions);
+            return { signature: result.signature, slot: result.slot };
+        }
+        catch (err) {
+            const programError = parseInstructionError(err, options?.errors ?? this.aggregateErrors());
+            if (programError) {
+                throw new InstructionError(`${programError.name} (${programError.code}): ${programError.message}`, programError, err);
+            }
+            throw err;
+        }
+    }
+    execute(prepared, options) {
+        const defaults = this.executionDefaults;
+        return executePreparedOperation(this, prepared, {
+            wallet: options?.wallet ?? defaults?.wallet,
+            send: defaults?.send || options?.send
+                ? { ...(defaults?.send ?? {}), ...(options?.send ?? {}) }
+                : undefined,
+            signers: options?.signers ?? defaults?.signers,
+            signerRegistry: options?.signerRegistry ?? defaults?.signerRegistry,
+            availableSignerAddresses: options?.availableSignerAddresses ?? defaults?.availableSignerAddresses,
+            onTransactionStart: options?.onTransactionStart ?? defaults?.onTransactionStart,
+            onTransactionSuccess: options?.onTransactionSuccess ?? defaults?.onTransactionSuccess,
+        });
+    }
+    /** Error metadata from every handler in the stack, deduped by code. */
+    aggregateErrors() {
+        if (!this._aggregatedErrors) {
+            const all = [];
+            const seen = new Set();
+            const collect = (handler) => {
+                for (const error of handler.errors ?? []) {
+                    if (!seen.has(error.code)) {
+                        seen.add(error.code);
+                        all.push(error);
+                    }
                 }
-                break;
+            };
+            for (const program of Object.values(this.stack.programs ?? {})) {
+                for (const handler of Object.values(program.rawInstructions ?? {})) {
+                    collect(handler);
+                }
+            }
+            this._aggregatedErrors = all;
         }
+        return this._aggregatedErrors;
     }
-    getAll(viewPath) {
-        const viewData = this.views.get(viewPath);
-        if (!viewData)
-            return [];
-        return viewData.values();
+    get connectionState() {
+        return this.connection.getState();
     }
-    get(viewPath, key) {
-        const viewData = this.views.get(viewPath);
-        if (!viewData)
-            return null;
-        const value = viewData.get(key);
-        return value !== undefined ? value : null;
+    get stackName() {
+        return this.stack.name;
     }
-    getAllSync(viewPath) {
-        const viewData = this.views.get(viewPath);
-        if (!viewData)
-            return undefined;
-        return viewData.values();
+    get store() {
+        return this.storage;
     }
-    getSync(viewPath, key) {
-        const viewData = this.views.get(viewPath);
-        if (!viewData)
-            return undefined;
-        const value = viewData.get(key);
-        return value !== undefined ? value : null;
+    onConnectionStateChange(callback) {
+        return this.connection.onStateChange(callback);
     }
-    keys(viewPath) {
-        const viewData = this.views.get(viewPath);
-        if (!viewData)
-            return [];
-        return viewData.keys();
+    onFrame(callback) {
+        return this.connection.onFrame(callback);
     }
-    size(viewPath) {
-        const viewData = this.views.get(viewPath);
-        return viewData?.size ?? 0;
+    onSocketIssue(callback) {
+        return this.connection.onSocketIssue(callback);
     }
-    clear() {
-        this.views.clear();
+    async connect() {
+        await this.connection.connect();
     }
-    clearView(viewPath) {
-        this.views.delete(viewPath);
-        this.viewConfigs.delete(viewPath);
+    disconnect() {
+        this.subscriptionRegistry.clear();
+        this.connection.disconnect();
     }
-    getViewConfig(viewPath) {
-        return this.viewConfigs.get(viewPath);
+    isConnected() {
+        return this.connection.isConnected();
     }
-    setViewConfig(viewPath, config) {
-        this.viewConfigs.set(viewPath, config);
-        const existingView = this.views.get(viewPath);
-        if (existingView && config.sort) {
-            existingView.setSortConfig(config.sort);
-        }
+    clearStore() {
+        this.storage.clear();
     }
-    onUpdate(callback) {
-        this.updateCallbacks.add(callback);
-        return () => {
-            this.updateCallbacks.delete(callback);
-        };
+    getStore() {
+        return this.storage;
     }
-    onRichUpdate(callback) {
-        this.richUpdateCallbacks.add(callback);
-        return () => {
-            this.richUpdateCallbacks.delete(callback);
-        };
+    getConnection() {
+        return this.connection;
     }
-    subscribe(viewPath, callback) {
-        const handler = (path, _key, update) => {
-            if (path === viewPath) {
-                callback(update);
-            }
-        };
-        this.updateCallbacks.add(handler);
-        return () => {
-            this.updateCallbacks.delete(handler);
-        };
+    getSubscriptionRegistry() {
+        return this.subscriptionRegistry;
     }
-    subscribeToKey(viewPath, key, callback) {
-        const handler = (path, updateKey, update) => {
-            if (path === viewPath && updateKey === key) {
-                callback(update);
+};
+
+function createSignerRegistry(entries = []) {
+    const signers = new Map();
+    for (const [address, signer] of entries) {
+        if (!address) {
+            throw new Error('Signer registry addresses must not be empty');
+        }
+        signers.set(address, signer);
+    }
+    return {
+        register(address, signer) {
+            if (!address) {
+                throw new Error('Signer registry addresses must not be empty');
             }
-        };
-        this.updateCallbacks.add(handler);
-        return () => {
-            this.updateCallbacks.delete(handler);
-        };
+            signers.set(address, signer);
+        },
+        unregister(address) {
+            return signers.delete(address);
+        },
+        get(address) {
+            return signers.get(address);
+        },
+        has(address) {
+            return signers.has(address);
+        },
+        addresses() {
+            return [...signers.keys()];
+        },
+        values() {
+            return [...signers.values()];
+        },
+        entries() {
+            return [...signers.entries()];
+        },
+        clear() {
+            signers.clear();
+        },
+    };
+}
+
+function resolveMemberConnectOptions(stack, member, options, forceHttpOnly) {
+    const transport = member?.transport ?? options?.transport ?? (forceHttpOnly ? 'http' : 'ws');
+    // Resolution order: per-member override → the stack's own endpoints →
+    // session-wide fallback endpoints.
+    const url = member?.url ?? (stack.endpoints.ws || options?.endpoints?.ws);
+    const httpUrl = member?.httpUrl ?? stack.endpoints.http ?? options?.endpoints?.http;
+    return {
+        url,
+        httpUrl,
+        transport,
+        auth: member?.auth ?? options?.auth,
+        storage: member?.storage,
+        autoReconnect: member?.autoReconnect,
+        wallet: options?.wallet,
+        fetch: options?.fetch,
+    };
+}
+function programAsStack(name, program) {
+    return {
+        name,
+        endpoints: { ws: '' },
+        views: {},
+        programs: { [name]: program },
+    };
+}
+async function createSession(definition, options) {
+    const stackEntries = Object.entries(definition.stacks ?? {});
+    const programEntries = Object.entries(definition.programs ?? {});
+    if (stackEntries.length === 0 && programEntries.length === 0) {
+        throw new AreteError('createSession requires at least one stack or program member', 'INVALID_CONFIG');
+    }
+    let wallet = options?.wallet;
+    const signerRegistry = options?.signerRegistry ?? createSignerRegistry();
+    const connectedStacks = await Promise.all(stackEntries.map(async ([key, stack]) => {
+        const memberOptions = options?.stacks?.[key];
+        const effectiveStack = withPrograms(stack, memberOptions?.programs);
+        const connectOptions = resolveMemberConnectOptions(effectiveStack, memberOptions, options, false);
+        const client = await Arete$1.connect(effectiveStack, connectOptions);
+        return [key, client];
+    }));
+    const connectedPrograms = await Promise.all(programEntries.map(async ([key, program]) => {
+        const syntheticStack = programAsStack(key, program);
+        const connectOptions = resolveMemberConnectOptions(syntheticStack, options?.programs?.[key], options, true);
+        const client = await Arete$1.connect(syntheticStack, connectOptions);
+        return [key, client];
+    }));
+    const memberClients = [
+        ...connectedStacks.map(([, client]) => client),
+        ...connectedPrograms.map(([, client]) => client),
+    ];
+    const executionHost = memberClients[0];
+    const stacks = Object.fromEntries(connectedStacks);
+    const explicitProgramKeys = new Set(connectedPrograms.map(([key]) => key));
+    const programOwners = new Map();
+    const connectedProgramEntries = connectedPrograms.map(([key, client]) => [
+        key,
+        client.programs[key],
+    ]);
+    const promotedPrograms = Object.fromEntries(connectedProgramEntries);
+    for (const [stackKey, client] of connectedStacks) {
+        for (const [programKey, program] of Object.entries(client.programs)) {
+            if (explicitProgramKeys.has(programKey)) {
+                continue;
+            }
+            const existingOwner = programOwners.get(programKey);
+            if (existingOwner) {
+                console.warn(`Program '${programKey}' is bundled by stacks '${existingOwner.stack}'` +
+                    ` (${existingOwner.programId ?? 'unknown program ID'}) and '${stackKey}'` +
+                    ` (${program.programId ?? 'unknown program ID'}); session.programs.${programKey}` +
+                    ` uses '${existingOwner.stack}' because it was connected first`);
+                continue;
+            }
+            promotedPrograms[programKey] = program;
+            programOwners.set(programKey, { stack: stackKey, programId: program.programId });
+        }
+    }
+    const programs = promotedPrograms;
+    const chain = options?.chain ?? (options?.endpoints?.http !== undefined
+        ? createChainClient(options.endpoints.http, (options?.fetch ?? globalThis.fetch?.bind(globalThis)))
+        : executionHost.chain);
+    const session = {
+        stacks,
+        programs,
+        get wallet() {
+            return wallet;
+        },
+        signerRegistry,
+        chain,
+        transaction(instructions, transactionOptions) {
+            const defaults = options?.execution;
+            const configuredSigners = transactionOptions?.signers ?? defaults?.signers;
+            const signers = [...new Set([...signerRegistry.values(), ...(configuredSigners ?? [])])];
+            return executionHost.transaction(instructions, {
+                wallet: transactionOptions?.wallet ?? defaults?.wallet,
+                send: defaults?.send || transactionOptions?.send
+                    ? { ...(defaults?.send ?? {}), ...(transactionOptions?.send ?? {}) }
+                    : undefined,
+                errors: transactionOptions?.errors,
+                signers: signers.length > 0 ? signers : undefined,
+            });
+        },
+        execute(prepared, executionOptions) {
+            const defaults = options?.execution;
+            const configuredSigners = executionOptions?.signers ?? defaults?.signers;
+            return executionHost.execute(prepared, {
+                wallet: executionOptions?.wallet ?? defaults?.wallet,
+                send: defaults?.send || executionOptions?.send
+                    ? { ...(defaults?.send ?? {}), ...(executionOptions?.send ?? {}) }
+                    : undefined,
+                signers: configuredSigners,
+                signerRegistry,
+                availableSignerAddresses: executionOptions?.availableSignerAddresses ?? defaults?.availableSignerAddresses,
+                onTransactionStart: executionOptions?.onTransactionStart ?? defaults?.onTransactionStart,
+                onTransactionSuccess: executionOptions?.onTransactionSuccess ?? defaults?.onTransactionSuccess,
+            });
+        },
+        setWallet(nextWallet) {
+            wallet = nextWallet;
+            for (const client of memberClients) {
+                client.setWallet(nextWallet);
+            }
+        },
+        close() {
+            for (const client of memberClients) {
+                client.disconnect();
+            }
+        },
+    };
+    return session;
+}
+
+function instructionOperation(prepare) {
+    return {
+        kind: 'instruction',
+        prepare: async (input) => prepare(input),
+    };
+}
+function transactionOperation(prepare) {
+    return {
+        kind: 'transaction',
+        prepare: async (input) => prepare(input),
+    };
+}
+function flowOperation(prepare) {
+    return {
+        kind: 'flow',
+        prepare: async (input) => prepare(input),
+    };
+}
+
+function chainAccountLoader(chain) {
+    return {
+        async getAccount(address) {
+            const account = await chain.account(address);
+            return account ? { data: account.data } : null;
+        },
+    };
+}
+
+const SPL_TOKEN_PROGRAM_ADDRESS = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA';
+const TOKEN_2022_PROGRAM_ADDRESS = 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb';
+const ASSOCIATED_TOKEN_PROGRAM_ADDRESS = 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL';
+const SYSTEM_PROGRAM_ADDRESS = '11111111111111111111111111111111';
+async function resolveTokenProgramAddress(chain, mint, override) {
+    if (override) {
+        return override;
+    }
+    const mintAccount = await chain.mint(mint);
+    if (!mintAccount) {
+        throw new Error(`Mint account not found while resolving token program: ${mint}`);
+    }
+    if (mintAccount.ownerProgram !== SPL_TOKEN_PROGRAM_ADDRESS &&
+        mintAccount.ownerProgram !== TOKEN_2022_PROGRAM_ADDRESS) {
+        throw new Error(`Mint ${mint} is owned by unsupported token program ${mintAccount.ownerProgram}`);
+    }
+    return mintAccount.ownerProgram;
+}
+function deriveAssociatedTokenAccount(input) {
+    const [address] = findProgramAddressSync([
+        createPublicKeySeed(input.owner),
+        createPublicKeySeed(input.tokenProgram ?? SPL_TOKEN_PROGRAM_ADDRESS),
+        createPublicKeySeed(input.mint),
+    ], ASSOCIATED_TOKEN_PROGRAM_ADDRESS);
+    return address;
+}
+
+/** Convert a UI amount ("1.5") to raw base units using string math (no float precision loss). */
+function parseUiAmountToRaw(value, decimals) {
+    const trimmed = String(value).trim();
+    if (!/^\d+(?:\.\d+)?$/.test(trimmed)) {
+        throw new Error(`Invalid UI amount: ${value}`);
+    }
+    const [wholePart, fractionPart = ''] = trimmed.split('.');
+    if (fractionPart.length > decimals) {
+        const excess = fractionPart.slice(decimals);
+        if (/[1-9]/.test(excess)) {
+            throw new Error(`UI amount ${value} has more fractional digits than the mint's ${decimals} decimals`);
+        }
+    }
+    const fraction = fractionPart.padEnd(decimals, '0');
+    const whole = BigInt(wholePart || '0') * 10n ** BigInt(decimals);
+    const fractional = BigInt(fraction.slice(0, decimals) || '0');
+    return whole + fractional;
+}
+/** Format raw base units as a UI decimal string (inverse of {@link parseUiAmountToRaw}). */
+function formatRawToUi(raw, decimals) {
+    const value = BigInt(raw);
+    const negative = value < 0n;
+    const magnitude = negative ? -value : value;
+    const scale = 10n ** BigInt(decimals);
+    const whole = magnitude / scale;
+    const fraction = magnitude % scale;
+    const sign = negative ? '-' : '';
+    if (decimals === 0 || fraction === 0n) {
+        return `${sign}${whole.toString()}`;
+    }
+    const fractionText = fraction.toString().padStart(decimals, '0').replace(/0+$/, '');
+    return `${sign}${whole.toString()}.${fractionText}`;
+}
+/** Resolve an {@link AmountInput} to raw base units with known decimals. */
+function toRawAmount(amount, decimals) {
+    if (typeof amount === 'bigint') {
+        return amount;
     }
-    notifyUpdate(viewPath, key, update) {
-        for (const callback of this.updateCallbacks) {
-            callback(viewPath, key, update);
-        }
+    if ('raw' in amount) {
+        return BigInt(amount.raw);
     }
-    notifyRichUpdate(viewPath, key, before, after, _op, patch) {
-        const richUpdate = before === undefined
-            ? { type: 'created', key, data: after }
-            : { type: 'updated', key, before, after, patch };
-        for (const callback of this.richUpdateCallbacks) {
-            callback(viewPath, key, richUpdate);
-        }
+    return parseUiAmountToRaw(amount.ui, decimals);
+}
+/** Fetch a mint's decimals via the chain read endpoint, throwing when unavailable. */
+async function getMintDecimals(chain, mint) {
+    const account = await chain.mint(mint);
+    if (!account || account.decimals == null) {
+        throw new Error(`Mint ${mint} is missing decimals on the configured read endpoint.`);
     }
-    notifyRichDelete(viewPath, key, lastKnown) {
-        const richUpdate = { type: 'deleted', key, lastKnown };
-        for (const callback of this.richUpdateCallbacks) {
-            callback(viewPath, key, richUpdate);
-        }
+    return account.decimals;
+}
+/**
+ * Resolve an {@link AmountInput} to raw base units, fetching the mint's
+ * decimals only when they are unknown and actually needed (a bare bigint or
+ * `{raw}` input with explicit `decimals` never touches the network).
+ */
+async function resolveAmount(chain, input) {
+    const needsDecimalsForParse = typeof input.amount !== 'bigint' && 'ui' in input.amount;
+    if (!needsDecimalsForParse) {
+        const raw = typeof input.amount === 'bigint'
+            ? input.amount
+            : BigInt(input.amount.raw);
+        const decimals = input.decimals ?? await getMintDecimals(chain, input.mint);
+        return { raw, decimals };
+    }
+    const decimals = input.decimals ?? await getMintDecimals(chain, input.mint);
+    return { raw: toRawAmount(input.amount, decimals), decimals };
+}
+/**
+ * Resolve an {@link AmountInput} to raw base units without forcing a decimals
+ * fetch when the input is already expressed in raw units.
+ */
+async function resolveAmountToRaw(chain, input) {
+    if (typeof input.amount === 'bigint') {
+        return input.amount;
+    }
+    if ('raw' in input.amount) {
+        return BigInt(input.amount.raw);
     }
+    const decimals = input.decimals ?? await getMintDecimals(chain, input.mint);
+    return toRawAmount(input.amount, decimals);
 }
+/** Resolve a named set of {@link AmountInput} values to raw base units. */
+async function resolveAmountsToRaw(chain, inputs) {
+    const entries = await Promise.all(Object.entries(inputs).map(async ([name, input]) => {
+        const raw = await resolveAmountToRaw(chain, input);
+        return [name, raw];
+    }));
+    return Object.fromEntries(entries);
+}
+
+const Arete = Object.assign(Arete$1, { session: createSession });
 
+exports.ASSOCIATED_TOKEN_PROGRAM_ADDRESS = ASSOCIATED_TOKEN_PROGRAM_ADDRESS;
 exports.Arete = Arete;
 exports.AreteError = AreteError;
 exports.ConnectionManager = ConnectionManager;
 exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
 exports.DEFAULT_MAX_ENTRIES_PER_VIEW = DEFAULT_MAX_ENTRIES_PER_VIEW;
-exports.EntityStore = EntityStore;
 exports.FrameProcessor = FrameProcessor;
+exports.InstructionError = InstructionError;
 exports.MemoryAdapter = MemoryAdapter;
+exports.OperationExecutionError = OperationExecutionError;
+exports.PROGRAM_OPERATION_EXTENSIONS = PROGRAM_OPERATION_EXTENSIONS;
+exports.ReadRequestError = ReadRequestError;
+exports.SPL_TOKEN_PROGRAM_ADDRESS = SPL_TOKEN_PROGRAM_ADDRESS;
+exports.STACK_RUNTIME_EXTENSIONS = STACK_RUNTIME_EXTENSIONS;
+exports.SYSTEM_PROGRAM_ADDRESS = SYSTEM_PROGRAM_ADDRESS;
 exports.SubscriptionRegistry = SubscriptionRegistry;
+exports.TOKEN_2022_PROGRAM_ADDRESS = TOKEN_2022_PROGRAM_ADDRESS;
 exports.account = account;
+exports.appendFlowTransactions = appendFlowTransactions;
+exports.appendTransactionInstructions = appendTransactionInstructions;
+exports.applyConnectedStackExtensions = applyConnectedStackExtensions;
 exports.arg = arg;
+exports.buildInstruction = buildInstruction;
 exports.bytes = bytes;
+exports.chainAccountLoader = chainAccountLoader;
+exports.createChainClient = createChainClient;
 exports.createEntityStream = createEntityStream;
 exports.createInstructionExecutor = createInstructionExecutor;
+exports.createInstructionHandler = createInstructionHandler;
+exports.createPreparedFlow = createPreparedFlow;
+exports.createPreparedInstruction = createPreparedInstruction;
+exports.createPreparedTransaction = createPreparedTransaction;
+exports.createPreparedTransactionBody = createPreparedTransactionBody;
 exports.createProgramPdas = createProgramPdas;
 exports.createPublicKeySeed = createPublicKeySeed;
 exports.createRichUpdateStream = createRichUpdateStream;
 exports.createSeed = createSeed;
+exports.createSession = createSession;
+exports.createSignerRegistry = createSignerRegistry;
 exports.createTypedListView = createTypedListView;
 exports.createTypedStateView = createTypedStateView;
 exports.createTypedViews = createTypedViews;
 exports.createUpdateStream = createUpdateStream;
 exports.decodeBase58 = decodeBase58;
+exports.defineProgramExtensions = defineProgramExtensions;
+exports.defineStackExtensions = defineStackExtensions;
+exports.deriveAssociatedTokenAccount = deriveAssociatedTokenAccount;
+exports.deriveHttpEndpoint = deriveHttpEndpoint;
 exports.derivePda = findProgramAddress;
+exports.describePreparedOperation = describePreparedOperation;
 exports.encodeBase58 = encodeBase58;
 exports.executeInstruction = executeInstruction;
+exports.executePreparedOperation = executePreparedOperation;
+exports.extendProgram = extendProgram;
+exports.extendPrograms = extendPrograms;
+exports.extendStack = extendStack;
 exports.findProgramAddress = findProgramAddress;
 exports.findProgramAddressSync = findProgramAddressSync;
+exports.flowOperation = flowOperation;
+exports.formatPreparedOperation = formatPreparedOperation;
 exports.formatProgramError = formatProgramError;
+exports.formatRawToUi = formatRawToUi;
+exports.getMintDecimals = getMintDecimals;
+exports.getProgramRuntimeExtensions = getProgramRuntimeExtensions;
+exports.getStackRuntimeExtensions = getStackRuntimeExtensions;
+exports.instructionOperation = instructionOperation;
 exports.isEntityFrame = isEntityFrame;
 exports.isSnapshotFrame = isSnapshotFrame;
 exports.isSubscribedFrame = isSubscribedFrame;
@@ -3066,9 +4427,22 @@ exports.literal = literal;
 exports.parseFrame = parseFrame;
 exports.parseFrameFromBlob = parseFrameFromBlob;
 exports.parseInstructionError = parseInstructionError;
+exports.parseUiAmountToRaw = parseUiAmountToRaw;
 exports.pda = pda;
+exports.prependFlowTransactionInstructions = prependFlowTransactionInstructions;
+exports.prependTransactionInstructions = prependTransactionInstructions;
+exports.programAccountRead = programAccountRead;
+exports.programQuery = programQuery;
 exports.resolveAccounts = resolveAccounts;
+exports.resolveAmount = resolveAmount;
+exports.resolveAmountToRaw = resolveAmountToRaw;
+exports.resolveAmountsToRaw = resolveAmountsToRaw;
+exports.resolveTokenProgramAddress = resolveTokenProgramAddress;
 exports.serializeInstructionData = serializeInstructionData;
+exports.stackQuery = stackQuery;
+exports.toJsonValue = toJsonValue;
+exports.toRawAmount = toRawAmount;
+exports.transactionOperation = transactionOperation;
 exports.validateAccountResolution = validateAccountResolution;
-exports.waitForConfirmation = waitForConfirmation;
+exports.withPrograms = withPrograms;
 //# sourceMappingURL=index.js.map