@donezone/client 0.1.0

package/dist/done.js

@@ -0,0 +1,473 @@
+import { buildEnvelope as buildEnvelopeHelper, CURRENT_ENVELOPE_VERSION, signDocDigest, toSignDoc, } from "./envelope";
+import { DoneBackendClient } from "./client";
+import { buildTransactionMessage } from "./messages";
+export class DoneContractClient {
+    backend;
+    address;
+    buildEnvelopeFn;
+    eventSourceFactory;
+    eventsPath;
+    defaultMetadata;
+    constructor(config) {
+        this.backend = new DoneBackendClient({ baseUrl: config.baseUrl, fetch: config.fetch });
+        this.address = config.address;
+        this.buildEnvelopeFn = config.buildEnvelope;
+        this.eventSourceFactory = config.eventSource;
+        this.eventsPath = config.eventsPath ?? "/events";
+        this.defaultMetadata = config.defaultMetadata;
+    }
+    get(path, request = {}, init = {}) {
+        const promise = this.fetchQuery(path, request, init);
+        return new DoneRequest(promise);
+    }
+    async query(path, request = {}, init = {}) {
+        const response = await this.fetchQuery(path, request, init);
+        return response.json();
+    }
+    async post(path, request = {}, init = {}) {
+        return this.execute(path, request, init);
+    }
+    async run(path, request = {}, init = {}) {
+        return this.execute(path, request, init);
+    }
+    async execute(path, request = {}, init = {}) {
+        if (!this.buildEnvelopeFn) {
+            throw new Error("execute requires a buildEnvelope function in contract config");
+        }
+        const normalizedCall = {
+            path,
+            query: request.query,
+            body: request.body,
+        };
+        const transactionMsg = buildTransactionMessage(this.address, normalizedCall, request);
+        const metadata = mergeMetadata(this.defaultMetadata, request.metadata, { trace_id: request.traceId, memo: request.memo, gas_limit: request.gasLimit });
+        const buildContext = {
+            msg: transactionMsg,
+            metadata,
+            path,
+            request,
+        };
+        const buildResult = await this.buildEnvelopeFn(buildContext);
+        if (metadata) {
+            buildResult.envelope.metadata = buildResult.envelope.metadata ?? metadata;
+        }
+        const executeOptions = mergeExecuteOptions(buildResult.options, {
+            memo: request.memo,
+            passkey: request.passkey,
+            signal: request.signal,
+        });
+        return this.backend.executeEnvelope(buildResult.envelope, executeOptions, init);
+    }
+    transaction(path, request = {}) {
+        const normalizedCall = {
+            path,
+            query: request.query,
+            body: request.body,
+        };
+        const msg = buildTransactionMessage(this.address, normalizedCall, request);
+        const metadata = mergeMetadata(this.defaultMetadata, request.metadata, {
+            trace_id: request.traceId,
+            memo: request.memo,
+            gas_limit: request.gasLimit,
+        });
+        return { msg, metadata };
+    }
+    subscribe(topic, handler, options = {}) {
+        const factory = this.eventSourceFactory ?? defaultEventSourceFactory;
+        const eventsBase = buildEventsUrl(this.backend.baseUrl, this.eventsPath);
+        const encodedTopic = Array.isArray(topic) ? JSON.stringify(topic) : topic;
+        const url = `${eventsBase}?topic=${encodeURIComponent(encodedTopic)}`;
+        const source = factory(url);
+        const messageListener = (event) => {
+            if (options.rawEvent) {
+                handler(event);
+                return;
+            }
+            const data = event.data;
+            try {
+                handler(JSON.parse(data));
+            }
+            catch {
+                handler(data);
+            }
+        };
+        if (typeof source.addEventListener === "function") {
+            source.addEventListener("message", messageListener);
+        }
+        else {
+            source.onmessage = messageListener;
+        }
+        if (options.onError) {
+            if (typeof source.addEventListener === "function") {
+                source.addEventListener("error", options.onError);
+            }
+            else {
+                source.onerror = options.onError;
+            }
+        }
+        const cleanup = () => {
+            if (typeof source.removeEventListener === "function") {
+                source.removeEventListener("message", messageListener);
+                if (options.onError) {
+                    source.removeEventListener("error", options.onError);
+                }
+            }
+            source.close();
+        };
+        if (options.signal) {
+            if (options.signal.aborted) {
+                cleanup();
+            }
+            else {
+                options.signal.addEventListener("abort", cleanup, { once: true });
+            }
+        }
+        return cleanup;
+    }
+    buildEnvelope(draft) {
+        return buildEnvelopeHelper(draft);
+    }
+    signDocDigest(envelope) {
+        return signDocDigest(toSignDoc(envelope));
+    }
+    get baseUrl() {
+        return this.backend.baseUrl;
+    }
+    async fetchQuery(path, request, init = {}) {
+        const call = { path, query: request.query, body: request.body };
+        return this.backend.queryContractRaw(this.address, call, init);
+    }
+}
+export class DoneRequest {
+    promise;
+    constructor(promise) {
+        this.promise = promise;
+    }
+    then(onfulfilled, onrejected) {
+        return this.promise.then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.promise.catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.promise.finally(onfinally);
+    }
+    json() {
+        return this.promise.then((response) => response.json());
+    }
+    text() {
+        return this.promise.then((response) => response.text());
+    }
+    arrayBuffer() {
+        return this.promise.then((response) => response.arrayBuffer());
+    }
+}
+function mergeMetadata(...entries) {
+    const merged = {};
+    for (const entry of entries) {
+        if (!entry)
+            continue;
+        if (entry.trace_id)
+            merged.trace_id = entry.trace_id;
+        if (entry.memo)
+            merged.memo = entry.memo;
+        if (typeof entry.gas_limit === "number")
+            merged.gas_limit = entry.gas_limit;
+    }
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+function mergeExecuteOptions(base, overrides) {
+    if (!base && !overrides.memo && !overrides.passkey && !overrides.signal) {
+        return undefined;
+    }
+    return {
+        memo: overrides.memo ?? base?.memo,
+        passkey: overrides.passkey ?? base?.passkey,
+        signal: overrides.signal ?? base?.signal,
+    };
+}
+function defaultEventSourceFactory(url) {
+    if (typeof EventSource === "undefined") {
+        throw new Error("EventSource is not available in this environment");
+    }
+    return new EventSource(url);
+}
+function buildEventsUrl(baseUrl, eventsPath) {
+    const normalized = eventsPath.startsWith("/") ? eventsPath : `/${eventsPath}`;
+    return `${baseUrl.replace(/\/$/, "")}${normalized}`;
+}
+function resolveFetch(fn) {
+    if (fn)
+        return fn;
+    if (typeof fetch === "function")
+        return fetch.bind(globalThis);
+    throw new Error("global fetch is not available; configure Done with a fetch implementation via Done.config");
+}
+function resolveEventSource(factory) {
+    if (factory)
+        return factory;
+    if (typeof EventSource === "function") {
+        return (url) => new EventSource(url);
+    }
+    return undefined;
+}
+function normalizeConfig(input = {}, base) {
+    const previous = base ?? {
+        doneHttp: "https://doneHttp.done.zone",
+        doneEvents: "https://doneEvents.done.zone",
+        fetch: resolveFetch(),
+        eventSource: resolveEventSource(),
+        envelopeBuilder: undefined,
+    };
+    return {
+        doneHttp: input.doneHttp ?? previous.doneHttp,
+        doneEvents: input.doneEvents ?? previous.doneEvents,
+        fetch: resolveFetch(input.fetch ?? previous.fetch),
+        eventSource: resolveEventSource(input.eventSource ?? previous.eventSource),
+        envelopeBuilder: input.envelopeBuilder ?? input.signer ?? previous.envelopeBuilder,
+    };
+}
+function resolveRoute(raw, base, extraSearch) {
+    const url = new URL(raw, base);
+    if (extraSearch) {
+        for (const [key, value] of Object.entries(extraSearch)) {
+            url.searchParams.set(key, String(value));
+        }
+    }
+    const pathSegments = url.pathname.replace(/^\/+/, "").split("/");
+    const contract = pathSegments.shift();
+    if (!contract) {
+        throw new Error("route must include contract address as first path segment");
+    }
+    const path = pathSegments.length > 0 ? `/${pathSegments.join("/")}` : "/";
+    const queryRecord = searchParamsToRecord(url.searchParams);
+    return {
+        url,
+        contract,
+        path,
+        query: Object.keys(queryRecord).length > 0 ? queryRecord : undefined,
+    };
+}
+function searchParamsToRecord(params) {
+    const record = {};
+    for (const [key, value] of params) {
+        const existing = record[key];
+        if (existing === undefined) {
+            record[key] = value;
+        }
+        else if (Array.isArray(existing)) {
+            existing.push(value);
+        }
+        else {
+            record[key] = [existing, value];
+        }
+    }
+    return record;
+}
+function normalizeContractBody(body) {
+    if (body === undefined || body === null) {
+        return body;
+    }
+    if (isPlainObject(body) || Array.isArray(body)) {
+        return body;
+    }
+    if (typeof body === "string") {
+        try {
+            return JSON.parse(body);
+        }
+        catch (err) {
+            throw new Error("string bodies must contain JSON payloads when invoking Done.run/query");
+        }
+    }
+    if (body instanceof URLSearchParams) {
+        return Object.fromEntries(Array.from(body));
+    }
+    throw new Error("unsupported body type for Done.run/query; provide a JSON-serialisable value");
+}
+function isPlainObject(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+function normalizeContractSegment(value) {
+    if (!value) {
+        throw new Error("contract identifier cannot be empty");
+    }
+    return value.replace(/^\/+/u, "").replace(/\/+$/u, "");
+}
+class DoneInstance {
+    settings;
+    backend;
+    CURRENT_ENVELOPE_VERSION = CURRENT_ENVELOPE_VERSION;
+    buildEnvelope = buildEnvelopeHelper;
+    signDocDigest = signDocDigest;
+    toSignDoc = toSignDoc;
+    constructor(input) {
+        this.settings = normalizeConfig(input);
+        this.backend = new DoneBackendClient({ baseUrl: this.settings.doneHttp, fetch: this.settings.fetch });
+    }
+    async run(url, init = {}) {
+        const { body: rawBody, funds, memo, traceId, gasLimit, passkey, metadata, search, ...rest } = init;
+        const fetchInit = { ...rest };
+        const resolved = resolveRoute(url, this.settings.doneHttp, search);
+        const contractBody = normalizeContractBody(rawBody);
+        const call = {
+            path: resolved.path,
+            query: resolved.query,
+            body: contractBody,
+        };
+        const msg = buildTransactionMessage(resolved.contract, call, { funds });
+        const mergedMetadata = mergeMetadata(metadata, {
+            trace_id: traceId,
+            memo,
+            gas_limit: gasLimit,
+        });
+        const builder = this.requireEnvelopeBuilder();
+        const request = {
+            body: contractBody,
+            query: resolved.query,
+            funds,
+            memo,
+            traceId,
+            gasLimit,
+            metadata: mergedMetadata,
+            passkey,
+            signal: fetchInit.signal,
+        };
+        const result = await Promise.resolve(builder({
+            msg,
+            metadata: mergedMetadata,
+            path: resolved.path,
+            request,
+        }));
+        if (mergedMetadata) {
+            result.envelope.metadata = result.envelope.metadata ?? mergedMetadata;
+        }
+        const executeOptions = mergeExecuteOptions(result.options, {
+            memo,
+            passkey,
+            signal: fetchInit.signal,
+        });
+        return this.backend.executeEnvelope(result.envelope, executeOptions ?? {}, fetchInit);
+    }
+    async query(url, init = {}) {
+        const { body: rawBody, search, ...rest } = init;
+        const fetchInit = { ...rest };
+        const resolved = resolveRoute(url, this.settings.doneHttp, search);
+        const contractBody = normalizeContractBody(rawBody);
+        const call = {
+            path: resolved.path,
+            query: resolved.query,
+            body: contractBody,
+        };
+        return this.backend.queryContract(resolved.contract, call, fetchInit);
+    }
+    subscribe(eventsUrl, topic, handler, options = {}) {
+        const factory = this.settings.eventSource ?? defaultEventSourceFactory;
+        if (!factory) {
+            throw new Error("EventSource is not available; configure Done with an eventSource factory");
+        }
+        const url = new URL(eventsUrl, this.settings.doneEvents);
+        const topicValue = Array.isArray(topic) ? JSON.stringify(topic) : topic;
+        url.searchParams.set("topic", topicValue);
+        const source = factory(url.toString());
+        const messageListener = (event) => {
+            if (options.rawEvent) {
+                handler(event);
+                return;
+            }
+            try {
+                handler(JSON.parse(event.data));
+            }
+            catch {
+                handler(event.data);
+            }
+        };
+        if (typeof source.addEventListener === "function") {
+            source.addEventListener("message", messageListener);
+        }
+        else {
+            source.onmessage = messageListener;
+        }
+        if (options.onError) {
+            if (typeof source.addEventListener === "function") {
+                source.addEventListener("error", options.onError);
+            }
+            else {
+                source.onerror = options.onError;
+            }
+        }
+        const cleanup = () => {
+            if (typeof source.removeEventListener === "function") {
+                source.removeEventListener("message", messageListener);
+                if (options.onError) {
+                    source.removeEventListener("error", options.onError);
+                }
+            }
+            source.close();
+        };
+        if (options.signal) {
+            if (options.signal.aborted) {
+                cleanup();
+            }
+            else {
+                options.signal.addEventListener("abort", cleanup, { once: true });
+            }
+        }
+        return cleanup;
+    }
+    config(update) {
+        this.settings = normalizeConfig(update, this.settings);
+        this.backend = new DoneBackendClient({ baseUrl: this.settings.doneHttp, fetch: this.settings.fetch });
+    }
+    create(update = {}) {
+        const merged = normalizeConfig(update, this.settings);
+        return new DoneInstance({
+            doneHttp: merged.doneHttp,
+            doneEvents: merged.doneEvents,
+            fetch: merged.fetch,
+            eventSource: merged.eventSource,
+            envelopeBuilder: merged.envelopeBuilder,
+        });
+    }
+    contract(config, maybeConfig) {
+        if (typeof config === "string") {
+            if (!maybeConfig) {
+                return this.buildContractHandle(config);
+            }
+            return new DoneContractClient({
+                baseUrl: config,
+                ...maybeConfig,
+                buildEnvelope: maybeConfig.buildEnvelope ?? this.settings.envelopeBuilder,
+                fetch: maybeConfig.fetch ?? this.settings.fetch,
+                eventSource: maybeConfig.eventSource ?? this.settings.eventSource,
+            });
+        }
+        return new DoneContractClient({
+            ...config,
+            baseUrl: config.baseUrl,
+            buildEnvelope: config.buildEnvelope ?? this.settings.envelopeBuilder,
+            fetch: config.fetch ?? this.settings.fetch,
+            eventSource: config.eventSource ?? this.settings.eventSource,
+        });
+    }
+    requireEnvelopeBuilder() {
+        if (!this.settings.envelopeBuilder) {
+            throw new Error("Done.run requires an envelope builder; configure Done.config({ signer: ... }) first");
+        }
+        return this.settings.envelopeBuilder;
+    }
+    buildContractHandle(contract) {
+        const address = normalizeContractSegment(contract);
+        const client = new DoneContractClient({
+            baseUrl: this.settings.doneHttp,
+            address,
+            buildEnvelope: this.settings.envelopeBuilder,
+            fetch: this.settings.fetch,
+            eventSource: this.settings.eventSource,
+        });
+        return client;
+    }
+}
+export const Done = new DoneInstance();

package/dist/envelope.d.ts

@@ -0,0 +1,29 @@
+import type { AuthEnvelope, AuthEnvelopeSignDoc, Coin, CosmosMsg, EnvelopeMetadata, EnvelopeRole, EnvelopeSignatures } from "./types";
+export declare const CURRENT_ENVELOPE_VERSION = 1;
+export interface EnvelopeDraft {
+    version?: number;
+    user_id: string;
+    session_id?: string;
+    msgs: CosmosMsg[];
+    nonce: number;
+    expires_at: number;
+    role: EnvelopeRole;
+    agent?: string;
+    forwarder?: string;
+    metadata?: EnvelopeMetadata;
+    signatures?: EnvelopeSignatures;
+}
+export interface TransactionCall {
+    contract: string;
+    path: string;
+    body?: unknown;
+    query?: Record<string, unknown>;
+    funds?: Coin[];
+}
+export declare function toSignDoc(envelope: AuthEnvelope | EnvelopeDraft): AuthEnvelopeSignDoc;
+export declare function buildEnvelope(draft: EnvelopeDraft): AuthEnvelope;
+export declare function signDocBytes(signDoc: AuthEnvelopeSignDoc): Uint8Array;
+export declare function signDocDigest(signDoc: AuthEnvelopeSignDoc): Uint8Array;
+export declare function encodeSignature(signature: Uint8Array): string;
+export declare function decodeSignature(signature: string): Uint8Array;
+//# sourceMappingURL=envelope.d.ts.map

package/dist/envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../src/envelope.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,YAAY,EACZ,mBAAmB,EACnB,IAAI,EACJ,SAAS,EACT,gBAAgB,EAChB,YAAY,EACZ,kBAAkB,EACnB,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,UAAU,CAAC,EAAE,kBAAkB,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;CAChB;AAWD,wBAAgB,SAAS,CAAC,QAAQ,EAAE,YAAY,GAAG,aAAa,GAAG,mBAAmB,CAcrF;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,GAAG,YAAY,CAmBhE;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,UAAU,CAGrE;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,mBAAmB,GAAG,UAAU,CAGtE;AAwBD,wBAAgB,eAAe,CAAC,SAAS,EAAE,UAAU,GAAG,MAAM,CAU7D;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,CAW7D"}

package/dist/envelope.js

@@ -0,0 +1,98 @@
+import { sha256 } from "@noble/hashes/sha256";
+export const CURRENT_ENVELOPE_VERSION = 1;
+function normalizeMetadata(metadata) {
+    if (!metadata)
+        return undefined;
+    const normalized = {};
+    if (metadata.trace_id)
+        normalized.trace_id = metadata.trace_id;
+    if (metadata.memo)
+        normalized.memo = metadata.memo;
+    if (typeof metadata.gas_limit === "number")
+        normalized.gas_limit = metadata.gas_limit;
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+export function toSignDoc(envelope) {
+    const metadata = normalizeMetadata(envelope.metadata);
+    return {
+        version: envelope.version ?? CURRENT_ENVELOPE_VERSION,
+        user_id: envelope.user_id,
+        session_id: envelope.session_id,
+        msgs: envelope.msgs.map((msg) => cloneMsg(msg)),
+        nonce: envelope.nonce,
+        expires_at: envelope.expires_at,
+        role: envelope.role,
+        agent: envelope.agent,
+        forwarder: envelope.forwarder,
+        metadata,
+    };
+}
+export function buildEnvelope(draft) {
+    if (!Array.isArray(draft.msgs) || draft.msgs.length === 0) {
+        throw new Error("envelope requires at least one message");
+    }
+    const version = draft.version ?? CURRENT_ENVELOPE_VERSION;
+    const metadata = normalizeMetadata(draft.metadata);
+    return {
+        version,
+        user_id: draft.user_id,
+        session_id: draft.session_id,
+        msgs: draft.msgs.map((msg) => cloneMsg(msg)),
+        nonce: draft.nonce,
+        expires_at: draft.expires_at,
+        role: draft.role,
+        agent: draft.agent,
+        forwarder: draft.forwarder,
+        signatures: draft.signatures ? { ...draft.signatures } : {},
+        metadata,
+    };
+}
+export function signDocBytes(signDoc) {
+    const json = canonicalStringify(signDoc);
+    return new TextEncoder().encode(json);
+}
+export function signDocDigest(signDoc) {
+    const bytes = signDocBytes(signDoc);
+    return sha256(bytes);
+}
+function cloneMsg(msg) {
+    return structuredClone(msg);
+}
+function canonicalStringify(value) {
+    return JSON.stringify(value, (_key, val) => {
+        if (val instanceof Map) {
+            return Object.fromEntries(Array.from(val.entries()).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
+        }
+        if (val && typeof val === "object" && !Array.isArray(val)) {
+            const entries = Object.entries(val).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+            return entries.reduce((acc, [key, entry]) => {
+                acc[key] = entry;
+                return acc;
+            }, {});
+        }
+        return val;
+    });
+}
+export function encodeSignature(signature) {
+    const nodeBuffer = globalThis.Buffer;
+    if (nodeBuffer) {
+        return nodeBuffer.from(signature).toString("base64");
+    }
+    let result = "";
+    for (const byte of signature) {
+        result += String.fromCharCode(byte);
+    }
+    return btoa(result);
+}
+export function decodeSignature(signature) {
+    const nodeBuffer = globalThis.Buffer;
+    if (nodeBuffer) {
+        return nodeBuffer.from(signature, "base64");
+    }
+    const binary = atob(signature);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./types";
+export { DoneBackendClient } from "./client";
+export type { EnvelopeDraft } from "./envelope";
+export type { TransactionOptions, QueryOptions } from "./client";
+export { Done, DoneContractClient } from "./done";
+export { DoneRequest } from "./done";
+export { createPasskeyEnvelopeBuilder, createSessionEnvelopeBuilder, type PasskeyEnvelopeBuilderOptions, type SessionEnvelopeBuilderOptions, } from "./auth";
+export { CURRENT_ENVELOPE_VERSION, buildEnvelope, decodeSignature, encodeSignature, signDocBytes, signDocDigest, toSignDoc, } from "./envelope";
+export { buildQueryMessage, buildTransactionMessage } from "./messages";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,YAAY,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACjE,OAAO,EAAE,IAAI,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,EACL,4BAA4B,EAC5B,4BAA4B,EAC5B,KAAK,6BAA6B,EAClC,KAAK,6BAA6B,GACnC,MAAM,QAAQ,CAAC;AAChB,OAAO,EACL,wBAAwB,EACxB,aAAa,EACb,eAAe,EACf,eAAe,EACf,YAAY,EACZ,aAAa,EACb,SAAS,GACV,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from "./types";
+export { DoneBackendClient } from "./client";
+export { Done, DoneContractClient } from "./done";
+export { DoneRequest } from "./done";
+export { createPasskeyEnvelopeBuilder, createSessionEnvelopeBuilder, } from "./auth";
+export { CURRENT_ENVELOPE_VERSION, buildEnvelope, decodeSignature, encodeSignature, signDocBytes, signDocDigest, toSignDoc, } from "./envelope";
+export { buildQueryMessage, buildTransactionMessage } from "./messages";

package/dist/messages.d.ts

@@ -0,0 +1,4 @@
+import type { CosmosMsg, DoneContractCall, ExecuteCallOptions } from "./types";
+export declare function buildTransactionMessage(contractAddr: string, call: DoneContractCall, options?: ExecuteCallOptions): CosmosMsg;
+export declare function buildQueryMessage(call: DoneContractCall): Record<string, unknown>;
+//# sourceMappingURL=messages.d.ts.map

package/dist/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../src/messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,SAAS,EACT,gBAAgB,EAChB,kBAAkB,EAEnB,MAAM,SAAS,CAAC;AAEjB,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,gBAAgB,EACtB,OAAO,GAAE,kBAAuB,GAC/B,SAAS,CAcX;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEjF"}

package/dist/messages.js

@@ -0,0 +1,46 @@
+export function buildTransactionMessage(contractAddr, call, options = {}) {
+    const payload = normalizeCall(call);
+    const msg = { msg: payload };
+    const funds = normalizeFunds(options.funds);
+    return {
+        wasm: {
+            execute: {
+                contract_addr: contractAddr,
+                msg,
+                funds: funds && funds.length > 0 ? funds : undefined,
+            },
+        },
+    };
+}
+export function buildQueryMessage(call) {
+    return { msg: normalizeCall(call) };
+}
+function normalizeCall(call) {
+    if (!call.path || !call.path.startsWith("/")) {
+        throw new Error("contract call path must start with '/'");
+    }
+    const payload = { path: call.path };
+    if (call.query instanceof URLSearchParams) {
+        payload.query = Object.fromEntries(Array.from(call.query));
+    }
+    else if (call.query) {
+        payload.query = call.query;
+    }
+    if (call.body !== undefined) {
+        payload.body = call.body;
+    }
+    return payload;
+}
+function normalizeFunds(funds) {
+    if (!funds)
+        return undefined;
+    if (Array.isArray(funds)) {
+        if (funds.length === 0)
+            return undefined;
+        return funds.map((coin) => ({ denom: coin.denom, amount: coin.amount }));
+    }
+    const entries = Object.entries(funds);
+    if (entries.length === 0)
+        return undefined;
+    return entries.map(([denom, amount]) => ({ denom, amount: String(amount) }));
+}